| // skip |
| |
| // Copyright 2012 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. |
| |
| // Run runs tests in the test directory. |
| package main |
| |
| import ( |
| "bytes" |
| "encoding/json" |
| "errors" |
| "flag" |
| "fmt" |
| "go/build" |
| "hash/fnv" |
| "io" |
| "io/fs" |
| "io/ioutil" |
| "log" |
| "os" |
| "os/exec" |
| "path" |
| "path/filepath" |
| "regexp" |
| "runtime" |
| "sort" |
| "strconv" |
| "strings" |
| "time" |
| "unicode" |
| ) |
| |
| // CompilerDefaultGLevel is the -G level used by default when not overridden by a |
| // command-line flag |
| const CompilerDefaultGLevel = 3 |
| |
| var ( |
| verbose = flag.Bool("v", false, "verbose. if set, parallelism is set to 1.") |
| keep = flag.Bool("k", false, "keep. keep temporary directory.") |
| numParallel = flag.Int("n", runtime.NumCPU(), "number of parallel tests to run") |
| summary = flag.Bool("summary", false, "show summary of results") |
| allCodegen = flag.Bool("all_codegen", defaultAllCodeGen(), "run all goos/goarch for codegen") |
| showSkips = flag.Bool("show_skips", false, "show skipped tests") |
| runSkips = flag.Bool("run_skips", false, "run skipped tests (ignore skip and build tags)") |
| linkshared = flag.Bool("linkshared", false, "") |
| updateErrors = flag.Bool("update_errors", false, "update error messages in test file based on compiler output") |
| runoutputLimit = flag.Int("l", defaultRunOutputLimit(), "number of parallel runoutput tests to run") |
| force = flag.Bool("f", false, "ignore expected-failure test lists") |
| generics = flag.String("G", defaultGLevels, "a comma-separated list of -G compiler flags to test with") |
| |
| shard = flag.Int("shard", 0, "shard index to run. Only applicable if -shards is non-zero.") |
| shards = flag.Int("shards", 0, "number of shards. If 0, all tests are run. This is used by the continuous build.") |
| ) |
| |
| type envVars struct { |
| GOOS string |
| GOARCH string |
| GOEXPERIMENT string |
| CGO_ENABLED string |
| } |
| |
| var env = func() (res envVars) { |
| cmd := exec.Command("go", "env", "-json") |
| stdout, err := cmd.StdoutPipe() |
| if err != nil { |
| log.Fatal("StdoutPipe:", err) |
| } |
| if err := cmd.Start(); err != nil { |
| log.Fatal("Start:", err) |
| } |
| if err := json.NewDecoder(stdout).Decode(&res); err != nil { |
| log.Fatal("Decode:", err) |
| } |
| if err := cmd.Wait(); err != nil { |
| log.Fatal("Wait:", err) |
| } |
| return |
| }() |
| |
| var unifiedEnabled, defaultGLevels = func() (bool, string) { |
| // TODO(mdempsky): This will give false negatives if the unified |
| // experiment is enabled by default, but presumably at that point we |
| // won't need to disable tests for it anymore anyway. |
| enabled := strings.Contains(","+env.GOEXPERIMENT+",", ",unified,") |
| |
| // Normal test runs should test with both -G=0 and -G=3 for types2 |
| // coverage. But the unified experiment always uses types2, so |
| // testing with -G=3 is redundant. |
| glevels := "0,3" |
| if enabled { |
| glevels = "0" |
| } |
| |
| return enabled, glevels |
| }() |
| |
| // defaultAllCodeGen returns the default value of the -all_codegen |
| // flag. By default, we prefer to be fast (returning false), except on |
| // the linux-amd64 builder that's already very fast, so we get more |
| // test coverage on trybots. See https://golang.org/issue/34297. |
| func defaultAllCodeGen() bool { |
| return os.Getenv("GO_BUILDER_NAME") == "linux-amd64" |
| } |
| |
| var ( |
| goos = env.GOOS |
| goarch = env.GOARCH |
| cgoEnabled, _ = strconv.ParseBool(env.CGO_ENABLED) |
| |
| // dirs are the directories to look for *.go files in. |
| // TODO(bradfitz): just use all directories? |
| dirs = []string{".", "ken", "chan", "interface", "syntax", "dwarf", "fixedbugs", "codegen", "runtime", "abi", "typeparam", "typeparam/mdempsky"} |
| |
| // ratec controls the max number of tests running at a time. |
| ratec chan bool |
| |
| // toRun is the channel of tests to run. |
| // It is nil until the first test is started. |
| toRun chan *test |
| |
| // rungatec controls the max number of runoutput tests |
| // executed in parallel as they can each consume a lot of memory. |
| rungatec chan bool |
| ) |
| |
| // maxTests is an upper bound on the total number of tests. |
| // It is used as a channel buffer size to make sure sends don't block. |
| const maxTests = 5000 |
| |
| func main() { |
| flag.Parse() |
| |
| var glevels []int |
| for _, s := range strings.Split(*generics, ",") { |
| glevel, err := strconv.Atoi(s) |
| if err != nil { |
| log.Fatalf("invalid -G flag: %v", err) |
| } |
| glevels = append(glevels, glevel) |
| } |
| |
| findExecCmd() |
| |
| // Disable parallelism if printing or if using a simulator. |
| if *verbose || len(findExecCmd()) > 0 { |
| *numParallel = 1 |
| *runoutputLimit = 1 |
| } |
| |
| ratec = make(chan bool, *numParallel) |
| rungatec = make(chan bool, *runoutputLimit) |
| |
| var tests []*test |
| if flag.NArg() > 0 { |
| for _, arg := range flag.Args() { |
| if arg == "-" || arg == "--" { |
| // Permit running: |
| // $ go run run.go - env.go |
| // $ go run run.go -- env.go |
| // $ go run run.go - ./fixedbugs |
| // $ go run run.go -- ./fixedbugs |
| continue |
| } |
| if fi, err := os.Stat(arg); err == nil && fi.IsDir() { |
| for _, baseGoFile := range goFiles(arg) { |
| tests = append(tests, startTests(arg, baseGoFile, glevels)...) |
| } |
| } else if strings.HasSuffix(arg, ".go") { |
| dir, file := filepath.Split(arg) |
| tests = append(tests, startTests(dir, file, glevels)...) |
| } else { |
| log.Fatalf("can't yet deal with non-directory and non-go file %q", arg) |
| } |
| } |
| } else { |
| for _, dir := range dirs { |
| for _, baseGoFile := range goFiles(dir) { |
| tests = append(tests, startTests(dir, baseGoFile, glevels)...) |
| } |
| } |
| } |
| |
| failed := false |
| resCount := map[string]int{} |
| for _, test := range tests { |
| <-test.donec |
| status := "ok " |
| errStr := "" |
| if e, isSkip := test.err.(skipError); isSkip { |
| test.err = nil |
| errStr = "unexpected skip for " + path.Join(test.dir, test.gofile) + ": " + string(e) |
| status = "FAIL" |
| } |
| if test.err != nil { |
| errStr = test.err.Error() |
| if test.expectFail { |
| errStr += " (expected)" |
| } else { |
| status = "FAIL" |
| } |
| } else if test.expectFail { |
| status = "FAIL" |
| errStr = "unexpected success" |
| } |
| if status == "FAIL" { |
| failed = true |
| } |
| resCount[status]++ |
| dt := fmt.Sprintf("%.3fs", test.dt.Seconds()) |
| if status == "FAIL" { |
| fmt.Printf("# go run run.go -G=%v %s\n%s\nFAIL\t%s\t%s\n", |
| test.glevel, |
| path.Join(test.dir, test.gofile), |
| errStr, test.goFileName(), dt) |
| continue |
| } |
| if !*verbose { |
| continue |
| } |
| fmt.Printf("%s\t%s\t%s\n", status, test.goFileName(), dt) |
| } |
| |
| if *summary { |
| for k, v := range resCount { |
| fmt.Printf("%5d %s\n", v, k) |
| } |
| } |
| |
| if failed { |
| os.Exit(1) |
| } |
| } |
| |
| // goTool reports the path of the go tool to use to run the tests. |
| // If possible, use the same Go used to run run.go, otherwise |
| // fallback to the go version found in the PATH. |
| func goTool() string { |
| var exeSuffix string |
| if runtime.GOOS == "windows" { |
| exeSuffix = ".exe" |
| } |
| path := filepath.Join(runtime.GOROOT(), "bin", "go"+exeSuffix) |
| if _, err := os.Stat(path); err == nil { |
| return path |
| } |
| // Just run "go" from PATH |
| return "go" |
| } |
| |
| func shardMatch(name string) bool { |
| if *shards == 0 { |
| return true |
| } |
| h := fnv.New32() |
| io.WriteString(h, name) |
| return int(h.Sum32()%uint32(*shards)) == *shard |
| } |
| |
| func goFiles(dir string) []string { |
| f, err := os.Open(dir) |
| if err != nil { |
| log.Fatal(err) |
| } |
| dirnames, err := f.Readdirnames(-1) |
| f.Close() |
| if err != nil { |
| log.Fatal(err) |
| } |
| names := []string{} |
| for _, name := range dirnames { |
| if !strings.HasPrefix(name, ".") && strings.HasSuffix(name, ".go") && shardMatch(name) { |
| names = append(names, name) |
| } |
| } |
| sort.Strings(names) |
| return names |
| } |
| |
| type runCmd func(...string) ([]byte, error) |
| |
| func compileFile(runcmd runCmd, longname string, flags []string) (out []byte, err error) { |
| cmd := []string{goTool(), "tool", "compile", "-e"} |
| cmd = append(cmd, flags...) |
| if *linkshared { |
| cmd = append(cmd, "-dynlink", "-installsuffix=dynlink") |
| } |
| cmd = append(cmd, longname) |
| return runcmd(cmd...) |
| } |
| |
| func compileInDir(runcmd runCmd, dir string, flags []string, localImports bool, names ...string) (out []byte, err error) { |
| cmd := []string{goTool(), "tool", "compile", "-e"} |
| if localImports { |
| // Set relative path for local imports and import search path to current dir. |
| cmd = append(cmd, "-D", ".", "-I", ".") |
| } |
| cmd = append(cmd, flags...) |
| if *linkshared { |
| cmd = append(cmd, "-dynlink", "-installsuffix=dynlink") |
| } |
| for _, name := range names { |
| cmd = append(cmd, filepath.Join(dir, name)) |
| } |
| return runcmd(cmd...) |
| } |
| |
| func linkFile(runcmd runCmd, goname string, ldflags []string) (err error) { |
| pfile := strings.Replace(goname, ".go", ".o", -1) |
| cmd := []string{goTool(), "tool", "link", "-w", "-o", "a.exe", "-L", "."} |
| if *linkshared { |
| cmd = append(cmd, "-linkshared", "-installsuffix=dynlink") |
| } |
| if ldflags != nil { |
| cmd = append(cmd, ldflags...) |
| } |
| cmd = append(cmd, pfile) |
| _, err = runcmd(cmd...) |
| return |
| } |
| |
| // skipError describes why a test was skipped. |
| type skipError string |
| |
| func (s skipError) Error() string { return string(s) } |
| |
| // test holds the state of a test. |
| type test struct { |
| dir, gofile string |
| donec chan bool // closed when done |
| dt time.Duration |
| glevel int // what -G level this test should use |
| |
| src string |
| |
| tempDir string |
| err error |
| |
| // expectFail indicates whether the (overall) test recipe is |
| // expected to fail under the current test configuration (e.g., -G=3 |
| // or GOEXPERIMENT=unified). |
| expectFail bool |
| } |
| |
| // initExpectFail initializes t.expectFail based on the build+test |
| // configuration. |
| func (t *test) initExpectFail(hasGFlag bool) { |
| if *force { |
| return |
| } |
| |
| if t.glevel == 0 && !hasGFlag && !unifiedEnabled { |
| // tests should always pass when run w/o types2 (i.e., using the |
| // legacy typechecker, option -G=0). |
| return |
| } |
| |
| failureSets := []map[string]bool{types2Failures} |
| |
| // Note: gccgo supports more 32-bit architectures than this, but |
| // hopefully the 32-bit failures are fixed before this matters. |
| switch goarch { |
| case "386", "arm", "mips", "mipsle": |
| failureSets = append(failureSets, types2Failures32Bit) |
| } |
| |
| if unifiedEnabled { |
| failureSets = append(failureSets, unifiedFailures) |
| } else { |
| failureSets = append(failureSets, g3Failures) |
| } |
| |
| filename := strings.Replace(t.goFileName(), "\\", "/", -1) // goFileName() uses \ on Windows |
| |
| for _, set := range failureSets { |
| if set[filename] { |
| t.expectFail = true |
| return |
| } |
| } |
| } |
| |
| func startTests(dir, gofile string, glevels []int) []*test { |
| tests := make([]*test, len(glevels)) |
| for i, glevel := range glevels { |
| t := &test{ |
| dir: dir, |
| gofile: gofile, |
| glevel: glevel, |
| donec: make(chan bool, 1), |
| } |
| if toRun == nil { |
| toRun = make(chan *test, maxTests) |
| go runTests() |
| } |
| select { |
| case toRun <- t: |
| default: |
| panic("toRun buffer size (maxTests) is too small") |
| } |
| tests[i] = t |
| } |
| return tests |
| } |
| |
| // runTests runs tests in parallel, but respecting the order they |
| // were enqueued on the toRun channel. |
| func runTests() { |
| for { |
| ratec <- true |
| t := <-toRun |
| go func() { |
| t.run() |
| <-ratec |
| }() |
| } |
| } |
| |
| var cwd, _ = os.Getwd() |
| |
| func (t *test) goFileName() string { |
| return filepath.Join(t.dir, t.gofile) |
| } |
| |
| func (t *test) goDirName() string { |
| return filepath.Join(t.dir, strings.Replace(t.gofile, ".go", ".dir", -1)) |
| } |
| |
| func goDirFiles(longdir string) (filter []os.FileInfo, err error) { |
| files, dirErr := ioutil.ReadDir(longdir) |
| if dirErr != nil { |
| return nil, dirErr |
| } |
| for _, gofile := range files { |
| if filepath.Ext(gofile.Name()) == ".go" { |
| filter = append(filter, gofile) |
| } |
| } |
| return |
| } |
| |
| var packageRE = regexp.MustCompile(`(?m)^package ([\p{Lu}\p{Ll}\w]+)`) |
| |
| func getPackageNameFromSource(fn string) (string, error) { |
| data, err := ioutil.ReadFile(fn) |
| if err != nil { |
| return "", err |
| } |
| pkgname := packageRE.FindStringSubmatch(string(data)) |
| if pkgname == nil { |
| return "", fmt.Errorf("cannot find package name in %s", fn) |
| } |
| return pkgname[1], nil |
| } |
| |
| // If singlefilepkgs is set, each file is considered a separate package |
| // even if the package names are the same. |
| func goDirPackages(longdir string, singlefilepkgs bool) ([][]string, error) { |
| files, err := goDirFiles(longdir) |
| if err != nil { |
| return nil, err |
| } |
| var pkgs [][]string |
| m := make(map[string]int) |
| for _, file := range files { |
| name := file.Name() |
| pkgname, err := getPackageNameFromSource(filepath.Join(longdir, name)) |
| if err != nil { |
| log.Fatal(err) |
| } |
| i, ok := m[pkgname] |
| if singlefilepkgs || !ok { |
| i = len(pkgs) |
| pkgs = append(pkgs, nil) |
| m[pkgname] = i |
| } |
| pkgs[i] = append(pkgs[i], name) |
| } |
| return pkgs, nil |
| } |
| |
| type context struct { |
| GOOS string |
| GOARCH string |
| cgoEnabled bool |
| noOptEnv bool |
| } |
| |
| // shouldTest looks for build tags in a source file and returns |
| // whether the file should be used according to the tags. |
| func shouldTest(src string, goos, goarch string) (ok bool, whyNot string) { |
| if *runSkips { |
| return true, "" |
| } |
| for _, line := range strings.Split(src, "\n") { |
| line = strings.TrimSpace(line) |
| if strings.HasPrefix(line, "//") { |
| line = line[2:] |
| } else { |
| continue |
| } |
| line = strings.TrimSpace(line) |
| if len(line) == 0 || line[0] != '+' { |
| continue |
| } |
| gcFlags := os.Getenv("GO_GCFLAGS") |
| ctxt := &context{ |
| GOOS: goos, |
| GOARCH: goarch, |
| cgoEnabled: cgoEnabled, |
| noOptEnv: strings.Contains(gcFlags, "-N") || strings.Contains(gcFlags, "-l"), |
| } |
| |
| words := strings.Fields(line) |
| if words[0] == "+build" { |
| ok := false |
| for _, word := range words[1:] { |
| if ctxt.match(word) { |
| ok = true |
| break |
| } |
| } |
| if !ok { |
| // no matching tag found. |
| return false, line |
| } |
| } |
| } |
| // no build tags |
| return true, "" |
| } |
| |
| func (ctxt *context) match(name string) bool { |
| if name == "" { |
| return false |
| } |
| if i := strings.Index(name, ","); i >= 0 { |
| // comma-separated list |
| return ctxt.match(name[:i]) && ctxt.match(name[i+1:]) |
| } |
| if strings.HasPrefix(name, "!!") { // bad syntax, reject always |
| return false |
| } |
| if strings.HasPrefix(name, "!") { // negation |
| return len(name) > 1 && !ctxt.match(name[1:]) |
| } |
| |
| // Tags must be letters, digits, underscores or dots. |
| // Unlike in Go identifiers, all digits are fine (e.g., "386"). |
| for _, c := range name { |
| if !unicode.IsLetter(c) && !unicode.IsDigit(c) && c != '_' && c != '.' { |
| return false |
| } |
| } |
| |
| if strings.HasPrefix(name, "goexperiment.") { |
| for _, tag := range build.Default.ToolTags { |
| if tag == name { |
| return true |
| } |
| } |
| return false |
| } |
| |
| if name == "cgo" && ctxt.cgoEnabled { |
| return true |
| } |
| |
| if name == ctxt.GOOS || name == ctxt.GOARCH || name == "gc" { |
| return true |
| } |
| |
| if ctxt.noOptEnv && name == "gcflags_noopt" { |
| return true |
| } |
| |
| if name == "test_run" { |
| return true |
| } |
| |
| return false |
| } |
| |
| func init() { checkShouldTest() } |
| |
| // goGcflags returns the -gcflags argument to use with go build / go run. |
| // This must match the flags used for building the standard library, |
| // or else the commands will rebuild any needed packages (like runtime) |
| // over and over. |
| func (t *test) goGcflags() string { |
| flags := os.Getenv("GO_GCFLAGS") |
| if t.glevel != CompilerDefaultGLevel { |
| flags = fmt.Sprintf("%s -G=%v", flags, t.glevel) |
| } |
| return "-gcflags=all=" + flags |
| } |
| |
| func (t *test) goGcflagsIsEmpty() bool { |
| return "" == os.Getenv("GO_GCFLAGS") && t.glevel == CompilerDefaultGLevel |
| } |
| |
| var errTimeout = errors.New("command exceeded time limit") |
| |
| // run runs a test. |
| func (t *test) run() { |
| start := time.Now() |
| defer func() { |
| t.dt = time.Since(start) |
| close(t.donec) |
| }() |
| |
| srcBytes, err := ioutil.ReadFile(t.goFileName()) |
| if err != nil { |
| t.err = err |
| return |
| } |
| t.src = string(srcBytes) |
| if t.src[0] == '\n' { |
| t.err = skipError("starts with newline") |
| return |
| } |
| |
| // Execution recipe stops at first blank line. |
| pos := strings.Index(t.src, "\n\n") |
| if pos == -1 { |
| t.err = fmt.Errorf("double newline ending execution recipe not found in %s", t.goFileName()) |
| return |
| } |
| action := t.src[:pos] |
| if nl := strings.Index(action, "\n"); nl >= 0 && strings.Contains(action[:nl], "+build") { |
| // skip first line |
| action = action[nl+1:] |
| } |
| action = strings.TrimPrefix(action, "//") |
| |
| // Check for build constraints only up to the actual code. |
| pkgPos := strings.Index(t.src, "\npackage") |
| if pkgPos == -1 { |
| pkgPos = pos // some files are intentionally malformed |
| } |
| if ok, why := shouldTest(t.src[:pkgPos], goos, goarch); !ok { |
| if *showSkips { |
| fmt.Printf("%-20s %-20s: %s\n", "skip", t.goFileName(), why) |
| } |
| return |
| } |
| |
| var args, flags, runenv []string |
| var tim int |
| wantError := false |
| wantAuto := false |
| singlefilepkgs := false |
| setpkgpaths := false |
| localImports := true |
| f, err := splitQuoted(action) |
| if err != nil { |
| t.err = fmt.Errorf("invalid test recipe: %v", err) |
| return |
| } |
| if len(f) > 0 { |
| action = f[0] |
| args = f[1:] |
| } |
| |
| // TODO: Clean up/simplify this switch statement. |
| switch action { |
| case "compile", "compiledir", "build", "builddir", "buildrundir", "run", "buildrun", "runoutput", "rundir", "runindir", "asmcheck": |
| // nothing to do |
| case "errorcheckandrundir": |
| wantError = false // should be no error if also will run |
| case "errorcheckwithauto": |
| action = "errorcheck" |
| wantAuto = true |
| wantError = true |
| case "errorcheck", "errorcheckdir", "errorcheckoutput": |
| wantError = true |
| case "skip": |
| if *runSkips { |
| break |
| } |
| return |
| default: |
| t.err = skipError("skipped; unknown pattern: " + action) |
| return |
| } |
| |
| goexp := env.GOEXPERIMENT |
| |
| // collect flags |
| for len(args) > 0 && strings.HasPrefix(args[0], "-") { |
| switch args[0] { |
| case "-1": |
| wantError = true |
| case "-0": |
| wantError = false |
| case "-s": |
| singlefilepkgs = true |
| case "-P": |
| setpkgpaths = true |
| case "-n": |
| // Do not set relative path for local imports to current dir, |
| // e.g. do not pass -D . -I . to the compiler. |
| // Used in fixedbugs/bug345.go to allow compilation and import of local pkg. |
| // See golang.org/issue/25635 |
| localImports = false |
| case "-t": // timeout in seconds |
| args = args[1:] |
| var err error |
| tim, err = strconv.Atoi(args[0]) |
| if err != nil { |
| t.err = fmt.Errorf("need number of seconds for -t timeout, got %s instead", args[0]) |
| } |
| case "-goexperiment": // set GOEXPERIMENT environment |
| args = args[1:] |
| if goexp != "" { |
| goexp += "," |
| } |
| goexp += args[0] |
| runenv = append(runenv, "GOEXPERIMENT="+goexp) |
| |
| default: |
| flags = append(flags, args[0]) |
| } |
| args = args[1:] |
| } |
| if action == "errorcheck" { |
| found := false |
| for i, f := range flags { |
| if strings.HasPrefix(f, "-d=") { |
| flags[i] = f + ",ssa/check/on" |
| found = true |
| break |
| } |
| } |
| if !found { |
| flags = append(flags, "-d=ssa/check/on") |
| } |
| } |
| |
| type Tool int |
| |
| const ( |
| _ Tool = iota |
| AsmCheck |
| Build |
| Run |
| Compile |
| ) |
| |
| // validForGLevel reports whether the current test is valid to run |
| // at the specified -G level. If so, it may update flags as |
| // necessary to test with -G. |
| validForGLevel := func(tool Tool) bool { |
| hasGFlag := false |
| for _, flag := range flags { |
| if strings.Contains(flag, "-G") { |
| hasGFlag = true |
| } |
| } |
| |
| if hasGFlag && t.glevel != CompilerDefaultGLevel { |
| // test provides explicit -G flag already; don't run again |
| if *verbose { |
| fmt.Printf("excl\t%s\n", t.goFileName()) |
| } |
| return false |
| } |
| |
| t.initExpectFail(hasGFlag) |
| |
| switch tool { |
| case Build, Run: |
| // ok; handled in goGcflags |
| |
| case Compile: |
| if !hasGFlag { |
| flags = append(flags, fmt.Sprintf("-G=%v", t.glevel)) |
| } |
| |
| default: |
| // we don't know how to add -G for this test yet |
| if *verbose { |
| fmt.Printf("excl\t%s\n", t.goFileName()) |
| } |
| return false |
| } |
| |
| return true |
| } |
| |
| t.makeTempDir() |
| if !*keep { |
| defer os.RemoveAll(t.tempDir) |
| } |
| |
| err = ioutil.WriteFile(filepath.Join(t.tempDir, t.gofile), srcBytes, 0644) |
| if err != nil { |
| log.Fatal(err) |
| } |
| |
| // A few tests (of things like the environment) require these to be set. |
| if os.Getenv("GOOS") == "" { |
| os.Setenv("GOOS", runtime.GOOS) |
| } |
| if os.Getenv("GOARCH") == "" { |
| os.Setenv("GOARCH", runtime.GOARCH) |
| } |
| |
| var ( |
| runInDir = t.tempDir |
| tempDirIsGOPATH = false |
| ) |
| runcmd := func(args ...string) ([]byte, error) { |
| cmd := exec.Command(args[0], args[1:]...) |
| var buf bytes.Buffer |
| cmd.Stdout = &buf |
| cmd.Stderr = &buf |
| cmd.Env = append(os.Environ(), "GOENV=off", "GOFLAGS=") |
| if runInDir != "" { |
| cmd.Dir = runInDir |
| // Set PWD to match Dir to speed up os.Getwd in the child process. |
| cmd.Env = append(cmd.Env, "PWD="+cmd.Dir) |
| } |
| if tempDirIsGOPATH { |
| cmd.Env = append(cmd.Env, "GOPATH="+t.tempDir) |
| } |
| cmd.Env = append(cmd.Env, runenv...) |
| |
| var err error |
| |
| if tim != 0 { |
| err = cmd.Start() |
| // This command-timeout code adapted from cmd/go/test.go |
| if err == nil { |
| tick := time.NewTimer(time.Duration(tim) * time.Second) |
| done := make(chan error) |
| go func() { |
| done <- cmd.Wait() |
| }() |
| select { |
| case err = <-done: |
| // ok |
| case <-tick.C: |
| cmd.Process.Signal(os.Interrupt) |
| time.Sleep(1 * time.Second) |
| cmd.Process.Kill() |
| <-done |
| err = errTimeout |
| } |
| tick.Stop() |
| } |
| } else { |
| err = cmd.Run() |
| } |
| if err != nil && err != errTimeout { |
| err = fmt.Errorf("%s\n%s", err, buf.Bytes()) |
| } |
| return buf.Bytes(), err |
| } |
| |
| long := filepath.Join(cwd, t.goFileName()) |
| switch action { |
| default: |
| t.err = fmt.Errorf("unimplemented action %q", action) |
| |
| case "asmcheck": |
| if !validForGLevel(AsmCheck) { |
| return |
| } |
| |
| // Compile Go file and match the generated assembly |
| // against a set of regexps in comments. |
| ops := t.wantedAsmOpcodes(long) |
| self := runtime.GOOS + "/" + runtime.GOARCH |
| for _, env := range ops.Envs() { |
| // Only run checks relevant to the current GOOS/GOARCH, |
| // to avoid triggering a cross-compile of the runtime. |
| if string(env) != self && !strings.HasPrefix(string(env), self+"/") && !*allCodegen { |
| continue |
| } |
| // -S=2 forces outermost line numbers when disassembling inlined code. |
| cmdline := []string{"build", "-gcflags", "-S=2"} |
| |
| // Append flags, but don't override -gcflags=-S=2; add to it instead. |
| for i := 0; i < len(flags); i++ { |
| flag := flags[i] |
| switch { |
| case strings.HasPrefix(flag, "-gcflags="): |
| cmdline[2] += " " + strings.TrimPrefix(flag, "-gcflags=") |
| case strings.HasPrefix(flag, "--gcflags="): |
| cmdline[2] += " " + strings.TrimPrefix(flag, "--gcflags=") |
| case flag == "-gcflags", flag == "--gcflags": |
| i++ |
| if i < len(flags) { |
| cmdline[2] += " " + flags[i] |
| } |
| default: |
| cmdline = append(cmdline, flag) |
| } |
| } |
| |
| cmdline = append(cmdline, long) |
| cmd := exec.Command(goTool(), cmdline...) |
| cmd.Env = append(os.Environ(), env.Environ()...) |
| if len(flags) > 0 && flags[0] == "-race" { |
| cmd.Env = append(cmd.Env, "CGO_ENABLED=1") |
| } |
| |
| var buf bytes.Buffer |
| cmd.Stdout, cmd.Stderr = &buf, &buf |
| if err := cmd.Run(); err != nil { |
| fmt.Println(env, "\n", cmd.Stderr) |
| t.err = err |
| return |
| } |
| |
| t.err = t.asmCheck(buf.String(), long, env, ops[env]) |
| if t.err != nil { |
| return |
| } |
| } |
| return |
| |
| case "errorcheck": |
| if !validForGLevel(Compile) { |
| return |
| } |
| |
| // Compile Go file. |
| // Fail if wantError is true and compilation was successful and vice versa. |
| // Match errors produced by gc against errors in comments. |
| // TODO(gri) remove need for -C (disable printing of columns in error messages) |
| cmdline := []string{goTool(), "tool", "compile", "-d=panic", "-C", "-e", "-o", "a.o"} |
| // No need to add -dynlink even if linkshared if we're just checking for errors... |
| cmdline = append(cmdline, flags...) |
| cmdline = append(cmdline, long) |
| out, err := runcmd(cmdline...) |
| if wantError { |
| if err == nil { |
| t.err = fmt.Errorf("compilation succeeded unexpectedly\n%s", out) |
| return |
| } |
| if err == errTimeout { |
| t.err = fmt.Errorf("compilation timed out") |
| return |
| } |
| } else { |
| if err != nil { |
| t.err = err |
| return |
| } |
| } |
| if *updateErrors { |
| t.updateErrors(string(out), long) |
| } |
| t.err = t.errorCheck(string(out), wantAuto, long, t.gofile) |
| |
| case "compile": |
| if !validForGLevel(Compile) { |
| return |
| } |
| |
| // Compile Go file. |
| _, t.err = compileFile(runcmd, long, flags) |
| |
| case "compiledir": |
| if !validForGLevel(Compile) { |
| return |
| } |
| |
| // Compile all files in the directory as packages in lexicographic order. |
| longdir := filepath.Join(cwd, t.goDirName()) |
| pkgs, err := goDirPackages(longdir, singlefilepkgs) |
| if err != nil { |
| t.err = err |
| return |
| } |
| for _, gofiles := range pkgs { |
| _, t.err = compileInDir(runcmd, longdir, flags, localImports, gofiles...) |
| if t.err != nil { |
| return |
| } |
| } |
| |
| case "errorcheckdir", "errorcheckandrundir": |
| if !validForGLevel(Compile) { |
| return |
| } |
| |
| flags = append(flags, "-d=panic") |
| // Compile and errorCheck all files in the directory as packages in lexicographic order. |
| // If errorcheckdir and wantError, compilation of the last package must fail. |
| // If errorcheckandrundir and wantError, compilation of the package prior the last must fail. |
| longdir := filepath.Join(cwd, t.goDirName()) |
| pkgs, err := goDirPackages(longdir, singlefilepkgs) |
| if err != nil { |
| t.err = err |
| return |
| } |
| errPkg := len(pkgs) - 1 |
| if wantError && action == "errorcheckandrundir" { |
| // The last pkg should compiled successfully and will be run in next case. |
| // Preceding pkg must return an error from compileInDir. |
| errPkg-- |
| } |
| for i, gofiles := range pkgs { |
| out, err := compileInDir(runcmd, longdir, flags, localImports, gofiles...) |
| if i == errPkg { |
| if wantError && err == nil { |
| t.err = fmt.Errorf("compilation succeeded unexpectedly\n%s", out) |
| return |
| } else if !wantError && err != nil { |
| t.err = err |
| return |
| } |
| } else if err != nil { |
| t.err = err |
| return |
| } |
| var fullshort []string |
| for _, name := range gofiles { |
| fullshort = append(fullshort, filepath.Join(longdir, name), name) |
| } |
| t.err = t.errorCheck(string(out), wantAuto, fullshort...) |
| if t.err != nil { |
| break |
| } |
| } |
| if action == "errorcheckdir" { |
| return |
| } |
| fallthrough |
| |
| case "rundir": |
| if !validForGLevel(Run) { |
| return |
| } |
| |
| // Compile all files in the directory as packages in lexicographic order. |
| // In case of errorcheckandrundir, ignore failed compilation of the package before the last. |
| // Link as if the last file is the main package, run it. |
| // Verify the expected output. |
| longdir := filepath.Join(cwd, t.goDirName()) |
| pkgs, err := goDirPackages(longdir, singlefilepkgs) |
| if err != nil { |
| t.err = err |
| return |
| } |
| // Split flags into gcflags and ldflags |
| ldflags := []string{} |
| for i, fl := range flags { |
| if fl == "-ldflags" { |
| ldflags = flags[i+1:] |
| flags = flags[0:i] |
| break |
| } |
| } |
| |
| for i, gofiles := range pkgs { |
| pflags := []string{} |
| pflags = append(pflags, flags...) |
| if setpkgpaths { |
| fp := filepath.Join(longdir, gofiles[0]) |
| pkgname, err := getPackageNameFromSource(fp) |
| if err != nil { |
| log.Fatal(err) |
| } |
| pflags = append(pflags, "-p", pkgname) |
| } |
| _, err := compileInDir(runcmd, longdir, pflags, localImports, gofiles...) |
| // Allow this package compilation fail based on conditions below; |
| // its errors were checked in previous case. |
| if err != nil && !(wantError && action == "errorcheckandrundir" && i == len(pkgs)-2) { |
| t.err = err |
| return |
| } |
| if i == len(pkgs)-1 { |
| err = linkFile(runcmd, gofiles[0], ldflags) |
| if err != nil { |
| t.err = err |
| return |
| } |
| var cmd []string |
| cmd = append(cmd, findExecCmd()...) |
| cmd = append(cmd, filepath.Join(t.tempDir, "a.exe")) |
| cmd = append(cmd, args...) |
| out, err := runcmd(cmd...) |
| if err != nil { |
| t.err = err |
| return |
| } |
| t.checkExpectedOutput(out) |
| } |
| } |
| |
| case "runindir": |
| if !validForGLevel(Run) { |
| return |
| } |
| |
| // Make a shallow copy of t.goDirName() in its own module and GOPATH, and |
| // run "go run ." in it. The module path (and hence import path prefix) of |
| // the copy is equal to the basename of the source directory. |
| // |
| // It's used when test a requires a full 'go build' in order to compile |
| // the sources, such as when importing multiple packages (issue29612.dir) |
| // or compiling a package containing assembly files (see issue15609.dir), |
| // but still needs to be run to verify the expected output. |
| tempDirIsGOPATH = true |
| srcDir := t.goDirName() |
| modName := filepath.Base(srcDir) |
| gopathSrcDir := filepath.Join(t.tempDir, "src", modName) |
| runInDir = gopathSrcDir |
| |
| if err := overlayDir(gopathSrcDir, srcDir); err != nil { |
| t.err = err |
| return |
| } |
| |
| modFile := fmt.Sprintf("module %s\ngo 1.14\n", modName) |
| if err := ioutil.WriteFile(filepath.Join(gopathSrcDir, "go.mod"), []byte(modFile), 0666); err != nil { |
| t.err = err |
| return |
| } |
| |
| cmd := []string{goTool(), "run", t.goGcflags()} |
| if *linkshared { |
| cmd = append(cmd, "-linkshared") |
| } |
| cmd = append(cmd, flags...) |
| cmd = append(cmd, ".") |
| out, err := runcmd(cmd...) |
| if err != nil { |
| t.err = err |
| return |
| } |
| t.checkExpectedOutput(out) |
| |
| case "build": |
| if !validForGLevel(Build) { |
| return |
| } |
| |
| // Build Go file. |
| _, err := runcmd(goTool(), "build", t.goGcflags(), "-o", "a.exe", long) |
| if err != nil { |
| t.err = err |
| } |
| |
| case "builddir", "buildrundir": |
| if !validForGLevel(Build) { |
| return |
| } |
| |
| // Build an executable from all the .go and .s files in a subdirectory. |
| // Run it and verify its output in the buildrundir case. |
| longdir := filepath.Join(cwd, t.goDirName()) |
| files, dirErr := ioutil.ReadDir(longdir) |
| if dirErr != nil { |
| t.err = dirErr |
| break |
| } |
| var gos []string |
| var asms []string |
| for _, file := range files { |
| switch filepath.Ext(file.Name()) { |
| case ".go": |
| gos = append(gos, filepath.Join(longdir, file.Name())) |
| case ".s": |
| asms = append(asms, filepath.Join(longdir, file.Name())) |
| } |
| |
| } |
| if len(asms) > 0 { |
| emptyHdrFile := filepath.Join(t.tempDir, "go_asm.h") |
| if err := ioutil.WriteFile(emptyHdrFile, nil, 0666); err != nil { |
| t.err = fmt.Errorf("write empty go_asm.h: %s", err) |
| return |
| } |
| cmd := []string{goTool(), "tool", "asm", "-gensymabis", "-o", "symabis"} |
| cmd = append(cmd, asms...) |
| _, err = runcmd(cmd...) |
| if err != nil { |
| t.err = err |
| break |
| } |
| } |
| var objs []string |
| cmd := []string{goTool(), "tool", "compile", "-e", "-D", ".", "-I", ".", "-o", "go.o"} |
| if len(asms) > 0 { |
| cmd = append(cmd, "-asmhdr", "go_asm.h", "-symabis", "symabis") |
| } |
| cmd = append(cmd, gos...) |
| _, err := runcmd(cmd...) |
| if err != nil { |
| t.err = err |
| break |
| } |
| objs = append(objs, "go.o") |
| if len(asms) > 0 { |
| cmd = []string{goTool(), "tool", "asm", "-e", "-I", ".", "-o", "asm.o"} |
| cmd = append(cmd, asms...) |
| _, err = runcmd(cmd...) |
| if err != nil { |
| t.err = err |
| break |
| } |
| objs = append(objs, "asm.o") |
| } |
| cmd = []string{goTool(), "tool", "pack", "c", "all.a"} |
| cmd = append(cmd, objs...) |
| _, err = runcmd(cmd...) |
| if err != nil { |
| t.err = err |
| break |
| } |
| cmd = []string{goTool(), "tool", "link", "-o", "a.exe", "all.a"} |
| _, err = runcmd(cmd...) |
| if err != nil { |
| t.err = err |
| break |
| } |
| if action == "buildrundir" { |
| cmd = append(findExecCmd(), filepath.Join(t.tempDir, "a.exe")) |
| out, err := runcmd(cmd...) |
| if err != nil { |
| t.err = err |
| break |
| } |
| t.checkExpectedOutput(out) |
| } |
| |
| case "buildrun": |
| if !validForGLevel(Build) { |
| return |
| } |
| |
| // Build an executable from Go file, then run it, verify its output. |
| // Useful for timeout tests where failure mode is infinite loop. |
| // TODO: not supported on NaCl |
| cmd := []string{goTool(), "build", t.goGcflags(), "-o", "a.exe"} |
| if *linkshared { |
| cmd = append(cmd, "-linkshared") |
| } |
| longdirgofile := filepath.Join(filepath.Join(cwd, t.dir), t.gofile) |
| cmd = append(cmd, flags...) |
| cmd = append(cmd, longdirgofile) |
| _, err := runcmd(cmd...) |
| if err != nil { |
| t.err = err |
| return |
| } |
| cmd = []string{"./a.exe"} |
| out, err := runcmd(append(cmd, args...)...) |
| if err != nil { |
| t.err = err |
| return |
| } |
| |
| t.checkExpectedOutput(out) |
| |
| case "run": |
| if !validForGLevel(Run) { |
| return |
| } |
| |
| // Run Go file if no special go command flags are provided; |
| // otherwise build an executable and run it. |
| // Verify the output. |
| runInDir = "" |
| var out []byte |
| var err error |
| if len(flags)+len(args) == 0 && t.goGcflagsIsEmpty() && !*linkshared && goarch == runtime.GOARCH && goos == runtime.GOOS && goexp == env.GOEXPERIMENT { |
| // If we're not using special go command flags, |
| // skip all the go command machinery. |
| // This avoids any time the go command would |
| // spend checking whether, for example, the installed |
| // package runtime is up to date. |
| // Because we run lots of trivial test programs, |
| // the time adds up. |
| pkg := filepath.Join(t.tempDir, "pkg.a") |
| if _, err := runcmd(goTool(), "tool", "compile", "-o", pkg, t.goFileName()); err != nil { |
| t.err = err |
| return |
| } |
| exe := filepath.Join(t.tempDir, "test.exe") |
| cmd := []string{goTool(), "tool", "link", "-s", "-w"} |
| cmd = append(cmd, "-o", exe, pkg) |
| if _, err := runcmd(cmd...); err != nil { |
| t.err = err |
| return |
| } |
| out, err = runcmd(append([]string{exe}, args...)...) |
| } else { |
| cmd := []string{goTool(), "run", t.goGcflags()} |
| if *linkshared { |
| cmd = append(cmd, "-linkshared") |
| } |
| cmd = append(cmd, flags...) |
| cmd = append(cmd, t.goFileName()) |
| out, err = runcmd(append(cmd, args...)...) |
| } |
| if err != nil { |
| t.err = err |
| return |
| } |
| t.checkExpectedOutput(out) |
| |
| case "runoutput": |
| if !validForGLevel(Run) { |
| return |
| } |
| |
| // Run Go file and write its output into temporary Go file. |
| // Run generated Go file and verify its output. |
| rungatec <- true |
| defer func() { |
| <-rungatec |
| }() |
| runInDir = "" |
| cmd := []string{goTool(), "run", t.goGcflags()} |
| if *linkshared { |
| cmd = append(cmd, "-linkshared") |
| } |
| cmd = append(cmd, t.goFileName()) |
| out, err := runcmd(append(cmd, args...)...) |
| if err != nil { |
| t.err = err |
| return |
| } |
| tfile := filepath.Join(t.tempDir, "tmp__.go") |
| if err := ioutil.WriteFile(tfile, out, 0666); err != nil { |
| t.err = fmt.Errorf("write tempfile:%s", err) |
| return |
| } |
| cmd = []string{goTool(), "run", t.goGcflags()} |
| if *linkshared { |
| cmd = append(cmd, "-linkshared") |
| } |
| cmd = append(cmd, tfile) |
| out, err = runcmd(cmd...) |
| if err != nil { |
| t.err = err |
| return |
| } |
| t.checkExpectedOutput(out) |
| |
| case "errorcheckoutput": |
| if !validForGLevel(Compile) { |
| return |
| } |
| |
| // Run Go file and write its output into temporary Go file. |
| // Compile and errorCheck generated Go file. |
| runInDir = "" |
| cmd := []string{goTool(), "run", t.goGcflags()} |
| if *linkshared { |
| cmd = append(cmd, "-linkshared") |
| } |
| cmd = append(cmd, t.goFileName()) |
| out, err := runcmd(append(cmd, args...)...) |
| if err != nil { |
| t.err = err |
| return |
| } |
| tfile := filepath.Join(t.tempDir, "tmp__.go") |
| err = ioutil.WriteFile(tfile, out, 0666) |
| if err != nil { |
| t.err = fmt.Errorf("write tempfile:%s", err) |
| return |
| } |
| cmdline := []string{goTool(), "tool", "compile", "-d=panic", "-e", "-o", "a.o"} |
| cmdline = append(cmdline, flags...) |
| cmdline = append(cmdline, tfile) |
| out, err = runcmd(cmdline...) |
| if wantError { |
| if err == nil { |
| t.err = fmt.Errorf("compilation succeeded unexpectedly\n%s", out) |
| return |
| } |
| } else { |
| if err != nil { |
| t.err = err |
| return |
| } |
| } |
| t.err = t.errorCheck(string(out), false, tfile, "tmp__.go") |
| return |
| } |
| } |
| |
| var execCmd []string |
| |
| func findExecCmd() []string { |
| if execCmd != nil { |
| return execCmd |
| } |
| execCmd = []string{} // avoid work the second time |
| if goos == runtime.GOOS && goarch == runtime.GOARCH { |
| return execCmd |
| } |
| path, err := exec.LookPath(fmt.Sprintf("go_%s_%s_exec", goos, goarch)) |
| if err == nil { |
| execCmd = []string{path} |
| } |
| return execCmd |
| } |
| |
| func (t *test) String() string { |
| return filepath.Join(t.dir, t.gofile) |
| } |
| |
| func (t *test) makeTempDir() { |
| var err error |
| t.tempDir, err = ioutil.TempDir("", "") |
| if err != nil { |
| log.Fatal(err) |
| } |
| if *keep { |
| log.Printf("Temporary directory is %s", t.tempDir) |
| } |
| } |
| |
| // checkExpectedOutput compares the output from compiling and/or running with the contents |
| // of the corresponding reference output file, if any (replace ".go" with ".out"). |
| // If they don't match, fail with an informative message. |
| func (t *test) checkExpectedOutput(gotBytes []byte) { |
| got := string(gotBytes) |
| filename := filepath.Join(t.dir, t.gofile) |
| filename = filename[:len(filename)-len(".go")] |
| filename += ".out" |
| b, err := ioutil.ReadFile(filename) |
| // File is allowed to be missing (err != nil) in which case output should be empty. |
| got = strings.Replace(got, "\r\n", "\n", -1) |
| if got != string(b) { |
| if err == nil { |
| t.err = fmt.Errorf("output does not match expected in %s. Instead saw\n%s", filename, got) |
| } else { |
| t.err = fmt.Errorf("output should be empty when (optional) expected-output file %s is not present. Instead saw\n%s", filename, got) |
| } |
| } |
| } |
| |
| func splitOutput(out string, wantAuto bool) []string { |
| // gc error messages continue onto additional lines with leading tabs. |
| // Split the output at the beginning of each line that doesn't begin with a tab. |
| // <autogenerated> lines are impossible to match so those are filtered out. |
| var res []string |
| for _, line := range strings.Split(out, "\n") { |
| if strings.HasSuffix(line, "\r") { // remove '\r', output by compiler on windows |
| line = line[:len(line)-1] |
| } |
| if strings.HasPrefix(line, "\t") { |
| res[len(res)-1] += "\n" + line |
| } else if strings.HasPrefix(line, "go tool") || strings.HasPrefix(line, "#") || !wantAuto && strings.HasPrefix(line, "<autogenerated>") { |
| continue |
| } else if strings.TrimSpace(line) != "" { |
| res = append(res, line) |
| } |
| } |
| return res |
| } |
| |
| // errorCheck matches errors in outStr against comments in source files. |
| // For each line of the source files which should generate an error, |
| // there should be a comment of the form // ERROR "regexp". |
| // If outStr has an error for a line which has no such comment, |
| // this function will report an error. |
| // Likewise if outStr does not have an error for a line which has a comment, |
| // or if the error message does not match the <regexp>. |
| // The <regexp> syntax is Perl but it's best to stick to egrep. |
| // |
| // Sources files are supplied as fullshort slice. |
| // It consists of pairs: full path to source file and its base name. |
| func (t *test) errorCheck(outStr string, wantAuto bool, fullshort ...string) (err error) { |
| defer func() { |
| if *verbose && err != nil { |
| log.Printf("%s gc output:\n%s", t, outStr) |
| } |
| }() |
| var errs []error |
| out := splitOutput(outStr, wantAuto) |
| |
| // Cut directory name. |
| for i := range out { |
| for j := 0; j < len(fullshort); j += 2 { |
| full, short := fullshort[j], fullshort[j+1] |
| out[i] = strings.Replace(out[i], full, short, -1) |
| } |
| } |
| |
| var want []wantedError |
| for j := 0; j < len(fullshort); j += 2 { |
| full, short := fullshort[j], fullshort[j+1] |
| want = append(want, t.wantedErrors(full, short)...) |
| } |
| |
| for _, we := range want { |
| var errmsgs []string |
| if we.auto { |
| errmsgs, out = partitionStrings("<autogenerated>", out) |
| } else { |
| errmsgs, out = partitionStrings(we.prefix, out) |
| } |
| if len(errmsgs) == 0 { |
| errs = append(errs, fmt.Errorf("%s:%d: missing error %q", we.file, we.lineNum, we.reStr)) |
| continue |
| } |
| matched := false |
| n := len(out) |
| for _, errmsg := range errmsgs { |
| // Assume errmsg says "file:line: foo". |
| // Cut leading "file:line: " to avoid accidental matching of file name instead of message. |
| text := errmsg |
| if i := strings.Index(text, " "); i >= 0 { |
| text = text[i+1:] |
| } |
| if we.re.MatchString(text) { |
| matched = true |
| } else { |
| out = append(out, errmsg) |
| } |
| } |
| if !matched { |
| errs = append(errs, fmt.Errorf("%s:%d: no match for %#q in:\n\t%s", we.file, we.lineNum, we.reStr, strings.Join(out[n:], "\n\t"))) |
| continue |
| } |
| } |
| |
| if len(out) > 0 { |
| errs = append(errs, fmt.Errorf("Unmatched Errors:")) |
| for _, errLine := range out { |
| errs = append(errs, fmt.Errorf("%s", errLine)) |
| } |
| } |
| |
| if len(errs) == 0 { |
| return nil |
| } |
| if len(errs) == 1 { |
| return errs[0] |
| } |
| var buf bytes.Buffer |
| fmt.Fprintf(&buf, "\n") |
| for _, err := range errs { |
| fmt.Fprintf(&buf, "%s\n", err.Error()) |
| } |
| return errors.New(buf.String()) |
| } |
| |
| func (t *test) updateErrors(out, file string) { |
| base := path.Base(file) |
| // Read in source file. |
| src, err := ioutil.ReadFile(file) |
| if err != nil { |
| fmt.Fprintln(os.Stderr, err) |
| return |
| } |
| lines := strings.Split(string(src), "\n") |
| // Remove old errors. |
| for i, ln := range lines { |
| pos := strings.Index(ln, " // ERROR ") |
| if pos >= 0 { |
| lines[i] = ln[:pos] |
| } |
| } |
| // Parse new errors. |
| errors := make(map[int]map[string]bool) |
| tmpRe := regexp.MustCompile(`autotmp_[0-9]+`) |
| for _, errStr := range splitOutput(out, false) { |
| colon1 := strings.Index(errStr, ":") |
| if colon1 < 0 || errStr[:colon1] != file { |
| continue |
| } |
| colon2 := strings.Index(errStr[colon1+1:], ":") |
| if colon2 < 0 { |
| continue |
| } |
| colon2 += colon1 + 1 |
| line, err := strconv.Atoi(errStr[colon1+1 : colon2]) |
| line-- |
| if err != nil || line < 0 || line >= len(lines) { |
| continue |
| } |
| msg := errStr[colon2+2:] |
| msg = strings.Replace(msg, file, base, -1) // normalize file mentions in error itself |
| msg = strings.TrimLeft(msg, " \t") |
| for _, r := range []string{`\`, `*`, `+`, `?`, `[`, `]`, `(`, `)`} { |
| msg = strings.Replace(msg, r, `\`+r, -1) |
| } |
| msg = strings.Replace(msg, `"`, `.`, -1) |
| msg = tmpRe.ReplaceAllLiteralString(msg, `autotmp_[0-9]+`) |
| if errors[line] == nil { |
| errors[line] = make(map[string]bool) |
| } |
| errors[line][msg] = true |
| } |
| // Add new errors. |
| for line, errs := range errors { |
| var sorted []string |
| for e := range errs { |
| sorted = append(sorted, e) |
| } |
| sort.Strings(sorted) |
| lines[line] += " // ERROR" |
| for _, e := range sorted { |
| lines[line] += fmt.Sprintf(` "%s$"`, e) |
| } |
| } |
| // Write new file. |
| err = ioutil.WriteFile(file, []byte(strings.Join(lines, "\n")), 0640) |
| if err != nil { |
| fmt.Fprintln(os.Stderr, err) |
| return |
| } |
| // Polish. |
| exec.Command(goTool(), "fmt", file).CombinedOutput() |
| } |
| |
| // matchPrefix reports whether s is of the form ^(.*/)?prefix(:|[), |
| // That is, it needs the file name prefix followed by a : or a [, |
| // and possibly preceded by a directory name. |
| func matchPrefix(s, prefix string) bool { |
| i := strings.Index(s, ":") |
| if i < 0 { |
| return false |
| } |
| j := strings.LastIndex(s[:i], "/") |
| s = s[j+1:] |
| if len(s) <= len(prefix) || s[:len(prefix)] != prefix { |
| return false |
| } |
| switch s[len(prefix)] { |
| case '[', ':': |
| return true |
| } |
| return false |
| } |
| |
| func partitionStrings(prefix string, strs []string) (matched, unmatched []string) { |
| for _, s := range strs { |
| if matchPrefix(s, prefix) { |
| matched = append(matched, s) |
| } else { |
| unmatched = append(unmatched, s) |
| } |
| } |
| return |
| } |
| |
| type wantedError struct { |
| reStr string |
| re *regexp.Regexp |
| lineNum int |
| auto bool // match <autogenerated> line |
| file string |
| prefix string |
| } |
| |
| var ( |
| errRx = regexp.MustCompile(`// (?:GC_)?ERROR (.*)`) |
| errAutoRx = regexp.MustCompile(`// (?:GC_)?ERRORAUTO (.*)`) |
| errQuotesRx = regexp.MustCompile(`"([^"]*)"`) |
| lineRx = regexp.MustCompile(`LINE(([+-])([0-9]+))?`) |
| ) |
| |
| func (t *test) wantedErrors(file, short string) (errs []wantedError) { |
| cache := make(map[string]*regexp.Regexp) |
| |
| src, _ := ioutil.ReadFile(file) |
| for i, line := range strings.Split(string(src), "\n") { |
| lineNum := i + 1 |
| if strings.Contains(line, "////") { |
| // double comment disables ERROR |
| continue |
| } |
| var auto bool |
| m := errAutoRx.FindStringSubmatch(line) |
| if m != nil { |
| auto = true |
| } else { |
| m = errRx.FindStringSubmatch(line) |
| } |
| if m == nil { |
| continue |
| } |
| all := m[1] |
| mm := errQuotesRx.FindAllStringSubmatch(all, -1) |
| if mm == nil { |
| log.Fatalf("%s:%d: invalid errchk line: %s", t.goFileName(), lineNum, line) |
| } |
| for _, m := range mm { |
| rx := lineRx.ReplaceAllStringFunc(m[1], func(m string) string { |
| n := lineNum |
| if strings.HasPrefix(m, "LINE+") { |
| delta, _ := strconv.Atoi(m[5:]) |
| n += delta |
| } else if strings.HasPrefix(m, "LINE-") { |
| delta, _ := strconv.Atoi(m[5:]) |
| n -= delta |
| } |
| return fmt.Sprintf("%s:%d", short, n) |
| }) |
| re := cache[rx] |
| if re == nil { |
| var err error |
| re, err = regexp.Compile(rx) |
| if err != nil { |
| log.Fatalf("%s:%d: invalid regexp \"%s\" in ERROR line: %v", t.goFileName(), lineNum, rx, err) |
| } |
| cache[rx] = re |
| } |
| prefix := fmt.Sprintf("%s:%d", short, lineNum) |
| errs = append(errs, wantedError{ |
| reStr: rx, |
| re: re, |
| prefix: prefix, |
| auto: auto, |
| lineNum: lineNum, |
| file: short, |
| }) |
| } |
| } |
| |
| return |
| } |
| |
| const ( |
| // Regexp to match a single opcode check: optionally begin with "-" (to indicate |
| // a negative check), followed by a string literal enclosed in "" or ``. For "", |
| // backslashes must be handled. |
| reMatchCheck = `-?(?:\x60[^\x60]*\x60|"(?:[^"\\]|\\.)*")` |
| ) |
| |
| var ( |
| // Regexp to split a line in code and comment, trimming spaces |
| rxAsmComment = regexp.MustCompile(`^\s*(.*?)\s*(?://\s*(.+)\s*)?$`) |
| |
| // Regexp to extract an architecture check: architecture name (or triplet), |
| // followed by semi-colon, followed by a comma-separated list of opcode checks. |
| // Extraneous spaces are ignored. |
| rxAsmPlatform = regexp.MustCompile(`(\w+)(/\w+)?(/\w*)?\s*:\s*(` + reMatchCheck + `(?:\s*,\s*` + reMatchCheck + `)*)`) |
| |
| // Regexp to extract a single opcoded check |
| rxAsmCheck = regexp.MustCompile(reMatchCheck) |
| |
| // List of all architecture variants. Key is the GOARCH architecture, |
| // value[0] is the variant-changing environment variable, and values[1:] |
| // are the supported variants. |
| archVariants = map[string][]string{ |
| "386": {"GO386", "sse2", "softfloat"}, |
| "amd64": {}, |
| "arm": {"GOARM", "5", "6", "7"}, |
| "arm64": {}, |
| "mips": {"GOMIPS", "hardfloat", "softfloat"}, |
| "mips64": {"GOMIPS64", "hardfloat", "softfloat"}, |
| "ppc64": {"GOPPC64", "power8", "power9"}, |
| "ppc64le": {"GOPPC64", "power8", "power9"}, |
| "s390x": {}, |
| "wasm": {}, |
| "riscv64": {}, |
| } |
| ) |
| |
| // wantedAsmOpcode is a single asmcheck check |
| type wantedAsmOpcode struct { |
| fileline string // original source file/line (eg: "/path/foo.go:45") |
| line int // original source line |
| opcode *regexp.Regexp // opcode check to be performed on assembly output |
| negative bool // true if the check is supposed to fail rather than pass |
| found bool // true if the opcode check matched at least one in the output |
| } |
| |
| // A build environment triplet separated by slashes (eg: linux/386/sse2). |
| // The third field can be empty if the arch does not support variants (eg: "plan9/amd64/") |
| type buildEnv string |
| |
| // Environ returns the environment it represents in cmd.Environ() "key=val" format |
| // For instance, "linux/386/sse2".Environ() returns {"GOOS=linux", "GOARCH=386", "GO386=sse2"} |
| func (b buildEnv) Environ() []string { |
| fields := strings.Split(string(b), "/") |
| if len(fields) != 3 { |
| panic("invalid buildEnv string: " + string(b)) |
| } |
| env := []string{"GOOS=" + fields[0], "GOARCH=" + fields[1]} |
| if fields[2] != "" { |
| env = append(env, archVariants[fields[1]][0]+"="+fields[2]) |
| } |
| return env |
| } |
| |
| // asmChecks represents all the asmcheck checks present in a test file |
| // The outer map key is the build triplet in which the checks must be performed. |
| // The inner map key represent the source file line ("filename.go:1234") at which the |
| // checks must be performed. |
| type asmChecks map[buildEnv]map[string][]wantedAsmOpcode |
| |
| // Envs returns all the buildEnv in which at least one check is present |
| func (a asmChecks) Envs() []buildEnv { |
| var envs []buildEnv |
| for e := range a { |
| envs = append(envs, e) |
| } |
| sort.Slice(envs, func(i, j int) bool { |
| return string(envs[i]) < string(envs[j]) |
| }) |
| return envs |
| } |
| |
| func (t *test) wantedAsmOpcodes(fn string) asmChecks { |
| ops := make(asmChecks) |
| |
| comment := "" |
| src, _ := ioutil.ReadFile(fn) |
| for i, line := range strings.Split(string(src), "\n") { |
| matches := rxAsmComment.FindStringSubmatch(line) |
| code, cmt := matches[1], matches[2] |
| |
| // Keep comments pending in the comment variable until |
| // we find a line that contains some code. |
| comment += " " + cmt |
| if code == "" { |
| continue |
| } |
| |
| // Parse and extract any architecture check from comments, |
| // made by one architecture name and multiple checks. |
| lnum := fn + ":" + strconv.Itoa(i+1) |
| for _, ac := range rxAsmPlatform.FindAllStringSubmatch(comment, -1) { |
| archspec, allchecks := ac[1:4], ac[4] |
| |
| var arch, subarch, os string |
| switch { |
| case archspec[2] != "": // 3 components: "linux/386/sse2" |
| os, arch, subarch = archspec[0], archspec[1][1:], archspec[2][1:] |
| case archspec[1] != "": // 2 components: "386/sse2" |
| os, arch, subarch = "linux", archspec[0], archspec[1][1:] |
| default: // 1 component: "386" |
| os, arch, subarch = "linux", archspec[0], "" |
| if arch == "wasm" { |
| os = "js" |
| } |
| } |
| |
| if _, ok := archVariants[arch]; !ok { |
| log.Fatalf("%s:%d: unsupported architecture: %v", t.goFileName(), i+1, arch) |
| } |
| |
| // Create the build environments corresponding the above specifiers |
| envs := make([]buildEnv, 0, 4) |
| if subarch != "" { |
| envs = append(envs, buildEnv(os+"/"+arch+"/"+subarch)) |
| } else { |
| subarchs := archVariants[arch] |
| if len(subarchs) == 0 { |
| envs = append(envs, buildEnv(os+"/"+arch+"/")) |
| } else { |
| for _, sa := range archVariants[arch][1:] { |
| envs = append(envs, buildEnv(os+"/"+arch+"/"+sa)) |
| } |
| } |
| } |
| |
| for _, m := range rxAsmCheck.FindAllString(allchecks, -1) { |
| negative := false |
| if m[0] == '-' { |
| negative = true |
| m = m[1:] |
| } |
| |
| rxsrc, err := strconv.Unquote(m) |
| if err != nil { |
| log.Fatalf("%s:%d: error unquoting string: %v", t.goFileName(), i+1, err) |
| } |
| |
| // Compile the checks as regular expressions. Notice that we |
| // consider checks as matching from the beginning of the actual |
| // assembler source (that is, what is left on each line of the |
| // compile -S output after we strip file/line info) to avoid |
| // trivial bugs such as "ADD" matching "FADD". This |
| // doesn't remove genericity: it's still possible to write |
| // something like "F?ADD", but we make common cases simpler |
| // to get right. |
| oprx, err := regexp.Compile("^" + rxsrc) |
| if err != nil { |
| log.Fatalf("%s:%d: %v", t.goFileName(), i+1, err) |
| } |
| |
| for _, env := range envs { |
| if ops[env] == nil { |
| ops[env] = make(map[string][]wantedAsmOpcode) |
| } |
| ops[env][lnum] = append(ops[env][lnum], wantedAsmOpcode{ |
| negative: negative, |
| fileline: lnum, |
| line: i + 1, |
| opcode: oprx, |
| }) |
| } |
| } |
| } |
| comment = "" |
| } |
| |
| return ops |
| } |
| |
| func (t *test) asmCheck(outStr string, fn string, env buildEnv, fullops map[string][]wantedAsmOpcode) (err error) { |
| // The assembly output contains the concatenated dump of multiple functions. |
| // the first line of each function begins at column 0, while the rest is |
| // indented by a tabulation. These data structures help us index the |
| // output by function. |
| functionMarkers := make([]int, 1) |
| lineFuncMap := make(map[string]int) |
| |
| lines := strings.Split(outStr, "\n") |
| rxLine := regexp.MustCompile(fmt.Sprintf(`\((%s:\d+)\)\s+(.*)`, regexp.QuoteMeta(fn))) |
| |
| for nl, line := range lines { |
| // Check if this line begins a function |
| if len(line) > 0 && line[0] != '\t' { |
| functionMarkers = append(functionMarkers, nl) |
| } |
| |
| // Search if this line contains a assembly opcode (which is prefixed by the |
| // original source file/line in parenthesis) |
| matches := rxLine.FindStringSubmatch(line) |
| if len(matches) == 0 { |
| continue |
| } |
| srcFileLine, asm := matches[1], matches[2] |
| |
| // Associate the original file/line information to the current |
| // function in the output; it will be useful to dump it in case |
| // of error. |
| lineFuncMap[srcFileLine] = len(functionMarkers) - 1 |
| |
| // If there are opcode checks associated to this source file/line, |
| // run the checks. |
| if ops, found := fullops[srcFileLine]; found { |
| for i := range ops { |
| if !ops[i].found && ops[i].opcode.FindString(asm) != "" { |
| ops[i].found = true |
| } |
| } |
| } |
| } |
| functionMarkers = append(functionMarkers, len(lines)) |
| |
| var failed []wantedAsmOpcode |
| for _, ops := range fullops { |
| for _, o := range ops { |
| // There's a failure if a negative match was found, |
| // or a positive match was not found. |
| if o.negative == o.found { |
| failed = append(failed, o) |
| } |
| } |
| } |
| if len(failed) == 0 { |
| return |
| } |
| |
| // At least one asmcheck failed; report them |
| sort.Slice(failed, func(i, j int) bool { |
| return failed[i].line < failed[j].line |
| }) |
| |
| lastFunction := -1 |
| var errbuf bytes.Buffer |
| fmt.Fprintln(&errbuf) |
| for _, o := range failed { |
| // Dump the function in which this opcode check was supposed to |
| // pass but failed. |
| funcIdx := lineFuncMap[o.fileline] |
| if funcIdx != 0 && funcIdx != lastFunction { |
| funcLines := lines[functionMarkers[funcIdx]:functionMarkers[funcIdx+1]] |
| log.Println(strings.Join(funcLines, "\n")) |
| lastFunction = funcIdx // avoid printing same function twice |
| } |
| |
| if o.negative { |
| fmt.Fprintf(&errbuf, "%s:%d: %s: wrong opcode found: %q\n", t.goFileName(), o.line, env, o.opcode.String()) |
| } else { |
| fmt.Fprintf(&errbuf, "%s:%d: %s: opcode not found: %q\n", t.goFileName(), o.line, env, o.opcode.String()) |
| } |
| } |
| err = errors.New(errbuf.String()) |
| return |
| } |
| |
| // defaultRunOutputLimit returns the number of runoutput tests that |
| // can be executed in parallel. |
| func defaultRunOutputLimit() int { |
| const maxArmCPU = 2 |
| |
| cpu := runtime.NumCPU() |
| if runtime.GOARCH == "arm" && cpu > maxArmCPU { |
| cpu = maxArmCPU |
| } |
| return cpu |
| } |
| |
| // checkShouldTest runs sanity checks on the shouldTest function. |
| func checkShouldTest() { |
| assert := func(ok bool, _ string) { |
| if !ok { |
| panic("fail") |
| } |
| } |
| assertNot := func(ok bool, _ string) { assert(!ok, "") } |
| |
| // Simple tests. |
| assert(shouldTest("// +build linux", "linux", "arm")) |
| assert(shouldTest("// +build !windows", "linux", "arm")) |
| assertNot(shouldTest("// +build !windows", "windows", "amd64")) |
| |
| // A file with no build tags will always be tested. |
| assert(shouldTest("// This is a test.", "os", "arch")) |
| |
| // Build tags separated by a space are OR-ed together. |
| assertNot(shouldTest("// +build arm 386", "linux", "amd64")) |
| |
| // Build tags separated by a comma are AND-ed together. |
| assertNot(shouldTest("// +build !windows,!plan9", "windows", "amd64")) |
| assertNot(shouldTest("// +build !windows,!plan9", "plan9", "386")) |
| |
| // Build tags on multiple lines are AND-ed together. |
| assert(shouldTest("// +build !windows\n// +build amd64", "linux", "amd64")) |
| assertNot(shouldTest("// +build !windows\n// +build amd64", "windows", "amd64")) |
| |
| // Test that (!a OR !b) matches anything. |
| assert(shouldTest("// +build !windows !plan9", "windows", "amd64")) |
| } |
| |
| func getenv(key, def string) string { |
| value := os.Getenv(key) |
| if value != "" { |
| return value |
| } |
| return def |
| } |
| |
| // overlayDir makes a minimal-overhead copy of srcRoot in which new files may be added. |
| func overlayDir(dstRoot, srcRoot string) error { |
| dstRoot = filepath.Clean(dstRoot) |
| if err := os.MkdirAll(dstRoot, 0777); err != nil { |
| return err |
| } |
| |
| srcRoot, err := filepath.Abs(srcRoot) |
| if err != nil { |
| return err |
| } |
| |
| return filepath.WalkDir(srcRoot, func(srcPath string, d fs.DirEntry, err error) error { |
| if err != nil || srcPath == srcRoot { |
| return err |
| } |
| |
| suffix := strings.TrimPrefix(srcPath, srcRoot) |
| for len(suffix) > 0 && suffix[0] == filepath.Separator { |
| suffix = suffix[1:] |
| } |
| dstPath := filepath.Join(dstRoot, suffix) |
| |
| var info fs.FileInfo |
| if d.Type()&os.ModeSymlink != 0 { |
| info, err = os.Stat(srcPath) |
| } else { |
| info, err = d.Info() |
| } |
| if err != nil { |
| return err |
| } |
| perm := info.Mode() & os.ModePerm |
| |
| // Always copy directories (don't symlink them). |
| // If we add a file in the overlay, we don't want to add it in the original. |
| if info.IsDir() { |
| return os.MkdirAll(dstPath, perm|0200) |
| } |
| |
| // If the OS supports symlinks, use them instead of copying bytes. |
| if err := os.Symlink(srcPath, dstPath); err == nil { |
| return nil |
| } |
| |
| // Otherwise, copy the bytes. |
| src, err := os.Open(srcPath) |
| if err != nil { |
| return err |
| } |
| defer src.Close() |
| |
| dst, err := os.OpenFile(dstPath, os.O_WRONLY|os.O_CREATE|os.O_EXCL, perm) |
| if err != nil { |
| return err |
| } |
| |
| _, err = io.Copy(dst, src) |
| if closeErr := dst.Close(); err == nil { |
| err = closeErr |
| } |
| return err |
| }) |
| } |
| |
| // The following is temporary scaffolding to get types2 typechecker |
| // up and running against the existing test cases. The explicitly |
| // listed files don't pass yet, usually because the error messages |
| // are slightly different (this list is not complete). Any errorcheck |
| // tests that require output from analysis phases past initial type- |
| // checking are also excluded since these phases are not running yet. |
| // We can get rid of this code once types2 is fully plugged in. |
| |
| // List of files that the compiler cannot errorcheck with the new typechecker (compiler -G option). |
| // Temporary scaffolding until we pass all the tests at which point this map can be removed. |
| var types2Failures = setOf( |
| "directive.go", // misplaced compiler directive checks |
| "float_lit3.go", // types2 reports extra errors |
| "import1.go", // types2 reports extra errors |
| "import6.go", // issue #43109 |
| "initializerr.go", // types2 reports extra errors |
| "linkname2.go", // error reported by noder (not running for types2 errorcheck test) |
| "notinheap.go", // types2 doesn't report errors about conversions that are invalid due to //go:notinheap |
| "shift1.go", // issue #42989 |
| "typecheck.go", // invalid function is not causing errors when called |
| |
| "interface/private.go", // types2 phrases errors differently (doesn't use non-spec "private" term) |
| |
| "fixedbugs/bug176.go", // types2 reports all errors (pref: types2) |
| "fixedbugs/bug195.go", // types2 reports slightly different (but correct) bugs |
| "fixedbugs/bug228.go", // types2 doesn't run when there are syntax errors |
| "fixedbugs/bug231.go", // types2 bug? (same error reported twice) |
| "fixedbugs/bug255.go", // types2 reports extra errors |
| "fixedbugs/bug374.go", // types2 reports extra errors |
| "fixedbugs/bug388.go", // types2 not run due to syntax errors |
| "fixedbugs/bug412.go", // types2 produces a follow-on error |
| |
| "fixedbugs/issue10700.go", // types2 reports ok hint, but does not match regexp |
| "fixedbugs/issue11590.go", // types2 doesn't report a follow-on error (pref: types2) |
| "fixedbugs/issue11610.go", // types2 not run after syntax errors |
| "fixedbugs/issue11614.go", // types2 reports an extra error |
| "fixedbugs/issue14520.go", // missing import path error by types2 |
| "fixedbugs/issue16428.go", // types2 reports two instead of one error |
| "fixedbugs/issue17038.go", // types2 doesn't report a follow-on error (pref: types2) |
| "fixedbugs/issue17645.go", // multiple errors on same line |
| "fixedbugs/issue18331.go", // missing error about misuse of //go:noescape (irgen needs code from noder) |
| "fixedbugs/issue18419.go", // types2 reports |
| "fixedbugs/issue19012.go", // multiple errors on same line |
| "fixedbugs/issue20233.go", // types2 reports two instead of one error (pref: compiler) |
| "fixedbugs/issue20245.go", // types2 reports two instead of one error (pref: compiler) |
| "fixedbugs/issue21979.go", // types2 doesn't report a follow-on error (pref: types2) |
| "fixedbugs/issue23732.go", // types2 reports different (but ok) line numbers |
| "fixedbugs/issue25958.go", // types2 doesn't report a follow-on error (pref: types2) |
| "fixedbugs/issue28079b.go", // types2 reports follow-on errors |
| "fixedbugs/issue28268.go", // types2 reports follow-on errors |
| "fixedbugs/issue31053.go", // types2 reports "unknown field" instead of "cannot refer to unexported field" |
| "fixedbugs/issue33460.go", // types2 reports alternative positions in separate error |
| "fixedbugs/issue42058a.go", // types2 doesn't report "channel element type too large" |
| "fixedbugs/issue42058b.go", // types2 doesn't report "channel element type too large" |
| "fixedbugs/issue4232.go", // types2 reports (correct) extra errors |
| "fixedbugs/issue4452.go", // types2 reports (correct) extra errors |
| "fixedbugs/issue4510.go", // types2 reports different (but ok) line numbers |
| "fixedbugs/issue47201.go", // types2 spells the error message differently |
| "fixedbugs/issue5609.go", // types2 needs a better error message |
| "fixedbugs/issue7525b.go", // types2 reports init cycle error on different line - ok otherwise |
| "fixedbugs/issue7525c.go", // types2 reports init cycle error on different line - ok otherwise |
| "fixedbugs/issue7525d.go", // types2 reports init cycle error on different line - ok otherwise |
| "fixedbugs/issue7525e.go", // types2 reports init cycle error on different line - ok otherwise |
| "fixedbugs/issue7525.go", // types2 reports init cycle error on different line - ok otherwise |
| ) |
| |
| var types2Failures32Bit = setOf( |
| "printbig.go", // large untyped int passed to print (32-bit) |
| "fixedbugs/bug114.go", // large untyped int passed to println (32-bit) |
| "fixedbugs/issue23305.go", // large untyped int passed to println (32-bit) |
| "fixedbugs/bug385_32.go", // types2 doesn't produce missing error "type .* too large" (32-bit specific) |
| ) |
| |
| var g3Failures = setOf( |
| "writebarrier.go", // correct diagnostics, but different lines (probably irgen's fault) |
| |
| "typeparam/nested.go", // -G=3 doesn't support function-local types with generics |
| |
| "typeparam/mdempsky/4.go", // -G=3 can't export functions with labeled breaks in loops |
| ) |
| |
| var unifiedFailures = setOf( |
| "closure3.go", // unified IR numbers closures differently than -d=inlfuncswithclosures |
| "escape4.go", // unified IR can inline f5 and f6; test doesn't expect this |
| "inline.go", // unified IR reports function literal diagnostics on different lines than -d=inlfuncswithclosures |
| |
| "fixedbugs/issue42284.go", // prints "T(0) does not escape", but test expects "a.I(a.T(0)) does not escape" |
| "fixedbugs/issue7921.go", // prints "… escapes to heap", but test expects "string(…) escapes to heap" |
| ) |
| |
| func setOf(keys ...string) map[string]bool { |
| m := make(map[string]bool, len(keys)) |
| for _, key := range keys { |
| m[key] = true |
| } |
| return m |
| } |
| |
| // splitQuoted splits the string s around each instance of one or more consecutive |
| // white space characters while taking into account quotes and escaping, and |
| // returns an array of substrings of s or an empty list if s contains only white space. |
| // Single quotes and double quotes are recognized to prevent splitting within the |
| // quoted region, and are removed from the resulting substrings. If a quote in s |
| // isn't closed err will be set and r will have the unclosed argument as the |
| // last element. The backslash is used for escaping. |
| // |
| // For example, the following string: |
| // |
| // a b:"c d" 'e''f' "g\"" |
| // |
| // Would be parsed as: |
| // |
| // []string{"a", "b:c d", "ef", `g"`} |
| // |
| // [copied from src/go/build/build.go] |
| func splitQuoted(s string) (r []string, err error) { |
| var args []string |
| arg := make([]rune, len(s)) |
| escaped := false |
| quoted := false |
| quote := '\x00' |
| i := 0 |
| for _, rune := range s { |
| switch { |
| case escaped: |
| escaped = false |
| case rune == '\\': |
| escaped = true |
| continue |
| case quote != '\x00': |
| if rune == quote { |
| quote = '\x00' |
| continue |
| } |
| case rune == '"' || rune == '\'': |
| quoted = true |
| quote = rune |
| continue |
| case unicode.IsSpace(rune): |
| if quoted || i > 0 { |
| quoted = false |
| args = append(args, string(arg[:i])) |
| i = 0 |
| } |
| continue |
| } |
| arg[i] = rune |
| i++ |
| } |
| if quoted || i > 0 { |
| args = append(args, string(arg[:i])) |
| } |
| if quote != 0 { |
| err = errors.New("unclosed quote") |
| } else if escaped { |
| err = errors.New("unfinished escaping") |
| } |
| return args, err |
| } |