| // 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 build |
| |
| import ( |
| "internal/testenv" |
| "io" |
| "os" |
| "path/filepath" |
| "reflect" |
| "runtime" |
| "strings" |
| "testing" |
| ) |
| |
| func TestMatch(t *testing.T) { |
| ctxt := Default |
| what := "default" |
| match := func(tag string, want map[string]bool) { |
| m := make(map[string]bool) |
| if !ctxt.match(tag, m) { |
| t.Errorf("%s context should match %s, does not", what, tag) |
| } |
| if !reflect.DeepEqual(m, want) { |
| t.Errorf("%s tags = %v, want %v", tag, m, want) |
| } |
| } |
| nomatch := func(tag string, want map[string]bool) { |
| m := make(map[string]bool) |
| if ctxt.match(tag, m) { |
| t.Errorf("%s context should NOT match %s, does", what, tag) |
| } |
| if !reflect.DeepEqual(m, want) { |
| t.Errorf("%s tags = %v, want %v", tag, m, want) |
| } |
| } |
| |
| match(runtime.GOOS+","+runtime.GOARCH, map[string]bool{runtime.GOOS: true, runtime.GOARCH: true}) |
| match(runtime.GOOS+","+runtime.GOARCH+",!foo", map[string]bool{runtime.GOOS: true, runtime.GOARCH: true, "foo": true}) |
| nomatch(runtime.GOOS+","+runtime.GOARCH+",foo", map[string]bool{runtime.GOOS: true, runtime.GOARCH: true, "foo": true}) |
| |
| what = "modified" |
| ctxt.BuildTags = []string{"foo"} |
| match(runtime.GOOS+","+runtime.GOARCH, map[string]bool{runtime.GOOS: true, runtime.GOARCH: true}) |
| match(runtime.GOOS+","+runtime.GOARCH+",foo", map[string]bool{runtime.GOOS: true, runtime.GOARCH: true, "foo": true}) |
| nomatch(runtime.GOOS+","+runtime.GOARCH+",!foo", map[string]bool{runtime.GOOS: true, runtime.GOARCH: true, "foo": true}) |
| match(runtime.GOOS+","+runtime.GOARCH+",!bar", map[string]bool{runtime.GOOS: true, runtime.GOARCH: true, "bar": true}) |
| nomatch(runtime.GOOS+","+runtime.GOARCH+",bar", map[string]bool{runtime.GOOS: true, runtime.GOARCH: true, "bar": true}) |
| nomatch("!", map[string]bool{}) |
| } |
| |
| func TestDotSlashImport(t *testing.T) { |
| p, err := ImportDir("testdata/other", 0) |
| if err != nil { |
| t.Fatal(err) |
| } |
| if len(p.Imports) != 1 || p.Imports[0] != "./file" { |
| t.Fatalf("testdata/other: Imports=%v, want [./file]", p.Imports) |
| } |
| |
| p1, err := Import("./file", "testdata/other", 0) |
| if err != nil { |
| t.Fatal(err) |
| } |
| if p1.Name != "file" { |
| t.Fatalf("./file: Name=%q, want %q", p1.Name, "file") |
| } |
| dir := filepath.Clean("testdata/other/file") // Clean to use \ on Windows |
| if p1.Dir != dir { |
| t.Fatalf("./file: Dir=%q, want %q", p1.Name, dir) |
| } |
| } |
| |
| func TestEmptyImport(t *testing.T) { |
| p, err := Import("", Default.GOROOT, FindOnly) |
| if err == nil { |
| t.Fatal(`Import("") returned nil error.`) |
| } |
| if p == nil { |
| t.Fatal(`Import("") returned nil package.`) |
| } |
| if p.ImportPath != "" { |
| t.Fatalf("ImportPath=%q, want %q.", p.ImportPath, "") |
| } |
| } |
| |
| func TestEmptyFolderImport(t *testing.T) { |
| _, err := Import(".", "testdata/empty", 0) |
| if _, ok := err.(*NoGoError); !ok { |
| t.Fatal(`Import("testdata/empty") did not return NoGoError.`) |
| } |
| } |
| |
| func TestMultiplePackageImport(t *testing.T) { |
| _, err := Import(".", "testdata/multi", 0) |
| mpe, ok := err.(*MultiplePackageError) |
| if !ok { |
| t.Fatal(`Import("testdata/multi") did not return MultiplePackageError.`) |
| } |
| want := &MultiplePackageError{ |
| Dir: filepath.FromSlash("testdata/multi"), |
| Packages: []string{"main", "test_package"}, |
| Files: []string{"file.go", "file_appengine.go"}, |
| } |
| if !reflect.DeepEqual(mpe, want) { |
| t.Errorf("got %#v; want %#v", mpe, want) |
| } |
| } |
| |
| func TestLocalDirectory(t *testing.T) { |
| if runtime.GOOS == "darwin" { |
| switch runtime.GOARCH { |
| case "arm", "arm64": |
| t.Skipf("skipping on %s/%s, no valid GOROOT", runtime.GOOS, runtime.GOARCH) |
| } |
| } |
| |
| cwd, err := os.Getwd() |
| if err != nil { |
| t.Fatal(err) |
| } |
| |
| p, err := ImportDir(cwd, 0) |
| if err != nil { |
| t.Fatal(err) |
| } |
| if p.ImportPath != "go/build" { |
| t.Fatalf("ImportPath=%q, want %q", p.ImportPath, "go/build") |
| } |
| } |
| |
| func TestShouldBuild(t *testing.T) { |
| const file1 = "// +build tag1\n\n" + |
| "package main\n" |
| want1 := map[string]bool{"tag1": true} |
| |
| const file2 = "// +build cgo\n\n" + |
| "// This package implements parsing of tags like\n" + |
| "// +build tag1\n" + |
| "package build" |
| want2 := map[string]bool{"cgo": true} |
| |
| const file3 = "// Copyright The Go Authors.\n\n" + |
| "package build\n\n" + |
| "// shouldBuild checks tags given by lines of the form\n" + |
| "// +build tag\n" + |
| "func shouldBuild(content []byte)\n" |
| want3 := map[string]bool{} |
| |
| ctx := &Context{BuildTags: []string{"tag1"}} |
| m := map[string]bool{} |
| if !ctx.shouldBuild([]byte(file1), m, nil) { |
| t.Errorf("shouldBuild(file1) = false, want true") |
| } |
| if !reflect.DeepEqual(m, want1) { |
| t.Errorf("shouldBuild(file1) tags = %v, want %v", m, want1) |
| } |
| |
| m = map[string]bool{} |
| if ctx.shouldBuild([]byte(file2), m, nil) { |
| t.Errorf("shouldBuild(file2) = true, want false") |
| } |
| if !reflect.DeepEqual(m, want2) { |
| t.Errorf("shouldBuild(file2) tags = %v, want %v", m, want2) |
| } |
| |
| m = map[string]bool{} |
| ctx = &Context{BuildTags: nil} |
| if !ctx.shouldBuild([]byte(file3), m, nil) { |
| t.Errorf("shouldBuild(file3) = false, want true") |
| } |
| if !reflect.DeepEqual(m, want3) { |
| t.Errorf("shouldBuild(file3) tags = %v, want %v", m, want3) |
| } |
| } |
| |
| type readNopCloser struct { |
| io.Reader |
| } |
| |
| func (r readNopCloser) Close() error { |
| return nil |
| } |
| |
| var ( |
| ctxtP9 = Context{GOARCH: "arm", GOOS: "plan9"} |
| ctxtAndroid = Context{GOARCH: "arm", GOOS: "android"} |
| ) |
| |
| var matchFileTests = []struct { |
| ctxt Context |
| name string |
| data string |
| match bool |
| }{ |
| {ctxtP9, "foo_arm.go", "", true}, |
| {ctxtP9, "foo1_arm.go", "// +build linux\n\npackage main\n", false}, |
| {ctxtP9, "foo_darwin.go", "", false}, |
| {ctxtP9, "foo.go", "", true}, |
| {ctxtP9, "foo1.go", "// +build linux\n\npackage main\n", false}, |
| {ctxtP9, "foo.badsuffix", "", false}, |
| {ctxtAndroid, "foo_linux.go", "", true}, |
| {ctxtAndroid, "foo_android.go", "", true}, |
| {ctxtAndroid, "foo_plan9.go", "", false}, |
| {ctxtAndroid, "android.go", "", true}, |
| {ctxtAndroid, "plan9.go", "", true}, |
| {ctxtAndroid, "plan9_test.go", "", true}, |
| {ctxtAndroid, "arm.s", "", true}, |
| {ctxtAndroid, "amd64.s", "", true}, |
| } |
| |
| func TestMatchFile(t *testing.T) { |
| for _, tt := range matchFileTests { |
| ctxt := tt.ctxt |
| ctxt.OpenFile = func(path string) (r io.ReadCloser, err error) { |
| if path != "x+"+tt.name { |
| t.Fatalf("OpenFile asked for %q, expected %q", path, "x+"+tt.name) |
| } |
| return &readNopCloser{strings.NewReader(tt.data)}, nil |
| } |
| ctxt.JoinPath = func(elem ...string) string { |
| return strings.Join(elem, "+") |
| } |
| match, err := ctxt.MatchFile("x", tt.name) |
| if match != tt.match || err != nil { |
| t.Fatalf("MatchFile(%q) = %v, %v, want %v, nil", tt.name, match, err, tt.match) |
| } |
| } |
| } |
| |
| func TestImportCmd(t *testing.T) { |
| if runtime.GOOS == "darwin" { |
| switch runtime.GOARCH { |
| case "arm", "arm64": |
| t.Skipf("skipping on %s/%s, no valid GOROOT", runtime.GOOS, runtime.GOARCH) |
| } |
| } |
| |
| p, err := Import("cmd/internal/objfile", "", 0) |
| if err != nil { |
| t.Fatal(err) |
| } |
| if !strings.HasSuffix(filepath.ToSlash(p.Dir), "src/cmd/internal/objfile") { |
| t.Fatalf("Import cmd/internal/objfile returned Dir=%q, want %q", filepath.ToSlash(p.Dir), ".../src/cmd/internal/objfile") |
| } |
| } |
| |
| var ( |
| expandSrcDirPath = filepath.Join(string(filepath.Separator)+"projects", "src", "add") |
| ) |
| |
| var expandSrcDirTests = []struct { |
| input, expected string |
| }{ |
| {"-L ${SRCDIR}/libs -ladd", "-L /projects/src/add/libs -ladd"}, |
| {"${SRCDIR}/add_linux_386.a -pthread -lstdc++", "/projects/src/add/add_linux_386.a -pthread -lstdc++"}, |
| {"Nothing to expand here!", "Nothing to expand here!"}, |
| {"$", "$"}, |
| {"$$", "$$"}, |
| {"${", "${"}, |
| {"$}", "$}"}, |
| {"$FOO ${BAR}", "$FOO ${BAR}"}, |
| {"Find me the $SRCDIRECTORY.", "Find me the $SRCDIRECTORY."}, |
| {"$SRCDIR is missing braces", "$SRCDIR is missing braces"}, |
| } |
| |
| func TestExpandSrcDir(t *testing.T) { |
| for _, test := range expandSrcDirTests { |
| output, _ := expandSrcDir(test.input, expandSrcDirPath) |
| if output != test.expected { |
| t.Errorf("%q expands to %q with SRCDIR=%q when %q is expected", test.input, output, expandSrcDirPath, test.expected) |
| } else { |
| t.Logf("%q expands to %q with SRCDIR=%q", test.input, output, expandSrcDirPath) |
| } |
| } |
| } |
| |
| func TestShellSafety(t *testing.T) { |
| tests := []struct { |
| input, srcdir, expected string |
| result bool |
| }{ |
| {"-I${SRCDIR}/../include", "/projects/src/issue 11868", "-I/projects/src/issue 11868/../include", true}, |
| {"-I${SRCDIR}", "wtf$@%", "-Iwtf$@%", true}, |
| {"-X${SRCDIR}/1,${SRCDIR}/2", "/projects/src/issue 11868", "-X/projects/src/issue 11868/1,/projects/src/issue 11868/2", true}, |
| {"-I/tmp -I/tmp", "/tmp2", "-I/tmp -I/tmp", true}, |
| {"-I/tmp", "/tmp/[0]", "-I/tmp", true}, |
| {"-I${SRCDIR}/dir", "/tmp/[0]", "-I/tmp/[0]/dir", false}, |
| {"-I${SRCDIR}/dir", "/tmp/go go", "-I/tmp/go go/dir", true}, |
| {"-I${SRCDIR}/dir dir", "/tmp/go", "-I/tmp/go/dir dir", true}, |
| } |
| for _, test := range tests { |
| output, ok := expandSrcDir(test.input, test.srcdir) |
| if ok != test.result { |
| t.Errorf("Expected %t while %q expands to %q with SRCDIR=%q; got %t", test.result, test.input, output, test.srcdir, ok) |
| } |
| if output != test.expected { |
| t.Errorf("Expected %q while %q expands with SRCDIR=%q; got %q", test.expected, test.input, test.srcdir, output) |
| } |
| } |
| } |
| |
| // Want to get a "cannot find package" error when directory for package does not exist. |
| // There should be valid partial information in the returned non-nil *Package. |
| func TestImportDirNotExist(t *testing.T) { |
| testenv.MustHaveGoBuild(t) // really must just have source |
| ctxt := Default |
| ctxt.GOPATH = "" |
| |
| tests := []struct { |
| label string |
| path, srcDir string |
| mode ImportMode |
| }{ |
| {"Import(full, 0)", "go/build/doesnotexist", "", 0}, |
| {"Import(local, 0)", "./doesnotexist", filepath.Join(ctxt.GOROOT, "src/go/build"), 0}, |
| {"Import(full, FindOnly)", "go/build/doesnotexist", "", FindOnly}, |
| {"Import(local, FindOnly)", "./doesnotexist", filepath.Join(ctxt.GOROOT, "src/go/build"), FindOnly}, |
| } |
| for _, test := range tests { |
| p, err := ctxt.Import(test.path, test.srcDir, test.mode) |
| if err == nil || !strings.HasPrefix(err.Error(), "cannot find package") { |
| t.Errorf(`%s got error: %q, want "cannot find package" error`, test.label, err) |
| } |
| // If an error occurs, build.Import is documented to return |
| // a non-nil *Package containing partial information. |
| if p == nil { |
| t.Fatalf(`%s got nil p, want non-nil *Package`, test.label) |
| } |
| // Verify partial information in p. |
| if p.ImportPath != "go/build/doesnotexist" { |
| t.Errorf(`%s got p.ImportPath: %q, want "go/build/doesnotexist"`, test.label, p.ImportPath) |
| } |
| } |
| } |
| |
| func TestImportVendor(t *testing.T) { |
| testenv.MustHaveGoBuild(t) // really must just have source |
| ctxt := Default |
| ctxt.GOPATH = "" |
| p, err := ctxt.Import("golang_org/x/net/http2/hpack", filepath.Join(ctxt.GOROOT, "src/net/http"), 0) |
| if err != nil { |
| t.Fatalf("cannot find vendored golang_org/x/net/http2/hpack from net/http directory: %v", err) |
| } |
| want := "vendor/golang_org/x/net/http2/hpack" |
| if p.ImportPath != want { |
| t.Fatalf("Import succeeded but found %q, want %q", p.ImportPath, want) |
| } |
| } |
| |
| func TestImportVendorFailure(t *testing.T) { |
| testenv.MustHaveGoBuild(t) // really must just have source |
| ctxt := Default |
| ctxt.GOPATH = "" |
| p, err := ctxt.Import("x.com/y/z", filepath.Join(ctxt.GOROOT, "src/net/http"), 0) |
| if err == nil { |
| t.Fatalf("found made-up package x.com/y/z in %s", p.Dir) |
| } |
| |
| e := err.Error() |
| if !strings.Contains(e, " (vendor tree)") { |
| t.Fatalf("error on failed import does not mention GOROOT/src/vendor directory:\n%s", e) |
| } |
| } |
| |
| func TestImportVendorParentFailure(t *testing.T) { |
| testenv.MustHaveGoBuild(t) // really must just have source |
| ctxt := Default |
| ctxt.GOPATH = "" |
| // This import should fail because the vendor/golang.org/x/net/http2 directory has no source code. |
| p, err := ctxt.Import("golang_org/x/net/http2", filepath.Join(ctxt.GOROOT, "src/net/http"), 0) |
| if err == nil { |
| t.Fatalf("found empty parent in %s", p.Dir) |
| } |
| if p != nil && p.Dir != "" { |
| t.Fatalf("decided to use %s", p.Dir) |
| } |
| e := err.Error() |
| if !strings.Contains(e, " (vendor tree)") { |
| t.Fatalf("error on failed import does not mention GOROOT/src/vendor directory:\n%s", e) |
| } |
| } |
