| // Copyright 2014 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. |
| |
| // go command is not available on android |
| |
| // +build !android |
| |
| package main |
| |
| import ( |
| "bytes" |
| "fmt" |
| "go/build" |
| "io" |
| "io/ioutil" |
| "os" |
| "os/exec" |
| "path/filepath" |
| "strings" |
| "testing" |
| |
| "golang.org/x/tools/internal/testenv" |
| ) |
| |
| // This file contains a test that compiles and runs each program in testdata |
| // after generating the string method for its type. The rule is that for testdata/x.go |
| // we run stringer -type X and then compile and run the program. The resulting |
| // binary panics if the String method for X is not correct, including for error cases. |
| |
| func TestEndToEnd(t *testing.T) { |
| dir, stringer := buildStringer(t) |
| defer os.RemoveAll(dir) |
| // Read the testdata directory. |
| fd, err := os.Open("testdata") |
| if err != nil { |
| t.Fatal(err) |
| } |
| defer fd.Close() |
| names, err := fd.Readdirnames(-1) |
| if err != nil { |
| t.Fatalf("Readdirnames: %s", err) |
| } |
| // Generate, compile, and run the test programs. |
| for _, name := range names { |
| if !strings.HasSuffix(name, ".go") { |
| t.Errorf("%s is not a Go file", name) |
| continue |
| } |
| if strings.HasPrefix(name, "tag_") || strings.HasPrefix(name, "vary_") { |
| // This file is used for tag processing in TestTags or TestConstValueChange, below. |
| continue |
| } |
| if name == "cgo.go" && !build.Default.CgoEnabled { |
| t.Logf("cgo is not enabled for %s", name) |
| continue |
| } |
| // Names are known to be ASCII and long enough. |
| typeName := fmt.Sprintf("%c%s", name[0]+'A'-'a', name[1:len(name)-len(".go")]) |
| stringerCompileAndRun(t, dir, stringer, typeName, name) |
| } |
| } |
| |
| // TestTags verifies that the -tags flag works as advertised. |
| func TestTags(t *testing.T) { |
| dir, stringer := buildStringer(t) |
| defer os.RemoveAll(dir) |
| var ( |
| protectedConst = []byte("TagProtected") |
| output = filepath.Join(dir, "const_string.go") |
| ) |
| for _, file := range []string{"tag_main.go", "tag_tag.go"} { |
| err := copy(filepath.Join(dir, file), filepath.Join("testdata", file)) |
| if err != nil { |
| t.Fatal(err) |
| } |
| } |
| // Run stringer in the directory that contains the package files. |
| // We cannot run stringer in the current directory for the following reasons: |
| // - Versions of Go earlier than Go 1.11, do not support absolute directories as a pattern. |
| // - When the current directory is inside a go module, the path will not be considered |
| // a valid path to a package. |
| err := runInDir(dir, stringer, "-type", "Const", ".") |
| if err != nil { |
| t.Fatal(err) |
| } |
| result, err := ioutil.ReadFile(output) |
| if err != nil { |
| t.Fatal(err) |
| } |
| if bytes.Contains(result, protectedConst) { |
| t.Fatal("tagged variable appears in untagged run") |
| } |
| err = os.Remove(output) |
| if err != nil { |
| t.Fatal(err) |
| } |
| err = runInDir(dir, stringer, "-type", "Const", "-tags", "tag", ".") |
| if err != nil { |
| t.Fatal(err) |
| } |
| result, err = ioutil.ReadFile(output) |
| if err != nil { |
| t.Fatal(err) |
| } |
| if !bytes.Contains(result, protectedConst) { |
| t.Fatal("tagged variable does not appear in tagged run") |
| } |
| } |
| |
| // TestConstValueChange verifies that if a constant value changes and |
| // the stringer code is not regenerated, we'll get a compiler error. |
| func TestConstValueChange(t *testing.T) { |
| dir, stringer := buildStringer(t) |
| defer os.RemoveAll(dir) |
| source := filepath.Join(dir, "day.go") |
| err := copy(source, filepath.Join("testdata", "day.go")) |
| if err != nil { |
| t.Fatal(err) |
| } |
| stringSource := filepath.Join(dir, "day_string.go") |
| // Run stringer in the directory that contains the package files. |
| err = runInDir(dir, stringer, "-type", "Day", "-output", stringSource) |
| if err != nil { |
| t.Fatal(err) |
| } |
| // Run the binary in the temporary directory as a sanity check. |
| err = run("go", "run", stringSource, source) |
| if err != nil { |
| t.Fatal(err) |
| } |
| // Overwrite the source file with a version that has changed constants. |
| err = copy(source, filepath.Join("testdata", "vary_day.go")) |
| if err != nil { |
| t.Fatal(err) |
| } |
| // Unfortunately different compilers may give different error messages, |
| // so there's no easy way to verify that the build failed specifically |
| // because the constants changed rather than because the vary_day.go |
| // file is invalid. |
| // |
| // Instead we'll just rely on manual inspection of the polluted test |
| // output. An alternative might be to check that the error output |
| // matches a set of possible error strings emitted by known |
| // Go compilers. |
| fmt.Fprintf(os.Stderr, "Note: the following messages should indicate an out-of-bounds compiler error\n") |
| err = run("go", "build", stringSource, source) |
| if err == nil { |
| t.Fatal("unexpected compiler success") |
| } |
| } |
| |
| // buildStringer creates a temporary directory and installs stringer there. |
| func buildStringer(t *testing.T) (dir string, stringer string) { |
| t.Helper() |
| testenv.NeedsTool(t, "go") |
| |
| dir, err := ioutil.TempDir("", "stringer") |
| if err != nil { |
| t.Fatal(err) |
| } |
| stringer = filepath.Join(dir, "stringer.exe") |
| err = run("go", "build", "-o", stringer) |
| if err != nil { |
| t.Fatalf("building stringer: %s", err) |
| } |
| return dir, stringer |
| } |
| |
| // stringerCompileAndRun runs stringer for the named file and compiles and |
| // runs the target binary in directory dir. That binary will panic if the String method is incorrect. |
| func stringerCompileAndRun(t *testing.T, dir, stringer, typeName, fileName string) { |
| t.Helper() |
| t.Logf("run: %s %s\n", fileName, typeName) |
| source := filepath.Join(dir, fileName) |
| err := copy(source, filepath.Join("testdata", fileName)) |
| if err != nil { |
| t.Fatalf("copying file to temporary directory: %s", err) |
| } |
| stringSource := filepath.Join(dir, typeName+"_string.go") |
| // Run stringer in temporary directory. |
| err = run(stringer, "-type", typeName, "-output", stringSource, source) |
| if err != nil { |
| t.Fatal(err) |
| } |
| // Run the binary in the temporary directory. |
| err = run("go", "run", stringSource, source) |
| if err != nil { |
| t.Fatal(err) |
| } |
| } |
| |
| // copy copies the from file to the to file. |
| func copy(to, from string) error { |
| toFd, err := os.Create(to) |
| if err != nil { |
| return err |
| } |
| defer toFd.Close() |
| fromFd, err := os.Open(from) |
| if err != nil { |
| return err |
| } |
| defer fromFd.Close() |
| _, err = io.Copy(toFd, fromFd) |
| return err |
| } |
| |
| // run runs a single command and returns an error if it does not succeed. |
| // os/exec should have this function, to be honest. |
| func run(name string, arg ...string) error { |
| return runInDir(".", name, arg...) |
| } |
| |
| // runInDir runs a single command in directory dir and returns an error if |
| // it does not succeed. |
| func runInDir(dir, name string, arg ...string) error { |
| cmd := exec.Command(name, arg...) |
| cmd.Dir = dir |
| cmd.Stdout = os.Stdout |
| cmd.Stderr = os.Stderr |
| cmd.Env = append(os.Environ(), "GO111MODULE=auto") |
| return cmd.Run() |
| } |
