// Copyright 2015 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package main import ( "bytes" "errors" "flag" "fmt" "io/ioutil" "log" "os" "os/exec" "path/filepath" "reflect" "regexp" "runtime" "strconv" "strings" "sync" "time" ) func cmdtest() { gogcflags = os.Getenv("GO_GCFLAGS") var t tester var noRebuild bool flag.BoolVar(&t.listMode, "list", false, "list available tests") flag.BoolVar(&t.rebuild, "rebuild", false, "rebuild everything first") flag.BoolVar(&noRebuild, "no-rebuild", false, "overrides -rebuild (historical dreg)") flag.BoolVar(&t.keepGoing, "k", false, "keep going even when error occurred") flag.BoolVar(&t.race, "race", false, "run in race builder mode (different set of tests)") flag.BoolVar(&t.compileOnly, "compile-only", false, "compile tests, but don't run them. This is for some builders. Not all dist tests respect this flag, but most do.") flag.StringVar(&t.banner, "banner", "##### ", "banner prefix; blank means no section banners") flag.StringVar(&t.runRxStr, "run", os.Getenv("GOTESTONLY"), "run only those tests matching the regular expression; empty means to run all. "+ "Special exception: if the string begins with '!', the match is inverted.") xflagparse(-1) // any number of args if noRebuild { t.rebuild = false } t.run() } // tester executes cmdtest. type tester struct { race bool listMode bool rebuild bool failed bool keepGoing bool compileOnly bool // just try to compile all tests, but no need to run runRxStr string runRx *regexp.Regexp runRxWant bool // want runRx to match (true) or not match (false) runNames []string // tests to run, exclusive with runRx; empty means all banner string // prefix, or "" for none lastHeading string // last dir heading printed cgoEnabled bool partial bool haveTime bool // the 'time' binary is available tests []distTest timeoutScale int worklist []*work } type work struct { dt *distTest cmd *exec.Cmd start chan bool out []byte err error end chan bool } // A distTest is a test run by dist test. // Each test has a unique name and belongs to a group (heading) type distTest struct { name string // unique test name; may be filtered with -run flag heading string // group section; this header is printed before the test is run. fn func(*distTest) error } func (t *tester) run() { timelog("start", "dist test") var exeSuffix string if goos == "windows" { exeSuffix = ".exe" } if _, err := os.Stat(filepath.Join(gobin, "go"+exeSuffix)); err == nil { os.Setenv("PATH", fmt.Sprintf("%s%c%s", gobin, os.PathListSeparator, os.Getenv("PATH"))) } slurp, err := exec.Command("go", "env", "CGO_ENABLED").Output() if err != nil { log.Fatalf("Error running go env CGO_ENABLED: %v", err) } t.cgoEnabled, _ = strconv.ParseBool(strings.TrimSpace(string(slurp))) if flag.NArg() > 0 && t.runRxStr != "" { log.Fatalf("the -run regular expression flag is mutually exclusive with test name arguments") } t.runNames = flag.Args() if t.hasBash() { if _, err := exec.LookPath("time"); err == nil { t.haveTime = true } } if t.rebuild { t.out("Building packages and commands.") // Force rebuild the whole toolchain. goInstall("go", append([]string{"-a", "-i"}, toolchain...)...) } // Complete rebuild bootstrap, even with -no-rebuild. // If everything is up-to-date, this is a no-op. // If everything is not up-to-date, the first checkNotStale // during the test process will kill the tests, so we might // as well install the world. // Now that for example "go install cmd/compile" does not // also install runtime (you need "go install -i cmd/compile" // for that), it's easy for previous workflows like // "rebuild the compiler and then run run.bash" // to break if we don't automatically refresh things here. // Rebuilding is a shortened bootstrap. // See cmdbootstrap for a description of the overall process. if !t.listMode { goInstall("go", append([]string{"-i"}, toolchain...)...) goInstall("go", append([]string{"-i"}, toolchain...)...) goInstall("go", "std", "cmd") checkNotStale("go", "std", "cmd") } t.timeoutScale = 1 switch goarch { case "arm": t.timeoutScale = 2 case "mips", "mipsle", "mips64", "mips64le": t.timeoutScale = 4 } if s := os.Getenv("GO_TEST_TIMEOUT_SCALE"); s != "" { t.timeoutScale, err = strconv.Atoi(s) if err != nil { log.Fatalf("failed to parse $GO_TEST_TIMEOUT_SCALE = %q as integer: %v", s, err) } } if t.runRxStr != "" { if t.runRxStr[0] == '!' { t.runRxWant = false t.runRxStr = t.runRxStr[1:] } else { t.runRxWant = true } t.runRx = regexp.MustCompile(t.runRxStr) } t.registerTests() if t.listMode { for _, tt := range t.tests { fmt.Println(tt.name) } return } // We must unset GOROOT_FINAL before tests, because runtime/debug requires // correct access to source code, so if we have GOROOT_FINAL in effect, // at least runtime/debug test will fail. // If GOROOT_FINAL was set before, then now all the commands will appear stale. // Nothing we can do about that other than not checking them below. // (We call checkNotStale but only with "std" not "cmd".) os.Setenv("GOROOT_FINAL_OLD", os.Getenv("GOROOT_FINAL")) // for cmd/link test os.Unsetenv("GOROOT_FINAL") for _, name := range t.runNames { if !t.isRegisteredTestName(name) { log.Fatalf("unknown test %q", name) } } for _, dt := range t.tests { if !t.shouldRunTest(dt.name) { t.partial = true continue } dt := dt // dt used in background after this iteration if err := dt.fn(&dt); err != nil { t.runPending(&dt) // in case that hasn't been done yet t.failed = true if t.keepGoing { log.Printf("Failed: %v", err) } else { log.Fatalf("Failed: %v", err) } } } t.runPending(nil) timelog("end", "dist test") if t.failed { fmt.Println("\nFAILED") os.Exit(1) } else if t.partial { fmt.Println("\nALL TESTS PASSED (some were excluded)") } else { fmt.Println("\nALL TESTS PASSED") } } func (t *tester) shouldRunTest(name string) bool { if t.runRx != nil { return t.runRx.MatchString(name) == t.runRxWant } if len(t.runNames) == 0 { return true } for _, runName := range t.runNames { if runName == name { return true } } return false } // goTest returns the beginning of the go test command line. // Callers should use goTest and then pass flags overriding these // defaults as later arguments in the command line. func (t *tester) goTest() []string { return []string{ "go", "test", "-short", "-count=1", t.tags(), t.runFlag(""), } } func (t *tester) tags() string { if t.iOS() { return "-tags=lldb" } return "-tags=" } func (t *tester) timeout(sec int) string { return "-timeout=" + fmt.Sprint(time.Duration(sec)*time.Second*time.Duration(t.timeoutScale)) } // ranGoTest and stdMatches are state closed over by the stdlib // testing func in registerStdTest below. The tests are run // sequentially, so there's no need for locks. // // ranGoBench and benchMatches are the same, but are only used // in -race mode. var ( ranGoTest bool stdMatches []string ranGoBench bool benchMatches []string ) func (t *tester) registerStdTest(pkg string) { testName := "go_test:" + pkg if t.runRx == nil || t.runRx.MatchString(testName) == t.runRxWant { stdMatches = append(stdMatches, pkg) } timeoutSec := 180 if pkg == "cmd/go" { timeoutSec *= 2 } t.tests = append(t.tests, distTest{ name: testName, heading: "Testing packages.", fn: func(dt *distTest) error { if ranGoTest { return nil } t.runPending(dt) timelog("start", dt.name) defer timelog("end", dt.name) ranGoTest = true args := []string{ "test", "-short", t.tags(), t.timeout(timeoutSec), "-gcflags=all=" + gogcflags, } if t.race { args = append(args, "-race") } if t.compileOnly { args = append(args, "-run=^$") } args = append(args, stdMatches...) cmd := exec.Command("go", args...) cmd.Stdout = os.Stdout cmd.Stderr = os.Stderr return cmd.Run() }, }) } func (t *tester) registerRaceBenchTest(pkg string) { testName := "go_test_bench:" + pkg if t.runRx == nil || t.runRx.MatchString(testName) == t.runRxWant { benchMatches = append(benchMatches, pkg) } t.tests = append(t.tests, distTest{ name: testName, heading: "Running benchmarks briefly.", fn: func(dt *distTest) error { if ranGoBench { return nil } t.runPending(dt) timelog("start", dt.name) defer timelog("end", dt.name) ranGoBench = true args := []string{ "test", "-short", "-race", "-run=^$", // nothing. only benchmarks. "-benchtime=.1s", "-cpu=4", } if !t.compileOnly { args = append(args, "-bench=.*") } args = append(args, benchMatches...) cmd := exec.Command("go", args...) cmd.Stdout = os.Stdout cmd.Stderr = os.Stderr return cmd.Run() }, }) } // stdOutErrAreTerminals is defined in test_linux.go, to report // whether stdout & stderr are terminals. var stdOutErrAreTerminals func() bool func (t *tester) registerTests() { if strings.HasSuffix(os.Getenv("GO_BUILDER_NAME"), "-vetall") { // Run vet over std and cmd and call it quits. for k := range cgoEnabled { osarch := k t.tests = append(t.tests, distTest{ name: "vet/" + osarch, heading: "cmd/vet/all", fn: func(dt *distTest) error { t.addCmd(dt, "src/cmd/vet/all", "go", "run", "main.go", "-p="+osarch) return nil }, }) } return } // Fast path to avoid the ~1 second of `go list std cmd` when // the caller lists specific tests to run. (as the continuous // build coordinator does). if len(t.runNames) > 0 { for _, name := range t.runNames { if strings.HasPrefix(name, "go_test:") { t.registerStdTest(strings.TrimPrefix(name, "go_test:")) } if strings.HasPrefix(name, "go_test_bench:") { t.registerRaceBenchTest(strings.TrimPrefix(name, "go_test_bench:")) } } } else { // Use a format string to only list packages and commands that have tests. const format = "{{if (or .TestGoFiles .XTestGoFiles)}}{{.ImportPath}}{{end}}" cmd := exec.Command("go", "list", "-f", format) if t.race { cmd.Args = append(cmd.Args, "-tags=race") } cmd.Args = append(cmd.Args, "std") if !t.race { cmd.Args = append(cmd.Args, "cmd") } all, err := cmd.Output() if err != nil { log.Fatalf("Error running go list std cmd: %v, %s", err, all) } pkgs := strings.Fields(string(all)) for _, pkg := range pkgs { t.registerStdTest(pkg) } if t.race { for _, pkg := range pkgs { if t.packageHasBenchmarks(pkg) { t.registerRaceBenchTest(pkg) } } } } if t.race { return } // Runtime CPU tests. if !t.compileOnly { testName := "runtime:cpu124" t.tests = append(t.tests, distTest{ name: testName, heading: "GOMAXPROCS=2 runtime -cpu=1,2,4 -quick", fn: func(dt *distTest) error { cmd := t.addCmd(dt, "src", t.goTest(), t.timeout(300), "runtime", "-cpu=1,2,4", "-quick") // We set GOMAXPROCS=2 in addition to -cpu=1,2,4 in order to test runtime bootstrap code, // creation of first goroutines and first garbage collections in the parallel setting. cmd.Env = append(os.Environ(), "GOMAXPROCS=2") return nil }, }) } // This test needs its stdout/stderr to be terminals, so we don't run it from cmd/go's tests. // See issue 18153. if goos == "linux" { t.tests = append(t.tests, distTest{ name: "cmd_go_test_terminal", heading: "cmd/go terminal test", fn: func(dt *distTest) error { t.runPending(dt) timelog("start", dt.name) defer timelog("end", dt.name) if !stdOutErrAreTerminals() { fmt.Println("skipping terminal test; stdout/stderr not terminals") return nil } cmd := exec.Command("go", "test") cmd.Dir = filepath.Join(os.Getenv("GOROOT"), "src/cmd/go/testdata/testterminal18153") cmd.Stdout = os.Stdout cmd.Stderr = os.Stderr return cmd.Run() }, }) } // On the builders only, test that a moved GOROOT still works. // Fails on iOS because CC_FOR_TARGET refers to clangwrap.sh // in the unmoved GOROOT. // Fails on Android with an exec format error. // Fails on plan9 with "cannot find GOROOT" (issue #21016). if os.Getenv("GO_BUILDER_NAME") != "" && goos != "android" && !t.iOS() && goos != "plan9" { t.tests = append(t.tests, distTest{ name: "moved_goroot", heading: "moved GOROOT", fn: func(dt *distTest) error { t.runPending(dt) timelog("start", dt.name) defer timelog("end", dt.name) moved := goroot + "-moved" if err := os.Rename(goroot, moved); err != nil { if goos == "windows" { // Fails on Windows (with "Access is denied") if a process // or binary is in this directory. For instance, using all.bat // when run from c:\workdir\go\src fails here // if GO_BUILDER_NAME is set. Our builders invoke tests // a different way which happens to work when sharding // tests, but we should be tolerant of the non-sharded // all.bat case. log.Printf("skipping test on Windows") return nil } return err } // Run `go test fmt` in the moved GOROOT. // Disable GOCACHE because it points back at the old GOROOT. cmd := exec.Command(filepath.Join(moved, "bin", "go"), "test", "fmt") cmd.Stdout = os.Stdout cmd.Stderr = os.Stderr // Don't set GOROOT in the environment. for _, e := range os.Environ() { if !strings.HasPrefix(e, "GOROOT=") && !strings.HasPrefix(e, "GOCACHE=") { cmd.Env = append(cmd.Env, e) } } cmd.Env = append(cmd.Env, "GOCACHE=off") err := cmd.Run() if rerr := os.Rename(moved, goroot); rerr != nil { log.Fatalf("failed to restore GOROOT: %v", rerr) } return err }, }) } // Test that internal linking of standard packages does not // require libgcc. This ensures that we can install a Go // release on a system that does not have a C compiler // installed and still build Go programs (that don't use cgo). for _, pkg := range cgoPackages { if !t.internalLink() { break } // ARM libgcc may be Thumb, which internal linking does not support. if goarch == "arm" { break } pkg := pkg var run string if pkg == "net" { run = "TestTCPStress" } t.tests = append(t.tests, distTest{ name: "nolibgcc:" + pkg, heading: "Testing without libgcc.", fn: func(dt *distTest) error { t.addCmd(dt, "src", t.goTest(), "-ldflags=-linkmode=internal -libgcc=none", pkg, t.runFlag(run)) return nil }, }) } // Test internal linking of PIE binaries where it is supported. if goos == "linux" && goarch == "amd64" && !isAlpineLinux() { // Issue 18243: We don't have a way to set the default // dynamic linker used in internal linking mode. So // this test is skipped on Alpine. t.tests = append(t.tests, distTest{ name: "pie_internal", heading: "internal linking of -buildmode=pie", fn: func(dt *distTest) error { t.addCmd(dt, "src", t.goTest(), "reflect", "-buildmode=pie", "-ldflags=-linkmode=internal", t.timeout(60)) return nil }, }) } // sync tests t.tests = append(t.tests, distTest{ name: "sync_cpu", heading: "sync -cpu=10", fn: func(dt *distTest) error { t.addCmd(dt, "src", t.goTest(), "sync", t.timeout(120), "-cpu=10", t.runFlag("")) return nil }, }) if t.raceDetectorSupported() { t.tests = append(t.tests, distTest{ name: "race", heading: "Testing race detector", fn: t.raceTest, }) } if t.cgoEnabled && !t.iOS() { // Disabled on iOS. golang.org/issue/15919 t.tests = append(t.tests, distTest{ name: "cgo_stdio", heading: "../misc/cgo/stdio", fn: func(dt *distTest) error { t.addCmd(dt, "misc/cgo/stdio", "go", "run", filepath.Join(os.Getenv("GOROOT"), "test/run.go"), "-", ".") return nil }, }) t.tests = append(t.tests, distTest{ name: "cgo_life", heading: "../misc/cgo/life", fn: func(dt *distTest) error { t.addCmd(dt, "misc/cgo/life", "go", "run", filepath.Join(os.Getenv("GOROOT"), "test/run.go"), "-", ".") return nil }, }) fortran := os.Getenv("FC") if fortran == "" { fortran, _ = exec.LookPath("gfortran") } if t.hasBash() && fortran != "" { t.tests = append(t.tests, distTest{ name: "cgo_fortran", heading: "../misc/cgo/fortran", fn: func(dt *distTest) error { t.addCmd(dt, "misc/cgo/fortran", "./test.bash", fortran) return nil }, }) } if t.hasSwig() && goos != "android" { t.tests = append(t.tests, distTest{ name: "swig_stdio", heading: "../misc/swig/stdio", fn: func(dt *distTest) error { t.addCmd(dt, "misc/swig/stdio", t.goTest()) return nil }, }) if cxx, _ := exec.LookPath(compilerEnvLookup(defaultcxx, goos, goarch)); cxx != "" { t.tests = append(t.tests, distTest{ name: "swig_callback", heading: "../misc/swig/callback", fn: func(dt *distTest) error { t.addCmd(dt, "misc/swig/callback", t.goTest()) return nil }, }) } } } if t.cgoEnabled { t.tests = append(t.tests, distTest{ name: "cgo_test", heading: "../misc/cgo/test", fn: t.cgoTest, }) } if t.hasBash() && t.cgoEnabled && goos != "android" && goos != "darwin" { t.registerTest("testgodefs", "../misc/cgo/testgodefs", "./test.bash") } // Don't run these tests with $GO_GCFLAGS because most of them // assume that they can run "go install" with no -gcflags and not // recompile the entire standard library. If make.bash ran with // special -gcflags, that's not true. if t.cgoEnabled && gogcflags == "" { if t.cgoTestSOSupported() { t.tests = append(t.tests, distTest{ name: "testso", heading: "../misc/cgo/testso", fn: func(dt *distTest) error { return t.cgoTestSO(dt, "misc/cgo/testso") }, }) t.tests = append(t.tests, distTest{ name: "testsovar", heading: "../misc/cgo/testsovar", fn: func(dt *distTest) error { return t.cgoTestSO(dt, "misc/cgo/testsovar") }, }) } if t.supportedBuildmode("c-archive") { t.registerHostTest("testcarchive", "../misc/cgo/testcarchive", "misc/cgo/testcarchive", "carchive_test.go") } if t.supportedBuildmode("c-shared") { t.registerHostTest("testcshared", "../misc/cgo/testcshared", "misc/cgo/testcshared", "cshared_test.go") } if t.supportedBuildmode("shared") { t.registerTest("testshared", "../misc/cgo/testshared", t.goTest(), t.timeout(600)) } if t.supportedBuildmode("plugin") { t.registerTest("testplugin", "../misc/cgo/testplugin", "./test.bash") } if gohostos == "linux" && goarch == "amd64" { t.registerTest("testasan", "../misc/cgo/testasan", "go", "run", "main.go") } if goos == "linux" && goarch == "amd64" { t.registerHostTest("testsanitizers/msan", "../misc/cgo/testsanitizers", "misc/cgo/testsanitizers", ".") } if t.hasBash() && goos != "android" && !t.iOS() && gohostos != "windows" { t.registerHostTest("cgo_errors", "../misc/cgo/errors", "misc/cgo/errors", ".") } if gohostos == "linux" && t.extLink() { t.registerTest("testsigfwd", "../misc/cgo/testsigfwd", "go", "run", "main.go") } } // Doc tests only run on builders. // They find problems approximately never. if t.hasBash() && goos != "nacl" && goos != "android" && !t.iOS() && os.Getenv("GO_BUILDER_NAME") != "" { t.registerTest("doc_progs", "../doc/progs", "time", "go", "run", "run.go") t.registerTest("wiki", "../doc/articles/wiki", "./test.bash") t.registerTest("codewalk", "../doc/codewalk", "time", "./run") } if goos != "android" && !t.iOS() { t.registerTest("bench_go1", "../test/bench/go1", t.goTest(), t.timeout(600)) } if goos != "android" && !t.iOS() { // Only start multiple test dir shards on builders, // where they get distributed to multiple machines. // See issue 20141. nShards := 1 if os.Getenv("GO_BUILDER_NAME") != "" { nShards = 10 } for shard := 0; shard < nShards; shard++ { shard := shard t.tests = append(t.tests, distTest{ name: fmt.Sprintf("test:%d_%d", shard, nShards), heading: "../test", fn: func(dt *distTest) error { return t.testDirTest(dt, shard, nShards) }, }) } } if goos != "nacl" && goos != "android" && !t.iOS() { t.tests = append(t.tests, distTest{ name: "api", heading: "API check", fn: func(dt *distTest) error { if t.compileOnly { t.addCmd(dt, "src", "go", "build", filepath.Join(goroot, "src/cmd/api/run.go")) return nil } t.addCmd(dt, "src", "go", "run", filepath.Join(goroot, "src/cmd/api/run.go")) return nil }, }) } } // isRegisteredTestName reports whether a test named testName has already // been registered. func (t *tester) isRegisteredTestName(testName string) bool { for _, tt := range t.tests { if tt.name == testName { return true } } return false } func (t *tester) registerTest1(seq bool, name, dirBanner string, cmdline ...interface{}) { bin, args := flattenCmdline(cmdline) if bin == "time" && !t.haveTime { bin, args = args[0], args[1:] } if t.isRegisteredTestName(name) { panic("duplicate registered test name " + name) } t.tests = append(t.tests, distTest{ name: name, heading: dirBanner, fn: func(dt *distTest) error { if seq { t.runPending(dt) timelog("start", name) defer timelog("end", name) return t.dirCmd(filepath.Join(goroot, "src", dirBanner), bin, args).Run() } t.addCmd(dt, filepath.Join(goroot, "src", dirBanner), bin, args) return nil }, }) } func (t *tester) registerTest(name, dirBanner string, cmdline ...interface{}) { t.registerTest1(false, name, dirBanner, cmdline...) } func (t *tester) registerSeqTest(name, dirBanner string, cmdline ...interface{}) { t.registerTest1(true, name, dirBanner, cmdline...) } func (t *tester) bgDirCmd(dir, bin string, args ...string) *exec.Cmd { cmd := exec.Command(bin, args...) if filepath.IsAbs(dir) { cmd.Dir = dir } else { cmd.Dir = filepath.Join(goroot, dir) } return cmd } func (t *tester) dirCmd(dir string, cmdline ...interface{}) *exec.Cmd { bin, args := flattenCmdline(cmdline) cmd := t.bgDirCmd(dir, bin, args...) cmd.Stdout = os.Stdout cmd.Stderr = os.Stderr if vflag > 1 { errprintf("%s\n", strings.Join(cmd.Args, " ")) } return cmd } // flattenCmdline flattens a mixture of string and []string as single list // and then interprets it as a command line: first element is binary, then args. func flattenCmdline(cmdline []interface{}) (bin string, args []string) { var list []string for _, x := range cmdline { switch x := x.(type) { case string: list = append(list, x) case []string: list = append(list, x...) default: panic("invalid addCmd argument type: " + reflect.TypeOf(x).String()) } } // The go command is too picky about duplicated flags. // Drop all but the last of the allowed duplicated flags. drop := make([]bool, len(list)) have := map[string]int{} for i := 1; i < len(list); i++ { j := strings.Index(list[i], "=") if j < 0 { continue } flag := list[i][:j] switch flag { case "-run", "-tags": if have[flag] != 0 { drop[have[flag]] = true } have[flag] = i } } out := list[:0] for i, x := range list { if !drop[i] { out = append(out, x) } } list = out return list[0], list[1:] } func (t *tester) addCmd(dt *distTest, dir string, cmdline ...interface{}) *exec.Cmd { bin, args := flattenCmdline(cmdline) w := &work{ dt: dt, cmd: t.bgDirCmd(dir, bin, args...), } t.worklist = append(t.worklist, w) return w.cmd } func (t *tester) iOS() bool { return goos == "darwin" && (goarch == "arm" || goarch == "arm64") } func (t *tester) out(v string) { if t.banner == "" { return } fmt.Println("\n" + t.banner + v) } func (t *tester) extLink() bool { pair := gohostos + "-" + goarch switch pair { case "android-arm", "darwin-arm", "darwin-arm64", "dragonfly-amd64", "freebsd-386", "freebsd-amd64", "freebsd-arm", "linux-386", "linux-amd64", "linux-arm", "linux-arm64", "linux-ppc64le", "linux-mips64", "linux-mips64le", "linux-mips", "linux-mipsle", "linux-s390x", "netbsd-386", "netbsd-amd64", "openbsd-386", "openbsd-amd64", "windows-386", "windows-amd64": return true case "darwin-386", "darwin-amd64": // linkmode=external fails on OS X 10.6 and earlier == Darwin // 10.8 and earlier. unameR, err := exec.Command("uname", "-r").Output() if err != nil { log.Fatalf("uname -r: %v", err) } major, _ := strconv.Atoi(string(unameR[:bytes.IndexByte(unameR, '.')])) return major > 10 } return false } func (t *tester) internalLink() bool { if gohostos == "dragonfly" { // linkmode=internal fails on dragonfly since errno is a TLS relocation. return false } if gohostarch == "ppc64le" { // linkmode=internal fails on ppc64le because cmd/link doesn't // handle the TOC correctly (issue 15409). return false } if goos == "android" { return false } if goos == "darwin" && (goarch == "arm" || goarch == "arm64") { return false } // Internally linking cgo is incomplete on some architectures. // https://golang.org/issue/10373 // https://golang.org/issue/14449 if goarch == "arm64" || goarch == "mips64" || goarch == "mips64le" || goarch == "mips" || goarch == "mipsle" { return false } if isAlpineLinux() { // Issue 18243. return false } return true } func (t *tester) supportedBuildmode(mode string) bool { pair := goos + "-" + goarch switch mode { case "c-archive": if !t.extLink() { return false } switch pair { case "darwin-386", "darwin-amd64", "darwin-arm", "darwin-arm64", "linux-amd64", "linux-386", "linux-ppc64le", "linux-s390x", "windows-amd64", "windows-386": return true } return false case "c-shared": switch pair { case "linux-386", "linux-amd64", "linux-arm", "linux-arm64", "linux-ppc64le", "linux-s390x", "darwin-amd64", "darwin-386", "android-arm", "android-arm64", "android-386", "windows-amd64", "windows-386": return true } return false case "shared": switch pair { case "linux-386", "linux-amd64", "linux-arm", "linux-arm64", "linux-ppc64le", "linux-s390x": return true } return false case "plugin": // linux-arm64 is missing because it causes the external linker // to crash, see https://golang.org/issue/17138 switch pair { case "linux-386", "linux-amd64", "linux-arm", "linux-s390x", "linux-ppc64le": return true case "darwin-amd64": return true } return false case "pie": switch pair { case "linux-386", "linux-amd64", "linux-arm", "linux-arm64", "linux-ppc64le", "linux-s390x", "android-amd64", "android-arm", "android-arm64", "android-386": return true case "darwin-amd64": return true } return false default: log.Fatalf("internal error: unknown buildmode %s", mode) return false } } func (t *tester) registerHostTest(name, heading, dir, pkg string) { t.tests = append(t.tests, distTest{ name: name, heading: heading, fn: func(dt *distTest) error { t.runPending(dt) timelog("start", name) defer timelog("end", name) return t.runHostTest(dir, pkg) }, }) } func (t *tester) runHostTest(dir, pkg string) error { defer os.Remove(filepath.Join(goroot, dir, "test.test")) cmd := t.dirCmd(dir, t.goTest(), "-c", "-o", "test.test", pkg) cmd.Env = append(os.Environ(), "GOARCH="+gohostarch, "GOOS="+gohostos) if err := cmd.Run(); err != nil { return err } return t.dirCmd(dir, "./test.test").Run() } func (t *tester) cgoTest(dt *distTest) error { t.addCmd(dt, "misc/cgo/test", t.goTest(), "-ldflags", "-linkmode=auto") if t.internalLink() { t.addCmd(dt, "misc/cgo/test", t.goTest(), "-tags=internal", "-ldflags", "-linkmode=internal") } pair := gohostos + "-" + goarch switch pair { case "darwin-386", "darwin-amd64", "openbsd-386", "openbsd-amd64", "windows-386", "windows-amd64": // test linkmode=external, but __thread not supported, so skip testtls. if !t.extLink() { break } t.addCmd(dt, "misc/cgo/test", t.goTest(), "-ldflags", "-linkmode=external") t.addCmd(dt, "misc/cgo/test", t.goTest(), "-ldflags", "-linkmode=external -s") case "android-arm", "dragonfly-amd64", "freebsd-386", "freebsd-amd64", "freebsd-arm", "linux-386", "linux-amd64", "linux-arm", "linux-ppc64le", "linux-s390x", "netbsd-386", "netbsd-amd64": t.addCmd(dt, "misc/cgo/test", t.goTest(), "-ldflags", "-linkmode=external") t.addCmd(dt, "misc/cgo/testtls", t.goTest(), "-ldflags", "-linkmode=auto") t.addCmd(dt, "misc/cgo/testtls", t.goTest(), "-ldflags", "-linkmode=external") switch pair { case "netbsd-386", "netbsd-amd64": // no static linking case "freebsd-arm": // -fPIC compiled tls code will use __tls_get_addr instead // of __aeabi_read_tp, however, on FreeBSD/ARM, __tls_get_addr // is implemented in rtld-elf, so -fPIC isn't compatible with // static linking on FreeBSD/ARM with clang. (cgo depends on // -fPIC fundamentally.) default: cmd := t.dirCmd("misc/cgo/test", compilerEnvLookup(defaultcc, goos, goarch), "-xc", "-o", "/dev/null", "-static", "-") cmd.Stdin = strings.NewReader("int main() {}") if err := cmd.Run(); err != nil { fmt.Println("No support for static linking found (lacks libc.a?), skip cgo static linking test.") } else { if goos != "android" { t.addCmd(dt, "misc/cgo/testtls", t.goTest(), "-ldflags", `-linkmode=external -extldflags "-static -pthread"`) } t.addCmd(dt, "misc/cgo/nocgo", t.goTest()) t.addCmd(dt, "misc/cgo/nocgo", t.goTest(), "-ldflags", `-linkmode=external`) if goos != "android" { t.addCmd(dt, "misc/cgo/nocgo", t.goTest(), "-ldflags", `-linkmode=external -extldflags "-static -pthread"`) } } if t.supportedBuildmode("pie") { t.addCmd(dt, "misc/cgo/test", t.goTest(), "-buildmode=pie") t.addCmd(dt, "misc/cgo/testtls", t.goTest(), "-buildmode=pie") t.addCmd(dt, "misc/cgo/nocgo", t.goTest(), "-buildmode=pie") } } } return nil } // run pending test commands, in parallel, emitting headers as appropriate. // When finished, emit header for nextTest, which is going to run after the // pending commands are done (and runPending returns). // A test should call runPending if it wants to make sure that it is not // running in parallel with earlier tests, or if it has some other reason // for needing the earlier tests to be done. func (t *tester) runPending(nextTest *distTest) { checkNotStale("go", "std") worklist := t.worklist t.worklist = nil for _, w := range worklist { w.start = make(chan bool) w.end = make(chan bool) go func(w *work) { if !<-w.start { timelog("skip", w.dt.name) w.out = []byte(fmt.Sprintf("skipped due to earlier error\n")) } else { timelog("start", w.dt.name) w.out, w.err = w.cmd.CombinedOutput() } timelog("end", w.dt.name) w.end <- true }(w) } started := 0 ended := 0 var last *distTest for ended < len(worklist) { for started < len(worklist) && started-ended < maxbg { //println("start", started) w := worklist[started] started++ w.start <- !t.failed || t.keepGoing } w := worklist[ended] dt := w.dt if dt.heading != "" && t.lastHeading != dt.heading { t.lastHeading = dt.heading t.out(dt.heading) } if dt != last { // Assumes all the entries for a single dt are in one worklist. last = w.dt if vflag > 0 { fmt.Printf("# go tool dist test -run=^%s$\n", dt.name) } } if vflag > 1 { errprintf("%s\n", strings.Join(w.cmd.Args, " ")) } //println("wait", ended) ended++ <-w.end os.Stdout.Write(w.out) if w.err != nil { log.Printf("Failed: %v", w.err) t.failed = true } checkNotStale("go", "std") } if t.failed && !t.keepGoing { log.Fatal("FAILED") } if dt := nextTest; dt != nil { if dt.heading != "" && t.lastHeading != dt.heading { t.lastHeading = dt.heading t.out(dt.heading) } if vflag > 0 { fmt.Printf("# go tool dist test -run=^%s$\n", dt.name) } } } func (t *tester) cgoTestSOSupported() bool { if goos == "android" || t.iOS() { // No exec facility on Android or iOS. return false } if goarch == "ppc64" { // External linking not implemented on ppc64 (issue #8912). return false } if goarch == "mips64le" || goarch == "mips64" { // External linking not implemented on mips64. return false } return true } func (t *tester) cgoTestSO(dt *distTest, testpath string) error { t.runPending(dt) timelog("start", dt.name) defer timelog("end", dt.name) dir := filepath.Join(goroot, testpath) // build shared object output, err := exec.Command("go", "env", "CC").Output() if err != nil { return fmt.Errorf("Error running go env CC: %v", err) } cc := strings.TrimSuffix(string(output), "\n") if cc == "" { return errors.New("CC environment variable (go env CC) cannot be empty") } output, err = exec.Command("go", "env", "GOGCCFLAGS").Output() if err != nil { return fmt.Errorf("Error running go env GOGCCFLAGS: %v", err) } gogccflags := strings.Split(strings.TrimSuffix(string(output), "\n"), " ") ext := "so" args := append(gogccflags, "-shared") switch goos { case "darwin": ext = "dylib" args = append(args, "-undefined", "suppress", "-flat_namespace") case "windows": ext = "dll" args = append(args, "-DEXPORT_DLL") } sofname := "libcgosotest." + ext args = append(args, "-o", sofname, "cgoso_c.c") if err := t.dirCmd(dir, cc, args).Run(); err != nil { return err } defer os.Remove(filepath.Join(dir, sofname)) if err := t.dirCmd(dir, "go", "build", "-o", "main.exe", "main.go").Run(); err != nil { return err } defer os.Remove(filepath.Join(dir, "main.exe")) cmd := t.dirCmd(dir, "./main.exe") if goos != "windows" { s := "LD_LIBRARY_PATH" if goos == "darwin" { s = "DYLD_LIBRARY_PATH" } cmd.Env = append(os.Environ(), s+"=.") // On FreeBSD 64-bit architectures, the 32-bit linker looks for // different environment variables. if goos == "freebsd" && gohostarch == "386" { cmd.Env = append(cmd.Env, "LD_32_LIBRARY_PATH=.") } } return cmd.Run() } func (t *tester) hasBash() bool { switch gohostos { case "windows", "plan9": return false } return true } func (t *tester) hasSwig() bool { swig, err := exec.LookPath("swig") if err != nil { return false } // Check that swig was installed with Go support by checking // that a go directory exists inside the swiglib directory. // See https://golang.org/issue/23469. output, err := exec.Command(swig, "-go", "-swiglib").Output() if err != nil { return false } swigDir := strings.TrimSpace(string(output)) _, err = os.Stat(filepath.Join(swigDir, "go")) if err != nil { return false } // Check that swig has a new enough version. // See https://golang.org/issue/22858. out, err := exec.Command(swig, "-version").CombinedOutput() if err != nil { return false } re := regexp.MustCompile(`[vV]ersion +([\d]+)([.][\d]+)?([.][\d]+)?`) matches := re.FindSubmatch(out) if matches == nil { // Can't find version number; hope for the best. return true } major, err := strconv.Atoi(string(matches[1])) if err != nil { // Can't find version number; hope for the best. return true } if major < 3 { return false } if major > 3 { // 4.0 or later return true } // We have SWIG version 3.x. if len(matches[2]) > 0 { minor, err := strconv.Atoi(string(matches[2][1:])) if err != nil { return true } if minor > 0 { // 3.1 or later return true } } // We have SWIG version 3.0.x. if len(matches[3]) > 0 { patch, err := strconv.Atoi(string(matches[3][1:])) if err != nil { return true } if patch < 6 { // Before 3.0.6. return false } } return true } func (t *tester) raceDetectorSupported() bool { switch gohostos { case "linux", "darwin", "freebsd", "windows": // The race detector doesn't work on Alpine Linux: // golang.org/issue/14481 return t.cgoEnabled && goarch == "amd64" && gohostos == goos && !isAlpineLinux() } return false } func isAlpineLinux() bool { if runtime.GOOS != "linux" { return false } fi, err := os.Lstat("/etc/alpine-release") return err == nil && fi.Mode().IsRegular() } func (t *tester) runFlag(rx string) string { if t.compileOnly { return "-run=^$" } return "-run=" + rx } func (t *tester) raceTest(dt *distTest) error { t.addCmd(dt, "src", t.goTest(), "-race", "-i", "runtime/race", "flag", "os", "os/exec") t.addCmd(dt, "src", t.goTest(), "-race", t.runFlag("Output"), "runtime/race") t.addCmd(dt, "src", t.goTest(), "-race", t.runFlag("TestParse|TestEcho|TestStdinCloseRace|TestClosedPipeRace|TestTypeRace"), "flag", "os", "os/exec", "encoding/gob") // We don't want the following line, because it // slows down all.bash (by 10 seconds on my laptop). // The race builder should catch any error here, but doesn't. // TODO(iant): Figure out how to catch this. // t.addCmd(dt, "src", t.goTest(), "-race", "-run=TestParallelTest", "cmd/go") if t.cgoEnabled { cmd := t.addCmd(dt, "misc/cgo/test", t.goTest(), "-race") cmd.Env = append(os.Environ(), "GOTRACEBACK=2") } if t.extLink() { // Test with external linking; see issue 9133. t.addCmd(dt, "src", t.goTest(), "-race", "-ldflags=-linkmode=external", t.runFlag("TestParse|TestEcho|TestStdinCloseRace"), "flag", "os/exec") } return nil } var runtest struct { sync.Once exe string err error } func (t *tester) testDirTest(dt *distTest, shard, shards int) error { runtest.Do(func() { const exe = "runtest.exe" // named exe for Windows, but harmless elsewhere cmd := t.dirCmd("test", "go", "build", "-o", exe, "run.go") cmd.Env = append(os.Environ(), "GOOS="+gohostos, "GOARCH="+gohostarch) runtest.exe = filepath.Join(cmd.Dir, exe) if err := cmd.Run(); err != nil { runtest.err = err return } xatexit(func() { os.Remove(runtest.exe) }) }) if runtest.err != nil { return runtest.err } if t.compileOnly { return nil } t.addCmd(dt, "test", runtest.exe, fmt.Sprintf("--shard=%d", shard), fmt.Sprintf("--shards=%d", shards), ) return nil } // cgoPackages is the standard packages that use cgo. var cgoPackages = []string{ "crypto/x509", "net", "os/user", } var funcBenchmark = []byte("\nfunc Benchmark") // packageHasBenchmarks reports whether pkg has benchmarks. // On any error, it conservatively returns true. // // This exists just to eliminate work on the builders, since compiling // a test in race mode just to discover it has no benchmarks costs a // second or two per package, and this function returns false for // about 100 packages. func (t *tester) packageHasBenchmarks(pkg string) bool { pkgDir := filepath.Join(goroot, "src", pkg) d, err := os.Open(pkgDir) if err != nil { return true // conservatively } defer d.Close() names, err := d.Readdirnames(-1) if err != nil { return true // conservatively } for _, name := range names { if !strings.HasSuffix(name, "_test.go") { continue } slurp, err := ioutil.ReadFile(filepath.Join(pkgDir, name)) if err != nil { return true // conservatively } if bytes.Contains(slurp, funcBenchmark) { return true } } return false }