func TestCycles(t *testing.T) { for _, test := range []struct { descr string ctxt *build.Context wantErr string }{ { "self-cycle", fakeContext(map[string]string{ "main": `package main; import _ "selfcycle"`, "selfcycle": `package selfcycle; import _ "selfcycle"`, }), `import cycle: selfcycle -> selfcycle`, }, { "three-package cycle", fakeContext(map[string]string{ "main": `package main; import _ "a"`, "a": `package a; import _ "b"`, "b": `package b; import _ "c"`, "c": `package c; import _ "a"`, }), `import cycle: c -> a -> b -> c`, }, { "self-cycle in dependency of test file", buildutil.FakeContext(map[string]map[string]string{ "main": { "main.go": `package main`, "main_test.go": `package main; import _ "a"`, }, "a": { "a.go": `package a; import _ "a"`, }, }), `import cycle: a -> a`, }, // TODO(adonovan): fix: these fail // { // "two-package cycle in dependency of test file", // buildutil.FakeContext(map[string]map[string]string{ // "main": { // "main.go": `package main`, // "main_test.go": `package main; import _ "a"`, // }, // "a": { // "a.go": `package a; import _ "main"`, // }, // }), // `import cycle: main -> a -> main`, // }, // { // "self-cycle in augmented package", // buildutil.FakeContext(map[string]map[string]string{ // "main": { // "main.go": `package main`, // "main_test.go": `package main; import _ "main"`, // }, // }), // `import cycle: main -> main`, // }, } { conf := loader.Config{ AllowErrors: true, SourceImports: true, Build: test.ctxt, } var mu sync.Mutex var allErrors []error conf.TypeChecker.Error = func(err error) { mu.Lock() allErrors = append(allErrors, err) mu.Unlock() } conf.ImportWithTests("main") prog, err := conf.Load() if err != nil { t.Errorf("%s: Load failed: %s", test.descr, err) } if prog == nil { t.Fatalf("%s: Load returned nil *Program", test.descr) } if !hasError(allErrors, test.wantErr) { t.Errorf("%s: Load() errors = %q, want %q", test.descr, allErrors, test.wantErr) } } // TODO(adonovan): // - Test that in a legal test cycle, none of the symbols // defined by augmentation are visible via import. }
func TestStdlib(t *testing.T) { runtime.GC() t0 := time.Now() var memstats runtime.MemStats runtime.ReadMemStats(&memstats) alloc := memstats.Alloc // Load, parse and type-check the program. ctxt := build.Default // copy ctxt.GOPATH = "" // disable GOPATH conf := loader.Config{Build: &ctxt} for _, path := range buildutil.AllPackages(conf.Build) { if err := conf.ImportWithTests(path); err != nil { t.Error(err) } } prog, err := conf.Load() if err != nil { t.Fatalf("Load failed: %v", err) } t1 := time.Now() runtime.GC() runtime.ReadMemStats(&memstats) numPkgs := len(prog.AllPackages) if want := 205; numPkgs < want { t.Errorf("Loaded only %d packages, want at least %d", numPkgs, want) } // Dump package members. if false { for pkg := range prog.AllPackages { fmt.Printf("Package %s:\n", pkg.Path()) scope := pkg.Scope() for _, name := range scope.Names() { if ast.IsExported(name) { fmt.Printf("\t%s\n", types.ObjectString(pkg, scope.Lookup(name))) } } fmt.Println() } } // Check that Test functions for io/ioutil, regexp and // compress/bzip2 are all simultaneously present. // (The apparent cycle formed when augmenting all three of // these packages by their tests was the original motivation // for reporting b/7114.) // // compress/bzip2.TestBitReader in bzip2_test.go imports io/ioutil // io/ioutil.TestTempFile in tempfile_test.go imports regexp // regexp.TestRE2Search in exec_test.go imports compress/bzip2 for _, test := range []struct{ pkg, fn string }{ {"io/ioutil", "TestTempFile"}, {"regexp", "TestRE2Search"}, {"compress/bzip2", "TestBitReader"}, } { info := prog.Imported[test.pkg] if info == nil { t.Errorf("failed to load package %q", test.pkg) continue } obj, _ := info.Pkg.Scope().Lookup(test.fn).(*types.Func) if obj == nil { t.Errorf("package %q has no func %q", test.pkg, test.fn) continue } } // Dump some statistics. // determine line count var lineCount int prog.Fset.Iterate(func(f *token.File) bool { lineCount += f.LineCount() return true }) t.Log("GOMAXPROCS: ", runtime.GOMAXPROCS(0)) t.Log("#Source lines: ", lineCount) t.Log("Load/parse/typecheck: ", t1.Sub(t0)) t.Log("#MB: ", int64(memstats.Alloc-alloc)/1000000) }