Source file src/go/build/build_test.go

Documentation: go/build

		 1  // Copyright 2011 The Go Authors. All rights reserved.
		 2  // Use of this source code is governed by a BSD-style
		 3  // license that can be found in the LICENSE file.
		 4  
		 5  package build
		 6  
		 7  import (
		 8  	"flag"
		 9  	"internal/testenv"
		10  	"io"
		11  	"os"
		12  	"path/filepath"
		13  	"reflect"
		14  	"runtime"
		15  	"strings"
		16  	"testing"
		17  )
		18  
		19  func TestMain(m *testing.M) {
		20  	flag.Parse()
		21  	if goTool, err := testenv.GoTool(); err == nil {
		22  		os.Setenv("PATH", filepath.Dir(goTool)+string(os.PathListSeparator)+os.Getenv("PATH"))
		23  	}
		24  	os.Exit(m.Run())
		25  }
		26  
		27  func TestMatch(t *testing.T) {
		28  	ctxt := Default
		29  	what := "default"
		30  	match := func(tag string, want map[string]bool) {
		31  		t.Helper()
		32  		m := make(map[string]bool)
		33  		if !ctxt.matchAuto(tag, m) {
		34  			t.Errorf("%s context should match %s, does not", what, tag)
		35  		}
		36  		if !reflect.DeepEqual(m, want) {
		37  			t.Errorf("%s tags = %v, want %v", tag, m, want)
		38  		}
		39  	}
		40  	nomatch := func(tag string, want map[string]bool) {
		41  		t.Helper()
		42  		m := make(map[string]bool)
		43  		if ctxt.matchAuto(tag, m) {
		44  			t.Errorf("%s context should NOT match %s, does", what, tag)
		45  		}
		46  		if !reflect.DeepEqual(m, want) {
		47  			t.Errorf("%s tags = %v, want %v", tag, m, want)
		48  		}
		49  	}
		50  
		51  	match(runtime.GOOS+","+runtime.GOARCH, map[string]bool{runtime.GOOS: true, runtime.GOARCH: true})
		52  	match(runtime.GOOS+","+runtime.GOARCH+",!foo", map[string]bool{runtime.GOOS: true, runtime.GOARCH: true, "foo": true})
		53  	nomatch(runtime.GOOS+","+runtime.GOARCH+",foo", map[string]bool{runtime.GOOS: true, runtime.GOARCH: true, "foo": true})
		54  
		55  	what = "modified"
		56  	ctxt.BuildTags = []string{"foo"}
		57  	match(runtime.GOOS+","+runtime.GOARCH, map[string]bool{runtime.GOOS: true, runtime.GOARCH: true})
		58  	match(runtime.GOOS+","+runtime.GOARCH+",foo", map[string]bool{runtime.GOOS: true, runtime.GOARCH: true, "foo": true})
		59  	nomatch(runtime.GOOS+","+runtime.GOARCH+",!foo", map[string]bool{runtime.GOOS: true, runtime.GOARCH: true, "foo": true})
		60  	match(runtime.GOOS+","+runtime.GOARCH+",!bar", map[string]bool{runtime.GOOS: true, runtime.GOARCH: true, "bar": true})
		61  	nomatch(runtime.GOOS+","+runtime.GOARCH+",bar", map[string]bool{runtime.GOOS: true, runtime.GOARCH: true, "bar": true})
		62  }
		63  
		64  func TestDotSlashImport(t *testing.T) {
		65  	p, err := ImportDir("testdata/other", 0)
		66  	if err != nil {
		67  		t.Fatal(err)
		68  	}
		69  	if len(p.Imports) != 1 || p.Imports[0] != "./file" {
		70  		t.Fatalf("testdata/other: Imports=%v, want [./file]", p.Imports)
		71  	}
		72  
		73  	p1, err := Import("./file", "testdata/other", 0)
		74  	if err != nil {
		75  		t.Fatal(err)
		76  	}
		77  	if p1.Name != "file" {
		78  		t.Fatalf("./file: Name=%q, want %q", p1.Name, "file")
		79  	}
		80  	dir := filepath.Clean("testdata/other/file") // Clean to use \ on Windows
		81  	if p1.Dir != dir {
		82  		t.Fatalf("./file: Dir=%q, want %q", p1.Name, dir)
		83  	}
		84  }
		85  
		86  func TestEmptyImport(t *testing.T) {
		87  	p, err := Import("", Default.GOROOT, FindOnly)
		88  	if err == nil {
		89  		t.Fatal(`Import("") returned nil error.`)
		90  	}
		91  	if p == nil {
		92  		t.Fatal(`Import("") returned nil package.`)
		93  	}
		94  	if p.ImportPath != "" {
		95  		t.Fatalf("ImportPath=%q, want %q.", p.ImportPath, "")
		96  	}
		97  }
		98  
		99  func TestEmptyFolderImport(t *testing.T) {
	 100  	_, err := Import(".", "testdata/empty", 0)
	 101  	if _, ok := err.(*NoGoError); !ok {
	 102  		t.Fatal(`Import("testdata/empty") did not return NoGoError.`)
	 103  	}
	 104  }
	 105  
	 106  func TestMultiplePackageImport(t *testing.T) {
	 107  	pkg, err := Import(".", "testdata/multi", 0)
	 108  
	 109  	mpe, ok := err.(*MultiplePackageError)
	 110  	if !ok {
	 111  		t.Fatal(`Import("testdata/multi") did not return MultiplePackageError.`)
	 112  	}
	 113  	want := &MultiplePackageError{
	 114  		Dir:			filepath.FromSlash("testdata/multi"),
	 115  		Packages: []string{"main", "test_package"},
	 116  		Files:		[]string{"file.go", "file_appengine.go"},
	 117  	}
	 118  	if !reflect.DeepEqual(mpe, want) {
	 119  		t.Errorf("err = %#v; want %#v", mpe, want)
	 120  	}
	 121  
	 122  	// TODO(#45999): Since the name is ambiguous, pkg.Name should be left empty.
	 123  	if wantName := "main"; pkg.Name != wantName {
	 124  		t.Errorf("pkg.Name = %q; want %q", pkg.Name, wantName)
	 125  	}
	 126  
	 127  	if wantGoFiles := []string{"file.go", "file_appengine.go"}; !reflect.DeepEqual(pkg.GoFiles, wantGoFiles) {
	 128  		t.Errorf("pkg.GoFiles = %q; want %q", pkg.GoFiles, wantGoFiles)
	 129  	}
	 130  
	 131  	if wantInvalidFiles := []string{"file_appengine.go"}; !reflect.DeepEqual(pkg.InvalidGoFiles, wantInvalidFiles) {
	 132  		t.Errorf("pkg.InvalidGoFiles = %q; want %q", pkg.InvalidGoFiles, wantInvalidFiles)
	 133  	}
	 134  }
	 135  
	 136  func TestLocalDirectory(t *testing.T) {
	 137  	if runtime.GOOS == "ios" {
	 138  		t.Skipf("skipping on %s/%s, no valid GOROOT", runtime.GOOS, runtime.GOARCH)
	 139  	}
	 140  
	 141  	cwd, err := os.Getwd()
	 142  	if err != nil {
	 143  		t.Fatal(err)
	 144  	}
	 145  
	 146  	p, err := ImportDir(cwd, 0)
	 147  	if err != nil {
	 148  		t.Fatal(err)
	 149  	}
	 150  	if p.ImportPath != "go/build" {
	 151  		t.Fatalf("ImportPath=%q, want %q", p.ImportPath, "go/build")
	 152  	}
	 153  }
	 154  
	 155  var shouldBuildTests = []struct {
	 156  	name				string
	 157  	content		 string
	 158  	tags				map[string]bool
	 159  	binaryOnly	bool
	 160  	shouldBuild bool
	 161  	err				 error
	 162  }{
	 163  	{
	 164  		name: "Yes",
	 165  		content: "// +build yes\n\n" +
	 166  			"package main\n",
	 167  		tags:				map[string]bool{"yes": true},
	 168  		shouldBuild: true,
	 169  	},
	 170  	{
	 171  		name: "Yes2",
	 172  		content: "//go:build yes\n" +
	 173  			"package main\n",
	 174  		tags:				map[string]bool{"yes": true},
	 175  		shouldBuild: true,
	 176  	},
	 177  	{
	 178  		name: "Or",
	 179  		content: "// +build no yes\n\n" +
	 180  			"package main\n",
	 181  		tags:				map[string]bool{"yes": true, "no": true},
	 182  		shouldBuild: true,
	 183  	},
	 184  	{
	 185  		name: "Or2",
	 186  		content: "//go:build no || yes\n" +
	 187  			"package main\n",
	 188  		tags:				map[string]bool{"yes": true, "no": true},
	 189  		shouldBuild: true,
	 190  	},
	 191  	{
	 192  		name: "And",
	 193  		content: "// +build no,yes\n\n" +
	 194  			"package main\n",
	 195  		tags:				map[string]bool{"yes": true, "no": true},
	 196  		shouldBuild: false,
	 197  	},
	 198  	{
	 199  		name: "And2",
	 200  		content: "//go:build no && yes\n" +
	 201  			"package main\n",
	 202  		tags:				map[string]bool{"yes": true, "no": true},
	 203  		shouldBuild: false,
	 204  	},
	 205  	{
	 206  		name: "Cgo",
	 207  		content: "// +build cgo\n\n" +
	 208  			"// Copyright The Go Authors.\n\n" +
	 209  			"// This package implements parsing of tags like\n" +
	 210  			"// +build tag1\n" +
	 211  			"package build",
	 212  		tags:				map[string]bool{"cgo": true},
	 213  		shouldBuild: false,
	 214  	},
	 215  	{
	 216  		name: "Cgo2",
	 217  		content: "//go:build cgo\n" +
	 218  			"// Copyright The Go Authors.\n\n" +
	 219  			"// This package implements parsing of tags like\n" +
	 220  			"// +build tag1\n" +
	 221  			"package build",
	 222  		tags:				map[string]bool{"cgo": true},
	 223  		shouldBuild: false,
	 224  	},
	 225  	{
	 226  		name: "AfterPackage",
	 227  		content: "// Copyright The Go Authors.\n\n" +
	 228  			"package build\n\n" +
	 229  			"// shouldBuild checks tags given by lines of the form\n" +
	 230  			"// +build tag\n" +
	 231  			"//go:build tag\n" +
	 232  			"func shouldBuild(content []byte)\n",
	 233  		tags:				map[string]bool{},
	 234  		shouldBuild: true,
	 235  	},
	 236  	{
	 237  		name: "TooClose",
	 238  		content: "// +build yes\n" +
	 239  			"package main\n",
	 240  		tags:				map[string]bool{},
	 241  		shouldBuild: true,
	 242  	},
	 243  	{
	 244  		name: "TooClose2",
	 245  		content: "//go:build yes\n" +
	 246  			"package main\n",
	 247  		tags:				map[string]bool{"yes": true},
	 248  		shouldBuild: true,
	 249  	},
	 250  	{
	 251  		name: "TooCloseNo",
	 252  		content: "// +build no\n" +
	 253  			"package main\n",
	 254  		tags:				map[string]bool{},
	 255  		shouldBuild: true,
	 256  	},
	 257  	{
	 258  		name: "TooCloseNo2",
	 259  		content: "//go:build no\n" +
	 260  			"package main\n",
	 261  		tags:				map[string]bool{"no": true},
	 262  		shouldBuild: false,
	 263  	},
	 264  	{
	 265  		name: "BinaryOnly",
	 266  		content: "//go:binary-only-package\n" +
	 267  			"// +build yes\n" +
	 268  			"package main\n",
	 269  		tags:				map[string]bool{},
	 270  		binaryOnly:	true,
	 271  		shouldBuild: true,
	 272  	},
	 273  	{
	 274  		name: "BinaryOnly2",
	 275  		content: "//go:binary-only-package\n" +
	 276  			"//go:build no\n" +
	 277  			"package main\n",
	 278  		tags:				map[string]bool{"no": true},
	 279  		binaryOnly:	true,
	 280  		shouldBuild: false,
	 281  	},
	 282  	{
	 283  		name: "ValidGoBuild",
	 284  		content: "// +build yes\n\n" +
	 285  			"//go:build no\n" +
	 286  			"package main\n",
	 287  		tags:				map[string]bool{"no": true},
	 288  		shouldBuild: false,
	 289  	},
	 290  	{
	 291  		name: "MissingBuild2",
	 292  		content: "/* */\n" +
	 293  			"// +build yes\n\n" +
	 294  			"//go:build no\n" +
	 295  			"package main\n",
	 296  		tags:				map[string]bool{"no": true},
	 297  		shouldBuild: false,
	 298  	},
	 299  	{
	 300  		name: "Comment1",
	 301  		content: "/*\n" +
	 302  			"//go:build no\n" +
	 303  			"*/\n\n" +
	 304  			"package main\n",
	 305  		tags:				map[string]bool{},
	 306  		shouldBuild: true,
	 307  	},
	 308  	{
	 309  		name: "Comment2",
	 310  		content: "/*\n" +
	 311  			"text\n" +
	 312  			"*/\n\n" +
	 313  			"//go:build no\n" +
	 314  			"package main\n",
	 315  		tags:				map[string]bool{"no": true},
	 316  		shouldBuild: false,
	 317  	},
	 318  	{
	 319  		name: "Comment3",
	 320  		content: "/*/*/ /* hi *//* \n" +
	 321  			"text\n" +
	 322  			"*/\n\n" +
	 323  			"//go:build no\n" +
	 324  			"package main\n",
	 325  		tags:				map[string]bool{"no": true},
	 326  		shouldBuild: false,
	 327  	},
	 328  	{
	 329  		name: "Comment4",
	 330  		content: "/**///go:build no\n" +
	 331  			"package main\n",
	 332  		tags:				map[string]bool{},
	 333  		shouldBuild: true,
	 334  	},
	 335  	{
	 336  		name: "Comment5",
	 337  		content: "/**/\n" +
	 338  			"//go:build no\n" +
	 339  			"package main\n",
	 340  		tags:				map[string]bool{"no": true},
	 341  		shouldBuild: false,
	 342  	},
	 343  }
	 344  
	 345  func TestShouldBuild(t *testing.T) {
	 346  	for _, tt := range shouldBuildTests {
	 347  		t.Run(tt.name, func(t *testing.T) {
	 348  			ctx := &Context{BuildTags: []string{"yes"}}
	 349  			tags := map[string]bool{}
	 350  			shouldBuild, binaryOnly, err := ctx.shouldBuild([]byte(tt.content), tags)
	 351  			if shouldBuild != tt.shouldBuild || binaryOnly != tt.binaryOnly || !reflect.DeepEqual(tags, tt.tags) || err != tt.err {
	 352  				t.Errorf("mismatch:\n"+
	 353  					"have shouldBuild=%v, binaryOnly=%v, tags=%v, err=%v\n"+
	 354  					"want shouldBuild=%v, binaryOnly=%v, tags=%v, err=%v",
	 355  					shouldBuild, binaryOnly, tags, err,
	 356  					tt.shouldBuild, tt.binaryOnly, tt.tags, tt.err)
	 357  			}
	 358  		})
	 359  	}
	 360  }
	 361  
	 362  func TestGoodOSArchFile(t *testing.T) {
	 363  	ctx := &Context{BuildTags: []string{"linux"}, GOOS: "darwin"}
	 364  	m := map[string]bool{}
	 365  	want := map[string]bool{"linux": true}
	 366  	if !ctx.goodOSArchFile("hello_linux.go", m) {
	 367  		t.Errorf("goodOSArchFile(hello_linux.go) = false, want true")
	 368  	}
	 369  	if !reflect.DeepEqual(m, want) {
	 370  		t.Errorf("goodOSArchFile(hello_linux.go) tags = %v, want %v", m, want)
	 371  	}
	 372  }
	 373  
	 374  type readNopCloser struct {
	 375  	io.Reader
	 376  }
	 377  
	 378  func (r readNopCloser) Close() error {
	 379  	return nil
	 380  }
	 381  
	 382  var (
	 383  	ctxtP9			= Context{GOARCH: "arm", GOOS: "plan9"}
	 384  	ctxtAndroid = Context{GOARCH: "arm", GOOS: "android"}
	 385  )
	 386  
	 387  var matchFileTests = []struct {
	 388  	ctxt	Context
	 389  	name	string
	 390  	data	string
	 391  	match bool
	 392  }{
	 393  	{ctxtP9, "foo_arm.go", "", true},
	 394  	{ctxtP9, "foo1_arm.go", "// +build linux\n\npackage main\n", false},
	 395  	{ctxtP9, "foo_darwin.go", "", false},
	 396  	{ctxtP9, "foo.go", "", true},
	 397  	{ctxtP9, "foo1.go", "// +build linux\n\npackage main\n", false},
	 398  	{ctxtP9, "foo.badsuffix", "", false},
	 399  	{ctxtAndroid, "foo_linux.go", "", true},
	 400  	{ctxtAndroid, "foo_android.go", "", true},
	 401  	{ctxtAndroid, "foo_plan9.go", "", false},
	 402  	{ctxtAndroid, "android.go", "", true},
	 403  	{ctxtAndroid, "plan9.go", "", true},
	 404  	{ctxtAndroid, "plan9_test.go", "", true},
	 405  	{ctxtAndroid, "arm.s", "", true},
	 406  	{ctxtAndroid, "amd64.s", "", true},
	 407  }
	 408  
	 409  func TestMatchFile(t *testing.T) {
	 410  	for _, tt := range matchFileTests {
	 411  		ctxt := tt.ctxt
	 412  		ctxt.OpenFile = func(path string) (r io.ReadCloser, err error) {
	 413  			if path != "x+"+tt.name {
	 414  				t.Fatalf("OpenFile asked for %q, expected %q", path, "x+"+tt.name)
	 415  			}
	 416  			return &readNopCloser{strings.NewReader(tt.data)}, nil
	 417  		}
	 418  		ctxt.JoinPath = func(elem ...string) string {
	 419  			return strings.Join(elem, "+")
	 420  		}
	 421  		match, err := ctxt.MatchFile("x", tt.name)
	 422  		if match != tt.match || err != nil {
	 423  			t.Fatalf("MatchFile(%q) = %v, %v, want %v, nil", tt.name, match, err, tt.match)
	 424  		}
	 425  	}
	 426  }
	 427  
	 428  func TestImportCmd(t *testing.T) {
	 429  	if runtime.GOOS == "ios" {
	 430  		t.Skipf("skipping on %s/%s, no valid GOROOT", runtime.GOOS, runtime.GOARCH)
	 431  	}
	 432  
	 433  	p, err := Import("cmd/internal/objfile", "", 0)
	 434  	if err != nil {
	 435  		t.Fatal(err)
	 436  	}
	 437  	if !strings.HasSuffix(filepath.ToSlash(p.Dir), "src/cmd/internal/objfile") {
	 438  		t.Fatalf("Import cmd/internal/objfile returned Dir=%q, want %q", filepath.ToSlash(p.Dir), ".../src/cmd/internal/objfile")
	 439  	}
	 440  }
	 441  
	 442  var (
	 443  	expandSrcDirPath = filepath.Join(string(filepath.Separator)+"projects", "src", "add")
	 444  )
	 445  
	 446  var expandSrcDirTests = []struct {
	 447  	input, expected string
	 448  }{
	 449  	{"-L ${SRCDIR}/libs -ladd", "-L /projects/src/add/libs -ladd"},
	 450  	{"${SRCDIR}/add_linux_386.a -pthread -lstdc++", "/projects/src/add/add_linux_386.a -pthread -lstdc++"},
	 451  	{"Nothing to expand here!", "Nothing to expand here!"},
	 452  	{"$", "$"},
	 453  	{"$$", "$$"},
	 454  	{"${", "${"},
	 455  	{"$}", "$}"},
	 456  	{"$FOO ${BAR}", "$FOO ${BAR}"},
	 457  	{"Find me the $SRCDIRECTORY.", "Find me the $SRCDIRECTORY."},
	 458  	{"$SRCDIR is missing braces", "$SRCDIR is missing braces"},
	 459  }
	 460  
	 461  func TestExpandSrcDir(t *testing.T) {
	 462  	for _, test := range expandSrcDirTests {
	 463  		output, _ := expandSrcDir(test.input, expandSrcDirPath)
	 464  		if output != test.expected {
	 465  			t.Errorf("%q expands to %q with SRCDIR=%q when %q is expected", test.input, output, expandSrcDirPath, test.expected)
	 466  		} else {
	 467  			t.Logf("%q expands to %q with SRCDIR=%q", test.input, output, expandSrcDirPath)
	 468  		}
	 469  	}
	 470  }
	 471  
	 472  func TestShellSafety(t *testing.T) {
	 473  	tests := []struct {
	 474  		input, srcdir, expected string
	 475  		result									bool
	 476  	}{
	 477  		{"-I${SRCDIR}/../include", "/projects/src/issue 11868", "-I/projects/src/issue 11868/../include", true},
	 478  		{"-I${SRCDIR}", "~wtf$@%^", "-I~wtf$@%^", true},
	 479  		{"-X${SRCDIR}/1,${SRCDIR}/2", "/projects/src/issue 11868", "-X/projects/src/issue 11868/1,/projects/src/issue 11868/2", true},
	 480  		{"-I/tmp -I/tmp", "/tmp2", "-I/tmp -I/tmp", true},
	 481  		{"-I/tmp", "/tmp/[0]", "-I/tmp", true},
	 482  		{"-I${SRCDIR}/dir", "/tmp/[0]", "-I/tmp/[0]/dir", false},
	 483  		{"-I${SRCDIR}/dir", "/tmp/go go", "-I/tmp/go go/dir", true},
	 484  		{"-I${SRCDIR}/dir dir", "/tmp/go", "-I/tmp/go/dir dir", true},
	 485  	}
	 486  	for _, test := range tests {
	 487  		output, ok := expandSrcDir(test.input, test.srcdir)
	 488  		if ok != test.result {
	 489  			t.Errorf("Expected %t while %q expands to %q with SRCDIR=%q; got %t", test.result, test.input, output, test.srcdir, ok)
	 490  		}
	 491  		if output != test.expected {
	 492  			t.Errorf("Expected %q while %q expands with SRCDIR=%q; got %q", test.expected, test.input, test.srcdir, output)
	 493  		}
	 494  	}
	 495  }
	 496  
	 497  // Want to get a "cannot find package" error when directory for package does not exist.
	 498  // There should be valid partial information in the returned non-nil *Package.
	 499  func TestImportDirNotExist(t *testing.T) {
	 500  	testenv.MustHaveGoBuild(t) // really must just have source
	 501  	ctxt := Default
	 502  
	 503  	emptyDir := t.TempDir()
	 504  
	 505  	ctxt.GOPATH = emptyDir
	 506  	ctxt.Dir = emptyDir
	 507  
	 508  	tests := []struct {
	 509  		label				string
	 510  		path, srcDir string
	 511  		mode				 ImportMode
	 512  	}{
	 513  		{"Import(full, 0)", "go/build/doesnotexist", "", 0},
	 514  		{"Import(local, 0)", "./doesnotexist", filepath.Join(ctxt.GOROOT, "src/go/build"), 0},
	 515  		{"Import(full, FindOnly)", "go/build/doesnotexist", "", FindOnly},
	 516  		{"Import(local, FindOnly)", "./doesnotexist", filepath.Join(ctxt.GOROOT, "src/go/build"), FindOnly},
	 517  	}
	 518  
	 519  	defer os.Setenv("GO111MODULE", os.Getenv("GO111MODULE"))
	 520  
	 521  	for _, GO111MODULE := range []string{"off", "on"} {
	 522  		t.Run("GO111MODULE="+GO111MODULE, func(t *testing.T) {
	 523  			os.Setenv("GO111MODULE", GO111MODULE)
	 524  
	 525  			for _, test := range tests {
	 526  				p, err := ctxt.Import(test.path, test.srcDir, test.mode)
	 527  
	 528  				errOk := (err != nil && strings.HasPrefix(err.Error(), "cannot find package"))
	 529  				wantErr := `"cannot find package" error`
	 530  				if test.srcDir == "" {
	 531  					if err != nil && strings.Contains(err.Error(), "is not in GOROOT") {
	 532  						errOk = true
	 533  					}
	 534  					wantErr = `"cannot find package" or "is not in GOROOT" error`
	 535  				}
	 536  				if !errOk {
	 537  					t.Errorf("%s got error: %q, want %s", test.label, err, wantErr)
	 538  				}
	 539  				// If an error occurs, build.Import is documented to return
	 540  				// a non-nil *Package containing partial information.
	 541  				if p == nil {
	 542  					t.Fatalf(`%s got nil p, want non-nil *Package`, test.label)
	 543  				}
	 544  				// Verify partial information in p.
	 545  				if p.ImportPath != "go/build/doesnotexist" {
	 546  					t.Errorf(`%s got p.ImportPath: %q, want "go/build/doesnotexist"`, test.label, p.ImportPath)
	 547  				}
	 548  			}
	 549  		})
	 550  	}
	 551  }
	 552  
	 553  func TestImportVendor(t *testing.T) {
	 554  	testenv.MustHaveGoBuild(t) // really must just have source
	 555  
	 556  	t.Setenv("GO111MODULE", "off")
	 557  
	 558  	ctxt := Default
	 559  	wd, err := os.Getwd()
	 560  	if err != nil {
	 561  		t.Fatal(err)
	 562  	}
	 563  	ctxt.GOPATH = filepath.Join(wd, "testdata/withvendor")
	 564  	p, err := ctxt.Import("c/d", filepath.Join(ctxt.GOPATH, "src/a/b"), 0)
	 565  	if err != nil {
	 566  		t.Fatalf("cannot find vendored c/d from testdata src/a/b directory: %v", err)
	 567  	}
	 568  	want := "a/vendor/c/d"
	 569  	if p.ImportPath != want {
	 570  		t.Fatalf("Import succeeded but found %q, want %q", p.ImportPath, want)
	 571  	}
	 572  }
	 573  
	 574  func TestImportVendorFailure(t *testing.T) {
	 575  	testenv.MustHaveGoBuild(t) // really must just have source
	 576  
	 577  	t.Setenv("GO111MODULE", "off")
	 578  
	 579  	ctxt := Default
	 580  	wd, err := os.Getwd()
	 581  	if err != nil {
	 582  		t.Fatal(err)
	 583  	}
	 584  	ctxt.GOPATH = filepath.Join(wd, "testdata/withvendor")
	 585  	p, err := ctxt.Import("x.com/y/z", filepath.Join(ctxt.GOPATH, "src/a/b"), 0)
	 586  	if err == nil {
	 587  		t.Fatalf("found made-up package x.com/y/z in %s", p.Dir)
	 588  	}
	 589  
	 590  	e := err.Error()
	 591  	if !strings.Contains(e, " (vendor tree)") {
	 592  		t.Fatalf("error on failed import does not mention GOROOT/src/vendor directory:\n%s", e)
	 593  	}
	 594  }
	 595  
	 596  func TestImportVendorParentFailure(t *testing.T) {
	 597  	testenv.MustHaveGoBuild(t) // really must just have source
	 598  
	 599  	t.Setenv("GO111MODULE", "off")
	 600  
	 601  	ctxt := Default
	 602  	wd, err := os.Getwd()
	 603  	if err != nil {
	 604  		t.Fatal(err)
	 605  	}
	 606  	ctxt.GOPATH = filepath.Join(wd, "testdata/withvendor")
	 607  	// This import should fail because the vendor/c directory has no source code.
	 608  	p, err := ctxt.Import("c", filepath.Join(ctxt.GOPATH, "src/a/b"), 0)
	 609  	if err == nil {
	 610  		t.Fatalf("found empty parent in %s", p.Dir)
	 611  	}
	 612  	if p != nil && p.Dir != "" {
	 613  		t.Fatalf("decided to use %s", p.Dir)
	 614  	}
	 615  	e := err.Error()
	 616  	if !strings.Contains(e, " (vendor tree)") {
	 617  		t.Fatalf("error on failed import does not mention GOROOT/src/vendor directory:\n%s", e)
	 618  	}
	 619  }
	 620  
	 621  // Check that a package is loaded in module mode if GO111MODULE=on, even when
	 622  // no go.mod file is present. It should fail to resolve packages outside std.
	 623  // Verifies golang.org/issue/34669.
	 624  func TestImportPackageOutsideModule(t *testing.T) {
	 625  	testenv.MustHaveGoBuild(t)
	 626  
	 627  	// Disable module fetching for this test so that 'go list' fails quickly
	 628  	// without trying to find the latest version of a module.
	 629  	t.Setenv("GOPROXY", "off")
	 630  
	 631  	// Create a GOPATH in a temporary directory. We don't use testdata
	 632  	// because it's in GOROOT, which interferes with the module heuristic.
	 633  	gopath := t.TempDir()
	 634  	if err := os.MkdirAll(filepath.Join(gopath, "src/example.com/p"), 0777); err != nil {
	 635  		t.Fatal(err)
	 636  	}
	 637  	if err := os.WriteFile(filepath.Join(gopath, "src/example.com/p/p.go"), []byte("package p"), 0666); err != nil {
	 638  		t.Fatal(err)
	 639  	}
	 640  
	 641  	t.Setenv("GO111MODULE", "on")
	 642  	t.Setenv("GOPATH", gopath)
	 643  	ctxt := Default
	 644  	ctxt.GOPATH = gopath
	 645  	ctxt.Dir = filepath.Join(gopath, "src/example.com/p")
	 646  
	 647  	want := "go.mod file not found in current directory or any parent directory"
	 648  	if _, err := ctxt.Import("example.com/p", gopath, FindOnly); err == nil {
	 649  		t.Fatal("importing package when no go.mod is present succeeded unexpectedly")
	 650  	} else if errStr := err.Error(); !strings.Contains(errStr, want) {
	 651  		t.Fatalf("error when importing package when no go.mod is present: got %q; want %q", errStr, want)
	 652  	} else {
	 653  		t.Logf(`ctxt.Import("example.com/p", _, FindOnly): %v`, err)
	 654  	}
	 655  }
	 656  
	 657  func TestImportDirTarget(t *testing.T) {
	 658  	testenv.MustHaveGoBuild(t) // really must just have source
	 659  	ctxt := Default
	 660  	ctxt.GOPATH = ""
	 661  	p, err := ctxt.ImportDir(filepath.Join(ctxt.GOROOT, "src/path"), 0)
	 662  	if err != nil {
	 663  		t.Fatal(err)
	 664  	}
	 665  	if p.PkgTargetRoot == "" || p.PkgObj == "" {
	 666  		t.Errorf("p.PkgTargetRoot == %q, p.PkgObj == %q, want non-empty", p.PkgTargetRoot, p.PkgObj)
	 667  	}
	 668  }
	 669  
	 670  // TestIssue23594 prevents go/build from regressing and populating Package.Doc
	 671  // from comments in test files.
	 672  func TestIssue23594(t *testing.T) {
	 673  	// Package testdata/doc contains regular and external test files
	 674  	// with comments attached to their package declarations. The names of the files
	 675  	// ensure that we see the comments from the test files first.
	 676  	p, err := ImportDir("testdata/doc", 0)
	 677  	if err != nil {
	 678  		t.Fatalf("could not import testdata: %v", err)
	 679  	}
	 680  
	 681  	if p.Doc != "Correct" {
	 682  		t.Fatalf("incorrectly set .Doc to %q", p.Doc)
	 683  	}
	 684  }
	 685  
	 686  // TestMissingImportErrorRepetition checks that when an unknown package is
	 687  // imported, the package path is only shown once in the error.
	 688  // Verifies golang.org/issue/34752.
	 689  func TestMissingImportErrorRepetition(t *testing.T) {
	 690  	testenv.MustHaveGoBuild(t) // need 'go list' internally
	 691  	tmp := t.TempDir()
	 692  	if err := os.WriteFile(filepath.Join(tmp, "go.mod"), []byte("module m"), 0666); err != nil {
	 693  		t.Fatal(err)
	 694  	}
	 695  	t.Setenv("GO111MODULE", "on")
	 696  	t.Setenv("GOPROXY", "off")
	 697  	t.Setenv("GONOPROXY", "none")
	 698  
	 699  	ctxt := Default
	 700  	ctxt.Dir = tmp
	 701  
	 702  	pkgPath := "example.com/hello"
	 703  	_, err := ctxt.Import(pkgPath, tmp, FindOnly)
	 704  	if err == nil {
	 705  		t.Fatal("unexpected success")
	 706  	}
	 707  
	 708  	// Don't count the package path with a URL like https://...?go-get=1.
	 709  	// See golang.org/issue/35986.
	 710  	errStr := strings.ReplaceAll(err.Error(), "://"+pkgPath+"?go-get=1", "://...?go-get=1")
	 711  
	 712  	// Also don't count instances in suggested "go get" or similar commands
	 713  	// (see https://golang.org/issue/41576). The suggested command typically
	 714  	// follows a semicolon.
	 715  	errStr = strings.SplitN(errStr, ";", 2)[0]
	 716  
	 717  	if n := strings.Count(errStr, pkgPath); n != 1 {
	 718  		t.Fatalf("package path %q appears in error %d times; should appear once\nerror: %v", pkgPath, n, err)
	 719  	}
	 720  }
	 721  
	 722  // TestCgoImportsIgnored checks that imports in cgo files are not included
	 723  // in the imports list when cgo is disabled.
	 724  // Verifies golang.org/issue/35946.
	 725  func TestCgoImportsIgnored(t *testing.T) {
	 726  	ctxt := Default
	 727  	ctxt.CgoEnabled = false
	 728  	p, err := ctxt.ImportDir("testdata/cgo_disabled", 0)
	 729  	if err != nil {
	 730  		t.Fatal(err)
	 731  	}
	 732  	for _, path := range p.Imports {
	 733  		if path == "should/be/ignored" {
	 734  			t.Errorf("found import %q in ignored cgo file", path)
	 735  		}
	 736  	}
	 737  }
	 738  

View as plain text