예제 #1
0
func check(t *testing.T, b *bytes.Buffer, expected []event) {
	actual := &traceFile{}
	ut.AssertEqual(t, nil, json.Unmarshal(b.Bytes(), actual))
	// Zap out .Timestamp since it is not deterministic. Convert Duration to
	// binary value, either 0 or 1 since it's value is either set or not set.
	for i := range actual.Events {
		ut.AssertEqual(t, true, actual.Events[i].Timestamp >= 0)
		actual.Events[i].Timestamp = 0
		if actual.Events[i].Duration != 0 {
			actual.Events[i].Duration = 1
		}
	}
	for i := range expected {
		if expected[i].Pid == 0 {
			expected[i].Pid = 1
		}
		if expected[i].Tid == 0 {
			expected[i].Tid = 1
		}
	}
	wd, _ := os.Getwd()
	e := &traceFile{traceContext{os.Args, wd}, expected}
	ut.AssertEqual(t, e.Context, actual.Context)
	ut.AssertEqual(t, e.Events, actual.Events)
	ut.AssertEqual(t, e, actual)
}
예제 #2
0
func TestParseDumpAsm(t *testing.T) {
	data := []string{
		"panic: reflect.Set: value of type",
		"",
		"goroutine 16 [garbage collection]:",
		"runtime.switchtoM()",
		"\t" + goroot + "/src/runtime/asm_amd64.s:198 fp=0xc20cfb80d8 sp=0xc20cfb80d0",
		"",
	}
	extra := &bytes.Buffer{}
	goroutines, err := ParseDump(bytes.NewBufferString(strings.Join(data, "\n")), extra)
	ut.AssertEqual(t, nil, err)
	expected := []Goroutine{
		{
			Signature: Signature{
				State: "garbage collection",
				Stack: []Call{
					{
						SourcePath: goroot + "/src/runtime/asm_amd64.s",
						Line:       198,
						Func:       Function{Raw: "runtime.switchtoM"},
					},
				},
			},
			ID:    16,
			First: true,
		},
	}
	ut.AssertEqual(t, expected, goroutines)
	ut.AssertEqual(t, "panic: reflect.Set: value of type\n\n", extra.String())
}
예제 #3
0
func testNodesTableImpl(t testing.TB, cas CasTable, nodes NodesTable) {
	items, err := EnumerateNodesAsList(nodes)
	ut.AssertEqual(t, nil, err)
	ut.AssertEqual(t, []string{}, items)

	tree1 := map[string]string{
		"file1":           "content1",
		"dir1/dir2/file2": "content2",
	}
	archiveData(t, cas, nodes, tree1)
	items, err = EnumerateNodesAsList(nodes)
	ut.AssertEqual(t, nil, err)
	ut.AssertEqual(t, 2, len(items))
	name := strings.Replace(items[0], string(filepath.Separator), "/", -1)

	body := request(t, nodes, "/", 200, "")
	ut.AssertEqual(t, 2, strings.Count(body, "<a "))
	request(t, nodes, "/foo", 404, "")
	request(t, nodes, "/foo/", 404, "")
	request(t, nodes, "/"+name, 301, "")
	request(t, nodes, "/"+name+"/", 200, "")
	request(t, nodes, "/"+name+"/file1", 200, "content1")
	request(t, nodes, "/"+name+"/dir1/dir2/file2", 200, "content2")
	request(t, nodes, "/"+name+"/dir1/dir2/file3", 404, "")
	request(t, nodes, "/"+name+"/dir1/dir2", 301, "")
}
예제 #4
0
func TestDoRetryExceeded(t *testing.T) {
	c := &Config{1, 0, 0, 0}
	r := &retriable{errs: []error{errRetry}}
	ut.AssertEqual(t, errRetry, c.Do(r))
	ut.AssertEqual(t, 1, r.closed)
	ut.AssertEqual(t, 1, r.tries)
}
예제 #5
0
func TestDoRetry(t *testing.T) {
	c := &Config{2, 0, time.Millisecond, 0}
	r := &retriable{errs: []error{errRetry}}
	ut.AssertEqual(t, nil, c.Do(r))
	ut.AssertEqual(t, 1, r.closed)
	ut.AssertEqual(t, 2, r.tries)
}
예제 #6
0
func TestDoOnce(t *testing.T) {
	c := &Config{1, 0, 0, 0}
	r := &retriable{}
	ut.AssertEqual(t, nil, c.Do(r))
	ut.AssertEqual(t, 1, r.closed)
	ut.AssertEqual(t, 1, r.tries)
}
예제 #7
0
func TestParseDumpUnavail(t *testing.T) {
	data := []string{
		"panic: reflect.Set: value of type",
		"",
		"goroutine 24 [running]:",
		"\tgoroutine running on other thread; stack unavailable",
		"created by github.com/foo.New",
		"\t/gopath/src/github.com/foo/bar.go:131 +0x381",
		"",
	}
	extra := &bytes.Buffer{}
	goroutines, err := ParseDump(bytes.NewBufferString(strings.Join(data, "\n")), extra)
	ut.AssertEqual(t, nil, err)
	expected := []Goroutine{
		{
			Signature: Signature{
				State: "running",
				Stack: []Call{
					{
						SourcePath: "<unavailable>",
					},
				},
				CreatedBy: Call{
					SourcePath: "/gopath/src/github.com/foo/bar.go",
					Line:       131,
					Func:       Function{Raw: "github.com/foo.New"},
				},
			},
			ID:    24,
			First: true,
		},
	}
	ut.AssertEqual(t, expected, goroutines)
	ut.AssertEqual(t, "panic: reflect.Set: value of type\n\n", extra.String())
}
예제 #8
0
func TestChangIgnore(t *testing.T) {
	t.Parallel()
	c := newChange(&dummyRepo{t, "<root>"}, nil, nil, IgnorePatterns{"*.pb.go"})
	ut.AssertEqual(t, false, c.IsIgnored("foo.go"))
	ut.AssertEqual(t, true, c.IsIgnored("foo.pb.go"))
	ut.AssertEqual(t, true, c.IsIgnored("bar/foo.pb.go"))
}
예제 #9
0
func testCacheImpl(t testing.TB, load func() (Cache, error)) {
	now := time.Now().UTC().Unix()
	{
		c, err := load()
		ut.AssertEqual(t, nil, err)
		if c.Root().CountMembers() != 1 {
			c.Root().Print(os.Stderr, "")
			t.Fatalf("Oops: %d", c.Root().CountMembers())
		}
		if c.Root().Files != nil {
			c.Root().Print(os.Stderr, "")
			t.Fatalf("Oops: %d", c.Root().CountMembers())
		}
		i := FindInCache(c, filepath.Join("foo", "bar"))
		i.Sha1 = "x"
		i.Size = 1
		i.Timestamp = 2
		i.LastTested = now
		c.Close()
	}
	{
		c, err := load()
		ut.AssertEqual(t, nil, err)
		b := &bytes.Buffer{}
		c.Root().Print(b, "")
		ut.AssertEqual(t, "- 'foo'\n  - 'bar'\n    Sha1: x\n    Size: 1\n", b.String())
		foo := c.Root().Files["foo"]
		bar := foo.Files["bar"]
		if bar.Sha1 != "x" || bar.Size != 1 || bar.Timestamp != 2 || bar.LastTested != now {
			t.Fatalf("Oops: %d", c.Root().CountMembers())
		}
		c.Close()
	}
}
예제 #10
0
func TestParseDumpNoOffset(t *testing.T) {
	data := []string{
		"panic: runtime error: index out of range",
		"",
		"goroutine 37 [runnable]:",
		"github.com/foo.func·002()",
		"	/gopath/src/github.com/foo/bar.go:110",
		"created by github.com/foo.New",
		"	/gopath/src/github.com/foo/bar.go:113 +0x43b",
	}
	goroutines, err := ParseDump(bytes.NewBufferString(strings.Join(data, "\n")), &bytes.Buffer{})
	ut.AssertEqual(t, nil, err)
	expectedGR := []Goroutine{
		{
			Signature: Signature{
				State: "runnable",
				Stack: []Call{
					{
						SourcePath: "/gopath/src/github.com/foo/bar.go",
						Line:       110,
						Func:       Function{"github.com/foo.func·002"},
					},
				},
				CreatedBy: Call{
					SourcePath: "/gopath/src/github.com/foo/bar.go",
					Line:       113,
					Func:       Function{"github.com/foo.New"},
				},
			},
			ID:    37,
			First: true,
		},
	}
	ut.AssertEqual(t, expectedGR, goroutines)
}
예제 #11
0
func TestInstalledApp(t *testing.T) {
	i := &InstalledApp{
		ClientID:         "C",
		ClientSecret:     "S",
		AuthURL:          "http://localhost/auth",
		TokenURL:         "http://localhost/token",
		ScopedTokenCache: make(map[string]*TokenCache),
	}
	tokReply := `{"access_token":"a", "refresh_token": "r", "id_token": "i"}`
	resp := []*http.Response{
		{StatusCode: 200, Body: asReader(tokReply)},
	}
	r := &roundTripperStub{[]*http.Request{}, resp}
	prompt := func(string) string {
		return "auth"
	}
	_, err := i.GetClientPrompt("scope", r, prompt)
	ut.AssertEqual(t, nil, err)
	ut.AssertEqual(t, 1, len(r.requests))
	i.Lock()
	defer i.Unlock()
	ut.AssertEqual(t, true, i.ShouldSave())
	i.ClearDirtyBit()
	ut.AssertEqual(t, false, i.ShouldSave())
}
예제 #12
0
func TestRound(t *testing.T) {
	t.Parallel()
	ut.AssertEqual(t, 1500*time.Millisecond, round(1549*time.Millisecond, 100*time.Millisecond))
	ut.AssertEqual(t, 1600*time.Millisecond, round(1550*time.Millisecond, 100*time.Millisecond))
	ut.AssertEqual(t, -1500*time.Millisecond, round(-1549*time.Millisecond, 100*time.Millisecond))
	ut.AssertEqual(t, -1600*time.Millisecond, round(-1550*time.Millisecond, 100*time.Millisecond))
}
예제 #13
0
func TestCartesianProductOfValues(t *testing.T) {
	t.Parallel()
	set := func(vs ...string) map[variableValueKey]variableValue {
		out := map[variableValueKey]variableValue{}
		for _, v := range makeVVs(vs...) {
			out[v.key()] = v
		}
		return out
	}
	test := func(vvs variablesValuesSet, keys []string, expected ...[]variableValue) {
		res, err := vvs.cartesianProductOfValues(keys)
		ut.AssertEqual(t, nil, err)
		vvSort(expected)
		vvSort(res)
		ut.AssertEqual(t, vvToStr2D(expected), vvToStr2D(res))
	}
	keys := func(vs ...string) []string { return vs }

	vvs := variablesValuesSet{}
	test(vvs, keys())

	vvs["OS"] = set("win", "unbound")
	test(vvs, keys("OS"), makeVVs("win"), makeVVs("unbound"))

	vvs["bit"] = set("32")

	test(vvs, keys("OS"), makeVVs("win"), makeVVs("unbound")) // bit var name must be ignored.
	test(vvs, keys("bit", "OS"), makeVVs("32", "win"), makeVVs("32", "unbound"))
}
예제 #14
0
func TestRestore(t *testing.T) {
	t.Parallel()
	f := makeDumbcasAppMock(t)
	// Force the creation of CAS and NodesTable so content can be archived in
	// memory before running the command.
	_, _ = f.MakeCasTable("")
	_, _ = f.LoadNodesTable("", f.cas)

	// Create an archive.
	tree := map[string]string{
		"dir1/bar":           "bar\n",
		"dir1/dir2/dir3/foo": "foo\n",
		"dir1/dir2/file2":    "content2",
		"file1":              "content1",
		"x":                  "x\n",
	}
	_, nodeName, _ := archiveData(f.TB, f.cas, f.nodes, tree)

	tempData := makeTempDir(t, "restore")
	defer removeDir(t, tempData)

	args := []string{"restore", "-root=\\test_archive", "-out=" + tempData, nodeName}
	f.Run(args, 0)
	f.CheckBuffer(true, false)

	actualTree, err := readTree(tempData)
	ut.AssertEqual(t, nil, err)
	ut.AssertEqual(t, tree, actualTree)
}
예제 #15
0
func TestConfigYAMLBadMode(t *testing.T) {
	data, err := yaml.Marshal("foo")
	ut.AssertEqual(t, nil, err)
	v := PreCommit
	ut.AssertEqual(t, errors.New("invalid mode \"foo\""), yaml.Unmarshal(data, &v))
	ut.AssertEqual(t, PreCommit, v)
}
예제 #16
0
func TestCancelable(t *testing.T) {
	t.Parallel()
	c := newCanceler()
	ut.AssertEqual(t, nil, c.CancelationReason())
	select {
	case <-c.Channel():
		t.FailNow()
	default:
	}

	wg := sync.WaitGroup{}
	wg.Add(1)
	go func() {
		defer wg.Done()
		select {
		case err, isCanceled := <-c.Channel():
			ut.ExpectEqualf(t, true, isCanceled, "Closed, but shouldn't be.")
			ut.ExpectEqual(t, ErrCanceled, err)
		}
	}()
	c.Cancel(nil)
	ut.AssertEqual(t, ErrCanceled, c.CancelationReason())
	t.Log("waiting for goroutine above to end.")
	wg.Wait()
	ut.AssertEqual(t, nil, c.Close())
	assertClosed(t, c)
}
예제 #17
0
func setup(t *testing.T, tmpDir string) {
	_, code, err := internal.Capture(tmpDir, nil, "git", "init")
	ut.AssertEqual(t, 0, code)
	ut.AssertEqual(t, nil, err)
	run(t, tmpDir, nil, "config", "user.email", "nobody@localhost")
	run(t, tmpDir, nil, "config", "user.name", "nobody")
}
예제 #18
0
func TestFunctionAnonymous(t *testing.T) {
	f := Function{"main.func·001"}
	ut.AssertEqual(t, "main.func·001", f.String())
	ut.AssertEqual(t, "main.func·001", f.PkgDotName())
	ut.AssertEqual(t, "func·001", f.Name())
	ut.AssertEqual(t, "main", f.PkgName())
	ut.AssertEqual(t, false, f.IsExported())
}
예제 #19
0
func TestCaptureOne(t *testing.T) {
	t.Parallel()
	wd, err := os.Getwd()
	ut.AssertEqual(t, nil, err)
	_, code, err := Capture(wd, nil, "go")
	ut.AssertEqual(t, 2, code)
	ut.AssertEqual(t, nil, err)
}
예제 #20
0
func TestFunctionGC(t *testing.T) {
	f := Function{"gc"}
	ut.AssertEqual(t, "gc", f.String())
	ut.AssertEqual(t, "gc", f.PkgDotName())
	ut.AssertEqual(t, "gc", f.Name())
	ut.AssertEqual(t, "", f.PkgName())
	ut.AssertEqual(t, false, f.IsExported())
}
예제 #21
0
func TestCacheNormal(t *testing.T) {
	// Just makes sure loading the real cache doesn't crash.
	t.Parallel()
	cache, err := LoadCache()
	ut.AssertEqual(t, nil, err)
	defer cache.Close()
	ut.AssertEqual(t, false, nil == cache.Root())
}
예제 #22
0
func TestConfigYAML(t *testing.T) {
	config := New("0.1")
	data, err := yaml.Marshal(config)
	ut.AssertEqual(t, nil, err)
	actual := &Config{}
	ut.AssertEqual(t, nil, yaml.Unmarshal(data, actual))
	ut.AssertEqual(t, config, actual)
}
예제 #23
0
파일: gc_test.go 프로젝트: maruel/dumbcas
func TestGcEmpty(t *testing.T) {
	t.Parallel()
	f := makeDumbcasAppMock(t)
	args := []string{"gc", "-root=\\test_gc_empty"}
	f.Run(args, 0)
	i, err := dumbcaslib.EnumerateCasAsList(f.cas)
	ut.AssertEqual(t, nil, err)
	ut.AssertEqual(t, []string{}, i)
}
예제 #24
0
func TestCancelableDoubleCloseAndCancel(t *testing.T) {
	t.Parallel()
	errReason := errors.New("reason")
	c := newCanceler()
	ut.AssertEqual(t, nil, c.Close())
	ut.AssertEqual(t, nil, c.Close())
	c.Cancel(errReason)
	ut.AssertEqual(t, errReason, c.CancelationReason())
}
예제 #25
0
func TestCaptureNormal(t *testing.T) {
	t.Parallel()
	wd, err := os.Getwd()
	ut.AssertEqual(t, nil, err)
	out, code, err := Capture(wd, []string{"FOO=BAR"}, "go", "version")
	ut.AssertEqual(t, true, strings.Contains(out, runtime.Version()))
	ut.AssertEqual(t, 0, code)
	ut.AssertEqual(t, nil, err)
}
예제 #26
0
func TestCaptureEmpty(t *testing.T) {
	t.Parallel()
	wd, err := os.Getwd()
	ut.AssertEqual(t, nil, err)
	out, code, err := Capture(wd, nil)
	ut.AssertEqual(t, "", out)
	ut.AssertEqual(t, -1, code)
	ut.AssertEqual(t, errors.New("no command specified"), err)
}
예제 #27
0
func TestCaptureMissing(t *testing.T) {
	t.Parallel()
	wd, err := os.Getwd()
	ut.AssertEqual(t, nil, err)
	out, code, err := Capture(wd, nil, "program_is_non_existent")
	ut.AssertEqual(t, "", out)
	ut.AssertEqual(t, -1, code)
	ut.AssertEqual(t, true, err != nil)
}
예제 #28
0
func TestLoadIsolateAsConfig(t *testing.T) {
	t.Parallel()
	root := "/dir"
	if common.IsWindows() {
		root = "x:\\dir"
	}
	isolate, err := LoadIsolateAsConfig(root, []byte(sampleIsolateData))
	ut.AssertEqual(t, nil, err)
	ut.AssertEqual(t, []string{"OS", "bit"}, isolate.ConfigVariables)
}
예제 #29
0
func TestIsolateServerBadURL(t *testing.T) {
	t.Parallel()
	if testing.Short() {
		t.SkipNow()
	}
	client := newIsolateServer("http://asdfad.nonexistent", "default-gzip", fastRetry)
	caps, err := client.ServerCapabilities()
	ut.AssertEqual(t, (*isolated.ServerCapabilities)(nil), caps)
	ut.AssertEqual(t, true, err != nil)
}
예제 #30
0
func TestArchiverEmpty(t *testing.T) {
	t.Parallel()
	a := New(isolatedclient.New("https://localhost:1", "default-gzip"), nil)
	stats := a.Stats()
	ut.AssertEqual(t, 0, stats.TotalHits())
	ut.AssertEqual(t, 0, stats.TotalMisses())
	ut.AssertEqual(t, common.Size(0), stats.TotalBytesHits())
	ut.AssertEqual(t, common.Size(0), stats.TotalBytesPushed())
	ut.AssertEqual(t, nil, a.Close())
}