gotest: avoid conflicts with the name of the tested package

Uses a generic solution of renaming the tested package, instead of
using cryptic names for all other imports, variables and methods
in the generated _testmain.go file.

Fixes #2346.

R=golang-dev, r, adg
CC=golang-dev, rsc
https://golang.org/cl/5254061

diff --git a/src/cmd/gotest/gotest.go b/src/cmd/gotest/gotest.go
index 69b0d580b0792c9b08f5f951c9c6f15f194d0ae0..b03e79f00a9cbf907caa16e0ac59158c2bca69b4 100644 (file)
--- a/src/cmd/gotest/gotest.go
+++ b/src/cmd/gotest/gotest.go
@@ -234,7 +234,7 @@ func getTestNames() {
                        }
                        // TODO: worth checking the signature? Probably not.
                }
-               if strings.HasSuffix(f.pkg, "_test") {
+               if isOutsideTest(f.pkg) {
                        outsideFileNames = append(outsideFileNames, f.name)
                } else {
                        insideFileNames = append(insideFileNames, f.name)
@@ -371,38 +371,41 @@ func writeTestmainGo() {
                if len(f.tests) == 0 && len(f.benchmarks) == 0 {
                        continue
                }
-               if strings.HasSuffix(f.pkg, "_test") {
+               if isOutsideTest(f.pkg) {
                        outsideTests = true
                } else {
                        insideTests = true
                }
        }
+       // Rename the imports for the system under test,
+       // in case the tested package has the same name
+       // as any of the other imports, variables or methods.
        if insideTests {
                switch importPath {
                case "testing":
                case "main":
                        // Import path main is reserved, so import with
                        // explicit reference to ./_test/main instead.
-                       // Also, the file we are writing defines a function named main,
-                       // so rename this import to __main__ to avoid name conflict.
-                       fmt.Fprintf(b, "import __main__ %q\n", "./_test/main")
+                       fmt.Fprintf(b, "import target %q\n", "./_test/main")
                default:
-                       fmt.Fprintf(b, "import %q\n", importPath)
+                       fmt.Fprintf(b, "import target %q\n", importPath)
                }
        }
        if outsideTests {
-               fmt.Fprintf(b, "import %q\n", "./_xtest_")
+               // It is possible to have both inside and outside tests
+               // at the same time, so a different import name is needed.
+               fmt.Fprintf(b, "import target_test %q\n", "./_xtest_")
        }
        fmt.Fprintf(b, "import %q\n", "testing")
-       fmt.Fprintf(b, "import __os__ %q\n", "os")         // rename in case tested package is called os
-       fmt.Fprintf(b, "import __regexp__ %q\n", "regexp") // rename in case tested package is called regexp
-       fmt.Fprintln(b)                                    // for gofmt
+       fmt.Fprintf(b, "import %q\n", "os")
+       fmt.Fprintf(b, "import %q\n", "regexp")
+       fmt.Fprintln(b) // for gofmt
 
        // Tests.
        fmt.Fprintln(b, "var tests = []testing.InternalTest{")
        for _, f := range files {
                for _, t := range f.tests {
-                       fmt.Fprintf(b, "\t{\"%s.%s\", %s.%s},\n", f.pkg, t, notMain(f.pkg), t)
+                       fmt.Fprintf(b, "\t{\"%s.%s\", %s.%s},\n", f.pkg, t, renamedPackage(f.pkg), t)
                }
        }
        fmt.Fprintln(b, "}")
@@ -412,7 +415,7 @@ func writeTestmainGo() {
        fmt.Fprintf(b, "var benchmarks = []testing.InternalBenchmark{")
        for _, f := range files {
                for _, bm := range f.benchmarks {
-                       fmt.Fprintf(b, "\t{\"%s.%s\", %s.%s},\n", f.pkg, bm, notMain(f.pkg), bm)
+                       fmt.Fprintf(b, "\t{\"%s.%s\", %s.%s},\n", f.pkg, bm, renamedPackage(f.pkg), bm)
                }
        }
        fmt.Fprintln(b, "}")
@@ -421,7 +424,7 @@ func writeTestmainGo() {
        fmt.Fprintf(b, "var examples = []testing.InternalExample{")
        for _, f := range files {
                for _, eg := range f.examples {
-                       fmt.Fprintf(b, "\t{%q, %s.%s, %q},\n", eg.name, f.pkg, eg.name, eg.output)
+                       fmt.Fprintf(b, "\t{%q, %s.%s, %q},\n", eg.name, renamedPackage(f.pkg), eg.name, eg.output)
                }
        }
        fmt.Fprintln(b, "}")
@@ -430,23 +433,27 @@ func writeTestmainGo() {
        fmt.Fprintln(b, testBody)
 }
 
-// notMain returns the package, renaming as appropriate if it's "main".
-func notMain(pkg string) string {
-       if pkg == "main" {
-               return "__main__"
+// renamedPackage returns the name under which the test package was imported.
+func renamedPackage(pkg string) string {
+       if isOutsideTest(pkg) {
+               return "target_test"
        }
-       return pkg
+       return "target"
+}
+
+func isOutsideTest(pkg string) bool {
+       return strings.HasSuffix(pkg, "_test")
 }
 
 // testBody is just copied to the output. It's the code that runs the tests.
 var testBody = `
 var matchPat string
-var matchRe *__regexp__.Regexp
+var matchRe *regexp.Regexp
 
-func matchString(pat, str string) (result bool, err __os__.Error) {
+func matchString(pat, str string) (result bool, err os.Error) {
        if matchRe == nil || matchPat != pat {
                matchPat = pat
-               matchRe, err = __regexp__.Compile(matchPat)
+               matchRe, err = regexp.Compile(matchPat)
                if err != nil {
                        return
                }