func (h *ZJUJudger) Login(_ UserInterface) error {
h.client.Get("http://acm.zju.edu.cn/onlinejudge/login.do")
uv := url.Values{}
uv.Add("handle", h.username)
uv.Add("password", h.userpass)
req, err := http.NewRequest("POST", "http://acm.zju.edu.cn/onlinejudge/login.do", strings.NewReader(uv.Encode()))
if err != nil {
return BadInternet
}
req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
resp, err := h.client.Do(req)
if err != nil {
log.Println("err", err)
return BadInternet
}
defer resp.Body.Close()
b, _ := ioutil.ReadAll(resp.Body)
html := string(b)
if strings.Index(html, "Handle or password is invalid.") >= 0 ||
strings.Index(html, "Handle is required.") >= 0 ||
strings.Index(html, "Password is required.") >= 0 {
return LoginFailed
}
return nil
}
func RenderSpecialLink(rawBytes []byte, urlPrefix string) []byte {
ms := MentionPattern.FindAll(rawBytes, -1)
for _, m := range ms {
rawBytes = bytes.Replace(rawBytes, m,
[]byte(fmt.Sprintf(`<a href="/user/%s">%s</a>`, m[1:], m)), -1)
}
ms = commitPattern.FindAll(rawBytes, -1)
for _, m := range ms {
m = bytes.TrimSpace(m)
i := strings.Index(string(m), "commit/")
j := strings.Index(string(m), "#")
if j == -1 {
j = len(m)
}
rawBytes = bytes.Replace(rawBytes, m, []byte(fmt.Sprintf(
` <code><a href="%s">%s</a></code>`, m, ShortSha(string(m[i+7:j])))), -1)
}
ms = issueFullPattern.FindAll(rawBytes, -1)
for _, m := range ms {
m = bytes.TrimSpace(m)
i := strings.Index(string(m), "issues/")
j := strings.Index(string(m), "#")
if j == -1 {
j = len(m)
}
rawBytes = bytes.Replace(rawBytes, m, []byte(fmt.Sprintf(
` <a href="%s">#%s</a>`, m, ShortSha(string(m[i+7:j])))), -1)
}
ms = issueIndexPattern.FindAll(rawBytes, -1)
for _, m := range ms {
rawBytes = bytes.Replace(rawBytes, m, []byte(fmt.Sprintf(
`<a href="%s/issues/%s">%s</a>`, urlPrefix, m[1:], m)), -1)
}
return rawBytes
}
// substituteParams substitute all params inside double chevron to the correct value
// param value will be obtained from dicts map
func substituteParams(toReplace, words string, dicts map[string]interface{}) string {
// non empty scalar node remain unchanged
// except it has double chevron bracket
if toReplace != "" && (strings.Index(toReplace, "<<") < 0 && strings.Index(toReplace, ">>") < 0) {
return toReplace
}
if words == "" {
return toReplace
}
removeParamBracket := func(param string) string {
param = strings.TrimSpace(param)
return param[2 : len(param)-2]
}
// search params
params := dcRe.FindAllString(words, -1)
// substitute the params
for _, p := range params {
pVal := getParamValue(removeParamBracket(p), dicts)
words = strings.Replace(words, p, pVal, -1)
}
return words
}
func (this *SrcHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
tmaster := time.Now()
switch r.Method { // Likely faster not to use a map[string]func.
case "GET":
if strings.Index(r.URL.Path, common.SrcsPath) != 0 {
handlerutils.HttpError(w, "Bad path: "+r.URL.Path, http.StatusBadRequest)
return
}
this.getHandler(w, r)
case "POST":
if strings.Index(r.URL.Path, common.SrcPath) != 0 {
handlerutils.HttpError(w, "Bad path: "+r.URL.Path, http.StatusBadRequest)
return
}
src := r.URL.Path[len(common.SrcPath):]
this.postHandler(w, r, src)
case "PUT":
if strings.Index(r.URL.Path, common.SrcPath) != 0 {
handlerutils.HttpError(w, "Bad path: "+r.URL.Path, http.StatusBadRequest)
return
}
src := r.URL.Path[len(common.SrcPath):]
this.putHandler(w, r, src)
default:
handlerutils.HttpError(w, "Bad method: "+r.Method, http.StatusBadRequest)
return
}
glog.V(2).Infof("PERF: total service time: %v\n", time.Now().Sub(tmaster))
}
func bzrResolveRepo(vcsBzr *vcsCmd, rootDir, remoteRepo string) (realRepo string, err error) {
outb, err := vcsBzr.runOutput(rootDir, "info "+remoteRepo)
if err != nil {
return "", err
}
out := string(outb)
// Expect:
// ...
// (branch root|repository branch): <URL>
// ...
found := false
for _, prefix := range []string{"\n branch root: ", "\n repository branch: "} {
i := strings.Index(out, prefix)
if i >= 0 {
out = out[i+len(prefix):]
found = true
break
}
}
if !found {
return "", fmt.Errorf("unable to parse output of bzr info")
}
i := strings.Index(out, "\n")
if i < 0 {
return "", fmt.Errorf("unable to parse output of bzr info")
}
out = out[:i]
return strings.TrimSpace(string(out)), nil
}
func ReadSNMP(path string) (*Snmp, error) {
data, err := ioutil.ReadFile(path)
if err != nil {
return nil, err
}
lines := strings.Split(string(data), "\n")
// Maps a netstat metric to its value (i.e. SyncookiesSent --> 0)
statMap := make(map[string]string)
// patterns
// TcpExt: SyncookiesSent SyncookiesRecv SyncookiesFailed... <-- header
// TcpExt: 0 0 1764... <-- values
for i := 1; i < len(lines); i = i + 2 {
headers := strings.Fields(lines[i-1][strings.Index(lines[i-1], ":")+1:])
values := strings.Fields(lines[i][strings.Index(lines[i], ":")+1:])
for j, header := range headers {
statMap[header] = values[j]
}
}
out := Snmp{}
elem := reflect.ValueOf(&out.TCP).Elem()
typeOfElem := elem.Type()
for i := 0; i < elem.NumField(); i++ {
if val, ok := statMap[typeOfElem.Field(i).Name]; ok {
parsedVal, _ := strconv.ParseUint(val, 10, 64)
elem.Field(i).SetUint(parsedVal)
}
}
return &out, nil
}
func fileWriter(t *testing.T, file *os.File, logs []string) {
filename := file.Name()
time.Sleep(1 * time.Second) // wait for start Tail...
for _, line := range logs {
if strings.Index(line, RotateMarker) != -1 {
log.Println("fileWriter: rename file => file.old")
os.Rename(filename, filename+".old")
file.Close()
file, _ = os.OpenFile(filename, os.O_CREATE|os.O_WRONLY, 0644)
log.Println("fileWriter: re-opened file")
} else if strings.Index(line, TruncateMarker) != -1 {
time.Sleep(1 * time.Second)
log.Println("fileWriter: truncate(file, 0)")
os.Truncate(filename, 0)
file.Seek(int64(0), os.SEEK_SET)
}
_, err := file.WriteString(line)
log.Print("fileWriter: wrote ", line)
if err != nil {
log.Println("write failed", err)
}
time.Sleep(1 * time.Millisecond)
}
file.Close()
}
//NewSheet marshal the reader's content, the sst can be nil
//using setSharedStringTable set is later
func NewSheet(r io.Reader, sst *sharedStringTable) (*Sheet, error) {
data, err := ioutil.ReadAll(r)
content := string(data)
index1 := strings.Index(content, `<sheetData>`)
index2 := strings.Index(content, `</sheetData>`)
if index1 == -1 {
return nil, errors.New(fmt.Sprintf("Can't find the sheetData tag, %s", content))
}
if index2 == -1 {
return nil, errors.New(fmt.Sprintf("Can't find the </sheetData> %s", content))
}
head := content[0:index1]
tail := content[index2+len(`</sheetData>`):]
sheetData := content[index1 : index2+len(`</sheetData>`)]
if err != nil {
return nil, err
}
sheet := &Sheet{head: head, tail: tail, sst: sst}
err = xml.Unmarshal([]byte(sheetData), sheet)
if err != nil {
return nil, err
}
return sheet, nil
}
func cleanGitignore(input string) (output string, err error) {
if len(input) == 0 {
return input, nil
}
if strings.Contains(input, delimiterStart) {
if strings.Count(input, delimiterStart) > 1 {
return input, errors.New("multiple instances of start delimiter")
}
if strings.Contains(input, delimiterEnd) {
if strings.Count(input, delimiterEnd) > 1 {
return input, errors.New("multiple instances of closing delimiter")
}
startPos := strings.Index(input, delimiterStart)
endPos := strings.Index(input, delimiterEnd) + len(delimiterEnd)
if startPos-2 >= 0 && input[startPos-2] == '\n' {
startPos--
}
if endPos+1 < len(input) && input[endPos+1] == '\n' {
endPos++
}
output = input[:startPos] + input[endPos:]
} else {
return input, errors.New("found no closing delimiter")
}
} else {
output = input
}
return output, nil
}
// getDirSubdir takes a source and returns a tuple of the URL without
// the subdir and the URL with the subdir.
func getDirSubdir(src string) (string, string) {
// Calcaulate an offset to avoid accidentally marking the scheme
// as the dir.
var offset int
if idx := strings.Index(src, "://"); idx > -1 {
offset = idx + 3
}
// First see if we even have an explicit subdir
idx := strings.Index(src[offset:], "//")
if idx == -1 {
return src, ""
}
idx += offset
subdir := src[idx+2:]
src = src[:idx]
// Next, check if we have query parameters and push them onto the
// URL.
if idx = strings.Index(subdir, "?"); idx > -1 {
query := subdir[idx:]
subdir = subdir[:idx]
src += query
}
return src, subdir
}
func filePathsFromArgs(args []string) ([]string, error) {
var output []string
var err error
if len(args) == 0 {
output, err = filepath.Glob("*")
if err != nil {
return []string{}, err
}
} else {
for _, arg := range args {
if strings.Index(arg, "*") < 0 && strings.Index(arg, "?") < 0 {
output = append(output, arg)
continue
}
matches, err := filepath.Glob(arg)
if err != nil {
return []string{}, err
}
for _, match := range matches {
output = append(output, match)
}
}
}
sort.Strings(output)
return output, nil
}
func TestPurgeOnlyUploads(t *testing.T) {
oldUploadCount := 5
oneHourAgo := time.Now().Add(-1 * time.Hour)
fs := testUploadFS(t, oldUploadCount, "test-repo", oneHourAgo)
// Create a directory tree outside _uploads and ensure
// these files aren't deleted.
dataPath, err := pm.path(uploadDataPathSpec{name: "test-repo", uuid: uuid.New()})
if err != nil {
t.Fatalf(err.Error())
}
nonUploadPath := strings.Replace(dataPath, "_upload", "_important", -1)
if strings.Index(nonUploadPath, "_upload") != -1 {
t.Fatalf("Non-upload path not created correctly")
}
nonUploadFile := path.Join(nonUploadPath, "file")
if err = fs.PutContent(nonUploadFile, []byte("")); err != nil {
t.Fatalf("Unable to write data file")
}
deleted, errs := PurgeUploads(fs, time.Now(), true)
if len(errs) != 0 {
t.Error("Unexpected errors", errs)
}
for _, file := range deleted {
if strings.Index(file, "_upload") == -1 {
t.Errorf("Non-upload file deleted")
}
}
}
func opener(t *testing.T) func(string) (Reader, Reader) {
var wrdr, wrdr2 Reader
return func(path string) (Reader, Reader) {
buf, _ := ioutil.ReadFile(path)
rdr := bytes.NewReader(buf)
rdr2 := bytes.NewReader(buf)
var err error
if wrdr == nil {
wrdr, err = NewReader(rdr)
} else {
err = wrdr.Reset(rdr)
}
if err != nil {
if strings.Index(path, "invalid") != -1 {
return nil, nil
}
t.Fatalf("test case: %s; error: %v", path, err)
}
if wrdr2 == nil {
wrdr2, err = NewReader(rdr2)
} else {
err = wrdr2.Reset(rdr2)
}
if err != nil {
if strings.Index(path, "invalid") != -1 {
return nil, nil
}
t.Fatalf("test case: %s; error: %v", path, err)
}
return wrdr, wrdr2
}
}
func testAccDatabaseCheck(rn string, name *string) resource.TestCheckFunc {
return func(s *terraform.State) error {
rs, ok := s.RootModule().Resources[rn]
if !ok {
return fmt.Errorf("resource not found: %s", rn)
}
if rs.Primary.ID == "" {
return fmt.Errorf("database id not set")
}
conn := testAccProvider.Meta().(mysqlc.Conn)
rows, _, err := conn.Query("SHOW CREATE DATABASE terraform_acceptance_test")
if err != nil {
return fmt.Errorf("error reading database: %s", err)
}
if len(rows) != 1 {
return fmt.Errorf("expected 1 row reading database but got %d", len(rows))
}
row := rows[0]
createSQL := string(row[1].([]byte))
if strings.Index(createSQL, "CHARACTER SET utf8") == -1 {
return fmt.Errorf("database default charset isn't utf8")
}
if strings.Index(createSQL, "COLLATE utf8_bin") == -1 {
return fmt.Errorf("database default collation isn't utf8_bin")
}
*name = rs.Primary.ID
return nil
}
}
// Handle 352 who reply
func (conn *Conn) h_352(line *Line) {
nk := conn.st.GetNick(line.Args[5])
if nk == nil {
logging.Warn("irc.352(): received WHO reply for unknown nick %s",
line.Args[5])
return
}
if nk == conn.Me() {
return
}
nk.Ident = line.Args[2]
nk.Host = line.Args[3]
// XXX: do we care about the actual server the nick is on?
// or the hop count to this server?
// last arg contains "<hop count> <real name>"
a := strings.SplitN(line.Args[len(line.Args)-1], " ", 2)
nk.Name = a[1]
if idx := strings.Index(line.Args[6], "*"); idx != -1 {
nk.Modes.Oper = true
}
if idx := strings.Index(line.Args[6], "B"); idx != -1 {
nk.Modes.Bot = true
}
if idx := strings.Index(line.Args[6], "H"); idx != -1 {
nk.Modes.Invisible = true
}
}
func loadTestUsersCommand(c *Context, command *model.Command) bool {
cmd1 := "/loadtest users"
cmd2 := "/loadtest users fuzz"
if strings.Index(command.Command, cmd1) == 0 && !command.Suggest {
cmd := cmd1
doFuzz := false
if strings.Index(command.Command, cmd2) == 0 {
doFuzz = true
cmd = cmd2
}
usersr, err := parseRange(command.Command, cmd)
if err == false {
usersr = utils.Range{10, 15}
}
client := model.NewClient(c.GetSiteURL())
userCreator := NewAutoUserCreator(client, c.Session.TeamId)
userCreator.Fuzzy = doFuzz
userCreator.CreateTestUsers(usersr)
return true
} else if strings.Index(cmd1, command.Command) == 0 {
command.AddSuggestion(&model.SuggestCommand{Suggestion: cmd1, Description: "Add a specified number of random users to current team <Min Users> <Max Users>"})
command.AddSuggestion(&model.SuggestCommand{Suggestion: cmd2, Description: "Add a specified number of random users with fuzz text to current team <Min Users> <Max Users>"})
} else if strings.Index(cmd2, command.Command) == 0 {
command.AddSuggestion(&model.SuggestCommand{Suggestion: cmd2, Description: "Add a specified number of random users with fuzz text to current team <Min Users> <Max Users>"})
}
return false
}
func loadTestChannelsCommand(c *Context, command *model.Command) bool {
cmd1 := "/loadtest channels"
cmd2 := "/loadtest channels fuzz"
if strings.Index(command.Command, cmd1) == 0 && !command.Suggest {
cmd := cmd1
doFuzz := false
if strings.Index(command.Command, cmd2) == 0 {
doFuzz = true
cmd = cmd2
}
channelsr, err := parseRange(command.Command, cmd)
if err == false {
channelsr = utils.Range{20, 30}
}
client := model.NewClient(c.GetSiteURL())
client.MockSession(c.Session.Token)
channelCreator := NewAutoChannelCreator(client, c.Session.TeamId)
channelCreator.Fuzzy = doFuzz
channelCreator.CreateTestChannels(channelsr)
return true
} else if strings.Index(cmd1, command.Command) == 0 {
command.AddSuggestion(&model.SuggestCommand{Suggestion: cmd1, Description: "Add a specified number of random channels to current team <MinChannels> <MaxChannels>"})
command.AddSuggestion(&model.SuggestCommand{Suggestion: cmd2, Description: "Add a specified number of random channels with fuzz text to current team <Min Channels> <Max Channels>"})
} else if strings.Index(cmd2, command.Command) == 0 {
command.AddSuggestion(&model.SuggestCommand{Suggestion: cmd2, Description: "Add a specified number of random channels with fuzz text to current team <Min Channels> <Max Channels>"})
}
return false
}
func MeasurementFromSeriesKey(key string) string {
idx := strings.Index(key, ",")
if idx == -1 {
return key
}
return key[:strings.Index(key, ",")]
}
// FilenameParam groups input in two categories: URLs and files (files, directories, STDIN)
// If enforceNamespace is false, namespaces in the specs will be allowed to
// override the default namespace. If it is true, namespaces that don't match
// will cause an error.
// If ContinueOnError() is set prior to this method, objects on the path that are not
// recognized will be ignored (but logged at V(2)).
func (b *Builder) FilenameParam(enforceNamespace bool, filenameOptions *FilenameOptions) *Builder {
recursive := filenameOptions.Recursive
paths := filenameOptions.Filenames
for _, s := range paths {
switch {
case s == "-":
b.Stdin()
case strings.Index(s, "http://") == 0 || strings.Index(s, "https://") == 0:
url, err := url.Parse(s)
if err != nil {
b.errs = append(b.errs, fmt.Errorf("the URL passed to filename %q is not valid: %v", s, err))
continue
}
b.URL(defaultHttpGetAttempts, url)
default:
if !recursive {
b.singular = true
}
b.Path(recursive, s)
}
}
if enforceNamespace {
b.RequireNamespace()
}
return b
}
func combineURL(rootURL, subURL string) string {
protocolEnd := "://"
protoEndIndex := strings.Index(rootURL, protocolEnd)
a := rootURL[protoEndIndex+len(protocolEnd):]
rootIndex := strings.Index(a, "/")
return rootURL[0:protoEndIndex+len(protocolEnd)+rootIndex] + subURL
}
func sizer(originalTag string) string {
tag := originalTag
if strings.Index(tag, widthAttr) > -1 &&
strings.Index(tag, heightAttr) > -1 {
return tag // width & height attributes are already present
}
match := srcRx.FindStringSubmatch(tag)
if match == nil {
fmt.Println("can't find <img>'s src attribute", tag)
return tag
}
file, err := os.Open(match[1])
if err != nil {
fmt.Println("can't open image to read its size:", err)
return tag
}
defer file.Close()
config, _, err := image.DecodeConfig(file)
if err != nil {
fmt.Println("can't ascertain the image's size:", err)
return tag
}
tag, end := tagEnd(tag)
if strings.Index(tag, widthAttr) == -1 {
tag += fmt.Sprintf(` %s"%d"`, widthAttr, config.Width)
}
if strings.Index(tag, heightAttr) == -1 {
tag += fmt.Sprintf(` %s"%d"`, heightAttr, config.Height)
}
tag += end
return tag
}
func insertSQLClause(querySQL, clause string) string {
// get first index of any additional clause: group by, order by, limit, for update, sql end if nothing
// insert clause into the index position
sql := strings.ToLower(querySQL)
idxExtra := len(sql)
if idxGroupBy := strings.Index(sql, " group by"); idxGroupBy > 0 && idxGroupBy < idxExtra {
idxExtra = idxGroupBy
}
if idxOrderBy := strings.Index(sql, " order by"); idxOrderBy > 0 && idxOrderBy < idxExtra {
idxExtra = idxOrderBy
}
if idxLimit := strings.Index(sql, " limit"); idxLimit > 0 && idxLimit < idxExtra {
idxExtra = idxLimit
}
if idxForUpdate := strings.Index(sql, " for update"); idxForUpdate > 0 && idxForUpdate < idxExtra {
idxExtra = idxForUpdate
}
var b bytes.Buffer
b.Write([]byte(querySQL[:idxExtra]))
if strings.Contains(sql, "where") {
b.Write(kwAnd)
} else {
b.Write(kwWhere)
}
b.Write([]byte(clause))
if idxExtra < len(sql) {
b.Write([]byte(querySQL[idxExtra:]))
}
return b.String()
}
func TestPostStoreGet(t *testing.T) {
Setup()
o1 := &model.Post{}
o1.ChannelId = model.NewId()
o1.UserId = model.NewId()
o1.Message = "a" + model.NewId() + "b"
etag1 := (<-store.Post().GetEtag(o1.ChannelId)).Data.(string)
if strings.Index(etag1, model.CurrentVersion+".0.") != 0 {
t.Fatal("Invalid Etag")
}
o1 = (<-store.Post().Save(o1)).Data.(*model.Post)
etag2 := (<-store.Post().GetEtag(o1.ChannelId)).Data.(string)
if strings.Index(etag2, model.CurrentVersion+"."+o1.Id) != 0 {
t.Fatal("Invalid Etag")
}
if r1 := <-store.Post().Get(o1.Id); r1.Err != nil {
t.Fatal(r1.Err)
} else {
if r1.Data.(*model.PostList).Posts[o1.Id].CreateAt != o1.CreateAt {
t.Fatal("invalid returned post")
}
}
if err := (<-store.Post().Get("123")).Err; err == nil {
t.Fatal("Missing id should have failed")
}
}
func resolvePathObj(j *simplejson.Json, path string) *simplejson.Json {
if j == nil {
return nil
}
if idx := strings.Index(path, "["); idx > 0 {
var idx2 int
var objidx int
var err error
idx2 = strings.Index(path, "]")
if objidx, err = strconv.Atoi(path[idx+1 : strings.Index(path, "]")]); err != nil {
return nil
}
oldpath := path[0:idx]
newpath := path[idx2+2:]
return resolvePathObj(j.GetPath(oldpath).GetIndex(objidx), newpath)
} else {
if resolved := j.GetPath(path); resolved != nil {
return resolved
}
}
return nil
}
func TestStructNonStruct(t *testing.T) {
type Struct struct {
A string
}
type NonStruct string
s := Struct{"hello"}
var sp Struct
if err := encAndDec(s, &sp); err != nil {
t.Error(err)
}
var ns NonStruct
if err := encAndDec(s, &ns); err == nil {
t.Error("should get error for struct/non-struct")
} else if strings.Index(err.Error(), "type") < 0 {
t.Error("for struct/non-struct expected type error; got", err)
}
// Now try the other way
var nsp NonStruct
if err := encAndDec(ns, &nsp); err != nil {
t.Error(err)
}
if err := encAndDec(ns, &s); err == nil {
t.Error("should get error for non-struct/struct")
} else if strings.Index(err.Error(), "type") < 0 {
t.Error("for non-struct/struct expected type error; got", err)
}
}
func ComputePct100(accuracy string) int {
pct := strings.Index(accuracy, "%")
if pct > 0 {
accuracy = accuracy[0:pct]
}
dot := strings.Index(accuracy, ".")
if dot < 0 {
if n, err := strconv.Atoi(accuracy); err == nil {
return n * 100
}
return 0
}
pct100 := 0
if n, err := strconv.Atoi(accuracy[0:dot]); err == nil {
pct100 = n * 100
}
frac := accuracy[dot+1:]
if len(frac) == 1 {
if n, err := strconv.Atoi(frac); err == nil {
pct100 += n * 10
}
} else {
if len(frac) > 2 {
frac = frac[0:2]
}
if frac[0] == '0' {
frac = frac[1:]
}
if n, err := strconv.Atoi(frac); err == nil {
pct100 += n
}
}
return pct100
}
func TestGobEncoderFieldTypeError(t *testing.T) {
// GobEncoder to non-decoder: error
b := new(bytes.Buffer)
enc := NewEncoder(b)
err := enc.Encode(GobTest1{17, &StringStruct{"ABC"}})
if err != nil {
t.Fatal("encode error:", err)
}
dec := NewDecoder(b)
x := &GobTest2{}
err = dec.Decode(x)
if err == nil {
t.Fatal("expected decode error for mismatched fields (encoder to non-decoder)")
}
if strings.Index(err.Error(), "type") < 0 {
t.Fatal("expected type error; got", err)
}
// Non-encoder to GobDecoder: error
b.Reset()
err = enc.Encode(GobTest2{17, "ABC"})
if err != nil {
t.Fatal("encode error:", err)
}
y := &GobTest1{}
err = dec.Decode(y)
if err == nil {
t.Fatal("expected decode error for mismatched fields (non-encoder to decoder)")
}
if strings.Index(err.Error(), "type") < 0 {
t.Fatal("expected type error; got", err)
}
}
func (c *config) discoverSingle(glob string, m *map[string]string) error {
matches, err := filepath.Glob(glob)
if err != nil {
return err
}
if *m == nil {
*m = make(map[string]string)
}
prefix := filepath.Base(glob)
prefix = prefix[:strings.Index(prefix, "*")]
for _, match := range matches {
file := filepath.Base(match)
// If the filename has a ".", trim up to there
if idx := strings.Index(file, "."); idx >= 0 {
file = file[:idx]
}
// Look for foo-bar-baz. The plugin name is "baz"
plugin := file[len(prefix):]
log.Printf("[DEBUG] Discovered plugin: %s = %s", plugin, match)
(*m)[plugin] = match
}
return nil
}
func loadTestCommand(c *Context, command *model.Command) bool {
cmd := "/loadtest"
// This command is only available when EnableTesting is true
if !utils.Cfg.ServiceSettings.EnableTesting {
return false
}
if strings.Index(command.Command, cmd) == 0 {
if loadTestSetupCommand(c, command) {
return true
}
if loadTestUsersCommand(c, command) {
return true
}
if loadTestChannelsCommand(c, command) {
return true
}
if loadTestPostsCommand(c, command) {
return true
}
} else if strings.Index(cmd, command.Command) == 0 {
command.AddSuggestion(&model.SuggestCommand{Suggestion: cmd, Description: "Debug Load Testing"})
}
return false
}
func ContainsMoreThanOneSlashInNationalNumber(
number *PhoneNumber,
candidate string) bool {
var firstSlash = strings.Index(candidate, "/")
if firstSlash < 0 {
// No slashes, this is okay.
return false
}
// Now look for a second one.
var secondSlash = strings.Index(candidate[firstSlash+1:], "/")
if secondSlash < 0 {
// Only one slash, this is okay.
return false
}
// If the first slash is after the country calling code, this is permitted.
var candidateHasCountryCode = (number.GetCountryCodeSource() == PhoneNumber_FROM_NUMBER_WITH_PLUS_SIGN ||
number.GetCountryCodeSource() == PhoneNumber_FROM_NUMBER_WITHOUT_PLUS_SIGN)
cc := strconv.Itoa(int(number.GetCountryCode()))
if candidateHasCountryCode &&
NormalizeDigitsOnly(candidate[0:firstSlash]) == cc {
// Any more slashes and this is illegal.
return strings.Contains(candidate[secondSlash+1:], "/")
}
return true
}