func sortQuery(u *url.URL) {
q := u.Query()
if len(q) == 0 {
return
}
arKeys := make([]string, len(q))
i := 0
for k, _ := range q {
arKeys[i] = k
i++
}
sort.Strings(arKeys)
buf := new(bytes.Buffer)
for _, k := range arKeys {
sort.Strings(q[k])
for _, v := range q[k] {
if buf.Len() > 0 {
buf.WriteRune('&')
}
buf.WriteString(fmt.Sprintf("%s=%s", k, url.QueryEscape(v)))
}
}
// Rebuild the raw query string
u.RawQuery = buf.String()
}
func (s *SortField) filterTermsByMode(terms []string) string {
if len(terms) == 1 || (len(terms) > 1 && s.Mode == SortFieldDefault) {
return terms[0]
} else if len(terms) > 1 {
switch s.Mode {
case SortFieldMin:
sort.Strings(terms)
return terms[0]
case SortFieldMax:
sort.Strings(terms)
return terms[len(terms)-1]
}
}
// handle missing terms
if s.Missing == SortFieldMissingLast {
if s.Desc {
return LowTerm
}
return HighTerm
}
if s.Desc {
return HighTerm
}
return LowTerm
}
// Equal checks the equality of two resource configs.
func (c *ResourceConfig) Equal(c2 *ResourceConfig) bool {
// If either are nil, then they're only equal if they're both nil
if c == nil || c2 == nil {
return c == c2
}
// Sort the computed keys so they're deterministic
sort.Strings(c.ComputedKeys)
sort.Strings(c2.ComputedKeys)
// Two resource configs if their exported properties are equal.
// We don't compare "raw" because it is never used again after
// initialization and for all intents and purposes they are equal
// if the exported properties are equal.
check := [][2]interface{}{
{c.ComputedKeys, c2.ComputedKeys},
{c.Raw, c2.Raw},
{c.Config, c2.Config},
}
for _, pair := range check {
if !reflect.DeepEqual(pair[0], pair[1]) {
return false
}
}
return true
}
func (f *FakeRegistry) UnitStates() ([]*unit.UnitState, error) {
f.Lock()
defer f.Unlock()
states := make([]*unit.UnitState, 0)
// Sort by unit name, then by machineID
sUnitNames := make([]string, 0)
for name := range f.jobStates {
sUnitNames = append(sUnitNames, name)
}
sort.Strings(sUnitNames)
for _, name := range sUnitNames {
sMIDs := make([]string, 0)
for machineID := range f.jobStates[name] {
sMIDs = append(sMIDs, machineID)
}
sort.Strings(sMIDs)
for _, mID := range sMIDs {
states = append(states, f.jobStates[name][mID])
}
}
return states, nil
}
func modulesStr(ms []*Module) string {
result := ""
order := make([]int, 0, len(ms))
ks := make([]string, 0, len(ms))
mapping := make(map[string]int)
for i, m := range ms {
k := m.Id()
ks = append(ks, k)
mapping[k] = i
}
sort.Strings(ks)
for _, k := range ks {
order = append(order, mapping[k])
}
for _, i := range order {
m := ms[i]
result += fmt.Sprintf("%s\n", m.Id())
ks := make([]string, 0, len(m.RawConfig.Raw))
for k, _ := range m.RawConfig.Raw {
ks = append(ks, k)
}
sort.Strings(ks)
result += fmt.Sprintf(" source = %s\n", m.Source)
for _, k := range ks {
result += fmt.Sprintf(" %s\n", k)
}
}
return strings.TrimSpace(result)
}
func (r Request) String() string {
queryString := ""
if len(r.QueryParams) > 0 {
keys := make([]string, 0, len(r.QueryParams))
queryParts := make([]string, 0, len(r.QueryParams))
for k := range r.QueryParams {
keys = append(keys, k)
}
sort.Strings(keys)
for _, k := range keys {
for _, val := range r.QueryParams[k] {
queryParts = append(queryParts, fmt.Sprintf("%s=%s", k, url.QueryEscape(val)))
}
}
queryString = "?" + strings.Join(queryParts, "&")
}
var headers []string
if len(r.Headers) > 0 {
var headerKeys []string
for k := range r.Headers {
headerKeys = append(headerKeys, k)
}
sort.Strings(headerKeys)
for _, k := range headerKeys {
for _, val := range r.Headers[k] {
headers = append(headers, fmt.Sprintf("%s:%s", k, val))
}
}
}
return fmt.Sprintf("%s %s%s\n%s\n%s", r.Method, r.Route, queryString, headers, r.Body)
}
func (e *BadInterfacesError) Error() string {
inverted := make(map[string][]string)
for name, reason := range e.issues {
inverted[reason] = append(inverted[reason], name)
}
var buf bytes.Buffer
fmt.Fprintf(&buf, "snap %q has bad plugs or slots: ", e.snap)
reasons := make([]string, 0, len(inverted))
for reason := range inverted {
reasons = append(reasons, reason)
}
sort.Strings(reasons)
for _, reason := range reasons {
names := inverted[reason]
sort.Strings(names)
for i, name := range names {
if i > 0 {
buf.WriteString(", ")
}
buf.WriteString(name)
}
fmt.Fprintf(&buf, " (%s); ", reason)
}
return strings.TrimSuffix(buf.String(), "; ")
}
func Test_IterKeys(t *testing.T) {
loop := 100
expectedKeys := make([]string, loop)
m := New()
for i := 0; i < loop; i++ {
key := strconv.Itoa(i)
expectedKeys[i] = key
m.Set(key, i)
}
keys := make([]string, 0)
for key := range m.IterKeys() {
keys = append(keys, key)
}
if len(keys) != len(expectedKeys) {
t.Error("IterKeys doesn't loop the right times")
}
sort.Strings(keys)
sort.Strings(expectedKeys)
for i, v := range keys {
if v != expectedKeys[i] {
t.Error("IterKeys doesn't loop over the right keys")
}
}
}
func assertDirAtPath(root *Directory, pth string, children []string) error {
fsn, err := DirLookup(root, pth)
if err != nil {
return err
}
dir, ok := fsn.(*Directory)
if !ok {
return fmt.Errorf("%s was not a directory", pth)
}
listing, err := dir.List()
if err != nil {
return err
}
var names []string
for _, d := range listing {
names = append(names, d.Name)
}
sort.Strings(children)
sort.Strings(names)
if !compStrArrs(children, names) {
return errors.New("directories children did not match!")
}
return nil
}
func TestColumnsQuoted(t *testing.T) {
once.Do(setup)
p := new(Person)
names, err := ColumnsQuoted(p, true)
if err != nil {
t.Errorf("Error getting ColumnsQuoted: %v", err)
}
lst := []string{"id", "name", "Email", "Age", "opened", "closed", "updated", "height"}
sort.Strings(lst)
for i, orig := range lst {
lst[i] = Default.quoted(orig)
}
expected := strings.Join(lst, ",")
if len(names) != len(expected) {
t.Errorf("Length mismatch: expected %d, got %d", len(expected), len(names))
}
fields := strings.Split(names, ",")
sort.Strings(fields)
names = strings.Join(fields, ",")
if expected != names {
t.Errorf("Mismatch: expected %s, got %s", expected, names)
}
}
func sameIMMembers(a *isMasterResponse, b *isMasterResponse) bool {
if a == nil && b == nil {
return true
}
if a == nil {
a = &emptyIsMasterResponse
}
if b == nil {
b = &emptyIsMasterResponse
}
l := len(a.Hosts)
if l != len(b.Hosts) {
return false
}
aHosts := make([]string, 0, l+1)
bHosts := make([]string, 0, l+1)
for i := 0; i < l; i++ {
aHosts = append(aHosts, a.Hosts[i])
bHosts = append(bHosts, b.Hosts[i])
}
sort.Strings(aHosts)
sort.Strings(bHosts)
aHosts = append(aHosts, a.Primary)
bHosts = append(bHosts, b.Primary)
for i := range aHosts {
if aHosts[i] != bHosts[i] {
return false
}
}
return true
}
func sameRSMembers(a *replSetGetStatusResponse, b *replSetGetStatusResponse) bool {
if (a == nil || len(a.Members) == 0) && (b == nil || len(b.Members) == 0) {
return true
}
if a == nil || b == nil {
return false
}
l := len(a.Members)
if l != len(b.Members) {
return false
}
aMembers := make([]string, 0, l)
bMembers := make([]string, 0, l)
for i := 0; i < l; i++ {
aM := a.Members[i]
aMembers = append(aMembers, fmt.Sprintf("%s:%s", aM.Name, aM.State))
bM := b.Members[i]
bMembers = append(bMembers, fmt.Sprintf("%s:%s", bM.Name, bM.State))
}
sort.Strings(aMembers)
sort.Strings(bMembers)
for i := 0; i < l; i++ {
if aMembers[i] != bMembers[i] {
return false
}
}
return true
}
// 获取类型的类型信息
func GetTypeInfo(typ reflect.Type) TypeInfo {
realType := FromPtrType(typ)
switch realType.Kind() {
case reflect.Struct:
typeMemberNameList := make([]string, realType.NumField())
typeMemberInfoList := make([]TypeMemberInfo, realType.NumField())
for i := 0; i < len(typeMemberNameList); i++ {
typeMemberNameList[i] = realType.Field(i).Name
}
sort.Strings(typeMemberNameList)
for i, typeMemberName := range typeMemberNameList {
typeMember, _ := realType.FieldByName(typeMemberName)
typeMemberInfoList[i] = TypeMemberInfo{TypeMemberName: typeMember.Name, TypeMemberTypeName: typeMember.Type.String()}
}
return TypeInfo{TypeName: realType.Name(), TypeMemberInfos: typeMemberInfoList}
case reflect.Interface:
typeMemberNameList := make([]string, realType.NumMethod())
typeMemberInfoList := make([]TypeMemberInfo, realType.NumMethod())
for i := 0; i < len(typeMemberNameList); i++ {
typeMemberNameList[i] = realType.Method(i).Name
}
sort.Strings(typeMemberNameList)
for i, typeMemberName := range typeMemberNameList {
typeMember, _ := realType.MethodByName(typeMemberName)
typeMemberInfoList[i] = TypeMemberInfo{TypeMemberName: typeMember.Name, TypeMemberTypeName: typeMember.Type.String()}
}
return TypeInfo{TypeName: realType.Name(), TypeMemberInfos: typeMemberInfoList}
default:
return TypeInfo{TypeName: realType.Name()}
}
}
func search(w http.ResponseWriter, req *http.Request) {
query := req.URL.Query()
year, _ := strconv.Atoi(query.Get("year"))
actor := query.Get("actor")
genre := query.Get("genre")
page, _ := strconv.Atoi(query.Get("page"))
if page == 0 {
page = 1
}
director := query.Get("director")
movies, count, err := searchMovies(page, year, actor, genre, director)
if err != nil {
log.Println("searchMovies ", 1, err)
}
genres := []string{}
years := []string{}
for _, movie := range movies {
year := strconv.Itoa(movie.Year)
if stringInSlice(years, year) == false {
years = append(years, year)
}
filmGenres := movie.Genre
for _, genre := range filmGenres {
if stringInSlice(genres, genre) == false {
genres = append(genres, genre)
}
}
}
sort.Strings(genres)
sort.Strings(years)
cont := context{Title: "NNM-club RSS", Static: staticURL, Movies: movies, Genres: genres, Years: years, Count: count}
render(w, cont, "index")
}
func TestExplainTrace(t *testing.T) {
defer leaktest.AfterTest(t)()
s, sqlDB, _ := setup(t)
defer cleanup(s, sqlDB)
if _, err := sqlDB.Exec(`CREATE DATABASE test; CREATE TABLE test.foo (id INT PRIMARY KEY)`); err != nil {
t.Fatal(err)
}
rows, err := sqlDB.Query(`EXPLAIN (TRACE) INSERT INTO test.foo VALUES (1)`)
if err != nil {
t.Fatal(err)
}
expParts := []string{"coordinator", "node 1"}
var parts []string
pretty := rowsToStrings(rows)
for _, row := range pretty[1:] {
part := row[3] // Operation
if ind := sort.SearchStrings(parts, part); ind == len(parts) || parts[ind] != part {
parts = append(parts, part)
sort.Strings(parts)
}
}
sort.Strings(expParts)
if err := rows.Err(); err != nil {
t.Fatal(err)
}
if !reflect.DeepEqual(expParts, parts) {
t.Fatalf("expected %v, got %v\n\nResults:\n%v", expParts, parts, prettyPrint(pretty))
}
}
func TestBigItems(t *testing.T) {
var key [256]string
for i := 0; i < 256; i++ {
key[i] = "foo"
}
m := make(map[[256]string][256]string, 4)
for i := 0; i < 100; i++ {
key[37] = fmt.Sprintf("string%02d", i)
m[key] = key
}
var keys [100]string
var values [100]string
i := 0
for k, v := range m {
keys[i] = k[37]
values[i] = v[37]
i++
}
sort.Strings(keys[:])
sort.Strings(values[:])
for i := 0; i < 100; i++ {
if keys[i] != fmt.Sprintf("string%02d", i) {
t.Errorf("#%d: missing key: %v", i, keys[i])
}
if values[i] != fmt.Sprintf("string%02d", i) {
t.Errorf("#%d: missing value: %v", i, values[i])
}
}
}
func TestResolverBuildEntityIds(t *testing.T) {
shardMap := make(map[string][]interface{})
shardMap["-20"] = []interface{}{"0", 1}
shardMap["20-40"] = []interface{}{"2"}
sql := "select a from table where id=:id"
entityColName := "uid"
bindVar := make(map[string]interface{})
bindVar["id"] = 10
shards, sqls, bindVars := buildEntityIds(shardMap, sql, entityColName, bindVar)
wantShards := []string{"-20", "20-40"}
wantSqls := map[string]string{
"-20": "select a from table where id=:id and uid in (:uid0, :uid1)",
"20-40": "select a from table where id=:id and uid in (:uid0)",
}
wantBindVars := map[string]map[string]interface{}{
"-20": map[string]interface{}{"id": 10, "uid0": "0", "uid1": 1},
"20-40": map[string]interface{}{"id": 10, "uid0": "2"},
}
sort.Strings(wantShards)
sort.Strings(shards)
if !reflect.DeepEqual(wantShards, shards) {
t.Errorf("want %+v, got %+v", wantShards, shards)
}
if !reflect.DeepEqual(wantSqls, sqls) {
t.Errorf("want %+v, got %+v", wantSqls, sqls)
}
if !reflect.DeepEqual(wantBindVars, bindVars) {
t.Errorf("want %+v, got %+v", wantBindVars, bindVars)
}
}
func TestListTopics(t *testing.T) {
topicIds := []string{
"topic1",
"topic2",
"topic3",
"topic4",
"topic5",
"topic6",
}
ps := NewPubsub()
for _, id := range topicIds {
ps.OpenTopic(id, 0)
}
ps.OpenTopic("closed-topic", 0)
ps.CloseTopic("closed-topic")
outIds := ps.ListTopics()
sort.Strings(outIds)
sort.Strings(topicIds)
if assert.Equal(t, len(topicIds), len(outIds)) {
for i, id := range topicIds {
assert.Equal(t, id, outIds[i])
}
}
}
func LoadRepoConfig() {
// Load .gitignore and license files and readme templates.
types := []string{"gitignore", "license", "readme"}
typeFiles := make([][]string, 3)
for i, t := range types {
files, err := bindata.AssetDir("conf/" + t)
if err != nil {
log.Fatal(4, "Fail to get %s files: %v", t, err)
}
customPath := path.Join(setting.CustomPath, "conf", t)
if com.IsDir(customPath) {
customFiles, err := com.StatDir(customPath)
if err != nil {
log.Fatal(4, "Fail to get custom %s files: %v", t, err)
}
for _, f := range customFiles {
if !com.IsSliceContainsStr(files, f) {
files = append(files, f)
}
}
}
typeFiles[i] = files
}
Gitignores = typeFiles[0]
Licenses = typeFiles[1]
Readmes = typeFiles[2]
sort.Strings(Gitignores)
sort.Strings(Licenses)
sort.Strings(Readmes)
}
// TestList checks the returned list of keys after populating a directory tree.
func (suite *DriverSuite) TestList(c *check.C) {
rootDirectory := "/" + randomFilename(int64(8+rand.Intn(8)))
defer suite.StorageDriver.Delete(rootDirectory)
parentDirectory := rootDirectory + "/" + randomFilename(int64(8+rand.Intn(8)))
childFiles := make([]string, 50)
for i := 0; i < len(childFiles); i++ {
childFile := parentDirectory + "/" + randomFilename(int64(8+rand.Intn(8)))
childFiles[i] = childFile
err := suite.StorageDriver.PutContent(childFile, randomContents(32))
c.Assert(err, check.IsNil)
}
sort.Strings(childFiles)
keys, err := suite.StorageDriver.List("/")
c.Assert(err, check.IsNil)
c.Assert(keys, check.DeepEquals, []string{rootDirectory})
keys, err = suite.StorageDriver.List(rootDirectory)
c.Assert(err, check.IsNil)
c.Assert(keys, check.DeepEquals, []string{parentDirectory})
keys, err = suite.StorageDriver.List(parentDirectory)
c.Assert(err, check.IsNil)
sort.Strings(keys)
c.Assert(keys, check.DeepEquals, childFiles)
// A few checks to add here (check out #819 for more discussion on this):
// 1. Ensure that all paths are absolute.
// 2. Ensure that listings only include direct children.
// 3. Ensure that we only respond to directory listings that end with a slash (maybe?).
}
// assertChange asserts the given list of changes was reported by
// the watcher, but does not assume there are no following changes.
func (c StringsWatcherC) assertChange(single bool, expect ...string) {
c.State.StartSync()
timeout := time.After(testing.LongWait)
var actual []string
loop:
for {
select {
case changes, ok := <-c.Watcher.Changes():
c.Assert(ok, jc.IsTrue)
actual = append(actual, changes...)
if single || len(actual) >= len(expect) {
break loop
}
case <-timeout:
c.Fatalf("watcher did not send change")
}
}
if len(expect) == 0 {
c.Assert(actual, gc.HasLen, 0)
} else {
sort.Strings(expect)
sort.Strings(actual)
c.Assert(actual, gc.DeepEquals, expect)
}
}
func printProgram(prog *loader.Program) {
// Created packages are the initial packages specified by a call
// to CreateFromFilenames or CreateFromFiles.
var names []string
for _, info := range prog.Created {
names = append(names, info.Pkg.Path())
}
fmt.Printf("created: %s\n", names)
// Imported packages are the initial packages specified by a
// call to Import or ImportWithTests.
names = nil
for _, info := range prog.Imported {
names = append(names, info.Pkg.Path())
}
sort.Strings(names)
fmt.Printf("imported: %s\n", names)
// InitialPackages contains the union of created and imported.
names = nil
for _, info := range prog.InitialPackages() {
names = append(names, info.Pkg.Path())
}
sort.Strings(names)
fmt.Printf("initial: %s\n", names)
// AllPackages contains all initial packages and their dependencies.
names = nil
for pkg := range prog.AllPackages {
names = append(names, pkg.Path())
}
sort.Strings(names)
fmt.Printf("all: %s\n", names)
}
// sortLayer groups tasks by common dependencies, sorting alphabetically within each group
func sortLayer(layer []Task, idToDisplayName map[string]string) []Task {
sortKeys := make([]string, 0, len(layer))
sortKeyToTask := make(map[string]Task)
for _, task := range layer {
// Construct a key to sort by, consisting of all dependency names, sorted alphabetically,
// followed by the task name
sortKeyWords := make([]string, 0, len(task.DependsOn)+1)
for _, dep := range task.DependsOn {
depName, ok := idToDisplayName[dep.TaskId]
// Cross-variant dependencies will not be included in idToDisplayName
if !ok {
depName = dep.TaskId
}
sortKeyWords = append(sortKeyWords, depName)
}
sort.Strings(sortKeyWords)
sortKeyWords = append(sortKeyWords, task.DisplayName)
sortKey := strings.Join(sortKeyWords, " ")
sortKeys = append(sortKeys, sortKey)
sortKeyToTask[sortKey] = task
}
sort.Strings(sortKeys)
sortedLayer := make([]Task, 0, len(layer))
for _, sortKey := range sortKeys {
sortedLayer = append(sortedLayer, sortKeyToTask[sortKey])
}
return sortedLayer
}
func doLS(ctx context.Context, args ...string) {
switch len(args) {
default:
log.Fatalf("Can't do `cbt ls %s`", args)
case 0:
tables, err := getAdminClient().Tables(ctx)
if err != nil {
log.Fatalf("Getting list of tables: %v", err)
}
sort.Strings(tables)
for _, table := range tables {
fmt.Println(table)
}
case 1:
table := args[0]
ti, err := getAdminClient().TableInfo(ctx, table)
if err != nil {
log.Fatalf("Getting table info: %v", err)
}
sort.Strings(ti.Families)
for _, fam := range ti.Families {
fmt.Println(fam)
}
}
}
// mustContainKeys checks that a bucket contains a given set of keys.
func mustContainKeys(b *bolt.Bucket, m map[string]string) {
found := make(map[string]string)
b.ForEach(func(k, _ []byte) error {
found[string(k)] = ""
return nil
})
// Check for keys found in bucket that shouldn't be there.
var keys []string
for k, _ := range found {
if _, ok := m[string(k)]; !ok {
keys = append(keys, k)
}
}
if len(keys) > 0 {
sort.Strings(keys)
panic(fmt.Sprintf("keys found(%d): %s", len(keys), strings.Join(keys, ",")))
}
// Check for keys not found in bucket that should be there.
for k, _ := range m {
if _, ok := found[string(k)]; !ok {
keys = append(keys, k)
}
}
if len(keys) > 0 {
sort.Strings(keys)
panic(fmt.Sprintf("keys not found(%d): %s", len(keys), strings.Join(keys, ",")))
}
}
func TestGetGSResultFileLocations(t *testing.T) {
testutils.SkipIfShort(t)
storage, err := storage.New(http.DefaultClient)
assert.Nil(t, err)
startTS := time.Date(2014, time.December, 10, 0, 0, 0, 0, time.UTC).Unix()
endTS := time.Date(2014, time.December, 10, 23, 59, 59, 0, time.UTC).Unix()
// TODO(stephana): Switch this to a dedicated test bucket, so we are not
// in danger of removing it.
resultFiles, err := getGSResultsFileLocations(startTS, endTS, storage, "chromium-skia-gm", "dm-json-v1")
assert.Nil(t, err)
// Read the expected list of files and compare them.
content, err := ioutil.ReadFile("./testdata/filelist_dec_10.txt")
assert.Nil(t, err)
lines := strings.Split(strings.TrimSpace(string(content)), "\n")
sort.Strings(lines)
resultNames := make([]string, len(resultFiles))
for idx, rf := range resultFiles {
resultNames[idx] = rf.Name
}
sort.Strings(resultNames)
assert.Equal(t, len(lines), len(resultNames))
assert.Equal(t, lines, resultNames)
}
func (s *RepoSuite) AssertUnitMachines(c *gc.C, units []*state.Unit) {
tags := make([]names.UnitTag, len(units))
expectUnitNames := make([]string, len(units))
for i, u := range units {
expectUnitNames[i] = u.Name()
tags[i] = u.UnitTag()
}
// manually assign all units to machines. This replaces work normally done
// by the unitassigner code.
errs, err := s.APIState.UnitAssigner().AssignUnits(tags)
c.Assert(err, jc.ErrorIsNil)
c.Assert(errs, gc.DeepEquals, make([]error, len(units)))
sort.Strings(expectUnitNames)
machines, err := s.State.AllMachines()
c.Assert(err, jc.ErrorIsNil)
c.Assert(machines, gc.HasLen, len(units))
unitNames := []string{}
for _, m := range machines {
mUnits, err := m.Units()
c.Assert(err, jc.ErrorIsNil)
c.Assert(mUnits, gc.HasLen, 1)
unitNames = append(unitNames, mUnits[0].Name())
}
sort.Strings(unitNames)
c.Assert(unitNames, gc.DeepEquals, expectUnitNames)
}
func TestGetLocalResultFileLocations(t *testing.T) {
testutils.SkipIfShort(t)
err := testutils.DownloadTestDataArchive(t, TEST_DATA_STORAGE_PATH, TEST_DATA_DIR)
assert.Nil(t, err)
startTS := time.Date(2015, time.May, 5, 0, 0, 0, 0, time.UTC).Unix()
endTS := time.Date(2015, time.May, 17, 23, 59, 59, 0, time.UTC).Unix()
resultFiles, err := getLocalResultsFileLocations(startTS, endTS, filepath.Join(TEST_DATA_DIR, "nano-json-v1"))
assert.Nil(t, err)
// Read the expected list of files and compare them.
content, err := ioutil.ReadFile("./testdata/local_ingest_files.txt")
assert.Nil(t, err)
lines := strings.Split(strings.TrimSpace(string(content)), "\n")
sort.Strings(lines)
resultNames := make([]string, len(resultFiles))
for idx, rf := range resultFiles {
resultNames[idx] = rf.Name
}
sort.Strings(resultNames)
assert.Equal(t, len(lines), len(resultNames))
assert.Equal(t, lines, resultNames)
}
func (vs *virtualSchemaHolder) init(p *planner) error {
*vs = virtualSchemaHolder{
entries: make(map[string]virtualSchemaEntry, len(virtualSchemas)),
orderedNames: make([]string, len(virtualSchemas)),
}
for i, schema := range virtualSchemas {
dbName := schema.name
dbDesc := initVirtualDatabaseDesc(dbName)
tables := make(map[string]virtualTableEntry, len(schema.tables))
orderedTableNames := make([]string, 0, len(schema.tables))
for _, table := range schema.tables {
tableDesc, err := initVirtualTableDesc(p, table)
if err != nil {
return err
}
tables[tableDesc.Name] = virtualTableEntry{
tableDef: table,
desc: &tableDesc,
}
orderedTableNames = append(orderedTableNames, tableDesc.Name)
}
sort.Strings(orderedTableNames)
vs.entries[dbName] = virtualSchemaEntry{
desc: dbDesc,
tables: tables,
orderedTableNames: orderedTableNames,
}
vs.orderedNames[i] = dbName
}
sort.Strings(vs.orderedNames)
return nil
}
func TestTelegrafParseLine(t *testing.T) {
s := Telegraf{}
r, err := s.ParseLine("> mem,host=ubuntu available_percent=78.43483331332489,buffered=199602176i,used=1802661888i,used_percent=21.56516668667511 1469886743")
require.NoError(t, err)
assert.Len(t, r.Elements, 4)
for _, line := range r.Elements {
assert.Equal(t, line.Plugin, "telegraf.mem")
validGauges := []string{"mem_available.percent", "mem_buffered", "mem_used", "mem_used.percent"}
sort.Strings(validGauges)
i := sort.SearchStrings(validGauges, line.Gauge)
var gaugeFound = i < len(validGauges) && validGauges[i] == line.Gauge
assert.True(t, gaugeFound, "Valid Gauge Name")
}
r, err = s.ParseLine("> system,host=ubuntu load1=0.11,load15=0.06,load5=0.05,n_cpus=4i,n_users=2i,uptime=7252i 1469891972000000000")
require.NoError(t, err)
assert.Len(t, r.Elements, 6)
for _, line := range r.Elements {
assert.Equal(t, line.Plugin, "telegraf.system")
validGauges := []string{"system_load1", "system_load15", "system_load5", "system_n.cpus", "system_n.users", "system_uptime"}
sort.Strings(validGauges)
i := sort.SearchStrings(validGauges, line.Gauge)
var gaugeFound = i < len(validGauges) && validGauges[i] == line.Gauge
assert.True(t, gaugeFound, "Valid Gauge Name")
}
}