447 lines
13 KiB
Go
447 lines
13 KiB
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 build
|
||
|
|
|
||
|
|
import (
|
||
|
|
"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 != "github.com/magefile/mage/build" {
|
||
|
|
t.Fatalf("ImportPath=%q, want %q", p.ImportPath, "github.com/magefile/mage/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)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestRequiredTags(t *testing.T) {
|
||
|
|
tests := []struct {
|
||
|
|
name string
|
||
|
|
file string
|
||
|
|
should bool
|
||
|
|
}{
|
||
|
|
{
|
||
|
|
"no req tag",
|
||
|
|
"package main",
|
||
|
|
false,
|
||
|
|
},
|
||
|
|
{
|
||
|
|
"has req tag",
|
||
|
|
`// +build req
|
||
|
|
|
||
|
|
package main`,
|
||
|
|
true,
|
||
|
|
},
|
||
|
|
{
|
||
|
|
"OR with req",
|
||
|
|
`// +build no req
|
||
|
|
|
||
|
|
package main`,
|
||
|
|
true,
|
||
|
|
},
|
||
|
|
}
|
||
|
|
|
||
|
|
ctx := &Context{
|
||
|
|
BuildTags: []string{"req"},
|
||
|
|
RequiredTags: []string{"req"},
|
||
|
|
}
|
||
|
|
for _, tst := range tests {
|
||
|
|
t.Run(tst.name, func(t *testing.T) {
|
||
|
|
if tst.should != ctx.shouldBuild([]byte(tst.file), nil, nil) {
|
||
|
|
t.Errorf("shouldBuild = %v, want %v", !tst.should, tst.should)
|
||
|
|
}
|
||
|
|
})
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
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) {
|
||
|
|
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) {
|
||
|
|
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) {
|
||
|
|
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) {
|
||
|
|
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)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// HasGoBuild reports whether the current system can build programs with ``go build''
|
||
|
|
// and then run them with os.StartProcess or exec.Command.
|
||
|
|
func HasGoBuild() bool {
|
||
|
|
switch runtime.GOOS {
|
||
|
|
case "android", "nacl":
|
||
|
|
return false
|
||
|
|
case "darwin":
|
||
|
|
if strings.HasPrefix(runtime.GOARCH, "arm") {
|
||
|
|
return false
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return true
|
||
|
|
}
|
||
|
|
|
||
|
|
// MustHaveGoBuild checks that the current system can build programs with ``go build''
|
||
|
|
// and then run them with os.StartProcess or exec.Command.
|
||
|
|
// If not, MustHaveGoBuild calls t.Skip with an explanation.
|
||
|
|
func MustHaveGoBuild(t *testing.T) {
|
||
|
|
if !HasGoBuild() {
|
||
|
|
t.Skipf("skipping test: 'go build' not available on %s/%s", runtime.GOOS, runtime.GOARCH)
|
||
|
|
}
|
||
|
|
}
|