code review 5708054: cmd/go: fixes

src/cmd/go/test.go

 // Copyright 2011 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"
         "fmt"
         "go/ast"
         "go/build"
         "go/doc"
         "go/parser"
-        "go/scanner"
         "go/token"
         "os"
         "os/exec"
         "path"
         "path/filepath"
         "runtime"
         "sort"
         "strings"
         "text/template"
         "time"
         "unicode"
         "unicode/utf8"
 )
 
 // Break init loop.
 func init() {
         cmdTest.Run = runTest
 }
 
 var cmdTest = &Command{
         CustomFlags: true,
-        UsageLine:   "test [-c] [-i] [-p n] [-x] [importpath...] [flags for test binary]",
+        UsageLine:   "test [-c] [-i] [build flags] [packages] [flags for test binary]",
         Short:       "test packages",
         Long: `
 'Go test' automates testing the packages named by the import paths.
 It prints a summary of the test results in the format:
 
         ok   archive/tar   0.011s
         FAIL archive/zip   0.022s
         ok   compress/gzip 0.033s
         ...
 
 followed by detailed output for each failed package.
 
 'Go test' recompiles each package along with any files with names matching
 the file pattern "*_test.go".  These additional files can contain test functions,
 benchmark functions, and example functions.  See 'go help testfunc' for more.
 
 By default, go test needs no arguments.  It compiles and tests the package
 with source in the current directory, including tests, and runs the tests.
 
 The package is built in a temporary directory so it does not interfere with the
 non-test installation.
 
-The flags handled by 'go test' itself are:
+In addition to the build flags, the flags handled by 'go test' itself are:
 
         -c  Compile the test binary to pkg.test but do not run it.
 
         -i
             Install packages that are dependencies of the test.
             Do not run the test.
 
-        -p n
-            Compile and test up to n packages in parallel.
-            The default value is the number of CPUs available.
-
-        -x  Print each subcommand go test executes.
-
 The test binary also accepts flags that control execution of the test; these
 flags are also accessible by 'go test'.  See 'go help testflag' for details.
 
-See 'go help importpath' for more about import paths.
+For more about build flags, see 'go help build'.
+For more about specifying packages, see 'go help packages'.
 
 See also: go build, go vet.
 `,
 }
 
 var helpTestflag = &Command{
         UsageLine: "testflag",
         Short:     "description of testing flags",
         Long: `
 The 'go test' command takes both flags that apply to 'go test' itself
@@ skipping 40 matching lines @@
             exhaustive tests.
 
         -test.timeout t
                 If a test runs longer than t, panic.
 
         -test.benchtime n
                 Run enough iterations of each benchmark to take n seconds.
                 The default is 1 second.
 
         -test.cpu 1,2,4
-            Specify a list of GOMAXPROCS values for which the tests or 
+            Specify a list of GOMAXPROCS values for which the tests or
             benchmarks should be executed.  The default is the current value
             of GOMAXPROCS.
 
 For convenience, each of these -test.X flags of the test binary is
 also available as the flag -X in 'go test' itself.  Flags not listed
 here are passed through unaltered.  For instance, the command
 
         go test -x -v -cpuprofile=prof.out -dir=testdata -update
 
 will compile the test binary and then run it as
@@ skipping 152 matching lines @@
                 }
                 b.init()
         }
 
         var builds, runs, prints []*action
 
         // Prepare build + run + print actions for all packages being tested.
         for _, p := range pkgs {
                 buildTest, runTest, printTest, err := b.test(p)
                 if err != nil {
-                        if list, ok := err.(scanner.ErrorList); ok {
-                                const n = 10
-                                if len(list) > n {
-                                        list = list[:n]
-                                }
-                                for _, err := range list {
-                                        errorf("%s", err)
-                                }
-                                continue
+                        str := err.Error()
+                        if strings.HasPrefix(str, "\n") {
+                                str = str[1:]
                         }
-                        errorf("%s", err)
+                        if p.ImportPath != "" {
+                                errorf("# %s\n%s", p.ImportPath, str)
+                        } else {
+                                errorf("%s", str)
+                        }
                         continue
                 }
                 builds = append(builds, buildTest)
                 runs = append(runs, runTest)
                 prints = append(prints, printTest)
         }
 
         // Ultimately the goal is to print the output.
         root := &action{deps: prints}
 
@@ skipping 55 matching lines @@
                 print := &action{f: (*builder).notest, p: p, deps: []*action{build}}
                 return build, run, print, nil
         }
 
         // Build Package structs describing:
         //      ptest - package + test files
         //      pxtest - package of external test files
         //      pmain - pkg.test binary
         var ptest, pxtest, pmain *Package
 
-        // go/build does not distinguish the dependencies used
-        // by the TestGoFiles from the dependencies used by the
-        // XTestGoFiles, so we build one list and use it for both
-        // ptest and pxtest.  No harm done.
-        var imports []*Package
+        var imports, ximports []*Package
         var stk importStack
         stk.push(p.ImportPath + "_test")
         for _, path := range p.TestImports {
-                p1 := loadImport(path, p.Dir, &stk)
+                p1 := loadImport(path, p.Dir, &stk, p.build.TestImportPos[path])
                 if p1.Error != nil {
                         return nil, nil, nil, p1.Error
                 }
                 imports = append(imports, p1)
+        }
+        for _, path := range p.XTestImports {
+                p1 := loadImport(path, p.Dir, &stk, p.build.XTestImportPos[path])
+                if p1.Error != nil {
+                        return nil, nil, nil, p1.Error
+                }
+                ximports = append(ximports, p1)
         }
         stk.pop()
 
         // Use last element of import path, not package name.
         // They differ when package name is "main".
         _, elem := path.Split(p.ImportPath)
         testBinary := elem + ".test"
 
         // The ptest package needs to be importable under the
         // same import path that p has, but we cannot put it in
@@ skipping 26 matching lines @@
                 ptest = new(Package)
                 *ptest = *p
                 ptest.GoFiles = nil
                 ptest.GoFiles = append(ptest.GoFiles, p.GoFiles...)
                 ptest.GoFiles = append(ptest.GoFiles, p.TestGoFiles...)
                 ptest.target = ""
                 ptest.Imports = stringList(p.Imports, p.TestImports)
                 ptest.imports = append(append([]*Package{}, p.imports...), imports...)
                 ptest.pkgdir = testDir
                 ptest.fake = true
+                ptest.build = new(build.Package)
+                *ptest.build = *p.build
+                m := map[string][]token.Position{}
+                for k, v := range p.build.ImportPos {
+                        m[k] = append(m[k], v...)
+                }
+                for k, v := range p.build.TestImportPos {
+                        m[k] = append(m[k], v...)
+                }
+                ptest.build.ImportPos = m
                 a := b.action(modeBuild, modeBuild, ptest)
                 a.objdir = testDir + string(filepath.Separator)
                 a.objpkg = ptestObj
                 a.target = ptestObj
                 a.link = false
         } else {
                 ptest = p
         }
 
         // External test package.
         if len(p.XTestGoFiles) > 0 {
                 pxtest = &Package{
                         Name:       p.Name + "_test",
                         ImportPath: p.ImportPath + "_test",
                         Dir:        p.Dir,
                         GoFiles:    p.XTestGoFiles,
-                        Imports:    p.TestImports,
-                        build:      &build.Package{},
-                        imports:    imports,
-                        pkgdir:     testDir,
-                        fake:       true,
-                }
-                pxtest.imports = append(pxtest.imports, ptest)
+                        Imports:    p.XTestImports,
+                        build: &build.Package{
+                                ImportPos: p.build.XTestImportPos,
+                        },
+                        imports: append(ximports, ptest),
+                        pkgdir:  testDir,
+                        fake:    true,
+                }
                 a := b.action(modeBuild, modeBuild, pxtest)
                 a.objdir = testDir + string(filepath.Separator)
                 a.objpkg = buildToolchain.pkgpath(testDir, pxtest, false)
                 a.target = a.objpkg
         }
 
         // Action for building pkg.test.
         pmain = &Package{
                 Name:    "main",
                 Dir:     testDir,
                 GoFiles: []string{"_testmain.go"},
+                imports: []*Package{ptest},
                 build:   &build.Package{},
-                imports: []*Package{ptest},
                 fake:    true,
         }
         if pxtest != nil {
                 pmain.imports = append(pmain.imports, pxtest)
         }
 
         // The generated main also imports testing and regexp.
         stk.push("testmain")
-        ptesting := loadImport("testing", "", &stk)
+        ptesting := loadImport("testing", "", &stk, nil)
         if ptesting.Error != nil {
                 return nil, nil, nil, ptesting.Error
         }
-        pregexp := loadImport("regexp", "", &stk)
+        pregexp := loadImport("regexp", "", &stk, nil)
         if pregexp.Error != nil {
                 return nil, nil, nil, pregexp.Error
         }
         pmain.imports = append(pmain.imports, ptesting, pregexp)
 
         a := b.action(modeBuild, modeBuild, pmain)
         a.objdir = testDir + string(filepath.Separator)
         a.objpkg = filepath.Join(testDir, "main.a")
-        a.target = filepath.Join(testDir, testBinary) + b.exe
+        a.target = filepath.Join(testDir, testBinary) + exeSuffix
         pmainAction := a
 
         if testC {
                 // -c flag: create action to copy binary to ./test.out.
                 runAction = &action{
                         f:      (*builder).install,
                         deps:   []*action{pmainAction},
                         p:      pmain,
-                        target: testBinary + b.exe,
+                        target: testBinary + exeSuffix,
                 }
                 printAction = &action{p: p, deps: []*action{runAction}} // nop
         } else {
                 // run test
                 runAction = &action{
                         f:          (*builder).runTest,
                         deps:       []*action{pmainAction},
                         p:          p,
                         ignoreFail: true,
                 }
@@ skipping 168 matching lines @@
         Package string // imported package name (_test or _xtest)
         Name    string // function name
         Output  string // output, for examples
 }
 
 var testFileSet = token.NewFileSet()
 
 func (t *testFuncs) load(filename, pkg string, seen *bool) error {
         f, err := parser.ParseFile(testFileSet, filename, nil, parser.ParseComments)
         if err != nil {
-                return err
+                return expandScanner(err)
         }
         for _, d := range f.Decls {
                 n, ok := d.(*ast.FuncDecl)
                 if !ok {
                         continue
                 }
                 if n.Recv != nil {
                         continue
                 }
                 name := n.Name.String()
@@ skipping 62 matching lines @@
                 }
         }
         return matchRe.MatchString(str), nil
 }
 
 func main() {
         testing.Main(matchString, tests, benchmarks, examples)
 }
 
 `))