// 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"
"log"
"os"
"os/exec"
"path/filepath"
"regexp"
"strconv"
"strings"
"time"
)
func cmdtest() {
var t tester
flag.BoolVar(&t.listMode, "list", false, "list available tests")
flag.BoolVar(&t.noRebuild, "no-rebuild", false, "don't rebuild std and cmd packages")
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.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
t.run()
}
// tester executes cmdtest.
type tester struct {
race bool
listMode bool
noRebuild bool
keepGoing bool
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
goroot string
goarch string
gohostarch string
goos string
gohostos string
cgoEnabled bool
partial bool
haveTime bool // the 'time' binary is available
tests []distTest
timeoutScale int
}
// 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() error
}
func mustEnv(k string) string {
v := os.Getenv(k)
if v == "" {
log.Fatalf("Unset environment variable %v", k)
}
return v
}
func (t *tester) run() {
t.goroot = mustEnv("GOROOT")
t.goos = mustEnv("GOOS")
t.gohostos = mustEnv("GOHOSTOS")
t.goarch = mustEnv("GOARCH")
t.gohostarch = mustEnv("GOHOSTARCH")
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.noRebuild {
t.out("Building packages and commands.")
cmd := exec.Command("go", "install", "-a", "-v", "std", "cmd")
cmd.Stdout = os.Stdout
cmd.Stderr = os.Stderr
if err := cmd.Run(); err != nil {
log.Fatalf("building packages and commands: %v", err)
}
}
if t.iOS() {
// Install the Mach exception handler used to intercept
// EXC_BAD_ACCESS and convert it into a Go panic. This is
// necessary for a Go program running under lldb (the way
// we run tests). It is disabled by default because iOS
// apps are not allowed to access the exc_server symbol.
cmd := exec.Command("go", "install", "-a", "-tags", "lldb", "runtime/cgo")
cmd.Stdout = os.Stdout
cmd.Stderr = os.Stderr
if err := cmd.Run(); err != nil {
log.Fatalf("building mach exception handler: %v", err)
}
defer func() {
cmd := exec.Command("go", "install", "-a", "runtime/cgo")
cmd.Stdout = os.Stdout
cmd.Stderr = os.Stderr
if err := cmd.Run(); err != nil {
log.Fatalf("reverting mach exception handler: %v", err)
}
}()
}
t.timeoutScale = 1
if t.goarch == "arm" || t.goos == "windows" {
t.timeoutScale = 2
}
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.
os.Unsetenv("GOROOT_FINAL")
for _, name := range t.runNames {
if !t.isRegisteredTestName(name) {
log.Fatalf("unknown test %q", name)
}
}
var lastHeading string
ok := true
for _, dt := range t.tests {
if !t.shouldRunTest(dt.name) {
t.partial = true
continue
}
if dt.heading != "" && lastHeading != dt.heading {
lastHeading = dt.heading
t.out(dt.heading)
}
if vflag > 0 {
fmt.Printf("# go tool dist test -run=^%s$\n", dt.name)
}
if err := dt.fn(); err != nil {
ok = false
if t.keepGoing {
log.Printf("Failed: %v", err)
} else {
log.Fatalf("Failed: %v", err)
}
}
}
if !ok {
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
}
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) {
stdMatches = append(stdMatches, pkg)
}
t.tests = append(t.tests, distTest{
name: testName,
heading: "Testing packages.",
fn: func() error {
if ranGoTest {
return nil
}
ranGoTest = true
args := []string{
"test",
"-short",
t.tags(),
t.timeout(180),
"-gcflags=" + os.Getenv("GO_GCFLAGS"),
}
if t.race {
args = append(args, "-race")
}
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) {
benchMatches = append(benchMatches, pkg)
}
t.tests = append(t.tests, distTest{
name: testName,
heading: "Running benchmarks briefly.",
fn: func() error {
if ranGoBench {
return nil
}
ranGoBench = true
args := []string{
"test",
"-short",
"-race",
"-run=^$", // nothing. only benchmarks.
"-bench=.*",
"-benchtime=.1s",
"-cpu=4",
}
args = append(args, benchMatches...)
cmd := exec.Command("go", args...)
cmd.Stdout = os.Stdout
cmd.Stderr = os.Stderr
return cmd.Run()
},
})
}
func (t *tester) registerTests() {
// 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, "std")
if !t.race {
cmd.Args = append(cmd.Args, "cmd")
}
all, err := cmd.CombinedOutput()
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 {
t.registerRaceBenchTest(pkg)
}
}
}
if t.race {
return
}
// Runtime CPU tests.
testName := "runtime:cpu124"
t.tests = append(t.tests, distTest{
name: testName,
heading: "GOMAXPROCS=2 runtime -cpu=1,2,4",
fn: func() error {
cmd := t.dirCmd("src", "go", "test", "-short", t.timeout(300), t.tags(), "runtime", "-cpu=1,2,4")
// 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 = mergeEnvLists([]string{"GOMAXPROCS=2"}, os.Environ())
return cmd.Run()
},
})
// sync tests
t.tests = append(t.tests, distTest{
name: "sync_cpu",
heading: "sync -cpu=10",
fn: func() error {
return t.dirCmd("src", "go", "test", "sync", "-short", t.timeout(120), t.tags(), "-cpu=10").Run()
},
})
if t.cgoEnabled && t.goos != "android" && !t.iOS() {
// Disabled on android and iOS. golang.org/issue/8345
t.tests = append(t.tests, distTest{
name: "cgo_stdio",
heading: "../misc/cgo/stdio",
fn: func() error {
return t.dirCmd("misc/cgo/stdio",
"go", "run", filepath.Join(os.Getenv("GOROOT"), "test/run.go"), "-", ".").Run()
},
})
t.tests = append(t.tests, distTest{
name: "cgo_life",
heading: "../misc/cgo/life",
fn: func() error {
return t.dirCmd("misc/cgo/life",
"go", "run", filepath.Join(os.Getenv("GOROOT"), "test/run.go"), "-", ".").Run()
},
})
}
if t.cgoEnabled && t.goos != "android" && !t.iOS() {
// TODO(crawshaw): reenable on android and iOS
// golang.org/issue/8345
//
// These tests are not designed to run off the host.
t.tests = append(t.tests, distTest{
name: "cgo_test",
heading: "../misc/cgo/test",
fn: t.cgoTest,
})
}
if t.raceDetectorSupported() {
t.tests = append(t.tests, distTest{
name: "race",
heading: "Testing race detector",
fn: t.raceTest,
})
}
if t.hasBash() && t.cgoEnabled && t.goos != "android" && t.goos != "darwin" {
t.registerTest("testgodefs", "../misc/cgo/testgodefs", "./test.bash")
}
if t.cgoEnabled {
if t.cgoTestSOSupported() {
t.tests = append(t.tests, distTest{
name: "testso",
heading: "../misc/cgo/testso",
fn: func() error {
return t.cgoTestSO("misc/cgo/testso")
},
})
t.tests = append(t.tests, distTest{
name: "testsovar",
heading: "../misc/cgo/testsovar",
fn: func() error {
return t.cgoTestSO("misc/cgo/testsovar")
},
})
}
if t.supportedBuildmode("c-archive") {
t.registerTest("testcarchive", "../misc/cgo/testcarchive", "./test.bash")
}
if t.supportedBuildmode("c-shared") {
t.registerTest("testcshared", "../misc/cgo/testcshared", "./test.bash")
}
if t.supportedBuildmode("shared") {
t.registerTest("testshared", "../misc/cgo/testshared", "go", "test")
}
if t.gohostos == "linux" && t.goarch == "amd64" {
t.registerTest("testasan", "../misc/cgo/testasan", "go", "run", "main.go")
}
if t.hasBash() && t.goos != "android" && !t.iOS() && t.gohostos != "windows" {
t.registerTest("cgo_errors", "../misc/cgo/errors", "./test.bash")
}
if t.gohostos == "linux" && t.extLink() {
t.registerTest("testsigfwd", "../misc/cgo/testsigfwd", "go", "run", "main.go")
}
}
if t.hasBash() && t.goos != "nacl" && t.goos != "android" && !t.iOS() {
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")
t.registerTest("shootout", "../test/bench/shootout", "time", "./timing.sh", "-test")
}
if t.goos != "android" && !t.iOS() {
t.registerTest("bench_go1", "../test/bench/go1", "go", "test")
}
if t.goos != "android" && !t.iOS() {
const nShards = 5
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() error { return t.testDirTest(shard, nShards) },
})
}
}
if t.goos != "nacl" && t.goos != "android" && !t.iOS() {
t.tests = append(t.tests, distTest{
name: "api",
heading: "API check",
fn: func() error {
return t.dirCmd("src", "go", "run", filepath.Join(t.goroot, "src/cmd/api/run.go")).Run()
},
})
}
}
// 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) registerTest(name, dirBanner, bin string, args ...string) {
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() error {
return t.dirCmd(filepath.Join(t.goroot, "src", dirBanner), bin, args...).Run()
},
})
}
func (t *tester) dirCmd(dir string, bin string, args ...string) *exec.Cmd {
cmd := exec.Command(bin, args...)
if filepath.IsAbs(dir) {
cmd.Dir = dir
} else {
cmd.Dir = filepath.Join(t.goroot, dir)
}
cmd.Stdout = os.Stdout
cmd.Stderr = os.Stderr
if vflag > 1 {
errprintf("%s\n", strings.Join(cmd.Args, " "))
}
return cmd
}
func (t *tester) iOS() bool {
return t.goos == "darwin" && (t.goarch == "arm" || t.goarch == "arm64")
}
func (t *tester) out(v string) {
if t.banner == "" {
return
}
fmt.Println("\n" + t.banner + v)
}
func (t *tester) extLink() bool {
pair := t.gohostos + "-" + t.goarch
switch pair {
case "android-arm",
"darwin-arm", "darwin-arm64",
"dragonfly-386", "dragonfly-amd64",
"freebsd-386", "freebsd-amd64", "freebsd-arm",
"linux-386", "linux-amd64", "linux-arm", "linux-arm64",
"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) supportedBuildmode(mode string) bool {
pair := t.goos + "-" + t.goarch
switch mode {
case "c-archive":
if !t.extLink() {
return false
}
switch pair {
case "darwin-amd64", "darwin-arm", "darwin-arm64",
"linux-amd64", "linux-386":
return true
}
return false
case "c-shared":
// TODO(hyangah): add linux-386.
switch pair {
case "linux-amd64", "darwin-amd64", "android-arm":
return true
}
return false
case "shared":
switch pair {
case "linux-amd64":
return true
}
return false
default:
log.Fatal("internal error: unknown buildmode %s", mode)
return false
}
}
func (t *tester) cgoTest() error {
env := mergeEnvLists([]string{"GOTRACEBACK=2"}, os.Environ())
if t.goos == "android" || t.iOS() {
cmd := t.dirCmd("misc/cgo/test", "go", "test", t.tags())
cmd.Env = env
return cmd.Run()
}
cmd := t.dirCmd("misc/cgo/test", "go", "test", t.tags(), "-ldflags", "-linkmode=auto")
cmd.Env = env
if err := cmd.Run(); err != nil {
return err
}
if t.gohostos != "dragonfly" {
// linkmode=internal fails on dragonfly since errno is a TLS relocation.
cmd := t.dirCmd("misc/cgo/test", "go", "test", "-ldflags", "-linkmode=internal")
cmd.Env = env
if err := cmd.Run(); err != nil {
return err
}
}
pair := t.gohostos + "-" + t.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
}
cmd := t.dirCmd("misc/cgo/test", "go", "test", "-ldflags", "-linkmode=external")
cmd.Env = env
if err := cmd.Run(); err != nil {
return err
}
cmd = t.dirCmd("misc/cgo/test", "go", "test", "-ldflags", "-linkmode=external -s")
cmd.Env = env
if err := cmd.Run(); err != nil {
return err
}
case "android-arm",
"dragonfly-386", "dragonfly-amd64",
"freebsd-386", "freebsd-amd64", "freebsd-arm",
"linux-386", "linux-amd64", "linux-arm",
"netbsd-386", "netbsd-amd64":
cmd := t.dirCmd("misc/cgo/test", "go", "test", "-ldflags", "-linkmode=external")
cmd.Env = env
if err := cmd.Run(); err != nil {
return err
}
cmd = t.dirCmd("misc/cgo/testtls", "go", "test", "-ldflags", "-linkmode=auto")
cmd.Env = env
if err := cmd.Run(); err != nil {
return err
}
cmd = t.dirCmd("misc/cgo/testtls", "go", "test", "-ldflags", "-linkmode=external")
cmd.Env = env
if err := cmd.Run(); err != nil {
return err
}
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:
cc := mustEnv("CC")
cmd := t.dirCmd("misc/cgo/test",
cc, "-xc", "-o", "/dev/null", "-static", "-")
cmd.Env = env
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 {
cmd = t.dirCmd("misc/cgo/testtls", "go", "test", "-ldflags", `-linkmode=external -extldflags "-static -pthread"`)
cmd.Env = env
if err := cmd.Run(); err != nil {
return err
}
cmd = t.dirCmd("misc/cgo/nocgo", "go", "test")
cmd.Env = env
if err := cmd.Run(); err != nil {
return err
}
cmd = t.dirCmd("misc/cgo/nocgo", "go", "test", "-ldflags", `-linkmode=external`)
cmd.Env = env
if err := cmd.Run(); err != nil {
return err
}
cmd = t.dirCmd("misc/cgo/nocgo", "go", "test", "-ldflags", `-linkmode=external -extldflags "-static -pthread"`)
cmd.Env = env
if err := cmd.Run(); err != nil {
return err
}
}
if pair != "freebsd-amd64" { // clang -pie fails to link misc/cgo/test
cmd := t.dirCmd("misc/cgo/test",
cc, "-xc", "-o", "/dev/null", "-pie", "-")
cmd.Env = env
cmd.Stdin = strings.NewReader("int main() {}")
if err := cmd.Run(); err != nil {
fmt.Println("No support for -pie found, skip cgo PIE test.")
} else {
cmd = t.dirCmd("misc/cgo/test", "go", "test", "-ldflags", `-linkmode=external -extldflags "-pie"`)
cmd.Env = env
if err := cmd.Run(); err != nil {
return fmt.Errorf("pie cgo/test: %v", err)
}
cmd = t.dirCmd("misc/cgo/testtls", "go", "test", "-ldflags", `-linkmode=external -extldflags "-pie"`)
cmd.Env = env
if err := cmd.Run(); err != nil {
return fmt.Errorf("pie cgo/testtls: %v", err)
}
cmd = t.dirCmd("misc/cgo/nocgo", "go", "test", "-ldflags", `-linkmode=external -extldflags "-pie"`)
cmd.Env = env
if err := cmd.Run(); err != nil {
return fmt.Errorf("pie cgo/nocgo: %v", err)
}
}
}
}
}
return nil
}
func (t *tester) cgoTestSOSupported() bool {
if t.goos == "android" || t.iOS() {
// No exec facility on Android or iOS.
return false
}
if t.goarch == "ppc64le" || t.goarch == "ppc64" {
// External linking not implemented on ppc64 (issue #8912).
return false
}
return true
}
func (t *tester) cgoTestSO(testpath string) error {
dir := filepath.Join(t.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 t.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 t.goos != "windows" {
s := "LD_LIBRARY_PATH"
if t.goos == "darwin" {
s = "DYLD_LIBRARY_PATH"
}
cmd.Env = mergeEnvLists([]string{s + "=."}, os.Environ())
}
return cmd.Run()
}
func (t *tester) hasBash() bool {
switch t.gohostos {
case "windows", "plan9":
return false
}
return true
}
func (t *tester) raceDetectorSupported() bool {
switch t.gohostos {
case "linux", "darwin", "freebsd", "windows":
return t.cgoEnabled && t.goarch == "amd64" && t.gohostos == t.goos
}
return false
}
func (t *tester) raceTest() error {
if err := t.dirCmd("src", "go", "test", "-race", "-i", "runtime/race", "flag", "os/exec").Run(); err != nil {
return err
}
if err := t.dirCmd("src", "go", "test", "-race", "-run=Output", "runtime/race").Run(); err != nil {
return err
}
if err := t.dirCmd("src", "go", "test", "-race", "-short", "flag", "os/exec").Run(); err != nil {
return err
}
if t.cgoEnabled {
env := mergeEnvLists([]string{"GOTRACEBACK=2"}, os.Environ())
cmd := t.dirCmd("misc/cgo/test", "go", "test", "-race", "-short")
cmd.Env = env
if err := cmd.Run(); err != nil {
return err
}
}
if t.extLink() {
// Test with external linking; see issue 9133.
if err := t.dirCmd("src", "go", "test", "-race", "-short", "-ldflags=-linkmode=external", "flag", "os/exec").Run(); err != nil {
return err
}
}
return nil
}
func (t *tester) testDirTest(shard, shards int) error {
const runExe = "runtest.exe" // named exe for Windows, but harmless elsewhere
cmd := t.dirCmd("test", "go", "build", "-o", runExe, "run.go")
cmd.Env = mergeEnvLists([]string{"GOOS=" + t.gohostos, "GOARCH=" + t.gohostarch, "GOMAXPROCS="}, os.Environ())
if err := cmd.Run(); err != nil {
return err
}
absExe := filepath.Join(cmd.Dir, runExe)
defer os.Remove(absExe)
return t.dirCmd("test", absExe,
fmt.Sprintf("--shard=%d", shard),
fmt.Sprintf("--shards=%d", shards),
).Run()
}
// mergeEnvLists merges the two environment lists such that
// variables with the same name in "in" replace those in "out".
// out may be mutated.
func mergeEnvLists(in, out []string) []string {
NextVar:
for _, inkv := range in {
k := strings.SplitAfterN(inkv, "=", 2)[0]
for i, outkv := range out {
if strings.HasPrefix(outkv, k) {
out[i] = inkv
continue NextVar
}
}
out = append(out, inkv)
}
return out
}