github.com/zebozhuang/go@v0.0.0-20200207033046-f8a98f6f5c5d/src/cmd/go/go_test.go (about) 1 // Copyright 2015 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 main_test 6 7 import ( 8 "bytes" 9 "fmt" 10 "go/format" 11 "internal/race" 12 "internal/testenv" 13 "io" 14 "io/ioutil" 15 "os" 16 "os/exec" 17 "path/filepath" 18 "regexp" 19 "runtime" 20 "strconv" 21 "strings" 22 "testing" 23 "time" 24 ) 25 26 var ( 27 canRun = true // whether we can run go or ./testgo 28 canRace = false // whether we can run the race detector 29 canCgo = false // whether we can use cgo 30 31 exeSuffix string // ".exe" on Windows 32 33 skipExternal = false // skip external tests 34 ) 35 36 func init() { 37 switch runtime.GOOS { 38 case "android", "nacl": 39 canRun = false 40 case "darwin": 41 switch runtime.GOARCH { 42 case "arm", "arm64": 43 canRun = false 44 } 45 case "linux": 46 switch runtime.GOARCH { 47 case "arm": 48 // many linux/arm machines are too slow to run 49 // the full set of external tests. 50 skipExternal = true 51 case "mips", "mipsle", "mips64", "mips64le": 52 // Also slow. 53 skipExternal = true 54 if testenv.Builder() != "" { 55 // On the builders, skip the cmd/go 56 // tests. They're too slow and already 57 // covered by other ports. There's 58 // nothing os/arch specific in the 59 // tests. 60 canRun = false 61 } 62 } 63 case "freebsd": 64 switch runtime.GOARCH { 65 case "arm": 66 // many freebsd/arm machines are too slow to run 67 // the full set of external tests. 68 skipExternal = true 69 canRun = false 70 } 71 case "windows": 72 exeSuffix = ".exe" 73 } 74 } 75 76 // testGOROOT is the GOROOT to use when running testgo, a cmd/go binary 77 // build from this process's current GOROOT, but run from a different 78 // (temp) directory. 79 var testGOROOT string 80 81 var testCC string 82 83 // The TestMain function creates a go command for testing purposes and 84 // deletes it after the tests have been run. 85 func TestMain(m *testing.M) { 86 if canRun { 87 args := []string{"build", "-tags", "testgo", "-o", "testgo" + exeSuffix} 88 if race.Enabled { 89 args = append(args, "-race") 90 } 91 out, err := exec.Command("go", args...).CombinedOutput() 92 if err != nil { 93 fmt.Fprintf(os.Stderr, "building testgo failed: %v\n%s", err, out) 94 os.Exit(2) 95 } 96 97 out, err = exec.Command("go", "env", "GOROOT").CombinedOutput() 98 if err != nil { 99 fmt.Fprintf(os.Stderr, "could not find testing GOROOT: %v\n%s", err, out) 100 os.Exit(2) 101 } 102 testGOROOT = strings.TrimSpace(string(out)) 103 104 out, err = exec.Command("go", "env", "CC").CombinedOutput() 105 if err != nil { 106 fmt.Fprintf(os.Stderr, "could not find testing CC: %v\n%s", err, out) 107 os.Exit(2) 108 } 109 testCC = strings.TrimSpace(string(out)) 110 111 if out, err := exec.Command("./testgo"+exeSuffix, "env", "CGO_ENABLED").Output(); err != nil { 112 fmt.Fprintf(os.Stderr, "running testgo failed: %v\n", err) 113 canRun = false 114 } else { 115 canCgo, err = strconv.ParseBool(strings.TrimSpace(string(out))) 116 if err != nil { 117 fmt.Fprintf(os.Stderr, "can't parse go env CGO_ENABLED output: %v\n", strings.TrimSpace(string(out))) 118 } 119 } 120 121 switch runtime.GOOS { 122 case "linux", "darwin", "freebsd", "windows": 123 // The race detector doesn't work on Alpine Linux: 124 // golang.org/issue/14481 125 canRace = canCgo && runtime.GOARCH == "amd64" && !isAlpineLinux() 126 } 127 } 128 129 // Don't let these environment variables confuse the test. 130 os.Unsetenv("GOBIN") 131 os.Unsetenv("GOPATH") 132 os.Unsetenv("GIT_ALLOW_PROTOCOL") 133 if home, ccacheDir := os.Getenv("HOME"), os.Getenv("CCACHE_DIR"); home != "" && ccacheDir == "" { 134 // On some systems the default C compiler is ccache. 135 // Setting HOME to a non-existent directory will break 136 // those systems. Set CCACHE_DIR to cope. Issue 17668. 137 os.Setenv("CCACHE_DIR", filepath.Join(home, ".ccache")) 138 } 139 os.Setenv("HOME", "/test-go-home-does-not-exist") 140 141 r := m.Run() 142 143 if canRun { 144 os.Remove("testgo" + exeSuffix) 145 } 146 147 os.Exit(r) 148 } 149 150 func isAlpineLinux() bool { 151 if runtime.GOOS != "linux" { 152 return false 153 } 154 fi, err := os.Lstat("/etc/alpine-release") 155 return err == nil && fi.Mode().IsRegular() 156 } 157 158 // The length of an mtime tick on this system. This is an estimate of 159 // how long we need to sleep to ensure that the mtime of two files is 160 // different. 161 // We used to try to be clever but that didn't always work (see golang.org/issue/12205). 162 var mtimeTick time.Duration = 1 * time.Second 163 164 // Manage a single run of the testgo binary. 165 type testgoData struct { 166 t *testing.T 167 temps []string 168 wd string 169 env []string 170 tempdir string 171 ran bool 172 inParallel bool 173 stdout, stderr bytes.Buffer 174 } 175 176 // testgo sets up for a test that runs testgo. 177 func testgo(t *testing.T) *testgoData { 178 testenv.MustHaveGoBuild(t) 179 180 if skipExternal { 181 t.Skip("skipping external tests on %s/%s", runtime.GOOS, runtime.GOARCH) 182 } 183 184 return &testgoData{t: t} 185 } 186 187 // must gives a fatal error if err is not nil. 188 func (tg *testgoData) must(err error) { 189 if err != nil { 190 tg.t.Fatal(err) 191 } 192 } 193 194 // check gives a test non-fatal error if err is not nil. 195 func (tg *testgoData) check(err error) { 196 if err != nil { 197 tg.t.Error(err) 198 } 199 } 200 201 // parallel runs the test in parallel by calling t.Parallel. 202 func (tg *testgoData) parallel() { 203 if tg.ran { 204 tg.t.Fatal("internal testsuite error: call to parallel after run") 205 } 206 if tg.wd != "" { 207 tg.t.Fatal("internal testsuite error: call to parallel after cd") 208 } 209 for _, e := range tg.env { 210 if strings.HasPrefix(e, "GOROOT=") || strings.HasPrefix(e, "GOPATH=") || strings.HasPrefix(e, "GOBIN=") { 211 val := e[strings.Index(e, "=")+1:] 212 if strings.HasPrefix(val, "testdata") || strings.HasPrefix(val, "./testdata") { 213 tg.t.Fatalf("internal testsuite error: call to parallel with testdata in environment (%s)", e) 214 } 215 } 216 } 217 tg.inParallel = true 218 tg.t.Parallel() 219 } 220 221 // pwd returns the current directory. 222 func (tg *testgoData) pwd() string { 223 wd, err := os.Getwd() 224 if err != nil { 225 tg.t.Fatalf("could not get working directory: %v", err) 226 } 227 return wd 228 } 229 230 // cd changes the current directory to the named directory. Note that 231 // using this means that the test must not be run in parallel with any 232 // other tests. 233 func (tg *testgoData) cd(dir string) { 234 if tg.inParallel { 235 tg.t.Fatal("internal testsuite error: changing directory when running in parallel") 236 } 237 if tg.wd == "" { 238 tg.wd = tg.pwd() 239 } 240 abs, err := filepath.Abs(dir) 241 tg.must(os.Chdir(dir)) 242 if err == nil { 243 tg.setenv("PWD", abs) 244 } 245 } 246 247 // sleep sleeps for one tick, where a tick is a conservative estimate 248 // of how long it takes for a file modification to get a different 249 // mtime. 250 func (tg *testgoData) sleep() { 251 time.Sleep(mtimeTick) 252 } 253 254 // setenv sets an environment variable to use when running the test go 255 // command. 256 func (tg *testgoData) setenv(name, val string) { 257 if tg.inParallel && (name == "GOROOT" || name == "GOPATH" || name == "GOBIN") && (strings.HasPrefix(val, "testdata") || strings.HasPrefix(val, "./testdata")) { 258 tg.t.Fatalf("internal testsuite error: call to setenv with testdata (%s=%s) after parallel", name, val) 259 } 260 tg.unsetenv(name) 261 tg.env = append(tg.env, name+"="+val) 262 } 263 264 // unsetenv removes an environment variable. 265 func (tg *testgoData) unsetenv(name string) { 266 if tg.env == nil { 267 tg.env = append([]string(nil), os.Environ()...) 268 } 269 for i, v := range tg.env { 270 if strings.HasPrefix(v, name+"=") { 271 tg.env = append(tg.env[:i], tg.env[i+1:]...) 272 break 273 } 274 } 275 } 276 277 func (tg *testgoData) goTool() string { 278 if tg.wd == "" { 279 return "./testgo" + exeSuffix 280 } 281 return filepath.Join(tg.wd, "testgo"+exeSuffix) 282 } 283 284 // doRun runs the test go command, recording stdout and stderr and 285 // returning exit status. 286 func (tg *testgoData) doRun(args []string) error { 287 if !canRun { 288 panic("testgoData.doRun called but canRun false") 289 } 290 if tg.inParallel { 291 for _, arg := range args { 292 if strings.HasPrefix(arg, "testdata") || strings.HasPrefix(arg, "./testdata") { 293 tg.t.Fatal("internal testsuite error: parallel run using testdata") 294 } 295 } 296 } 297 298 hasGoroot := false 299 for _, v := range tg.env { 300 if strings.HasPrefix(v, "GOROOT=") { 301 hasGoroot = true 302 break 303 } 304 } 305 prog := tg.goTool() 306 if !hasGoroot { 307 tg.setenv("GOROOT", testGOROOT) 308 } 309 310 tg.t.Logf("running testgo %v", args) 311 cmd := exec.Command(prog, args...) 312 tg.stdout.Reset() 313 tg.stderr.Reset() 314 cmd.Stdout = &tg.stdout 315 cmd.Stderr = &tg.stderr 316 cmd.Env = tg.env 317 status := cmd.Run() 318 if tg.stdout.Len() > 0 { 319 tg.t.Log("standard output:") 320 tg.t.Log(tg.stdout.String()) 321 } 322 if tg.stderr.Len() > 0 { 323 tg.t.Log("standard error:") 324 tg.t.Log(tg.stderr.String()) 325 } 326 tg.ran = true 327 return status 328 } 329 330 // run runs the test go command, and expects it to succeed. 331 func (tg *testgoData) run(args ...string) { 332 if status := tg.doRun(args); status != nil { 333 tg.t.Logf("go %v failed unexpectedly: %v", args, status) 334 tg.t.FailNow() 335 } 336 } 337 338 // runFail runs the test go command, and expects it to fail. 339 func (tg *testgoData) runFail(args ...string) { 340 if status := tg.doRun(args); status == nil { 341 tg.t.Fatal("testgo succeeded unexpectedly") 342 } else { 343 tg.t.Log("testgo failed as expected:", status) 344 } 345 } 346 347 // runGit runs a git command, and expects it to succeed. 348 func (tg *testgoData) runGit(dir string, args ...string) { 349 cmd := exec.Command("git", args...) 350 tg.stdout.Reset() 351 tg.stderr.Reset() 352 cmd.Stdout = &tg.stdout 353 cmd.Stderr = &tg.stderr 354 cmd.Dir = dir 355 cmd.Env = tg.env 356 status := cmd.Run() 357 if tg.stdout.Len() > 0 { 358 tg.t.Log("git standard output:") 359 tg.t.Log(tg.stdout.String()) 360 } 361 if tg.stderr.Len() > 0 { 362 tg.t.Log("git standard error:") 363 tg.t.Log(tg.stderr.String()) 364 } 365 if status != nil { 366 tg.t.Logf("git %v failed unexpectedly: %v", args, status) 367 tg.t.FailNow() 368 } 369 } 370 371 // getStdout returns standard output of the testgo run as a string. 372 func (tg *testgoData) getStdout() string { 373 if !tg.ran { 374 tg.t.Fatal("internal testsuite error: stdout called before run") 375 } 376 return tg.stdout.String() 377 } 378 379 // getStderr returns standard error of the testgo run as a string. 380 func (tg *testgoData) getStderr() string { 381 if !tg.ran { 382 tg.t.Fatal("internal testsuite error: stdout called before run") 383 } 384 return tg.stderr.String() 385 } 386 387 // doGrepMatch looks for a regular expression in a buffer, and returns 388 // whether it is found. The regular expression is matched against 389 // each line separately, as with the grep command. 390 func (tg *testgoData) doGrepMatch(match string, b *bytes.Buffer) bool { 391 if !tg.ran { 392 tg.t.Fatal("internal testsuite error: grep called before run") 393 } 394 re := regexp.MustCompile(match) 395 for _, ln := range bytes.Split(b.Bytes(), []byte{'\n'}) { 396 if re.Match(ln) { 397 return true 398 } 399 } 400 return false 401 } 402 403 // doGrep looks for a regular expression in a buffer and fails if it 404 // is not found. The name argument is the name of the output we are 405 // searching, "output" or "error". The msg argument is logged on 406 // failure. 407 func (tg *testgoData) doGrep(match string, b *bytes.Buffer, name, msg string) { 408 if !tg.doGrepMatch(match, b) { 409 tg.t.Log(msg) 410 tg.t.Logf("pattern %v not found in standard %s", match, name) 411 tg.t.FailNow() 412 } 413 } 414 415 // grepStdout looks for a regular expression in the test run's 416 // standard output and fails, logging msg, if it is not found. 417 func (tg *testgoData) grepStdout(match, msg string) { 418 tg.doGrep(match, &tg.stdout, "output", msg) 419 } 420 421 // grepStderr looks for a regular expression in the test run's 422 // standard error and fails, logging msg, if it is not found. 423 func (tg *testgoData) grepStderr(match, msg string) { 424 tg.doGrep(match, &tg.stderr, "error", msg) 425 } 426 427 // grepBoth looks for a regular expression in the test run's standard 428 // output or stand error and fails, logging msg, if it is not found. 429 func (tg *testgoData) grepBoth(match, msg string) { 430 if !tg.doGrepMatch(match, &tg.stdout) && !tg.doGrepMatch(match, &tg.stderr) { 431 tg.t.Log(msg) 432 tg.t.Logf("pattern %v not found in standard output or standard error", match) 433 tg.t.FailNow() 434 } 435 } 436 437 // doGrepNot looks for a regular expression in a buffer and fails if 438 // it is found. The name and msg arguments are as for doGrep. 439 func (tg *testgoData) doGrepNot(match string, b *bytes.Buffer, name, msg string) { 440 if tg.doGrepMatch(match, b) { 441 tg.t.Log(msg) 442 tg.t.Logf("pattern %v found unexpectedly in standard %s", match, name) 443 tg.t.FailNow() 444 } 445 } 446 447 // grepStdoutNot looks for a regular expression in the test run's 448 // standard output and fails, logging msg, if it is found. 449 func (tg *testgoData) grepStdoutNot(match, msg string) { 450 tg.doGrepNot(match, &tg.stdout, "output", msg) 451 } 452 453 // grepStderrNot looks for a regular expression in the test run's 454 // standard error and fails, logging msg, if it is found. 455 func (tg *testgoData) grepStderrNot(match, msg string) { 456 tg.doGrepNot(match, &tg.stderr, "error", msg) 457 } 458 459 // grepBothNot looks for a regular expression in the test run's 460 // standard output or stand error and fails, logging msg, if it is 461 // found. 462 func (tg *testgoData) grepBothNot(match, msg string) { 463 if tg.doGrepMatch(match, &tg.stdout) || tg.doGrepMatch(match, &tg.stderr) { 464 tg.t.Log(msg) 465 tg.t.Fatalf("pattern %v found unexpectedly in standard output or standard error", match) 466 } 467 } 468 469 // doGrepCount counts the number of times a regexp is seen in a buffer. 470 func (tg *testgoData) doGrepCount(match string, b *bytes.Buffer) int { 471 if !tg.ran { 472 tg.t.Fatal("internal testsuite error: doGrepCount called before run") 473 } 474 re := regexp.MustCompile(match) 475 c := 0 476 for _, ln := range bytes.Split(b.Bytes(), []byte{'\n'}) { 477 if re.Match(ln) { 478 c++ 479 } 480 } 481 return c 482 } 483 484 // grepCountBoth returns the number of times a regexp is seen in both 485 // standard output and standard error. 486 func (tg *testgoData) grepCountBoth(match string) int { 487 return tg.doGrepCount(match, &tg.stdout) + tg.doGrepCount(match, &tg.stderr) 488 } 489 490 // creatingTemp records that the test plans to create a temporary file 491 // or directory. If the file or directory exists already, it will be 492 // removed. When the test completes, the file or directory will be 493 // removed if it exists. 494 func (tg *testgoData) creatingTemp(path string) { 495 if filepath.IsAbs(path) && !strings.HasPrefix(path, tg.tempdir) { 496 tg.t.Fatalf("internal testsuite error: creatingTemp(%q) with absolute path not in temporary directory", path) 497 } 498 // If we have changed the working directory, make sure we have 499 // an absolute path, because we are going to change directory 500 // back before we remove the temporary. 501 if tg.wd != "" && !filepath.IsAbs(path) { 502 path = filepath.Join(tg.pwd(), path) 503 } 504 tg.must(os.RemoveAll(path)) 505 tg.temps = append(tg.temps, path) 506 } 507 508 // makeTempdir makes a temporary directory for a run of testgo. If 509 // the temporary directory was already created, this does nothing. 510 func (tg *testgoData) makeTempdir() { 511 if tg.tempdir == "" { 512 var err error 513 tg.tempdir, err = ioutil.TempDir("", "gotest") 514 tg.must(err) 515 } 516 } 517 518 // tempFile adds a temporary file for a run of testgo. 519 func (tg *testgoData) tempFile(path, contents string) { 520 tg.makeTempdir() 521 tg.must(os.MkdirAll(filepath.Join(tg.tempdir, filepath.Dir(path)), 0755)) 522 bytes := []byte(contents) 523 if strings.HasSuffix(path, ".go") { 524 formatted, err := format.Source(bytes) 525 if err == nil { 526 bytes = formatted 527 } 528 } 529 tg.must(ioutil.WriteFile(filepath.Join(tg.tempdir, path), bytes, 0644)) 530 } 531 532 // tempDir adds a temporary directory for a run of testgo. 533 func (tg *testgoData) tempDir(path string) { 534 tg.makeTempdir() 535 if err := os.MkdirAll(filepath.Join(tg.tempdir, path), 0755); err != nil && !os.IsExist(err) { 536 tg.t.Fatal(err) 537 } 538 } 539 540 // path returns the absolute pathname to file with the temporary 541 // directory. 542 func (tg *testgoData) path(name string) string { 543 if tg.tempdir == "" { 544 tg.t.Fatalf("internal testsuite error: path(%q) with no tempdir", name) 545 } 546 if name == "." { 547 return tg.tempdir 548 } 549 return filepath.Join(tg.tempdir, name) 550 } 551 552 // mustExist fails if path does not exist. 553 func (tg *testgoData) mustExist(path string) { 554 if _, err := os.Stat(path); err != nil { 555 if os.IsNotExist(err) { 556 tg.t.Fatalf("%s does not exist but should", path) 557 } 558 tg.t.Fatalf("%s stat failed: %v", path, err) 559 } 560 } 561 562 // mustNotExist fails if path exists. 563 func (tg *testgoData) mustNotExist(path string) { 564 if _, err := os.Stat(path); err == nil || !os.IsNotExist(err) { 565 tg.t.Fatalf("%s exists but should not (%v)", path, err) 566 } 567 } 568 569 // wantExecutable fails with msg if path is not executable. 570 func (tg *testgoData) wantExecutable(path, msg string) { 571 if st, err := os.Stat(path); err != nil { 572 if !os.IsNotExist(err) { 573 tg.t.Log(err) 574 } 575 tg.t.Fatal(msg) 576 } else { 577 if runtime.GOOS != "windows" && st.Mode()&0111 == 0 { 578 tg.t.Fatalf("binary %s exists but is not executable", path) 579 } 580 } 581 } 582 583 // wantArchive fails if path is not an archive. 584 func (tg *testgoData) wantArchive(path string) { 585 f, err := os.Open(path) 586 if err != nil { 587 tg.t.Fatal(err) 588 } 589 buf := make([]byte, 100) 590 io.ReadFull(f, buf) 591 f.Close() 592 if !bytes.HasPrefix(buf, []byte("!<arch>\n")) { 593 tg.t.Fatalf("file %s exists but is not an archive", path) 594 } 595 } 596 597 // isStale reports whether pkg is stale, and why 598 func (tg *testgoData) isStale(pkg string) (bool, string) { 599 tg.run("list", "-f", "{{.Stale}}:{{.StaleReason}}", pkg) 600 v := strings.TrimSpace(tg.getStdout()) 601 f := strings.SplitN(v, ":", 2) 602 if len(f) == 2 { 603 switch f[0] { 604 case "true": 605 return true, f[1] 606 case "false": 607 return false, f[1] 608 } 609 } 610 tg.t.Fatalf("unexpected output checking staleness of package %v: %v", pkg, v) 611 panic("unreachable") 612 } 613 614 // wantStale fails with msg if pkg is not stale. 615 func (tg *testgoData) wantStale(pkg, reason, msg string) { 616 stale, why := tg.isStale(pkg) 617 if !stale { 618 tg.t.Fatal(msg) 619 } 620 if reason == "" && why != "" || !strings.Contains(why, reason) { 621 tg.t.Errorf("wrong reason for Stale=true: %q, want %q", why, reason) 622 } 623 } 624 625 // wantNotStale fails with msg if pkg is stale. 626 func (tg *testgoData) wantNotStale(pkg, reason, msg string) { 627 stale, why := tg.isStale(pkg) 628 if stale { 629 tg.t.Fatal(msg) 630 } 631 if reason == "" && why != "" || !strings.Contains(why, reason) { 632 tg.t.Errorf("wrong reason for Stale=false: %q, want %q", why, reason) 633 } 634 } 635 636 // cleanup cleans up a test that runs testgo. 637 func (tg *testgoData) cleanup() { 638 if tg.wd != "" { 639 if err := os.Chdir(tg.wd); err != nil { 640 // We are unlikely to be able to continue. 641 fmt.Fprintln(os.Stderr, "could not restore working directory, crashing:", err) 642 os.Exit(2) 643 } 644 } 645 for _, path := range tg.temps { 646 tg.check(os.RemoveAll(path)) 647 } 648 if tg.tempdir != "" { 649 tg.check(os.RemoveAll(tg.tempdir)) 650 } 651 } 652 653 // failSSH puts an ssh executable in the PATH that always fails. 654 // This is to stub out uses of ssh by go get. 655 func (tg *testgoData) failSSH() { 656 wd, err := os.Getwd() 657 if err != nil { 658 tg.t.Fatal(err) 659 } 660 fail := filepath.Join(wd, "testdata/failssh") 661 tg.setenv("PATH", fmt.Sprintf("%v%c%v", fail, filepath.ListSeparator, os.Getenv("PATH"))) 662 } 663 664 func TestFileLineInErrorMessages(t *testing.T) { 665 tg := testgo(t) 666 defer tg.cleanup() 667 tg.parallel() 668 tg.tempFile("err.go", `package main; import "bar"`) 669 path := tg.path("err.go") 670 tg.runFail("run", path) 671 shortPath := path 672 if rel, err := filepath.Rel(tg.pwd(), path); err == nil && len(rel) < len(path) { 673 shortPath = rel 674 } 675 tg.grepStderr("^"+regexp.QuoteMeta(shortPath)+":", "missing file:line in error message") 676 } 677 678 func TestProgramNameInCrashMessages(t *testing.T) { 679 tg := testgo(t) 680 defer tg.cleanup() 681 tg.parallel() 682 tg.tempFile("triv.go", `package main; func main() {}`) 683 tg.runFail("build", "-ldflags", "-crash_for_testing", tg.path("triv.go")) 684 tg.grepStderr(`[/\\]tool[/\\].*[/\\]link`, "missing linker name in error message") 685 } 686 687 func TestBrokenTestsWithoutTestFunctionsAllFail(t *testing.T) { 688 tg := testgo(t) 689 defer tg.cleanup() 690 // TODO: tg.parallel() 691 tg.runFail("test", "./testdata/src/badtest/...") 692 tg.grepBothNot("^ok", "test passed unexpectedly") 693 tg.grepBoth("FAIL.*badtest/badexec", "test did not run everything") 694 tg.grepBoth("FAIL.*badtest/badsyntax", "test did not run everything") 695 tg.grepBoth("FAIL.*badtest/badvar", "test did not run everything") 696 } 697 698 func TestGoBuildDashAInDevBranch(t *testing.T) { 699 if testing.Short() { 700 t.Skip("don't rebuild the standard library in short mode") 701 } 702 703 tg := testgo(t) 704 defer tg.cleanup() 705 tg.run("install", "math") // should be up to date already but just in case 706 tg.setenv("TESTGO_IS_GO_RELEASE", "0") 707 tg.run("build", "-v", "-a", "math") 708 tg.grepStderr("runtime", "testgo build -a math in dev branch DID NOT build runtime, but should have") 709 710 // Everything is out of date. Rebuild to leave things in a better state. 711 tg.run("install", "std") 712 } 713 714 func TestGoBuildDashAInReleaseBranch(t *testing.T) { 715 if testing.Short() { 716 t.Skip("don't rebuild the standard library in short mode") 717 } 718 719 tg := testgo(t) 720 defer tg.cleanup() 721 tg.run("install", "math", "net/http") // should be up to date already but just in case 722 tg.setenv("TESTGO_IS_GO_RELEASE", "1") 723 tg.run("install", "-v", "-a", "math") 724 tg.grepStderr("runtime", "testgo build -a math in release branch DID NOT build runtime, but should have") 725 726 // Now runtime.a is updated (newer mtime), so everything would look stale if not for being a release. 727 tg.run("build", "-v", "net/http") 728 tg.grepStderrNot("strconv", "testgo build -v net/http in release branch with newer runtime.a DID build strconv but should not have") 729 tg.grepStderrNot("golang.org/x/net/http2/hpack", "testgo build -v net/http in release branch with newer runtime.a DID build .../golang.org/x/net/http2/hpack but should not have") 730 tg.grepStderrNot("net/http", "testgo build -v net/http in release branch with newer runtime.a DID build net/http but should not have") 731 732 // Everything is out of date. Rebuild to leave things in a better state. 733 tg.run("install", "std") 734 } 735 736 func TestNewReleaseRebuildsStalePackagesInGOPATH(t *testing.T) { 737 if testing.Short() { 738 t.Skip("don't rebuild the standard library in short mode") 739 } 740 741 tg := testgo(t) 742 defer tg.cleanup() 743 744 addNL := func(name string) (restore func()) { 745 data, err := ioutil.ReadFile(name) 746 if err != nil { 747 t.Fatal(err) 748 } 749 old := data 750 data = append(data, '\n') 751 if err := ioutil.WriteFile(name, append(data, '\n'), 0666); err != nil { 752 t.Fatal(err) 753 } 754 tg.sleep() 755 return func() { 756 if err := ioutil.WriteFile(name, old, 0666); err != nil { 757 t.Fatal(err) 758 } 759 } 760 } 761 762 tg.setenv("TESTGO_IS_GO_RELEASE", "1") 763 764 tg.tempFile("d1/src/p1/p1.go", `package p1`) 765 tg.setenv("GOPATH", tg.path("d1")) 766 tg.run("install", "-a", "p1") 767 tg.wantNotStale("p1", "", "./testgo list claims p1 is stale, incorrectly") 768 tg.sleep() 769 770 // Changing mtime and content of runtime/internal/sys/sys.go 771 // should have no effect: we're in a release, which doesn't rebuild 772 // for general mtime or content changes. 773 sys := runtime.GOROOT() + "/src/runtime/internal/sys/sys.go" 774 restore := addNL(sys) 775 defer restore() 776 tg.wantNotStale("p1", "", "./testgo list claims p1 is stale, incorrectly, after updating runtime/internal/sys/sys.go") 777 restore() 778 tg.wantNotStale("p1", "", "./testgo list claims p1 is stale, incorrectly, after restoring runtime/internal/sys/sys.go") 779 780 // But changing runtime/internal/sys/zversion.go should have an effect: 781 // that's how we tell when we flip from one release to another. 782 zversion := runtime.GOROOT() + "/src/runtime/internal/sys/zversion.go" 783 restore = addNL(zversion) 784 defer restore() 785 tg.wantStale("p1", "build ID mismatch", "./testgo list claims p1 is NOT stale, incorrectly, after changing to new release") 786 restore() 787 tg.wantNotStale("p1", "", "./testgo list claims p1 is stale, incorrectly, after changing back to old release") 788 addNL(zversion) 789 tg.wantStale("p1", "build ID mismatch", "./testgo list claims p1 is NOT stale, incorrectly, after changing again to new release") 790 tg.run("install", "p1") 791 tg.wantNotStale("p1", "", "./testgo list claims p1 is stale after building with new release") 792 793 // Restore to "old" release. 794 restore() 795 tg.wantStale("p1", "build ID mismatch", "./testgo list claims p1 is NOT stale, incorrectly, after changing to old release after new build") 796 tg.run("install", "p1") 797 tg.wantNotStale("p1", "", "./testgo list claims p1 is stale after building with old release") 798 799 // Everything is out of date. Rebuild to leave things in a better state. 800 tg.run("install", "std") 801 } 802 803 func TestGoListStandard(t *testing.T) { 804 tg := testgo(t) 805 defer tg.cleanup() 806 // TODO: tg.parallel() 807 tg.cd(runtime.GOROOT() + "/src") 808 tg.run("list", "-f", "{{if not .Standard}}{{.ImportPath}}{{end}}", "./...") 809 stdout := tg.getStdout() 810 for _, line := range strings.Split(stdout, "\n") { 811 if strings.HasPrefix(line, "_/") && strings.HasSuffix(line, "/src") { 812 // $GOROOT/src shows up if there are any .go files there. 813 // We don't care. 814 continue 815 } 816 if line == "" { 817 continue 818 } 819 t.Errorf("package in GOROOT not listed as standard: %v", line) 820 } 821 822 // Similarly, expanding std should include some of our vendored code. 823 tg.run("list", "std", "cmd") 824 tg.grepStdout("golang.org/x/net/http2/hpack", "list std cmd did not mention vendored hpack") 825 tg.grepStdout("golang.org/x/arch/x86/x86asm", "list std cmd did not mention vendored x86asm") 826 } 827 828 func TestGoInstallCleansUpAfterGoBuild(t *testing.T) { 829 tg := testgo(t) 830 defer tg.cleanup() 831 // TODO: tg.parallel() 832 tg.tempFile("src/mycmd/main.go", `package main; func main(){}`) 833 tg.setenv("GOPATH", tg.path(".")) 834 tg.cd(tg.path("src/mycmd")) 835 836 doesNotExist := func(file, msg string) { 837 if _, err := os.Stat(file); err == nil { 838 t.Fatal(msg) 839 } else if !os.IsNotExist(err) { 840 t.Fatal(msg, "error:", err) 841 } 842 } 843 844 tg.run("build") 845 tg.wantExecutable("mycmd"+exeSuffix, "testgo build did not write command binary") 846 tg.run("install") 847 doesNotExist("mycmd"+exeSuffix, "testgo install did not remove command binary") 848 tg.run("build") 849 tg.wantExecutable("mycmd"+exeSuffix, "testgo build did not write command binary (second time)") 850 // Running install with arguments does not remove the target, 851 // even in the same directory. 852 tg.run("install", "mycmd") 853 tg.wantExecutable("mycmd"+exeSuffix, "testgo install mycmd removed command binary when run in mycmd") 854 tg.run("build") 855 tg.wantExecutable("mycmd"+exeSuffix, "testgo build did not write command binary (third time)") 856 // And especially not outside the directory. 857 tg.cd(tg.path(".")) 858 if data, err := ioutil.ReadFile("src/mycmd/mycmd" + exeSuffix); err != nil { 859 t.Fatal("could not read file:", err) 860 } else { 861 if err := ioutil.WriteFile("mycmd"+exeSuffix, data, 0555); err != nil { 862 t.Fatal("could not write file:", err) 863 } 864 } 865 tg.run("install", "mycmd") 866 tg.wantExecutable("src/mycmd/mycmd"+exeSuffix, "testgo install mycmd removed command binary from its source dir when run outside mycmd") 867 tg.wantExecutable("mycmd"+exeSuffix, "testgo install mycmd removed command binary from current dir when run outside mycmd") 868 } 869 870 func TestGoInstallRebuildsStalePackagesInOtherGOPATH(t *testing.T) { 871 tg := testgo(t) 872 defer tg.cleanup() 873 tg.parallel() 874 tg.tempFile("d1/src/p1/p1.go", `package p1 875 import "p2" 876 func F() { p2.F() }`) 877 tg.tempFile("d2/src/p2/p2.go", `package p2 878 func F() {}`) 879 sep := string(filepath.ListSeparator) 880 tg.setenv("GOPATH", tg.path("d1")+sep+tg.path("d2")) 881 tg.run("install", "p1") 882 tg.wantNotStale("p1", "", "./testgo list claims p1 is stale, incorrectly") 883 tg.wantNotStale("p2", "", "./testgo list claims p2 is stale, incorrectly") 884 tg.sleep() 885 if f, err := os.OpenFile(tg.path("d2/src/p2/p2.go"), os.O_WRONLY|os.O_APPEND, 0); err != nil { 886 t.Fatal(err) 887 } else if _, err = f.WriteString(`func G() {}`); err != nil { 888 t.Fatal(err) 889 } else { 890 tg.must(f.Close()) 891 } 892 tg.wantStale("p2", "newer source file", "./testgo list claims p2 is NOT stale, incorrectly") 893 tg.wantStale("p1", "stale dependency", "./testgo list claims p1 is NOT stale, incorrectly") 894 895 tg.run("install", "p1") 896 tg.wantNotStale("p2", "", "./testgo list claims p2 is stale after reinstall, incorrectly") 897 tg.wantNotStale("p1", "", "./testgo list claims p1 is stale after reinstall, incorrectly") 898 } 899 900 func TestGoInstallDetectsRemovedFiles(t *testing.T) { 901 tg := testgo(t) 902 defer tg.cleanup() 903 tg.parallel() 904 tg.tempFile("src/mypkg/x.go", `package mypkg`) 905 tg.tempFile("src/mypkg/y.go", `package mypkg`) 906 tg.tempFile("src/mypkg/z.go", `// +build missingtag 907 908 package mypkg`) 909 tg.setenv("GOPATH", tg.path(".")) 910 tg.run("install", "mypkg") 911 tg.wantNotStale("mypkg", "", "./testgo list mypkg claims mypkg is stale, incorrectly") 912 // z.go was not part of the build; removing it is okay. 913 tg.must(os.Remove(tg.path("src/mypkg/z.go"))) 914 tg.wantNotStale("mypkg", "", "./testgo list mypkg claims mypkg is stale after removing z.go; should not be stale") 915 // y.go was part of the package; removing it should be detected. 916 tg.must(os.Remove(tg.path("src/mypkg/y.go"))) 917 tg.wantStale("mypkg", "build ID mismatch", "./testgo list mypkg claims mypkg is NOT stale after removing y.go; should be stale") 918 } 919 920 func TestWildcardMatchesSyntaxErrorDirs(t *testing.T) { 921 tg := testgo(t) 922 defer tg.cleanup() 923 // TODO: tg.parallel() 924 tg.tempFile("src/mypkg/x.go", `package mypkg`) 925 tg.tempFile("src/mypkg/y.go", `pkg mypackage`) 926 tg.setenv("GOPATH", tg.path(".")) 927 tg.cd(tg.path("src/mypkg")) 928 tg.runFail("list", "./...") 929 tg.runFail("build", "./...") 930 tg.runFail("install", "./...") 931 } 932 933 func TestGoListWithTags(t *testing.T) { 934 tg := testgo(t) 935 defer tg.cleanup() 936 tg.tempFile("src/mypkg/x.go", "// +build thetag\n\npackage mypkg\n") 937 tg.setenv("GOPATH", tg.path(".")) 938 tg.cd(tg.path("./src")) 939 tg.run("list", "-tags=thetag", "./my...") 940 tg.grepStdout("mypkg", "did not find mypkg") 941 } 942 943 func TestGoInstallErrorOnCrossCompileToBin(t *testing.T) { 944 if testing.Short() { 945 t.Skip("don't install into GOROOT in short mode") 946 } 947 948 tg := testgo(t) 949 defer tg.cleanup() 950 tg.tempFile("src/mycmd/x.go", `package main 951 func main() {}`) 952 tg.setenv("GOPATH", tg.path(".")) 953 tg.cd(tg.path("src/mycmd")) 954 955 tg.run("build", "mycmd") 956 957 goarch := "386" 958 if runtime.GOARCH == "386" { 959 goarch = "amd64" 960 } 961 tg.setenv("GOOS", "linux") 962 tg.setenv("GOARCH", goarch) 963 tg.run("install", "mycmd") 964 tg.setenv("GOBIN", tg.path(".")) 965 tg.runFail("install", "mycmd") 966 tg.run("install", "cmd/pack") 967 } 968 969 func TestGoInstallDetectsRemovedFilesInPackageMain(t *testing.T) { 970 tg := testgo(t) 971 defer tg.cleanup() 972 tg.parallel() 973 tg.tempFile("src/mycmd/x.go", `package main 974 func main() {}`) 975 tg.tempFile("src/mycmd/y.go", `package main`) 976 tg.tempFile("src/mycmd/z.go", `// +build missingtag 977 978 package main`) 979 tg.setenv("GOPATH", tg.path(".")) 980 tg.run("install", "mycmd") 981 tg.wantNotStale("mycmd", "", "./testgo list mypkg claims mycmd is stale, incorrectly") 982 // z.go was not part of the build; removing it is okay. 983 tg.must(os.Remove(tg.path("src/mycmd/z.go"))) 984 tg.wantNotStale("mycmd", "", "./testgo list mycmd claims mycmd is stale after removing z.go; should not be stale") 985 // y.go was part of the package; removing it should be detected. 986 tg.must(os.Remove(tg.path("src/mycmd/y.go"))) 987 tg.wantStale("mycmd", "build ID mismatch", "./testgo list mycmd claims mycmd is NOT stale after removing y.go; should be stale") 988 } 989 990 func testLocalRun(tg *testgoData, exepath, local, match string) { 991 out, err := exec.Command(exepath).Output() 992 if err != nil { 993 tg.t.Fatalf("error running %v: %v", exepath, err) 994 } 995 if !regexp.MustCompile(match).Match(out) { 996 tg.t.Log(string(out)) 997 tg.t.Errorf("testdata/%s/easy.go did not generate expected output", local) 998 } 999 } 1000 1001 func testLocalEasy(tg *testgoData, local string) { 1002 exepath := "./easy" + exeSuffix 1003 tg.creatingTemp(exepath) 1004 tg.run("build", "-o", exepath, filepath.Join("testdata", local, "easy.go")) 1005 testLocalRun(tg, exepath, local, `(?m)^easysub\.Hello`) 1006 } 1007 1008 func testLocalEasySub(tg *testgoData, local string) { 1009 exepath := "./easysub" + exeSuffix 1010 tg.creatingTemp(exepath) 1011 tg.run("build", "-o", exepath, filepath.Join("testdata", local, "easysub", "main.go")) 1012 testLocalRun(tg, exepath, local, `(?m)^easysub\.Hello`) 1013 } 1014 1015 func testLocalHard(tg *testgoData, local string) { 1016 exepath := "./hard" + exeSuffix 1017 tg.creatingTemp(exepath) 1018 tg.run("build", "-o", exepath, filepath.Join("testdata", local, "hard.go")) 1019 testLocalRun(tg, exepath, local, `(?m)^sub\.Hello`) 1020 } 1021 1022 func testLocalInstall(tg *testgoData, local string) { 1023 tg.runFail("install", filepath.Join("testdata", local, "easy.go")) 1024 } 1025 1026 func TestLocalImportsEasy(t *testing.T) { 1027 tg := testgo(t) 1028 defer tg.cleanup() 1029 testLocalEasy(tg, "local") 1030 } 1031 1032 func TestLocalImportsEasySub(t *testing.T) { 1033 tg := testgo(t) 1034 defer tg.cleanup() 1035 testLocalEasySub(tg, "local") 1036 } 1037 1038 func TestLocalImportsHard(t *testing.T) { 1039 tg := testgo(t) 1040 defer tg.cleanup() 1041 testLocalHard(tg, "local") 1042 } 1043 1044 func TestLocalImportsGoInstallShouldFail(t *testing.T) { 1045 tg := testgo(t) 1046 defer tg.cleanup() 1047 testLocalInstall(tg, "local") 1048 } 1049 1050 const badDirName = `#$%:, &()*;<=>?\^{}` 1051 1052 func copyBad(tg *testgoData) { 1053 if runtime.GOOS == "windows" { 1054 tg.t.Skipf("skipping test because %q is an invalid directory name", badDirName) 1055 } 1056 1057 tg.must(filepath.Walk("testdata/local", 1058 func(path string, info os.FileInfo, err error) error { 1059 if err != nil { 1060 return err 1061 } 1062 if info.IsDir() { 1063 return nil 1064 } 1065 var data []byte 1066 data, err = ioutil.ReadFile(path) 1067 if err != nil { 1068 return err 1069 } 1070 newpath := strings.Replace(path, "local", badDirName, 1) 1071 tg.tempFile(newpath, string(data)) 1072 return nil 1073 })) 1074 tg.cd(tg.path(".")) 1075 } 1076 1077 func TestBadImportsEasy(t *testing.T) { 1078 tg := testgo(t) 1079 defer tg.cleanup() 1080 // TODO: tg.parallel() 1081 copyBad(tg) 1082 testLocalEasy(tg, badDirName) 1083 } 1084 1085 func TestBadImportsEasySub(t *testing.T) { 1086 tg := testgo(t) 1087 defer tg.cleanup() 1088 copyBad(tg) 1089 testLocalEasySub(tg, badDirName) 1090 } 1091 1092 func TestBadImportsHard(t *testing.T) { 1093 tg := testgo(t) 1094 defer tg.cleanup() 1095 copyBad(tg) 1096 testLocalHard(tg, badDirName) 1097 } 1098 1099 func TestBadImportsGoInstallShouldFail(t *testing.T) { 1100 tg := testgo(t) 1101 defer tg.cleanup() 1102 copyBad(tg) 1103 testLocalInstall(tg, badDirName) 1104 } 1105 1106 func TestInternalPackagesInGOROOTAreRespected(t *testing.T) { 1107 tg := testgo(t) 1108 defer tg.cleanup() 1109 tg.runFail("build", "-v", "./testdata/testinternal") 1110 tg.grepBoth(`testinternal(\/|\\)p\.go\:3\:8\: use of internal package not allowed`, "wrong error message for testdata/testinternal") 1111 } 1112 1113 func TestInternalPackagesOutsideGOROOTAreRespected(t *testing.T) { 1114 tg := testgo(t) 1115 defer tg.cleanup() 1116 tg.runFail("build", "-v", "./testdata/testinternal2") 1117 tg.grepBoth(`testinternal2(\/|\\)p\.go\:3\:8\: use of internal package not allowed`, "wrote error message for testdata/testinternal2") 1118 } 1119 1120 func TestRunInternal(t *testing.T) { 1121 tg := testgo(t) 1122 defer tg.cleanup() 1123 dir := filepath.Join(tg.pwd(), "testdata") 1124 tg.setenv("GOPATH", dir) 1125 tg.run("run", filepath.Join(dir, "src/run/good.go")) 1126 tg.runFail("run", filepath.Join(dir, "src/run/bad.go")) 1127 tg.grepStderr(`testdata(\/|\\)src(\/|\\)run(\/|\\)bad\.go\:3\:8\: use of internal package not allowed`, "unexpected error for run/bad.go") 1128 } 1129 1130 func testMove(t *testing.T, vcs, url, base, config string) { 1131 testenv.MustHaveExternalNetwork(t) 1132 1133 tg := testgo(t) 1134 defer tg.cleanup() 1135 tg.parallel() 1136 tg.tempDir("src") 1137 tg.setenv("GOPATH", tg.path(".")) 1138 tg.run("get", "-d", url) 1139 tg.run("get", "-d", "-u", url) 1140 switch vcs { 1141 case "svn": 1142 // SVN doesn't believe in text files so we can't just edit the config. 1143 // Check out a different repo into the wrong place. 1144 tg.must(os.RemoveAll(tg.path("src/code.google.com/p/rsc-svn"))) 1145 tg.run("get", "-d", "-u", "code.google.com/p/rsc-svn2/trunk") 1146 tg.must(os.Rename(tg.path("src/code.google.com/p/rsc-svn2"), tg.path("src/code.google.com/p/rsc-svn"))) 1147 default: 1148 path := tg.path(filepath.Join("src", config)) 1149 data, err := ioutil.ReadFile(path) 1150 tg.must(err) 1151 data = bytes.Replace(data, []byte(base), []byte(base+"XXX"), -1) 1152 tg.must(ioutil.WriteFile(path, data, 0644)) 1153 } 1154 if vcs == "git" { 1155 // git will ask for a username and password when we 1156 // run go get -d -f -u. An empty username and 1157 // password will work. Prevent asking by setting 1158 // GIT_ASKPASS. 1159 tg.creatingTemp("sink" + exeSuffix) 1160 tg.tempFile("src/sink/sink.go", `package main; func main() {}`) 1161 tg.run("build", "-o", "sink"+exeSuffix, "sink") 1162 tg.setenv("GIT_ASKPASS", filepath.Join(tg.pwd(), "sink"+exeSuffix)) 1163 } 1164 tg.runFail("get", "-d", "-u", url) 1165 tg.grepStderr("is a custom import path for", "go get -d -u "+url+" failed for wrong reason") 1166 tg.runFail("get", "-d", "-f", "-u", url) 1167 tg.grepStderr("validating server certificate|[nN]ot [fF]ound", "go get -d -f -u "+url+" failed for wrong reason") 1168 } 1169 1170 func TestInternalPackageErrorsAreHandled(t *testing.T) { 1171 tg := testgo(t) 1172 defer tg.cleanup() 1173 tg.run("list", "./testdata/testinternal3") 1174 } 1175 1176 func TestInternalCache(t *testing.T) { 1177 tg := testgo(t) 1178 defer tg.cleanup() 1179 tg.setenv("GOPATH", filepath.Join(tg.pwd(), "testdata/testinternal4")) 1180 tg.runFail("build", "p") 1181 tg.grepStderr("internal", "did not fail to build p") 1182 } 1183 1184 func TestMoveGit(t *testing.T) { 1185 testMove(t, "git", "rsc.io/pdf", "pdf", "rsc.io/pdf/.git/config") 1186 } 1187 1188 func TestMoveHG(t *testing.T) { 1189 testMove(t, "hg", "vcs-test.golang.org/go/custom-hg-hello", "custom-hg-hello", "vcs-test.golang.org/go/custom-hg-hello/.hg/hgrc") 1190 } 1191 1192 // TODO(rsc): Set up a test case on SourceForge (?) for svn. 1193 // func testMoveSVN(t *testing.T) { 1194 // testMove(t, "svn", "code.google.com/p/rsc-svn/trunk", "-", "-") 1195 // } 1196 1197 func TestImportCommandMatch(t *testing.T) { 1198 tg := testgo(t) 1199 defer tg.cleanup() 1200 tg.setenv("GOPATH", filepath.Join(tg.pwd(), "testdata/importcom")) 1201 tg.run("build", "./testdata/importcom/works.go") 1202 } 1203 1204 func TestImportCommentMismatch(t *testing.T) { 1205 tg := testgo(t) 1206 defer tg.cleanup() 1207 tg.setenv("GOPATH", filepath.Join(tg.pwd(), "testdata/importcom")) 1208 tg.runFail("build", "./testdata/importcom/wrongplace.go") 1209 tg.grepStderr(`wrongplace expects import "my/x"`, "go build did not mention incorrect import") 1210 } 1211 1212 func TestImportCommentSyntaxError(t *testing.T) { 1213 tg := testgo(t) 1214 defer tg.cleanup() 1215 tg.setenv("GOPATH", filepath.Join(tg.pwd(), "testdata/importcom")) 1216 tg.runFail("build", "./testdata/importcom/bad.go") 1217 tg.grepStderr("cannot parse import comment", "go build did not mention syntax error") 1218 } 1219 1220 func TestImportCommentConflict(t *testing.T) { 1221 tg := testgo(t) 1222 defer tg.cleanup() 1223 tg.setenv("GOPATH", filepath.Join(tg.pwd(), "testdata/importcom")) 1224 tg.runFail("build", "./testdata/importcom/conflict.go") 1225 tg.grepStderr("found import comments", "go build did not mention comment conflict") 1226 } 1227 1228 // cmd/go: custom import path checking should not apply to Go packages without import comment. 1229 func TestIssue10952(t *testing.T) { 1230 testenv.MustHaveExternalNetwork(t) 1231 if _, err := exec.LookPath("git"); err != nil { 1232 t.Skip("skipping because git binary not found") 1233 } 1234 1235 tg := testgo(t) 1236 defer tg.cleanup() 1237 tg.parallel() 1238 tg.tempDir("src") 1239 tg.setenv("GOPATH", tg.path(".")) 1240 const importPath = "github.com/zombiezen/go-get-issue-10952" 1241 tg.run("get", "-d", "-u", importPath) 1242 repoDir := tg.path("src/" + importPath) 1243 tg.runGit(repoDir, "remote", "set-url", "origin", "https://"+importPath+".git") 1244 tg.run("get", "-d", "-u", importPath) 1245 } 1246 1247 func TestIssue16471(t *testing.T) { 1248 testenv.MustHaveExternalNetwork(t) 1249 if _, err := exec.LookPath("git"); err != nil { 1250 t.Skip("skipping because git binary not found") 1251 } 1252 1253 tg := testgo(t) 1254 defer tg.cleanup() 1255 tg.parallel() 1256 tg.tempDir("src") 1257 tg.setenv("GOPATH", tg.path(".")) 1258 tg.must(os.MkdirAll(tg.path("src/rsc.io/go-get-issue-10952"), 0755)) 1259 tg.runGit(tg.path("src/rsc.io"), "clone", "https://github.com/zombiezen/go-get-issue-10952") 1260 tg.runFail("get", "-u", "rsc.io/go-get-issue-10952") 1261 tg.grepStderr("rsc.io/go-get-issue-10952 is a custom import path for https://github.com/rsc/go-get-issue-10952, but .* is checked out from https://github.com/zombiezen/go-get-issue-10952", "did not detect updated import path") 1262 } 1263 1264 // Test git clone URL that uses SCP-like syntax and custom import path checking. 1265 func TestIssue11457(t *testing.T) { 1266 testenv.MustHaveExternalNetwork(t) 1267 if _, err := exec.LookPath("git"); err != nil { 1268 t.Skip("skipping because git binary not found") 1269 } 1270 1271 tg := testgo(t) 1272 defer tg.cleanup() 1273 tg.parallel() 1274 tg.tempDir("src") 1275 tg.setenv("GOPATH", tg.path(".")) 1276 const importPath = "rsc.io/go-get-issue-11457" 1277 tg.run("get", "-d", "-u", importPath) 1278 repoDir := tg.path("src/" + importPath) 1279 tg.runGit(repoDir, "remote", "set-url", "origin", "git@github.com:rsc/go-get-issue-11457") 1280 1281 // At this time, custom import path checking compares remotes verbatim (rather than 1282 // just the host and path, skipping scheme and user), so we expect go get -u to fail. 1283 // However, the goal of this test is to verify that gitRemoteRepo correctly parsed 1284 // the SCP-like syntax, and we expect it to appear in the error message. 1285 tg.runFail("get", "-d", "-u", importPath) 1286 want := " is checked out from ssh://git@github.com/rsc/go-get-issue-11457" 1287 if !strings.HasSuffix(strings.TrimSpace(tg.getStderr()), want) { 1288 t.Error("expected clone URL to appear in stderr") 1289 } 1290 } 1291 1292 func TestGetGitDefaultBranch(t *testing.T) { 1293 testenv.MustHaveExternalNetwork(t) 1294 if _, err := exec.LookPath("git"); err != nil { 1295 t.Skip("skipping because git binary not found") 1296 } 1297 1298 tg := testgo(t) 1299 defer tg.cleanup() 1300 tg.parallel() 1301 tg.tempDir("src") 1302 tg.setenv("GOPATH", tg.path(".")) 1303 1304 // This repo has two branches, master and another-branch. 1305 // The another-branch is the default that you get from 'git clone'. 1306 // The go get command variants should not override this. 1307 const importPath = "github.com/rsc/go-get-default-branch" 1308 1309 tg.run("get", "-d", importPath) 1310 repoDir := tg.path("src/" + importPath) 1311 tg.runGit(repoDir, "branch", "--contains", "HEAD") 1312 tg.grepStdout(`\* another-branch`, "not on correct default branch") 1313 1314 tg.run("get", "-d", "-u", importPath) 1315 tg.runGit(repoDir, "branch", "--contains", "HEAD") 1316 tg.grepStdout(`\* another-branch`, "not on correct default branch") 1317 } 1318 1319 func TestAccidentalGitCheckout(t *testing.T) { 1320 testenv.MustHaveExternalNetwork(t) 1321 if _, err := exec.LookPath("git"); err != nil { 1322 t.Skip("skipping because git binary not found") 1323 } 1324 1325 tg := testgo(t) 1326 defer tg.cleanup() 1327 tg.parallel() 1328 tg.tempDir("src") 1329 tg.setenv("GOPATH", tg.path(".")) 1330 1331 tg.runFail("get", "-u", "vcs-test.golang.org/go/test1-svn-git") 1332 tg.grepStderr("src[\\\\/]vcs-test.* uses git, but parent .*src[\\\\/]vcs-test.* uses svn", "get did not fail for right reason") 1333 1334 tg.runFail("get", "-u", "vcs-test.golang.org/go/test2-svn-git/test2main") 1335 tg.grepStderr("src[\\\\/]vcs-test.* uses git, but parent .*src[\\\\/]vcs-test.* uses svn", "get did not fail for right reason") 1336 } 1337 1338 func TestErrorMessageForSyntaxErrorInTestGoFileSaysFAIL(t *testing.T) { 1339 tg := testgo(t) 1340 defer tg.cleanup() 1341 tg.setenv("GOPATH", filepath.Join(tg.pwd(), "testdata")) 1342 tg.runFail("test", "syntaxerror") 1343 tg.grepStderr("FAIL", "go test did not say FAIL") 1344 } 1345 1346 func TestWildcardsDoNotLookInUselessDirectories(t *testing.T) { 1347 tg := testgo(t) 1348 defer tg.cleanup() 1349 tg.setenv("GOPATH", filepath.Join(tg.pwd(), "testdata")) 1350 tg.runFail("list", "...") 1351 tg.grepBoth("badpkg", "go list ... failure does not mention badpkg") 1352 tg.run("list", "m...") 1353 } 1354 1355 func TestRelativeImportsGoTest(t *testing.T) { 1356 tg := testgo(t) 1357 defer tg.cleanup() 1358 tg.run("test", "./testdata/testimport") 1359 } 1360 1361 func TestRelativeImportsGoTestDashI(t *testing.T) { 1362 tg := testgo(t) 1363 defer tg.cleanup() 1364 tg.run("test", "-i", "./testdata/testimport") 1365 } 1366 1367 func TestRelativeImportsInCommandLinePackage(t *testing.T) { 1368 tg := testgo(t) 1369 defer tg.cleanup() 1370 // TODO: tg.parallel() 1371 files, err := filepath.Glob("./testdata/testimport/*.go") 1372 tg.must(err) 1373 tg.run(append([]string{"test"}, files...)...) 1374 } 1375 1376 func TestNonCanonicalImportPaths(t *testing.T) { 1377 tg := testgo(t) 1378 defer tg.cleanup() 1379 tg.parallel() 1380 tg.setenv("GOPATH", filepath.Join(tg.pwd(), "testdata")) 1381 tg.runFail("build", "canonical/d") 1382 tg.grepStderr("package canonical/d", "did not report canonical/d") 1383 tg.grepStderr("imports canonical/b", "did not report canonical/b") 1384 tg.grepStderr("imports canonical/a/: non-canonical", "did not report canonical/a/") 1385 } 1386 1387 func TestVersionControlErrorMessageIncludesCorrectDirectory(t *testing.T) { 1388 tg := testgo(t) 1389 defer tg.cleanup() 1390 tg.setenv("GOPATH", filepath.Join(tg.pwd(), "testdata/shadow/root1")) 1391 tg.runFail("get", "-u", "foo") 1392 1393 // TODO(iant): We should not have to use strconv.Quote here. 1394 // The code in vcs.go should be changed so that it is not required. 1395 quoted := strconv.Quote(filepath.Join("testdata", "shadow", "root1", "src", "foo")) 1396 quoted = quoted[1 : len(quoted)-1] 1397 1398 tg.grepStderr(regexp.QuoteMeta(quoted), "go get -u error does not mention shadow/root1/src/foo") 1399 } 1400 1401 func TestInstallFailsWithNoBuildableFiles(t *testing.T) { 1402 tg := testgo(t) 1403 defer tg.cleanup() 1404 tg.setenv("GOPATH", filepath.Join(tg.pwd(), "testdata")) 1405 tg.setenv("CGO_ENABLED", "0") 1406 tg.runFail("install", "cgotest") 1407 tg.grepStderr("build constraints exclude all Go files", "go install cgotest did not report 'build constraints exclude all Go files'") 1408 } 1409 1410 func TestRelativeGOBINFail(t *testing.T) { 1411 tg := testgo(t) 1412 defer tg.cleanup() 1413 tg.tempFile("triv.go", `package main; func main() {}`) 1414 tg.setenv("GOBIN", ".") 1415 tg.runFail("install") 1416 tg.grepStderr("cannot install, GOBIN must be an absolute path", "go install must fail if $GOBIN is a relative path") 1417 } 1418 1419 // Test that without $GOBIN set, binaries get installed 1420 // into the GOPATH bin directory. 1421 func TestInstallIntoGOPATH(t *testing.T) { 1422 tg := testgo(t) 1423 defer tg.cleanup() 1424 tg.creatingTemp("testdata/bin/go-cmd-test" + exeSuffix) 1425 tg.setenv("GOPATH", filepath.Join(tg.pwd(), "testdata")) 1426 tg.run("install", "go-cmd-test") 1427 tg.wantExecutable("testdata/bin/go-cmd-test"+exeSuffix, "go install go-cmd-test did not write to testdata/bin/go-cmd-test") 1428 } 1429 1430 // Issue 12407 1431 func TestBuildOutputToDevNull(t *testing.T) { 1432 tg := testgo(t) 1433 defer tg.cleanup() 1434 tg.setenv("GOPATH", filepath.Join(tg.pwd(), "testdata")) 1435 tg.run("build", "-o", os.DevNull, "go-cmd-test") 1436 } 1437 1438 func TestPackageMainTestImportsArchiveNotBinary(t *testing.T) { 1439 tg := testgo(t) 1440 defer tg.cleanup() 1441 tg.parallel() 1442 gobin := filepath.Join(tg.pwd(), "testdata", "bin") 1443 tg.creatingTemp(gobin) 1444 tg.setenv("GOBIN", gobin) 1445 tg.setenv("GOPATH", filepath.Join(tg.pwd(), "testdata")) 1446 tg.must(os.Chtimes("./testdata/src/main_test/m.go", time.Now(), time.Now())) 1447 tg.sleep() 1448 tg.run("test", "main_test") 1449 tg.run("install", "main_test") 1450 tg.wantNotStale("main_test", "", "after go install, main listed as stale") 1451 tg.run("test", "main_test") 1452 } 1453 1454 // The runtime version string takes one of two forms: 1455 // "go1.X[.Y]" for Go releases, and "devel +hash" at tip. 1456 // Determine whether we are in a released copy by 1457 // inspecting the version. 1458 var isGoRelease = strings.HasPrefix(runtime.Version(), "go1") 1459 1460 // Issue 12690 1461 func TestPackageNotStaleWithTrailingSlash(t *testing.T) { 1462 tg := testgo(t) 1463 defer tg.cleanup() 1464 1465 // Make sure the packages below are not stale. 1466 tg.run("install", "runtime", "os", "io") 1467 1468 goroot := runtime.GOROOT() 1469 tg.setenv("GOROOT", goroot+"/") 1470 1471 want := "" 1472 if isGoRelease { 1473 want = "standard package in Go release distribution" 1474 } 1475 1476 tg.wantNotStale("runtime", want, "with trailing slash in GOROOT, runtime listed as stale") 1477 tg.wantNotStale("os", want, "with trailing slash in GOROOT, os listed as stale") 1478 tg.wantNotStale("io", want, "with trailing slash in GOROOT, io listed as stale") 1479 } 1480 1481 // With $GOBIN set, binaries get installed to $GOBIN. 1482 func TestInstallIntoGOBIN(t *testing.T) { 1483 tg := testgo(t) 1484 defer tg.cleanup() 1485 gobin := filepath.Join(tg.pwd(), "testdata", "bin1") 1486 tg.creatingTemp(gobin) 1487 tg.setenv("GOBIN", gobin) 1488 tg.setenv("GOPATH", filepath.Join(tg.pwd(), "testdata")) 1489 tg.run("install", "go-cmd-test") 1490 tg.wantExecutable("testdata/bin1/go-cmd-test"+exeSuffix, "go install go-cmd-test did not write to testdata/bin1/go-cmd-test") 1491 } 1492 1493 // Issue 11065 1494 func TestInstallToCurrentDirectoryCreatesExecutable(t *testing.T) { 1495 tg := testgo(t) 1496 defer tg.cleanup() 1497 pkg := filepath.Join(tg.pwd(), "testdata", "src", "go-cmd-test") 1498 tg.creatingTemp(filepath.Join(pkg, "go-cmd-test"+exeSuffix)) 1499 tg.setenv("GOBIN", pkg) 1500 tg.setenv("GOPATH", filepath.Join(tg.pwd(), "testdata")) 1501 tg.cd(pkg) 1502 tg.run("install") 1503 tg.wantExecutable("go-cmd-test"+exeSuffix, "go install did not write to current directory") 1504 } 1505 1506 // Without $GOBIN set, installing a program outside $GOPATH should fail 1507 // (there is nowhere to install it). 1508 func TestInstallWithoutDestinationFails(t *testing.T) { 1509 tg := testgo(t) 1510 defer tg.cleanup() 1511 tg.runFail("install", "testdata/src/go-cmd-test/helloworld.go") 1512 tg.grepStderr("no install location for .go files listed on command line", "wrong error") 1513 } 1514 1515 // With $GOBIN set, should install there. 1516 func TestInstallToGOBINCommandLinePackage(t *testing.T) { 1517 tg := testgo(t) 1518 defer tg.cleanup() 1519 gobin := filepath.Join(tg.pwd(), "testdata", "bin1") 1520 tg.creatingTemp(gobin) 1521 tg.setenv("GOBIN", gobin) 1522 tg.run("install", "testdata/src/go-cmd-test/helloworld.go") 1523 tg.wantExecutable("testdata/bin1/helloworld"+exeSuffix, "go install testdata/src/go-cmd-test/helloworld.go did not write testdata/bin1/helloworld") 1524 } 1525 1526 func TestGoGetNonPkg(t *testing.T) { 1527 testenv.MustHaveExternalNetwork(t) 1528 1529 tg := testgo(t) 1530 defer tg.cleanup() 1531 tg.tempDir("gobin") 1532 tg.setenv("GOPATH", tg.path(".")) 1533 tg.setenv("GOBIN", tg.path("gobin")) 1534 tg.runFail("get", "-d", "golang.org/x/tools") 1535 tg.grepStderr("golang.org/x/tools: no Go files", "missing error") 1536 tg.runFail("get", "-d", "-u", "golang.org/x/tools") 1537 tg.grepStderr("golang.org/x/tools: no Go files", "missing error") 1538 tg.runFail("get", "-d", "golang.org/x/tools") 1539 tg.grepStderr("golang.org/x/tools: no Go files", "missing error") 1540 } 1541 1542 func TestGoGetTestOnlyPkg(t *testing.T) { 1543 testenv.MustHaveExternalNetwork(t) 1544 1545 tg := testgo(t) 1546 defer tg.cleanup() 1547 tg.tempDir("gopath") 1548 tg.setenv("GOPATH", tg.path("gopath")) 1549 tg.run("get", "golang.org/x/tour/content") 1550 tg.run("get", "-t", "golang.org/x/tour/content") 1551 } 1552 1553 func TestInstalls(t *testing.T) { 1554 if testing.Short() { 1555 t.Skip("don't install into GOROOT in short mode") 1556 } 1557 1558 tg := testgo(t) 1559 defer tg.cleanup() 1560 tg.parallel() 1561 tg.tempDir("gobin") 1562 tg.setenv("GOPATH", tg.path(".")) 1563 goroot := runtime.GOROOT() 1564 tg.setenv("GOROOT", goroot) 1565 1566 // cmd/fix installs into tool 1567 tg.run("env", "GOOS") 1568 goos := strings.TrimSpace(tg.getStdout()) 1569 tg.setenv("GOOS", goos) 1570 tg.run("env", "GOARCH") 1571 goarch := strings.TrimSpace(tg.getStdout()) 1572 tg.setenv("GOARCH", goarch) 1573 fixbin := filepath.Join(goroot, "pkg", "tool", goos+"_"+goarch, "fix") + exeSuffix 1574 tg.must(os.RemoveAll(fixbin)) 1575 tg.run("install", "cmd/fix") 1576 tg.wantExecutable(fixbin, "did not install cmd/fix to $GOROOT/pkg/tool") 1577 tg.must(os.Remove(fixbin)) 1578 tg.setenv("GOBIN", tg.path("gobin")) 1579 tg.run("install", "cmd/fix") 1580 tg.wantExecutable(fixbin, "did not install cmd/fix to $GOROOT/pkg/tool with $GOBIN set") 1581 tg.unsetenv("GOBIN") 1582 1583 // gopath program installs into GOBIN 1584 tg.tempFile("src/progname/p.go", `package main; func main() {}`) 1585 tg.setenv("GOBIN", tg.path("gobin")) 1586 tg.run("install", "progname") 1587 tg.unsetenv("GOBIN") 1588 tg.wantExecutable(tg.path("gobin/progname")+exeSuffix, "did not install progname to $GOBIN/progname") 1589 1590 // gopath program installs into GOPATH/bin 1591 tg.run("install", "progname") 1592 tg.wantExecutable(tg.path("bin/progname")+exeSuffix, "did not install progname to $GOPATH/bin/progname") 1593 } 1594 1595 func TestRejectRelativeDotPathInGOPATHCommandLinePackage(t *testing.T) { 1596 tg := testgo(t) 1597 defer tg.cleanup() 1598 tg.setenv("GOPATH", ".") 1599 tg.runFail("build", "testdata/src/go-cmd-test/helloworld.go") 1600 tg.grepStderr("GOPATH entry is relative", "expected an error message rejecting relative GOPATH entries") 1601 } 1602 1603 func TestRejectRelativePathsInGOPATH(t *testing.T) { 1604 tg := testgo(t) 1605 defer tg.cleanup() 1606 sep := string(filepath.ListSeparator) 1607 tg.setenv("GOPATH", sep+filepath.Join(tg.pwd(), "testdata")+sep+".") 1608 tg.runFail("build", "go-cmd-test") 1609 tg.grepStderr("GOPATH entry is relative", "expected an error message rejecting relative GOPATH entries") 1610 } 1611 1612 func TestRejectRelativePathsInGOPATHCommandLinePackage(t *testing.T) { 1613 tg := testgo(t) 1614 defer tg.cleanup() 1615 tg.setenv("GOPATH", "testdata") 1616 tg.runFail("build", "testdata/src/go-cmd-test/helloworld.go") 1617 tg.grepStderr("GOPATH entry is relative", "expected an error message rejecting relative GOPATH entries") 1618 } 1619 1620 // Issue 4104. 1621 func TestGoTestWithPackageListedMultipleTimes(t *testing.T) { 1622 tg := testgo(t) 1623 defer tg.cleanup() 1624 tg.parallel() 1625 tg.run("test", "errors", "errors", "errors", "errors", "errors") 1626 if strings.Contains(strings.TrimSpace(tg.getStdout()), "\n") { 1627 t.Error("go test errors errors errors errors errors tested the same package multiple times") 1628 } 1629 } 1630 1631 func TestGoListHasAConsistentOrder(t *testing.T) { 1632 tg := testgo(t) 1633 defer tg.cleanup() 1634 tg.parallel() 1635 tg.run("list", "std") 1636 first := tg.getStdout() 1637 tg.run("list", "std") 1638 if first != tg.getStdout() { 1639 t.Error("go list std ordering is inconsistent") 1640 } 1641 } 1642 1643 func TestGoListStdDoesNotIncludeCommands(t *testing.T) { 1644 tg := testgo(t) 1645 defer tg.cleanup() 1646 tg.parallel() 1647 tg.run("list", "std") 1648 tg.grepStdoutNot("cmd/", "go list std shows commands") 1649 } 1650 1651 func TestGoListCmdOnlyShowsCommands(t *testing.T) { 1652 tg := testgo(t) 1653 defer tg.cleanup() 1654 tg.parallel() 1655 tg.run("list", "cmd") 1656 out := strings.TrimSpace(tg.getStdout()) 1657 for _, line := range strings.Split(out, "\n") { 1658 if !strings.Contains(line, "cmd/") { 1659 t.Error("go list cmd shows non-commands") 1660 break 1661 } 1662 } 1663 } 1664 1665 func TestGoListDedupsPackages(t *testing.T) { 1666 tg := testgo(t) 1667 defer tg.cleanup() 1668 // TODO: tg.parallel() 1669 tg.setenv("GOPATH", filepath.Join(tg.pwd(), "testdata")) 1670 tg.run("list", "xtestonly", "./testdata/src/xtestonly/...") 1671 got := strings.TrimSpace(tg.getStdout()) 1672 const want = "xtestonly" 1673 if got != want { 1674 t.Errorf("got %q; want %q", got, want) 1675 } 1676 } 1677 1678 // Issue 4096. Validate the output of unsuccessful go install foo/quxx. 1679 func TestUnsuccessfulGoInstallShouldMentionMissingPackage(t *testing.T) { 1680 tg := testgo(t) 1681 defer tg.cleanup() 1682 tg.parallel() 1683 tg.runFail("install", "foo/quxx") 1684 if tg.grepCountBoth(`cannot find package "foo/quxx" in any of`) != 1 { 1685 t.Error(`go install foo/quxx expected error: .*cannot find package "foo/quxx" in any of`) 1686 } 1687 } 1688 1689 func TestGOROOTSearchFailureReporting(t *testing.T) { 1690 tg := testgo(t) 1691 defer tg.cleanup() 1692 tg.parallel() 1693 tg.runFail("install", "foo/quxx") 1694 if tg.grepCountBoth(regexp.QuoteMeta(filepath.Join("foo", "quxx"))+` \(from \$GOROOT\)$`) != 1 { 1695 t.Error(`go install foo/quxx expected error: .*foo/quxx (from $GOROOT)`) 1696 } 1697 } 1698 1699 func TestMultipleGOPATHEntriesReportedSeparately(t *testing.T) { 1700 tg := testgo(t) 1701 defer tg.cleanup() 1702 tg.parallel() 1703 sep := string(filepath.ListSeparator) 1704 tg.setenv("GOPATH", filepath.Join(tg.pwd(), "testdata", "a")+sep+filepath.Join(tg.pwd(), "testdata", "b")) 1705 tg.runFail("install", "foo/quxx") 1706 if tg.grepCountBoth(`testdata[/\\].[/\\]src[/\\]foo[/\\]quxx`) != 2 { 1707 t.Error(`go install foo/quxx expected error: .*testdata/a/src/foo/quxx (from $GOPATH)\n.*testdata/b/src/foo/quxx`) 1708 } 1709 } 1710 1711 // Test (from $GOPATH) annotation is reported for the first GOPATH entry, 1712 func TestMentionGOPATHInFirstGOPATHEntry(t *testing.T) { 1713 tg := testgo(t) 1714 defer tg.cleanup() 1715 tg.parallel() 1716 sep := string(filepath.ListSeparator) 1717 tg.setenv("GOPATH", filepath.Join(tg.pwd(), "testdata", "a")+sep+filepath.Join(tg.pwd(), "testdata", "b")) 1718 tg.runFail("install", "foo/quxx") 1719 if tg.grepCountBoth(regexp.QuoteMeta(filepath.Join("testdata", "a", "src", "foo", "quxx"))+` \(from \$GOPATH\)$`) != 1 { 1720 t.Error(`go install foo/quxx expected error: .*testdata/a/src/foo/quxx (from $GOPATH)`) 1721 } 1722 } 1723 1724 // but not on the second. 1725 func TestMentionGOPATHNotOnSecondEntry(t *testing.T) { 1726 tg := testgo(t) 1727 defer tg.cleanup() 1728 tg.parallel() 1729 sep := string(filepath.ListSeparator) 1730 tg.setenv("GOPATH", filepath.Join(tg.pwd(), "testdata", "a")+sep+filepath.Join(tg.pwd(), "testdata", "b")) 1731 tg.runFail("install", "foo/quxx") 1732 if tg.grepCountBoth(regexp.QuoteMeta(filepath.Join("testdata", "b", "src", "foo", "quxx"))+`$`) != 1 { 1733 t.Error(`go install foo/quxx expected error: .*testdata/b/src/foo/quxx`) 1734 } 1735 } 1736 1737 func homeEnvName() string { 1738 switch runtime.GOOS { 1739 case "windows": 1740 return "USERPROFILE" 1741 case "plan9": 1742 return "home" 1743 default: 1744 return "HOME" 1745 } 1746 } 1747 1748 func TestDefaultGOPATH(t *testing.T) { 1749 tg := testgo(t) 1750 defer tg.cleanup() 1751 tg.parallel() 1752 tg.tempDir("home/go") 1753 tg.setenv(homeEnvName(), tg.path("home")) 1754 1755 tg.run("env", "GOPATH") 1756 tg.grepStdout(regexp.QuoteMeta(tg.path("home/go")), "want GOPATH=$HOME/go") 1757 1758 tg.setenv("GOROOT", tg.path("home/go")) 1759 tg.run("env", "GOPATH") 1760 tg.grepStdoutNot(".", "want unset GOPATH because GOROOT=$HOME/go") 1761 1762 tg.setenv("GOROOT", tg.path("home/go")+"/") 1763 tg.run("env", "GOPATH") 1764 tg.grepStdoutNot(".", "want unset GOPATH because GOROOT=$HOME/go/") 1765 } 1766 1767 func TestDefaultGOPATHGet(t *testing.T) { 1768 testenv.MustHaveExternalNetwork(t) 1769 1770 tg := testgo(t) 1771 defer tg.cleanup() 1772 tg.setenv("GOPATH", "") 1773 tg.tempDir("home") 1774 tg.setenv(homeEnvName(), tg.path("home")) 1775 1776 // warn for creating directory 1777 tg.run("get", "-v", "github.com/golang/example/hello") 1778 tg.grepStderr("created GOPATH="+regexp.QuoteMeta(tg.path("home/go"))+"; see 'go help gopath'", "did not create GOPATH") 1779 1780 // no warning if directory already exists 1781 tg.must(os.RemoveAll(tg.path("home/go"))) 1782 tg.tempDir("home/go") 1783 tg.run("get", "github.com/golang/example/hello") 1784 tg.grepStderrNot(".", "expected no output on standard error") 1785 1786 // error if $HOME/go is a file 1787 tg.must(os.RemoveAll(tg.path("home/go"))) 1788 tg.tempFile("home/go", "") 1789 tg.runFail("get", "github.com/golang/example/hello") 1790 tg.grepStderr(`mkdir .*[/\\]go: .*(not a directory|cannot find the path)`, "expected error because $HOME/go is a file") 1791 } 1792 1793 func TestDefaultGOPATHPrintedSearchList(t *testing.T) { 1794 tg := testgo(t) 1795 defer tg.cleanup() 1796 tg.setenv("GOPATH", "") 1797 tg.tempDir("home") 1798 tg.setenv(homeEnvName(), tg.path("home")) 1799 1800 tg.runFail("install", "github.com/golang/example/hello") 1801 tg.grepStderr(regexp.QuoteMeta(tg.path("home/go/src/github.com/golang/example/hello"))+`.*from \$GOPATH`, "expected default GOPATH") 1802 } 1803 1804 // Issue 4186. go get cannot be used to download packages to $GOROOT. 1805 // Test that without GOPATH set, go get should fail. 1806 func TestGoGetIntoGOROOT(t *testing.T) { 1807 testenv.MustHaveExternalNetwork(t) 1808 1809 tg := testgo(t) 1810 defer tg.cleanup() 1811 tg.parallel() 1812 tg.tempDir("src") 1813 1814 // Fails because GOROOT=GOPATH 1815 tg.setenv("GOPATH", tg.path(".")) 1816 tg.setenv("GOROOT", tg.path(".")) 1817 tg.runFail("get", "-d", "github.com/golang/example/hello") 1818 tg.grepStderr("warning: GOPATH set to GOROOT", "go should detect GOPATH=GOROOT") 1819 tg.grepStderr(`\$GOPATH must not be set to \$GOROOT`, "go should detect GOPATH=GOROOT") 1820 1821 // Fails because GOROOT=GOPATH after cleaning. 1822 tg.setenv("GOPATH", tg.path(".")+"/") 1823 tg.setenv("GOROOT", tg.path(".")) 1824 tg.runFail("get", "-d", "github.com/golang/example/hello") 1825 tg.grepStderr("warning: GOPATH set to GOROOT", "go should detect GOPATH=GOROOT") 1826 tg.grepStderr(`\$GOPATH must not be set to \$GOROOT`, "go should detect GOPATH=GOROOT") 1827 1828 tg.setenv("GOPATH", tg.path(".")) 1829 tg.setenv("GOROOT", tg.path(".")+"/") 1830 tg.runFail("get", "-d", "github.com/golang/example/hello") 1831 tg.grepStderr("warning: GOPATH set to GOROOT", "go should detect GOPATH=GOROOT") 1832 tg.grepStderr(`\$GOPATH must not be set to \$GOROOT`, "go should detect GOPATH=GOROOT") 1833 1834 // Fails because GOROOT=$HOME/go so default GOPATH unset. 1835 tg.tempDir("home/go") 1836 tg.setenv(homeEnvName(), tg.path("home")) 1837 tg.setenv("GOPATH", "") 1838 tg.setenv("GOROOT", tg.path("home/go")) 1839 tg.runFail("get", "-d", "github.com/golang/example/hello") 1840 tg.grepStderr(`\$GOPATH not set`, "expected GOPATH not set") 1841 1842 tg.setenv(homeEnvName(), tg.path("home")+"/") 1843 tg.setenv("GOPATH", "") 1844 tg.setenv("GOROOT", tg.path("home/go")) 1845 tg.runFail("get", "-d", "github.com/golang/example/hello") 1846 tg.grepStderr(`\$GOPATH not set`, "expected GOPATH not set") 1847 1848 tg.setenv(homeEnvName(), tg.path("home")) 1849 tg.setenv("GOPATH", "") 1850 tg.setenv("GOROOT", tg.path("home/go")+"/") 1851 tg.runFail("get", "-d", "github.com/golang/example/hello") 1852 tg.grepStderr(`\$GOPATH not set`, "expected GOPATH not set") 1853 } 1854 1855 func TestLdflagsArgumentsWithSpacesIssue3941(t *testing.T) { 1856 tg := testgo(t) 1857 defer tg.cleanup() 1858 tg.parallel() 1859 tg.tempFile("main.go", `package main 1860 var extern string 1861 func main() { 1862 println(extern) 1863 }`) 1864 tg.run("run", "-ldflags", `-X "main.extern=hello world"`, tg.path("main.go")) 1865 tg.grepStderr("^hello world", `ldflags -X "main.extern=hello world"' failed`) 1866 } 1867 1868 func TestGoTestCpuprofileLeavesBinaryBehind(t *testing.T) { 1869 tg := testgo(t) 1870 defer tg.cleanup() 1871 // TODO: tg.parallel() 1872 tg.makeTempdir() 1873 tg.cd(tg.path(".")) 1874 tg.run("test", "-cpuprofile", "errors.prof", "errors") 1875 tg.wantExecutable("errors.test"+exeSuffix, "go test -cpuprofile did not create errors.test") 1876 } 1877 1878 func TestGoTestCpuprofileDashOControlsBinaryLocation(t *testing.T) { 1879 tg := testgo(t) 1880 defer tg.cleanup() 1881 // TODO: tg.parallel() 1882 tg.makeTempdir() 1883 tg.cd(tg.path(".")) 1884 tg.run("test", "-cpuprofile", "errors.prof", "-o", "myerrors.test"+exeSuffix, "errors") 1885 tg.wantExecutable("myerrors.test"+exeSuffix, "go test -cpuprofile -o myerrors.test did not create myerrors.test") 1886 } 1887 1888 func TestGoTestMutexprofileLeavesBinaryBehind(t *testing.T) { 1889 tg := testgo(t) 1890 defer tg.cleanup() 1891 // TODO: tg.parallel() 1892 tg.makeTempdir() 1893 tg.cd(tg.path(".")) 1894 tg.run("test", "-mutexprofile", "errors.prof", "errors") 1895 tg.wantExecutable("errors.test"+exeSuffix, "go test -mutexprofile did not create errors.test") 1896 } 1897 1898 func TestGoTestMutexprofileDashOControlsBinaryLocation(t *testing.T) { 1899 tg := testgo(t) 1900 defer tg.cleanup() 1901 // TODO: tg.parallel() 1902 tg.makeTempdir() 1903 tg.cd(tg.path(".")) 1904 tg.run("test", "-mutexprofile", "errors.prof", "-o", "myerrors.test"+exeSuffix, "errors") 1905 tg.wantExecutable("myerrors.test"+exeSuffix, "go test -mutexprofile -o myerrors.test did not create myerrors.test") 1906 } 1907 1908 func TestGoTestDashCDashOControlsBinaryLocation(t *testing.T) { 1909 tg := testgo(t) 1910 defer tg.cleanup() 1911 tg.parallel() 1912 tg.makeTempdir() 1913 tg.run("test", "-c", "-o", tg.path("myerrors.test"+exeSuffix), "errors") 1914 tg.wantExecutable(tg.path("myerrors.test"+exeSuffix), "go test -c -o myerrors.test did not create myerrors.test") 1915 } 1916 1917 func TestGoTestDashOWritesBinary(t *testing.T) { 1918 tg := testgo(t) 1919 defer tg.cleanup() 1920 tg.parallel() 1921 tg.makeTempdir() 1922 tg.run("test", "-o", tg.path("myerrors.test"+exeSuffix), "errors") 1923 tg.wantExecutable(tg.path("myerrors.test"+exeSuffix), "go test -o myerrors.test did not create myerrors.test") 1924 } 1925 1926 func TestGoTestDashIDashOWritesBinary(t *testing.T) { 1927 tg := testgo(t) 1928 defer tg.cleanup() 1929 tg.parallel() 1930 tg.makeTempdir() 1931 tg.run("test", "-v", "-i", "-o", tg.path("myerrors.test"+exeSuffix), "errors") 1932 tg.grepBothNot("PASS|FAIL", "test should not have run") 1933 tg.wantExecutable(tg.path("myerrors.test"+exeSuffix), "go test -o myerrors.test did not create myerrors.test") 1934 } 1935 1936 // Issue 4568. 1937 func TestSymlinksList(t *testing.T) { 1938 testenv.MustHaveSymlink(t) 1939 1940 tg := testgo(t) 1941 defer tg.cleanup() 1942 // TODO: tg.parallel() 1943 tg.tempDir("src") 1944 tg.must(os.Symlink(tg.path("."), tg.path("src/dir1"))) 1945 tg.tempFile("src/dir1/p.go", "package p") 1946 tg.setenv("GOPATH", tg.path(".")) 1947 tg.cd(tg.path("src")) 1948 tg.run("list", "-f", "{{.Root}}", "dir1") 1949 if strings.TrimSpace(tg.getStdout()) != tg.path(".") { 1950 t.Error("confused by symlinks") 1951 } 1952 } 1953 1954 // Issue 14054. 1955 func TestSymlinksVendor(t *testing.T) { 1956 testenv.MustHaveSymlink(t) 1957 1958 tg := testgo(t) 1959 defer tg.cleanup() 1960 // TODO: tg.parallel() 1961 tg.tempDir("gopath/src/dir1/vendor/v") 1962 tg.tempFile("gopath/src/dir1/p.go", "package main\nimport _ `v`\nfunc main(){}") 1963 tg.tempFile("gopath/src/dir1/vendor/v/v.go", "package v") 1964 tg.must(os.Symlink(tg.path("gopath/src/dir1"), tg.path("symdir1"))) 1965 tg.setenv("GOPATH", tg.path("gopath")) 1966 tg.cd(tg.path("symdir1")) 1967 tg.run("list", "-f", "{{.Root}}", ".") 1968 if strings.TrimSpace(tg.getStdout()) != tg.path("gopath") { 1969 t.Error("list confused by symlinks") 1970 } 1971 1972 // All of these should succeed, not die in vendor-handling code. 1973 tg.run("run", "p.go") 1974 tg.run("build") 1975 tg.run("install") 1976 } 1977 1978 // Issue 15201. 1979 func TestSymlinksVendor15201(t *testing.T) { 1980 testenv.MustHaveSymlink(t) 1981 1982 tg := testgo(t) 1983 defer tg.cleanup() 1984 1985 tg.tempDir("gopath/src/x/y/_vendor/src/x") 1986 tg.must(os.Symlink("../../..", tg.path("gopath/src/x/y/_vendor/src/x/y"))) 1987 tg.tempFile("gopath/src/x/y/w/w.go", "package w\nimport \"x/y/z\"\n") 1988 tg.must(os.Symlink("../_vendor/src", tg.path("gopath/src/x/y/w/vendor"))) 1989 tg.tempFile("gopath/src/x/y/z/z.go", "package z\n") 1990 1991 tg.setenv("GOPATH", tg.path("gopath/src/x/y/_vendor")+string(filepath.ListSeparator)+tg.path("gopath")) 1992 tg.cd(tg.path("gopath/src")) 1993 tg.run("list", "./...") 1994 } 1995 1996 func TestSymlinksInternal(t *testing.T) { 1997 testenv.MustHaveSymlink(t) 1998 1999 tg := testgo(t) 2000 defer tg.cleanup() 2001 tg.tempDir("gopath/src/dir1/internal/v") 2002 tg.tempFile("gopath/src/dir1/p.go", "package main\nimport _ `dir1/internal/v`\nfunc main(){}") 2003 tg.tempFile("gopath/src/dir1/internal/v/v.go", "package v") 2004 tg.must(os.Symlink(tg.path("gopath/src/dir1"), tg.path("symdir1"))) 2005 tg.setenv("GOPATH", tg.path("gopath")) 2006 tg.cd(tg.path("symdir1")) 2007 tg.run("list", "-f", "{{.Root}}", ".") 2008 if strings.TrimSpace(tg.getStdout()) != tg.path("gopath") { 2009 t.Error("list confused by symlinks") 2010 } 2011 2012 // All of these should succeed, not die in internal-handling code. 2013 tg.run("run", "p.go") 2014 tg.run("build") 2015 tg.run("install") 2016 } 2017 2018 // Issue 4515. 2019 func TestInstallWithTags(t *testing.T) { 2020 tg := testgo(t) 2021 defer tg.cleanup() 2022 tg.parallel() 2023 tg.tempDir("bin") 2024 tg.tempFile("src/example/a/main.go", `package main 2025 func main() {}`) 2026 tg.tempFile("src/example/b/main.go", `// +build mytag 2027 2028 package main 2029 func main() {}`) 2030 tg.setenv("GOPATH", tg.path(".")) 2031 tg.run("install", "-tags", "mytag", "example/a", "example/b") 2032 tg.wantExecutable(tg.path("bin/a"+exeSuffix), "go install example/a example/b did not install binaries") 2033 tg.wantExecutable(tg.path("bin/b"+exeSuffix), "go install example/a example/b did not install binaries") 2034 tg.must(os.Remove(tg.path("bin/a" + exeSuffix))) 2035 tg.must(os.Remove(tg.path("bin/b" + exeSuffix))) 2036 tg.run("install", "-tags", "mytag", "example/...") 2037 tg.wantExecutable(tg.path("bin/a"+exeSuffix), "go install example/... did not install binaries") 2038 tg.wantExecutable(tg.path("bin/b"+exeSuffix), "go install example/... did not install binaries") 2039 tg.run("list", "-tags", "mytag", "example/b...") 2040 if strings.TrimSpace(tg.getStdout()) != "example/b" { 2041 t.Error("go list example/b did not find example/b") 2042 } 2043 } 2044 2045 // Issue 4773 2046 func TestCaseCollisions(t *testing.T) { 2047 tg := testgo(t) 2048 defer tg.cleanup() 2049 tg.parallel() 2050 tg.tempDir("src/example/a/pkg") 2051 tg.tempDir("src/example/a/Pkg") 2052 tg.tempDir("src/example/b") 2053 tg.setenv("GOPATH", tg.path(".")) 2054 tg.tempFile("src/example/a/a.go", `package p 2055 import ( 2056 _ "example/a/pkg" 2057 _ "example/a/Pkg" 2058 )`) 2059 tg.tempFile("src/example/a/pkg/pkg.go", `package pkg`) 2060 tg.tempFile("src/example/a/Pkg/pkg.go", `package pkg`) 2061 tg.run("list", "-json", "example/a") 2062 tg.grepStdout("case-insensitive import collision", "go list -json example/a did not report import collision") 2063 tg.runFail("build", "example/a") 2064 tg.grepStderr("case-insensitive import collision", "go build example/a did not report import collision") 2065 tg.tempFile("src/example/b/file.go", `package b`) 2066 tg.tempFile("src/example/b/FILE.go", `package b`) 2067 f, err := os.Open(tg.path("src/example/b")) 2068 tg.must(err) 2069 names, err := f.Readdirnames(0) 2070 tg.must(err) 2071 tg.check(f.Close()) 2072 args := []string{"list"} 2073 if len(names) == 2 { 2074 // case-sensitive file system, let directory read find both files 2075 args = append(args, "example/b") 2076 } else { 2077 // case-insensitive file system, list files explicitly on command line 2078 args = append(args, tg.path("src/example/b/file.go"), tg.path("src/example/b/FILE.go")) 2079 } 2080 tg.runFail(args...) 2081 tg.grepStderr("case-insensitive file name collision", "go list example/b did not report file name collision") 2082 2083 tg.runFail("list", "example/a/pkg", "example/a/Pkg") 2084 tg.grepStderr("case-insensitive import collision", "go list example/a/pkg example/a/Pkg did not report import collision") 2085 tg.run("list", "-json", "-e", "example/a/pkg", "example/a/Pkg") 2086 tg.grepStdout("case-insensitive import collision", "go list -json -e example/a/pkg example/a/Pkg did not report import collision") 2087 tg.runFail("build", "example/a/pkg", "example/a/Pkg") 2088 tg.grepStderr("case-insensitive import collision", "go build example/a/pkg example/a/Pkg did not report import collision") 2089 } 2090 2091 // Issue 17451, 17662. 2092 func TestSymlinkWarning(t *testing.T) { 2093 tg := testgo(t) 2094 defer tg.cleanup() 2095 tg.parallel() 2096 tg.makeTempdir() 2097 tg.setenv("GOPATH", tg.path(".")) 2098 2099 tg.tempDir("src/example/xx") 2100 tg.tempDir("yy/zz") 2101 tg.tempFile("yy/zz/zz.go", "package zz\n") 2102 if err := os.Symlink(tg.path("yy"), tg.path("src/example/xx/yy")); err != nil { 2103 t.Skip("symlink failed: %v", err) 2104 } 2105 tg.run("list", "example/xx/z...") 2106 tg.grepStdoutNot(".", "list should not have matched anything") 2107 tg.grepStderr("matched no packages", "list should have reported that pattern matched no packages") 2108 tg.grepStderrNot("symlink", "list should not have reported symlink") 2109 2110 tg.run("list", "example/xx/...") 2111 tg.grepStdoutNot(".", "list should not have matched anything") 2112 tg.grepStderr("matched no packages", "list should have reported that pattern matched no packages") 2113 tg.grepStderr("ignoring symlink", "list should have reported symlink") 2114 } 2115 2116 // Issue 8181. 2117 func TestGoGetDashTIssue8181(t *testing.T) { 2118 testenv.MustHaveExternalNetwork(t) 2119 2120 tg := testgo(t) 2121 defer tg.cleanup() 2122 tg.parallel() 2123 tg.makeTempdir() 2124 tg.setenv("GOPATH", tg.path(".")) 2125 tg.run("get", "-v", "-t", "github.com/rsc/go-get-issue-8181/a", "github.com/rsc/go-get-issue-8181/b") 2126 tg.run("list", "...") 2127 tg.grepStdout("x/build/gerrit", "missing expected x/build/gerrit") 2128 } 2129 2130 func TestIssue11307(t *testing.T) { 2131 // go get -u was not working except in checkout directory 2132 testenv.MustHaveExternalNetwork(t) 2133 2134 tg := testgo(t) 2135 defer tg.cleanup() 2136 tg.parallel() 2137 tg.makeTempdir() 2138 tg.setenv("GOPATH", tg.path(".")) 2139 tg.run("get", "github.com/rsc/go-get-issue-11307") 2140 tg.run("get", "-u", "github.com/rsc/go-get-issue-11307") // was failing 2141 } 2142 2143 func TestShadowingLogic(t *testing.T) { 2144 tg := testgo(t) 2145 defer tg.cleanup() 2146 pwd := tg.pwd() 2147 sep := string(filepath.ListSeparator) 2148 tg.setenv("GOPATH", filepath.Join(pwd, "testdata", "shadow", "root1")+sep+filepath.Join(pwd, "testdata", "shadow", "root2")) 2149 2150 // The math in root1 is not "math" because the standard math is. 2151 tg.run("list", "-f", "({{.ImportPath}}) ({{.ConflictDir}})", "./testdata/shadow/root1/src/math") 2152 pwdForwardSlash := strings.Replace(pwd, string(os.PathSeparator), "/", -1) 2153 if !strings.HasPrefix(pwdForwardSlash, "/") { 2154 pwdForwardSlash = "/" + pwdForwardSlash 2155 } 2156 // The output will have makeImportValid applies, but we only 2157 // bother to deal with characters we might reasonably see. 2158 for _, r := range " :" { 2159 pwdForwardSlash = strings.Replace(pwdForwardSlash, string(r), "_", -1) 2160 } 2161 want := "(_" + pwdForwardSlash + "/testdata/shadow/root1/src/math) (" + filepath.Join(runtime.GOROOT(), "src", "math") + ")" 2162 if strings.TrimSpace(tg.getStdout()) != want { 2163 t.Error("shadowed math is not shadowed; looking for", want) 2164 } 2165 2166 // The foo in root1 is "foo". 2167 tg.run("list", "-f", "({{.ImportPath}}) ({{.ConflictDir}})", "./testdata/shadow/root1/src/foo") 2168 if strings.TrimSpace(tg.getStdout()) != "(foo) ()" { 2169 t.Error("unshadowed foo is shadowed") 2170 } 2171 2172 // The foo in root2 is not "foo" because the foo in root1 got there first. 2173 tg.run("list", "-f", "({{.ImportPath}}) ({{.ConflictDir}})", "./testdata/shadow/root2/src/foo") 2174 want = "(_" + pwdForwardSlash + "/testdata/shadow/root2/src/foo) (" + filepath.Join(pwd, "testdata", "shadow", "root1", "src", "foo") + ")" 2175 if strings.TrimSpace(tg.getStdout()) != want { 2176 t.Error("shadowed foo is not shadowed; looking for", want) 2177 } 2178 2179 // The error for go install should mention the conflicting directory. 2180 tg.runFail("install", "./testdata/shadow/root2/src/foo") 2181 want = "go install: no install location for " + filepath.Join(pwd, "testdata", "shadow", "root2", "src", "foo") + ": hidden by " + filepath.Join(pwd, "testdata", "shadow", "root1", "src", "foo") 2182 if strings.TrimSpace(tg.getStderr()) != want { 2183 t.Error("wrong shadowed install error; looking for", want) 2184 } 2185 } 2186 2187 // Only succeeds if source order is preserved. 2188 func TestSourceFileNameOrderPreserved(t *testing.T) { 2189 tg := testgo(t) 2190 defer tg.cleanup() 2191 tg.run("test", "testdata/example1_test.go", "testdata/example2_test.go") 2192 } 2193 2194 // Check that coverage analysis works at all. 2195 // Don't worry about the exact numbers but require not 0.0%. 2196 func checkCoverage(tg *testgoData, data string) { 2197 if regexp.MustCompile(`[^0-9]0\.0%`).MatchString(data) { 2198 tg.t.Error("some coverage results are 0.0%") 2199 } 2200 tg.t.Log(data) 2201 } 2202 2203 func TestCoverageRuns(t *testing.T) { 2204 if testing.Short() { 2205 t.Skip("don't build libraries for coverage in short mode") 2206 } 2207 tg := testgo(t) 2208 defer tg.cleanup() 2209 tg.run("test", "-short", "-coverpkg=strings", "strings", "regexp") 2210 data := tg.getStdout() + tg.getStderr() 2211 tg.run("test", "-short", "-cover", "strings", "math", "regexp") 2212 data += tg.getStdout() + tg.getStderr() 2213 checkCoverage(tg, data) 2214 } 2215 2216 // Check that coverage analysis uses set mode. 2217 func TestCoverageUsesSetMode(t *testing.T) { 2218 if testing.Short() { 2219 t.Skip("don't build libraries for coverage in short mode") 2220 } 2221 tg := testgo(t) 2222 defer tg.cleanup() 2223 tg.creatingTemp("testdata/cover.out") 2224 tg.run("test", "-short", "-cover", "encoding/binary", "-coverprofile=testdata/cover.out") 2225 data := tg.getStdout() + tg.getStderr() 2226 if out, err := ioutil.ReadFile("testdata/cover.out"); err != nil { 2227 t.Error(err) 2228 } else { 2229 if !bytes.Contains(out, []byte("mode: set")) { 2230 t.Error("missing mode: set") 2231 } 2232 } 2233 checkCoverage(tg, data) 2234 } 2235 2236 func TestCoverageUsesAtomicModeForRace(t *testing.T) { 2237 if testing.Short() { 2238 t.Skip("don't build libraries for coverage in short mode") 2239 } 2240 if !canRace { 2241 t.Skip("skipping because race detector not supported") 2242 } 2243 2244 tg := testgo(t) 2245 defer tg.cleanup() 2246 tg.creatingTemp("testdata/cover.out") 2247 tg.run("test", "-short", "-race", "-cover", "encoding/binary", "-coverprofile=testdata/cover.out") 2248 data := tg.getStdout() + tg.getStderr() 2249 if out, err := ioutil.ReadFile("testdata/cover.out"); err != nil { 2250 t.Error(err) 2251 } else { 2252 if !bytes.Contains(out, []byte("mode: atomic")) { 2253 t.Error("missing mode: atomic") 2254 } 2255 } 2256 checkCoverage(tg, data) 2257 } 2258 2259 func TestCoverageImportMainLoop(t *testing.T) { 2260 tg := testgo(t) 2261 defer tg.cleanup() 2262 tg.setenv("GOPATH", filepath.Join(tg.pwd(), "testdata")) 2263 tg.runFail("test", "importmain/test") 2264 tg.grepStderr("not an importable package", "did not detect import main") 2265 tg.runFail("test", "-cover", "importmain/test") 2266 tg.grepStderr("not an importable package", "did not detect import main") 2267 } 2268 2269 func TestPluginNonMain(t *testing.T) { 2270 wd, err := os.Getwd() 2271 if err != nil { 2272 t.Fatal(err) 2273 } 2274 2275 pkg := filepath.Join(wd, "testdata", "testdep", "p2") 2276 2277 tg := testgo(t) 2278 defer tg.cleanup() 2279 2280 tg.runFail("build", "-buildmode=plugin", pkg) 2281 } 2282 2283 func TestTestEmpty(t *testing.T) { 2284 if !canRace { 2285 t.Skip("no race detector") 2286 } 2287 2288 wd, _ := os.Getwd() 2289 testdata := filepath.Join(wd, "testdata") 2290 for _, dir := range []string{"pkg", "test", "xtest", "pkgtest", "pkgxtest", "pkgtestxtest", "testxtest"} { 2291 t.Run(dir, func(t *testing.T) { 2292 tg := testgo(t) 2293 defer tg.cleanup() 2294 tg.setenv("GOPATH", testdata) 2295 tg.cd(filepath.Join(testdata, "src/empty/"+dir)) 2296 tg.run("test", "-cover", "-coverpkg=.", "-race") 2297 }) 2298 if testing.Short() { 2299 break 2300 } 2301 } 2302 } 2303 2304 func TestNoGoError(t *testing.T) { 2305 wd, _ := os.Getwd() 2306 testdata := filepath.Join(wd, "testdata") 2307 for _, dir := range []string{"empty/test", "empty/xtest", "empty/testxtest", "exclude", "exclude/ignore", "exclude/empty"} { 2308 t.Run(dir, func(t *testing.T) { 2309 tg := testgo(t) 2310 defer tg.cleanup() 2311 tg.setenv("GOPATH", testdata) 2312 tg.cd(filepath.Join(testdata, "src")) 2313 tg.runFail("build", "./"+dir) 2314 var want string 2315 if strings.Contains(dir, "test") { 2316 want = "no non-test Go files in " 2317 } else if dir == "exclude" { 2318 want = "build constraints exclude all Go files in " 2319 } else { 2320 want = "no Go files in " 2321 } 2322 tg.grepStderr(want, "wrong reason for failure") 2323 }) 2324 } 2325 } 2326 2327 func TestTestRaceInstall(t *testing.T) { 2328 if !canRace { 2329 t.Skip("no race detector") 2330 } 2331 if testing.Short() && testenv.Builder() == "" { 2332 t.Skip("don't rebuild the standard library in short mode") 2333 } 2334 2335 tg := testgo(t) 2336 defer tg.cleanup() 2337 tg.setenv("GOPATH", filepath.Join(tg.pwd(), "testdata")) 2338 2339 tg.tempDir("pkg") 2340 pkgdir := tg.path("pkg") 2341 tg.run("install", "-race", "-pkgdir="+pkgdir, "std") 2342 tg.run("test", "-race", "-pkgdir="+pkgdir, "-i", "-v", "empty/pkg") 2343 if tg.getStderr() != "" { 2344 t.Error("go test -i -race: rebuilds cached packages") 2345 } 2346 } 2347 2348 func TestBuildDryRunWithCgo(t *testing.T) { 2349 if !canCgo { 2350 t.Skip("skipping because cgo not enabled") 2351 } 2352 2353 tg := testgo(t) 2354 defer tg.cleanup() 2355 tg.tempFile("foo.go", `package main 2356 2357 /* 2358 #include <limits.h> 2359 */ 2360 import "C" 2361 2362 func main() { 2363 println(C.INT_MAX) 2364 }`) 2365 tg.run("build", "-n", tg.path("foo.go")) 2366 tg.grepStderrNot(`os.Stat .* no such file or directory`, "unexpected stat of archive file") 2367 } 2368 2369 func TestCoverageWithCgo(t *testing.T) { 2370 if !canCgo { 2371 t.Skip("skipping because cgo not enabled") 2372 } 2373 2374 for _, dir := range []string{"cgocover", "cgocover2", "cgocover3", "cgocover4"} { 2375 t.Run(dir, func(t *testing.T) { 2376 tg := testgo(t) 2377 tg.parallel() 2378 defer tg.cleanup() 2379 tg.setenv("GOPATH", filepath.Join(tg.pwd(), "testdata")) 2380 tg.run("test", "-short", "-cover", dir) 2381 data := tg.getStdout() + tg.getStderr() 2382 checkCoverage(tg, data) 2383 }) 2384 } 2385 } 2386 2387 func TestCgoAsmError(t *testing.T) { 2388 if !canCgo { 2389 t.Skip("skipping because cgo not enabled") 2390 } 2391 2392 tg := testgo(t) 2393 tg.parallel() 2394 defer tg.cleanup() 2395 tg.setenv("GOPATH", filepath.Join(tg.pwd(), "testdata")) 2396 tg.runFail("build", "cgoasm") 2397 tg.grepBoth("package using cgo has Go assembly file", "did not detect Go assembly file") 2398 } 2399 2400 func TestCgoDependsOnSyscall(t *testing.T) { 2401 if testing.Short() { 2402 t.Skip("skipping test that removes $GOROOT/pkg/*_race in short mode") 2403 } 2404 if !canCgo { 2405 t.Skip("skipping because cgo not enabled") 2406 } 2407 if !canRace { 2408 t.Skip("skipping because race detector not supported") 2409 } 2410 2411 tg := testgo(t) 2412 defer tg.cleanup() 2413 files, err := filepath.Glob(filepath.Join(runtime.GOROOT(), "pkg", "*_race")) 2414 tg.must(err) 2415 for _, file := range files { 2416 tg.check(os.RemoveAll(file)) 2417 } 2418 tg.tempFile("src/foo/foo.go", ` 2419 package foo 2420 //#include <stdio.h> 2421 import "C"`) 2422 tg.setenv("GOPATH", tg.path(".")) 2423 tg.run("build", "-race", "foo") 2424 } 2425 2426 func TestCgoShowsFullPathNames(t *testing.T) { 2427 if !canCgo { 2428 t.Skip("skipping because cgo not enabled") 2429 } 2430 2431 tg := testgo(t) 2432 defer tg.cleanup() 2433 tg.parallel() 2434 tg.tempFile("src/x/y/dirname/foo.go", ` 2435 package foo 2436 import "C" 2437 func f() {`) 2438 tg.setenv("GOPATH", tg.path(".")) 2439 tg.runFail("build", "x/y/dirname") 2440 tg.grepBoth("x/y/dirname", "error did not use full path") 2441 } 2442 2443 func TestCgoHandlesWlORIGIN(t *testing.T) { 2444 if !canCgo { 2445 t.Skip("skipping because cgo not enabled") 2446 } 2447 2448 tg := testgo(t) 2449 defer tg.cleanup() 2450 tg.parallel() 2451 tg.tempFile("src/origin/origin.go", `package origin 2452 // #cgo !darwin LDFLAGS: -Wl,-rpath,$ORIGIN 2453 // void f(void) {} 2454 import "C" 2455 func f() { C.f() }`) 2456 tg.setenv("GOPATH", tg.path(".")) 2457 tg.run("build", "origin") 2458 } 2459 2460 func TestCgoPkgConfig(t *testing.T) { 2461 if !canCgo { 2462 t.Skip("skipping because cgo not enabled") 2463 } 2464 tg := testgo(t) 2465 defer tg.cleanup() 2466 tg.parallel() 2467 2468 tg.run("env", "PKG_CONFIG") 2469 pkgConfig := strings.TrimSpace(tg.getStdout()) 2470 if out, err := exec.Command(pkgConfig, "--atleast-pkgconfig-version", "0.24").CombinedOutput(); err != nil { 2471 t.Skipf("%s --atleast-pkgconfig-version 0.24: %v\n%s", pkgConfig, err, out) 2472 } 2473 2474 // OpenBSD's pkg-config is strict about whitespace and only 2475 // supports backslash-escaped whitespace. It does not support 2476 // quotes, which the normal freedesktop.org pkg-config does 2477 // support. See http://man.openbsd.org/pkg-config.1 2478 tg.tempFile("foo.pc", ` 2479 Name: foo 2480 Description: The foo library 2481 Version: 1.0.0 2482 Cflags: -Dhello=10 -Dworld=+32 -DDEFINED_FROM_PKG_CONFIG=hello\ world 2483 `) 2484 tg.tempFile("foo.go", `package main 2485 2486 /* 2487 #cgo pkg-config: foo 2488 int value() { 2489 return DEFINED_FROM_PKG_CONFIG; 2490 } 2491 */ 2492 import "C" 2493 import "os" 2494 2495 func main() { 2496 if C.value() != 42 { 2497 println("value() =", C.value(), "wanted 42") 2498 os.Exit(1) 2499 } 2500 } 2501 `) 2502 tg.setenv("PKG_CONFIG_PATH", tg.path(".")) 2503 tg.run("run", tg.path("foo.go")) 2504 } 2505 2506 // "go test -c -test.bench=XXX errors" should not hang 2507 func TestIssue6480(t *testing.T) { 2508 tg := testgo(t) 2509 defer tg.cleanup() 2510 // TODO: tg.parallel() 2511 tg.makeTempdir() 2512 tg.cd(tg.path(".")) 2513 tg.run("test", "-c", "-test.bench=XXX", "errors") 2514 } 2515 2516 // cmd/cgo: undefined reference when linking a C-library using gccgo 2517 func TestIssue7573(t *testing.T) { 2518 if !canCgo { 2519 t.Skip("skipping because cgo not enabled") 2520 } 2521 if _, err := exec.LookPath("gccgo"); err != nil { 2522 t.Skip("skipping because no gccgo compiler found") 2523 } 2524 2525 tg := testgo(t) 2526 defer tg.cleanup() 2527 tg.parallel() 2528 tg.tempFile("src/cgoref/cgoref.go", ` 2529 package main 2530 // #cgo LDFLAGS: -L alibpath -lalib 2531 // void f(void) {} 2532 import "C" 2533 2534 func main() { C.f() }`) 2535 tg.setenv("GOPATH", tg.path(".")) 2536 tg.run("build", "-n", "-compiler", "gccgo", "cgoref") 2537 tg.grepStderr(`gccgo.*\-L [^ ]*alibpath \-lalib`, `no Go-inline "#cgo LDFLAGS:" ("-L alibpath -lalib") passed to gccgo linking stage`) 2538 } 2539 2540 func TestListTemplateContextFunction(t *testing.T) { 2541 t.Parallel() 2542 for _, tt := range []struct { 2543 v string 2544 want string 2545 }{ 2546 {"GOARCH", runtime.GOARCH}, 2547 {"GOOS", runtime.GOOS}, 2548 {"GOROOT", filepath.Clean(runtime.GOROOT())}, 2549 {"GOPATH", os.Getenv("GOPATH")}, 2550 {"CgoEnabled", ""}, 2551 {"UseAllFiles", ""}, 2552 {"Compiler", ""}, 2553 {"BuildTags", ""}, 2554 {"ReleaseTags", ""}, 2555 {"InstallSuffix", ""}, 2556 } { 2557 tt := tt 2558 t.Run(tt.v, func(t *testing.T) { 2559 tg := testgo(t) 2560 tg.parallel() 2561 defer tg.cleanup() 2562 tmpl := "{{context." + tt.v + "}}" 2563 tg.run("list", "-f", tmpl) 2564 if tt.want == "" { 2565 return 2566 } 2567 if got := strings.TrimSpace(tg.getStdout()); got != tt.want { 2568 t.Errorf("go list -f %q: got %q; want %q", tmpl, got, tt.want) 2569 } 2570 }) 2571 } 2572 } 2573 2574 // cmd/go: "go test" should fail if package does not build 2575 func TestIssue7108(t *testing.T) { 2576 tg := testgo(t) 2577 defer tg.cleanup() 2578 tg.setenv("GOPATH", filepath.Join(tg.pwd(), "testdata")) 2579 tg.runFail("test", "notest") 2580 } 2581 2582 // cmd/go: go test -a foo does not rebuild regexp. 2583 func TestIssue6844(t *testing.T) { 2584 if testing.Short() { 2585 t.Skip("don't rebuild the standard library in short mode") 2586 } 2587 2588 tg := testgo(t) 2589 defer tg.cleanup() 2590 tg.creatingTemp("deps.test" + exeSuffix) 2591 tg.run("test", "-x", "-a", "-c", "testdata/dep_test.go") 2592 tg.grepStderr("regexp", "go test -x -a -c testdata/dep-test.go did not rebuild regexp") 2593 } 2594 2595 func TestBuildDashIInstallsDependencies(t *testing.T) { 2596 tg := testgo(t) 2597 defer tg.cleanup() 2598 tg.parallel() 2599 tg.tempFile("src/x/y/foo/foo.go", `package foo 2600 func F() {}`) 2601 tg.tempFile("src/x/y/bar/bar.go", `package bar 2602 import "x/y/foo" 2603 func F() { foo.F() }`) 2604 tg.setenv("GOPATH", tg.path(".")) 2605 2606 checkbar := func(desc string) { 2607 tg.sleep() 2608 tg.must(os.Chtimes(tg.path("src/x/y/foo/foo.go"), time.Now(), time.Now())) 2609 tg.sleep() 2610 tg.run("build", "-v", "-i", "x/y/bar") 2611 tg.grepBoth("x/y/foo", "first build -i "+desc+" did not build x/y/foo") 2612 tg.run("build", "-v", "-i", "x/y/bar") 2613 tg.grepBothNot("x/y/foo", "second build -i "+desc+" built x/y/foo") 2614 } 2615 checkbar("pkg") 2616 tg.creatingTemp("bar" + exeSuffix) 2617 tg.tempFile("src/x/y/bar/bar.go", `package main 2618 import "x/y/foo" 2619 func main() { foo.F() }`) 2620 checkbar("cmd") 2621 } 2622 2623 func TestGoBuildInTestOnlyDirectoryFailsWithAGoodError(t *testing.T) { 2624 tg := testgo(t) 2625 defer tg.cleanup() 2626 tg.runFail("build", "./testdata/testonly") 2627 tg.grepStderr("no non-test Go files in", "go build ./testdata/testonly produced unexpected error") 2628 } 2629 2630 func TestGoTestDetectsTestOnlyImportCycles(t *testing.T) { 2631 tg := testgo(t) 2632 defer tg.cleanup() 2633 tg.setenv("GOPATH", filepath.Join(tg.pwd(), "testdata")) 2634 tg.runFail("test", "-c", "testcycle/p3") 2635 tg.grepStderr("import cycle not allowed in test", "go test testcycle/p3 produced unexpected error") 2636 2637 tg.runFail("test", "-c", "testcycle/q1") 2638 tg.grepStderr("import cycle not allowed in test", "go test testcycle/q1 produced unexpected error") 2639 } 2640 2641 func TestGoTestFooTestWorks(t *testing.T) { 2642 tg := testgo(t) 2643 defer tg.cleanup() 2644 tg.run("test", "testdata/standalone_test.go") 2645 } 2646 2647 func TestGoTestFlagsAfterPackage(t *testing.T) { 2648 tg := testgo(t) 2649 defer tg.cleanup() 2650 tg.run("test", "testdata/flag_test.go", "-v", "-args", "-v=7") // Two distinct -v flags. 2651 tg.run("test", "-v", "testdata/flag_test.go", "-args", "-v=7") // Two distinct -v flags. 2652 } 2653 2654 func TestGoTestXtestonlyWorks(t *testing.T) { 2655 tg := testgo(t) 2656 defer tg.cleanup() 2657 tg.setenv("GOPATH", filepath.Join(tg.pwd(), "testdata")) 2658 tg.run("clean", "-i", "xtestonly") 2659 tg.run("test", "xtestonly") 2660 } 2661 2662 func TestGoTestBuildsAnXtestContainingOnlyNonRunnableExamples(t *testing.T) { 2663 tg := testgo(t) 2664 defer tg.cleanup() 2665 tg.run("test", "-v", "./testdata/norunexample") 2666 tg.grepStdout("File with non-runnable example was built.", "file with non-runnable example was not built") 2667 } 2668 2669 func TestGoGenerateHandlesSimpleCommand(t *testing.T) { 2670 if runtime.GOOS == "windows" { 2671 t.Skip("skipping because windows has no echo command") 2672 } 2673 2674 tg := testgo(t) 2675 defer tg.cleanup() 2676 tg.run("generate", "./testdata/generate/test1.go") 2677 tg.grepStdout("Success", "go generate ./testdata/generate/test1.go generated wrong output") 2678 } 2679 2680 func TestGoGenerateHandlesCommandAlias(t *testing.T) { 2681 if runtime.GOOS == "windows" { 2682 t.Skip("skipping because windows has no echo command") 2683 } 2684 2685 tg := testgo(t) 2686 defer tg.cleanup() 2687 tg.run("generate", "./testdata/generate/test2.go") 2688 tg.grepStdout("Now is the time for all good men", "go generate ./testdata/generate/test2.go generated wrong output") 2689 } 2690 2691 func TestGoGenerateVariableSubstitution(t *testing.T) { 2692 if runtime.GOOS == "windows" { 2693 t.Skip("skipping because windows has no echo command") 2694 } 2695 2696 tg := testgo(t) 2697 defer tg.cleanup() 2698 tg.run("generate", "./testdata/generate/test3.go") 2699 tg.grepStdout(runtime.GOARCH+" test3.go:7 pabc xyzp/test3.go/123", "go generate ./testdata/generate/test3.go generated wrong output") 2700 } 2701 2702 func TestGoGenerateRunFlag(t *testing.T) { 2703 if runtime.GOOS == "windows" { 2704 t.Skip("skipping because windows has no echo command") 2705 } 2706 2707 tg := testgo(t) 2708 defer tg.cleanup() 2709 tg.run("generate", "-run", "y.s", "./testdata/generate/test4.go") 2710 tg.grepStdout("yes", "go generate -run yes ./testdata/generate/test4.go did not select yes") 2711 tg.grepStdoutNot("no", "go generate -run yes ./testdata/generate/test4.go selected no") 2712 } 2713 2714 func TestGoGenerateEnv(t *testing.T) { 2715 switch runtime.GOOS { 2716 case "plan9", "windows": 2717 t.Skipf("skipping because %s does not have the env command", runtime.GOOS) 2718 } 2719 tg := testgo(t) 2720 defer tg.cleanup() 2721 tg.parallel() 2722 tg.tempFile("env.go", "package main\n\n//go:generate env") 2723 tg.run("generate", tg.path("env.go")) 2724 for _, v := range []string{"GOARCH", "GOOS", "GOFILE", "GOLINE", "GOPACKAGE", "DOLLAR"} { 2725 tg.grepStdout("^"+v+"=", "go generate environment missing "+v) 2726 } 2727 } 2728 2729 func TestGoGenerateBadImports(t *testing.T) { 2730 if runtime.GOOS == "windows" { 2731 t.Skip("skipping because windows has no echo command") 2732 } 2733 2734 // This package has an invalid import causing an import cycle, 2735 // but go generate is supposed to still run. 2736 tg := testgo(t) 2737 defer tg.cleanup() 2738 tg.setenv("GOPATH", filepath.Join(tg.pwd(), "testdata")) 2739 tg.run("generate", "gencycle") 2740 tg.grepStdout("hello world", "go generate gencycle did not run generator") 2741 } 2742 2743 func TestGoGetCustomDomainWildcard(t *testing.T) { 2744 testenv.MustHaveExternalNetwork(t) 2745 2746 tg := testgo(t) 2747 defer tg.cleanup() 2748 tg.makeTempdir() 2749 tg.setenv("GOPATH", tg.path(".")) 2750 tg.run("get", "-u", "rsc.io/pdf/...") 2751 tg.wantExecutable(tg.path("bin/pdfpasswd"+exeSuffix), "did not build rsc/io/pdf/pdfpasswd") 2752 } 2753 2754 func TestGoGetInternalWildcard(t *testing.T) { 2755 testenv.MustHaveExternalNetwork(t) 2756 2757 tg := testgo(t) 2758 defer tg.cleanup() 2759 tg.makeTempdir() 2760 tg.setenv("GOPATH", tg.path(".")) 2761 // used to fail with errors about internal packages 2762 tg.run("get", "github.com/rsc/go-get-issue-11960/...") 2763 } 2764 2765 func TestGoVetWithExternalTests(t *testing.T) { 2766 tg := testgo(t) 2767 defer tg.cleanup() 2768 tg.makeTempdir() 2769 tg.run("install", "cmd/vet") 2770 tg.setenv("GOPATH", filepath.Join(tg.pwd(), "testdata")) 2771 tg.runFail("vet", "vetpkg") 2772 tg.grepBoth("missing argument for Printf", "go vet vetpkg did not find missing argument for Printf") 2773 } 2774 2775 func TestGoVetWithTags(t *testing.T) { 2776 tg := testgo(t) 2777 defer tg.cleanup() 2778 tg.makeTempdir() 2779 tg.run("install", "cmd/vet") 2780 tg.setenv("GOPATH", filepath.Join(tg.pwd(), "testdata")) 2781 tg.runFail("vet", "-tags", "tagtest", "vetpkg") 2782 tg.grepBoth(`c\.go.*wrong number of args for format`, "go vet vetpkg did not run scan tagged file") 2783 } 2784 2785 func TestGoVetWithFlagsOn(t *testing.T) { 2786 tg := testgo(t) 2787 defer tg.cleanup() 2788 tg.makeTempdir() 2789 tg.run("install", "cmd/vet") 2790 tg.setenv("GOPATH", filepath.Join(tg.pwd(), "testdata")) 2791 tg.runFail("vet", "-printf", "vetpkg") 2792 tg.grepBoth("missing argument for Printf", "go vet -printf vetpkg did not find missing argument for Printf") 2793 } 2794 2795 func TestGoVetWithFlagsOff(t *testing.T) { 2796 tg := testgo(t) 2797 defer tg.cleanup() 2798 tg.makeTempdir() 2799 tg.run("install", "cmd/vet") 2800 tg.setenv("GOPATH", filepath.Join(tg.pwd(), "testdata")) 2801 tg.run("vet", "-printf=false", "vetpkg") 2802 } 2803 2804 // Issue 9767, 19769. 2805 func TestGoGetDotSlashDownload(t *testing.T) { 2806 testenv.MustHaveExternalNetwork(t) 2807 2808 tg := testgo(t) 2809 defer tg.cleanup() 2810 tg.tempDir("src/rsc.io") 2811 tg.setenv("GOPATH", tg.path(".")) 2812 tg.cd(tg.path("src/rsc.io")) 2813 tg.run("get", "./pprof_mac_fix") 2814 } 2815 2816 // Issue 13037: Was not parsing <meta> tags in 404 served over HTTPS 2817 func TestGoGetHTTPS404(t *testing.T) { 2818 testenv.MustHaveExternalNetwork(t) 2819 switch runtime.GOOS { 2820 case "darwin", "linux", "freebsd": 2821 default: 2822 t.Skipf("test case does not work on %s", runtime.GOOS) 2823 } 2824 2825 tg := testgo(t) 2826 defer tg.cleanup() 2827 tg.tempDir("src") 2828 tg.setenv("GOPATH", tg.path(".")) 2829 tg.run("get", "bazil.org/fuse/fs/fstestutil") 2830 } 2831 2832 // Test that you cannot import a main package. 2833 // See golang.org/issue/4210 and golang.org/issue/17475. 2834 func TestImportMain(t *testing.T) { 2835 tg := testgo(t) 2836 tg.parallel() 2837 defer tg.cleanup() 2838 2839 // Importing package main from that package main's test should work. 2840 tg.tempFile("src/x/main.go", `package main 2841 var X int 2842 func main() {}`) 2843 tg.tempFile("src/x/main_test.go", `package main_test 2844 import xmain "x" 2845 import "testing" 2846 var _ = xmain.X 2847 func TestFoo(t *testing.T) {} 2848 `) 2849 tg.setenv("GOPATH", tg.path(".")) 2850 tg.creatingTemp("x" + exeSuffix) 2851 tg.run("build", "x") 2852 tg.run("test", "x") 2853 2854 // Importing package main from another package should fail. 2855 tg.tempFile("src/p1/p.go", `package p1 2856 import xmain "x" 2857 var _ = xmain.X 2858 `) 2859 tg.runFail("build", "p1") 2860 tg.grepStderr("import \"x\" is a program, not an importable package", "did not diagnose package main") 2861 2862 // ... even in that package's test. 2863 tg.tempFile("src/p2/p.go", `package p2 2864 `) 2865 tg.tempFile("src/p2/p_test.go", `package p2 2866 import xmain "x" 2867 import "testing" 2868 var _ = xmain.X 2869 func TestFoo(t *testing.T) {} 2870 `) 2871 tg.run("build", "p2") 2872 tg.runFail("test", "p2") 2873 tg.grepStderr("import \"x\" is a program, not an importable package", "did not diagnose package main") 2874 2875 // ... even if that package's test is an xtest. 2876 tg.tempFile("src/p3/p.go", `package p 2877 `) 2878 tg.tempFile("src/p3/p_test.go", `package p_test 2879 import xmain "x" 2880 import "testing" 2881 var _ = xmain.X 2882 func TestFoo(t *testing.T) {} 2883 `) 2884 tg.run("build", "p3") 2885 tg.runFail("test", "p3") 2886 tg.grepStderr("import \"x\" is a program, not an importable package", "did not diagnose package main") 2887 2888 // ... even if that package is a package main 2889 tg.tempFile("src/p4/p.go", `package main 2890 func main() {} 2891 `) 2892 tg.tempFile("src/p4/p_test.go", `package main 2893 import xmain "x" 2894 import "testing" 2895 var _ = xmain.X 2896 func TestFoo(t *testing.T) {} 2897 `) 2898 tg.creatingTemp("p4" + exeSuffix) 2899 tg.run("build", "p4") 2900 tg.runFail("test", "p4") 2901 tg.grepStderr("import \"x\" is a program, not an importable package", "did not diagnose package main") 2902 2903 // ... even if that package is a package main using an xtest. 2904 tg.tempFile("src/p5/p.go", `package main 2905 func main() {} 2906 `) 2907 tg.tempFile("src/p5/p_test.go", `package main_test 2908 import xmain "x" 2909 import "testing" 2910 var _ = xmain.X 2911 func TestFoo(t *testing.T) {} 2912 `) 2913 tg.creatingTemp("p5" + exeSuffix) 2914 tg.run("build", "p5") 2915 tg.runFail("test", "p5") 2916 tg.grepStderr("import \"x\" is a program, not an importable package", "did not diagnose package main") 2917 } 2918 2919 // Test that you cannot use a local import in a package 2920 // accessed by a non-local import (found in a GOPATH/GOROOT). 2921 // See golang.org/issue/17475. 2922 func TestImportLocal(t *testing.T) { 2923 tg := testgo(t) 2924 tg.parallel() 2925 defer tg.cleanup() 2926 2927 tg.tempFile("src/dir/x/x.go", `package x 2928 var X int 2929 `) 2930 tg.setenv("GOPATH", tg.path(".")) 2931 tg.run("build", "dir/x") 2932 2933 // Ordinary import should work. 2934 tg.tempFile("src/dir/p0/p.go", `package p0 2935 import "dir/x" 2936 var _ = x.X 2937 `) 2938 tg.run("build", "dir/p0") 2939 2940 // Relative import should not. 2941 tg.tempFile("src/dir/p1/p.go", `package p1 2942 import "../x" 2943 var _ = x.X 2944 `) 2945 tg.runFail("build", "dir/p1") 2946 tg.grepStderr("local import.*in non-local package", "did not diagnose local import") 2947 2948 // ... even in a test. 2949 tg.tempFile("src/dir/p2/p.go", `package p2 2950 `) 2951 tg.tempFile("src/dir/p2/p_test.go", `package p2 2952 import "../x" 2953 import "testing" 2954 var _ = x.X 2955 func TestFoo(t *testing.T) {} 2956 `) 2957 tg.run("build", "dir/p2") 2958 tg.runFail("test", "dir/p2") 2959 tg.grepStderr("local import.*in non-local package", "did not diagnose local import") 2960 2961 // ... even in an xtest. 2962 tg.tempFile("src/dir/p2/p_test.go", `package p2_test 2963 import "../x" 2964 import "testing" 2965 var _ = x.X 2966 func TestFoo(t *testing.T) {} 2967 `) 2968 tg.run("build", "dir/p2") 2969 tg.runFail("test", "dir/p2") 2970 tg.grepStderr("local import.*in non-local package", "did not diagnose local import") 2971 2972 // Relative import starting with ./ should not work either. 2973 tg.tempFile("src/dir/d.go", `package dir 2974 import "./x" 2975 var _ = x.X 2976 `) 2977 tg.runFail("build", "dir") 2978 tg.grepStderr("local import.*in non-local package", "did not diagnose local import") 2979 2980 // ... even in a test. 2981 tg.tempFile("src/dir/d.go", `package dir 2982 `) 2983 tg.tempFile("src/dir/d_test.go", `package dir 2984 import "./x" 2985 import "testing" 2986 var _ = x.X 2987 func TestFoo(t *testing.T) {} 2988 `) 2989 tg.run("build", "dir") 2990 tg.runFail("test", "dir") 2991 tg.grepStderr("local import.*in non-local package", "did not diagnose local import") 2992 2993 // ... even in an xtest. 2994 tg.tempFile("src/dir/d_test.go", `package dir_test 2995 import "./x" 2996 import "testing" 2997 var _ = x.X 2998 func TestFoo(t *testing.T) {} 2999 `) 3000 tg.run("build", "dir") 3001 tg.runFail("test", "dir") 3002 tg.grepStderr("local import.*in non-local package", "did not diagnose local import") 3003 3004 // Relative import plain ".." should not work. 3005 tg.tempFile("src/dir/x/y/y.go", `package dir 3006 import ".." 3007 var _ = x.X 3008 `) 3009 tg.runFail("build", "dir/x/y") 3010 tg.grepStderr("local import.*in non-local package", "did not diagnose local import") 3011 3012 // ... even in a test. 3013 tg.tempFile("src/dir/x/y/y.go", `package y 3014 `) 3015 tg.tempFile("src/dir/x/y/y_test.go", `package y 3016 import ".." 3017 import "testing" 3018 var _ = x.X 3019 func TestFoo(t *testing.T) {} 3020 `) 3021 tg.run("build", "dir/x/y") 3022 tg.runFail("test", "dir/x/y") 3023 tg.grepStderr("local import.*in non-local package", "did not diagnose local import") 3024 3025 // ... even in an x test. 3026 tg.tempFile("src/dir/x/y/y_test.go", `package y_test 3027 import ".." 3028 import "testing" 3029 var _ = x.X 3030 func TestFoo(t *testing.T) {} 3031 `) 3032 tg.run("build", "dir/x/y") 3033 tg.runFail("test", "dir/x/y") 3034 tg.grepStderr("local import.*in non-local package", "did not diagnose local import") 3035 3036 // Relative import "." should not work. 3037 tg.tempFile("src/dir/x/xx.go", `package x 3038 import "." 3039 var _ = x.X 3040 `) 3041 tg.runFail("build", "dir/x") 3042 tg.grepStderr("local import.*in non-local package", "did not diagnose local import") 3043 3044 // ... even in a test. 3045 tg.tempFile("src/dir/x/xx.go", `package x 3046 `) 3047 tg.tempFile("src/dir/x/xx_test.go", `package x 3048 import "." 3049 import "testing" 3050 var _ = x.X 3051 func TestFoo(t *testing.T) {} 3052 `) 3053 tg.run("build", "dir/x") 3054 tg.runFail("test", "dir/x") 3055 tg.grepStderr("local import.*in non-local package", "did not diagnose local import") 3056 3057 // ... even in an xtest. 3058 tg.tempFile("src/dir/x/xx.go", `package x 3059 `) 3060 tg.tempFile("src/dir/x/xx_test.go", `package x_test 3061 import "." 3062 import "testing" 3063 var _ = x.X 3064 func TestFoo(t *testing.T) {} 3065 `) 3066 tg.run("build", "dir/x") 3067 tg.runFail("test", "dir/x") 3068 tg.grepStderr("local import.*in non-local package", "did not diagnose local import") 3069 } 3070 3071 func TestGoGetInsecure(t *testing.T) { 3072 testenv.MustHaveExternalNetwork(t) 3073 3074 tg := testgo(t) 3075 defer tg.cleanup() 3076 tg.makeTempdir() 3077 tg.setenv("GOPATH", tg.path(".")) 3078 tg.failSSH() 3079 3080 const repo = "insecure.go-get-issue-15410.appspot.com/pkg/p" 3081 3082 // Try go get -d of HTTP-only repo (should fail). 3083 tg.runFail("get", "-d", repo) 3084 3085 // Try again with -insecure (should succeed). 3086 tg.run("get", "-d", "-insecure", repo) 3087 3088 // Try updating without -insecure (should fail). 3089 tg.runFail("get", "-d", "-u", "-f", repo) 3090 } 3091 3092 func TestGoGetUpdateInsecure(t *testing.T) { 3093 testenv.MustHaveExternalNetwork(t) 3094 3095 tg := testgo(t) 3096 defer tg.cleanup() 3097 tg.makeTempdir() 3098 tg.setenv("GOPATH", tg.path(".")) 3099 3100 const repo = "github.com/golang/example" 3101 3102 // Clone the repo via HTTP manually. 3103 cmd := exec.Command("git", "clone", "-q", "http://"+repo, tg.path("src/"+repo)) 3104 if out, err := cmd.CombinedOutput(); err != nil { 3105 t.Fatalf("cloning %v repo: %v\n%s", repo, err, out) 3106 } 3107 3108 // Update without -insecure should fail. 3109 // Update with -insecure should succeed. 3110 // We need -f to ignore import comments. 3111 const pkg = repo + "/hello" 3112 tg.runFail("get", "-d", "-u", "-f", pkg) 3113 tg.run("get", "-d", "-u", "-f", "-insecure", pkg) 3114 } 3115 3116 func TestGoGetInsecureCustomDomain(t *testing.T) { 3117 testenv.MustHaveExternalNetwork(t) 3118 3119 tg := testgo(t) 3120 defer tg.cleanup() 3121 tg.makeTempdir() 3122 tg.setenv("GOPATH", tg.path(".")) 3123 3124 const repo = "insecure.go-get-issue-15410.appspot.com/pkg/p" 3125 tg.runFail("get", "-d", repo) 3126 tg.run("get", "-d", "-insecure", repo) 3127 } 3128 3129 func TestGoRunDirs(t *testing.T) { 3130 tg := testgo(t) 3131 defer tg.cleanup() 3132 tg.cd("testdata/rundir") 3133 tg.runFail("run", "x.go", "sub/sub.go") 3134 tg.grepStderr("named files must all be in one directory; have ./ and sub/", "wrong output") 3135 tg.runFail("run", "sub/sub.go", "x.go") 3136 tg.grepStderr("named files must all be in one directory; have sub/ and ./", "wrong output") 3137 } 3138 3139 func TestGoInstallPkgdir(t *testing.T) { 3140 tg := testgo(t) 3141 tg.parallel() 3142 defer tg.cleanup() 3143 tg.makeTempdir() 3144 pkg := tg.path(".") 3145 tg.run("install", "-pkgdir", pkg, "errors") 3146 _, err := os.Stat(filepath.Join(pkg, "errors.a")) 3147 tg.must(err) 3148 _, err = os.Stat(filepath.Join(pkg, "runtime.a")) 3149 tg.must(err) 3150 } 3151 3152 func TestGoTestRaceInstallCgo(t *testing.T) { 3153 if !canRace { 3154 t.Skip("skipping because race detector not supported") 3155 } 3156 3157 // golang.org/issue/10500. 3158 // This used to install a race-enabled cgo. 3159 tg := testgo(t) 3160 defer tg.cleanup() 3161 tg.run("tool", "-n", "cgo") 3162 cgo := strings.TrimSpace(tg.stdout.String()) 3163 old, err := os.Stat(cgo) 3164 tg.must(err) 3165 tg.run("test", "-race", "-i", "runtime/race") 3166 new, err := os.Stat(cgo) 3167 tg.must(err) 3168 if !new.ModTime().Equal(old.ModTime()) { 3169 t.Fatalf("go test -i runtime/race reinstalled cmd/cgo") 3170 } 3171 } 3172 3173 func TestGoTestRaceFailures(t *testing.T) { 3174 if !canRace { 3175 t.Skip("skipping because race detector not supported") 3176 } 3177 3178 tg := testgo(t) 3179 tg.parallel() 3180 defer tg.cleanup() 3181 tg.setenv("GOPATH", filepath.Join(tg.pwd(), "testdata")) 3182 3183 tg.run("test", "testrace") 3184 3185 tg.runFail("test", "-race", "testrace") 3186 tg.grepStdout("FAIL: TestRace", "TestRace did not fail") 3187 tg.grepBothNot("PASS", "something passed") 3188 3189 tg.runFail("test", "-race", "testrace", "-run", "XXX", "-bench", ".") 3190 tg.grepStdout("FAIL: BenchmarkRace", "BenchmarkRace did not fail") 3191 tg.grepBothNot("PASS", "something passed") 3192 } 3193 3194 func TestGoTestImportErrorStack(t *testing.T) { 3195 const out = `package testdep/p1 (test) 3196 imports testdep/p2 3197 imports testdep/p3: build constraints exclude all Go files ` 3198 3199 tg := testgo(t) 3200 defer tg.cleanup() 3201 tg.setenv("GOPATH", filepath.Join(tg.pwd(), "testdata")) 3202 tg.runFail("test", "testdep/p1") 3203 if !strings.Contains(tg.stderr.String(), out) { 3204 t.Fatalf("did not give full import stack:\n\n%s", tg.stderr.String()) 3205 } 3206 } 3207 3208 func TestGoGetUpdate(t *testing.T) { 3209 // golang.org/issue/9224. 3210 // The recursive updating was trying to walk to 3211 // former dependencies, not current ones. 3212 3213 testenv.MustHaveExternalNetwork(t) 3214 3215 tg := testgo(t) 3216 defer tg.cleanup() 3217 tg.makeTempdir() 3218 tg.setenv("GOPATH", tg.path(".")) 3219 3220 rewind := func() { 3221 tg.run("get", "github.com/rsc/go-get-issue-9224-cmd") 3222 cmd := exec.Command("git", "reset", "--hard", "HEAD~") 3223 cmd.Dir = tg.path("src/github.com/rsc/go-get-issue-9224-lib") 3224 out, err := cmd.CombinedOutput() 3225 if err != nil { 3226 t.Fatalf("git: %v\n%s", err, out) 3227 } 3228 } 3229 3230 rewind() 3231 tg.run("get", "-u", "github.com/rsc/go-get-issue-9224-cmd") 3232 3233 // Again with -d -u. 3234 rewind() 3235 tg.run("get", "-d", "-u", "github.com/rsc/go-get-issue-9224-cmd") 3236 } 3237 3238 // Issue #20512. 3239 func TestGoGetRace(t *testing.T) { 3240 testenv.MustHaveExternalNetwork(t) 3241 if !canRace { 3242 t.Skip("skipping because race detector not supported") 3243 } 3244 3245 tg := testgo(t) 3246 defer tg.cleanup() 3247 tg.makeTempdir() 3248 tg.setenv("GOPATH", tg.path(".")) 3249 tg.run("get", "-race", "github.com/rsc/go-get-issue-9224-cmd") 3250 } 3251 3252 func TestGoGetDomainRoot(t *testing.T) { 3253 // golang.org/issue/9357. 3254 // go get foo.io (not foo.io/subdir) was not working consistently. 3255 3256 testenv.MustHaveExternalNetwork(t) 3257 3258 tg := testgo(t) 3259 defer tg.cleanup() 3260 tg.makeTempdir() 3261 tg.setenv("GOPATH", tg.path(".")) 3262 3263 // go-get-issue-9357.appspot.com is running 3264 // the code at github.com/rsc/go-get-issue-9357, 3265 // a trivial Go on App Engine app that serves a 3266 // <meta> tag for the domain root. 3267 tg.run("get", "-d", "go-get-issue-9357.appspot.com") 3268 tg.run("get", "go-get-issue-9357.appspot.com") 3269 tg.run("get", "-u", "go-get-issue-9357.appspot.com") 3270 3271 tg.must(os.RemoveAll(tg.path("src/go-get-issue-9357.appspot.com"))) 3272 tg.run("get", "go-get-issue-9357.appspot.com") 3273 3274 tg.must(os.RemoveAll(tg.path("src/go-get-issue-9357.appspot.com"))) 3275 tg.run("get", "-u", "go-get-issue-9357.appspot.com") 3276 } 3277 3278 func TestGoInstallShadowedGOPATH(t *testing.T) { 3279 // golang.org/issue/3652. 3280 // go get foo.io (not foo.io/subdir) was not working consistently. 3281 3282 testenv.MustHaveExternalNetwork(t) 3283 3284 tg := testgo(t) 3285 defer tg.cleanup() 3286 tg.makeTempdir() 3287 tg.setenv("GOPATH", tg.path("gopath1")+string(filepath.ListSeparator)+tg.path("gopath2")) 3288 3289 tg.tempDir("gopath1/src/test") 3290 tg.tempDir("gopath2/src/test") 3291 tg.tempFile("gopath2/src/test/main.go", "package main\nfunc main(){}\n") 3292 3293 tg.cd(tg.path("gopath2/src/test")) 3294 tg.runFail("install") 3295 tg.grepStderr("no install location for.*gopath2.src.test: hidden by .*gopath1.src.test", "missing error") 3296 } 3297 3298 func TestGoBuildGOPATHOrder(t *testing.T) { 3299 // golang.org/issue/14176#issuecomment-179895769 3300 // golang.org/issue/14192 3301 // -I arguments to compiler could end up not in GOPATH order, 3302 // leading to unexpected import resolution in the compiler. 3303 // This is still not a complete fix (see golang.org/issue/14271 and next test) 3304 // but it is clearly OK and enough to fix both of the two reported 3305 // instances of the underlying problem. It will have to do for now. 3306 3307 tg := testgo(t) 3308 defer tg.cleanup() 3309 tg.makeTempdir() 3310 tg.setenv("GOPATH", tg.path("p1")+string(filepath.ListSeparator)+tg.path("p2")) 3311 3312 tg.tempFile("p1/src/foo/foo.go", "package foo\n") 3313 tg.tempFile("p2/src/baz/baz.go", "package baz\n") 3314 tg.tempFile("p2/pkg/"+runtime.GOOS+"_"+runtime.GOARCH+"/foo.a", "bad\n") 3315 tg.tempFile("p1/src/bar/bar.go", ` 3316 package bar 3317 import _ "baz" 3318 import _ "foo" 3319 `) 3320 3321 tg.run("install", "-x", "bar") 3322 } 3323 3324 func TestGoBuildGOPATHOrderBroken(t *testing.T) { 3325 // This test is known not to work. 3326 // See golang.org/issue/14271. 3327 t.Skip("golang.org/issue/14271") 3328 3329 tg := testgo(t) 3330 defer tg.cleanup() 3331 tg.makeTempdir() 3332 3333 tg.tempFile("p1/src/foo/foo.go", "package foo\n") 3334 tg.tempFile("p2/src/baz/baz.go", "package baz\n") 3335 tg.tempFile("p1/pkg/"+runtime.GOOS+"_"+runtime.GOARCH+"/baz.a", "bad\n") 3336 tg.tempFile("p2/pkg/"+runtime.GOOS+"_"+runtime.GOARCH+"/foo.a", "bad\n") 3337 tg.tempFile("p1/src/bar/bar.go", ` 3338 package bar 3339 import _ "baz" 3340 import _ "foo" 3341 `) 3342 3343 colon := string(filepath.ListSeparator) 3344 tg.setenv("GOPATH", tg.path("p1")+colon+tg.path("p2")) 3345 tg.run("install", "-x", "bar") 3346 3347 tg.setenv("GOPATH", tg.path("p2")+colon+tg.path("p1")) 3348 tg.run("install", "-x", "bar") 3349 } 3350 3351 func TestIssue11709(t *testing.T) { 3352 tg := testgo(t) 3353 defer tg.cleanup() 3354 tg.tempFile("run.go", ` 3355 package main 3356 import "os" 3357 func main() { 3358 if os.Getenv("TERM") != "" { 3359 os.Exit(1) 3360 } 3361 }`) 3362 tg.unsetenv("TERM") 3363 tg.run("run", tg.path("run.go")) 3364 } 3365 3366 func TestIssue12096(t *testing.T) { 3367 tg := testgo(t) 3368 defer tg.cleanup() 3369 tg.tempFile("test_test.go", ` 3370 package main 3371 import ("os"; "testing") 3372 func TestEnv(t *testing.T) { 3373 if os.Getenv("TERM") != "" { 3374 t.Fatal("TERM is set") 3375 } 3376 }`) 3377 tg.unsetenv("TERM") 3378 tg.run("test", tg.path("test_test.go")) 3379 } 3380 3381 func TestGoBuildOutput(t *testing.T) { 3382 tg := testgo(t) 3383 defer tg.cleanup() 3384 3385 tg.makeTempdir() 3386 tg.cd(tg.path(".")) 3387 3388 nonExeSuffix := ".exe" 3389 if exeSuffix == ".exe" { 3390 nonExeSuffix = "" 3391 } 3392 3393 tg.tempFile("x.go", "package main\nfunc main(){}\n") 3394 tg.run("build", "x.go") 3395 tg.wantExecutable("x"+exeSuffix, "go build x.go did not write x"+exeSuffix) 3396 tg.must(os.Remove(tg.path("x" + exeSuffix))) 3397 tg.mustNotExist("x" + nonExeSuffix) 3398 3399 tg.run("build", "-o", "myprog", "x.go") 3400 tg.mustNotExist("x") 3401 tg.mustNotExist("x.exe") 3402 tg.wantExecutable("myprog", "go build -o myprog x.go did not write myprog") 3403 tg.mustNotExist("myprog.exe") 3404 3405 tg.tempFile("p.go", "package p\n") 3406 tg.run("build", "p.go") 3407 tg.mustNotExist("p") 3408 tg.mustNotExist("p.a") 3409 tg.mustNotExist("p.o") 3410 tg.mustNotExist("p.exe") 3411 3412 tg.run("build", "-o", "p.a", "p.go") 3413 tg.wantArchive("p.a") 3414 3415 tg.run("build", "cmd/gofmt") 3416 tg.wantExecutable("gofmt"+exeSuffix, "go build cmd/gofmt did not write gofmt"+exeSuffix) 3417 tg.must(os.Remove(tg.path("gofmt" + exeSuffix))) 3418 tg.mustNotExist("gofmt" + nonExeSuffix) 3419 3420 tg.run("build", "-o", "mygofmt", "cmd/gofmt") 3421 tg.wantExecutable("mygofmt", "go build -o mygofmt cmd/gofmt did not write mygofmt") 3422 tg.mustNotExist("mygofmt.exe") 3423 tg.mustNotExist("gofmt") 3424 tg.mustNotExist("gofmt.exe") 3425 3426 tg.run("build", "sync/atomic") 3427 tg.mustNotExist("atomic") 3428 tg.mustNotExist("atomic.exe") 3429 3430 tg.run("build", "-o", "myatomic.a", "sync/atomic") 3431 tg.wantArchive("myatomic.a") 3432 tg.mustNotExist("atomic") 3433 tg.mustNotExist("atomic.a") 3434 tg.mustNotExist("atomic.exe") 3435 3436 tg.runFail("build", "-o", "whatever", "cmd/gofmt", "sync/atomic") 3437 tg.grepStderr("multiple packages", "did not reject -o with multiple packages") 3438 } 3439 3440 func TestGoBuildARM(t *testing.T) { 3441 if testing.Short() { 3442 t.Skip("skipping cross-compile in short mode") 3443 } 3444 3445 tg := testgo(t) 3446 defer tg.cleanup() 3447 3448 tg.makeTempdir() 3449 tg.cd(tg.path(".")) 3450 3451 tg.setenv("GOARCH", "arm") 3452 tg.setenv("GOOS", "linux") 3453 tg.setenv("GOARM", "5") 3454 tg.tempFile("hello.go", `package main 3455 func main() {}`) 3456 tg.run("build", "hello.go") 3457 tg.grepStderrNot("unable to find math.a", "did not build math.a correctly") 3458 } 3459 3460 func TestIssue13655(t *testing.T) { 3461 tg := testgo(t) 3462 defer tg.cleanup() 3463 for _, pkg := range []string{"runtime", "runtime/internal/atomic"} { 3464 tg.run("list", "-f", "{{.Deps}}", pkg) 3465 tg.grepStdout("runtime/internal/sys", "did not find required dependency of "+pkg+" on runtime/internal/sys") 3466 } 3467 } 3468 3469 // For issue 14337. 3470 func TestParallelTest(t *testing.T) { 3471 tg := testgo(t) 3472 tg.parallel() 3473 defer tg.cleanup() 3474 tg.makeTempdir() 3475 const testSrc = `package package_test 3476 import ( 3477 "testing" 3478 ) 3479 func TestTest(t *testing.T) { 3480 }` 3481 tg.tempFile("src/p1/p1_test.go", strings.Replace(testSrc, "package_test", "p1_test", 1)) 3482 tg.tempFile("src/p2/p2_test.go", strings.Replace(testSrc, "package_test", "p2_test", 1)) 3483 tg.tempFile("src/p3/p3_test.go", strings.Replace(testSrc, "package_test", "p3_test", 1)) 3484 tg.tempFile("src/p4/p4_test.go", strings.Replace(testSrc, "package_test", "p4_test", 1)) 3485 tg.setenv("GOPATH", tg.path(".")) 3486 tg.run("test", "-p=4", "p1", "p2", "p3", "p4") 3487 } 3488 3489 func TestCgoConsistentResults(t *testing.T) { 3490 if !canCgo { 3491 t.Skip("skipping because cgo not enabled") 3492 } 3493 switch runtime.GOOS { 3494 case "freebsd": 3495 testenv.SkipFlaky(t, 15405) 3496 case "solaris": 3497 testenv.SkipFlaky(t, 13247) 3498 } 3499 3500 tg := testgo(t) 3501 defer tg.cleanup() 3502 tg.parallel() 3503 tg.makeTempdir() 3504 tg.setenv("GOPATH", filepath.Join(tg.pwd(), "testdata")) 3505 exe1 := tg.path("cgotest1" + exeSuffix) 3506 exe2 := tg.path("cgotest2" + exeSuffix) 3507 tg.run("build", "-o", exe1, "cgotest") 3508 tg.run("build", "-x", "-o", exe2, "cgotest") 3509 b1, err := ioutil.ReadFile(exe1) 3510 tg.must(err) 3511 b2, err := ioutil.ReadFile(exe2) 3512 tg.must(err) 3513 3514 if !tg.doGrepMatch(`-fdebug-prefix-map=\$WORK`, &tg.stderr) { 3515 t.Skip("skipping because C compiler does not support -fdebug-prefix-map") 3516 } 3517 if !bytes.Equal(b1, b2) { 3518 t.Error("building cgotest twice did not produce the same output") 3519 } 3520 } 3521 3522 // Issue 14444: go get -u .../ duplicate loads errors 3523 func TestGoGetUpdateAllDoesNotTryToLoadDuplicates(t *testing.T) { 3524 testenv.MustHaveExternalNetwork(t) 3525 3526 tg := testgo(t) 3527 defer tg.cleanup() 3528 tg.makeTempdir() 3529 tg.setenv("GOPATH", tg.path(".")) 3530 tg.run("get", "-u", ".../") 3531 tg.grepStderrNot("duplicate loads of", "did not remove old packages from cache") 3532 } 3533 3534 // Issue 17119 more duplicate load errors 3535 func TestIssue17119(t *testing.T) { 3536 testenv.MustHaveExternalNetwork(t) 3537 3538 tg := testgo(t) 3539 defer tg.cleanup() 3540 tg.parallel() 3541 tg.setenv("GOPATH", filepath.Join(tg.pwd(), "testdata")) 3542 tg.runFail("build", "dupload") 3543 tg.grepBothNot("duplicate load|internal error", "internal error") 3544 } 3545 3546 func TestFatalInBenchmarkCauseNonZeroExitStatus(t *testing.T) { 3547 tg := testgo(t) 3548 defer tg.cleanup() 3549 // TODO: tg.parallel() 3550 tg.runFail("test", "-run", "^$", "-bench", ".", "./testdata/src/benchfatal") 3551 tg.grepBothNot("^ok", "test passed unexpectedly") 3552 tg.grepBoth("FAIL.*benchfatal", "test did not run everything") 3553 } 3554 3555 func TestBinaryOnlyPackages(t *testing.T) { 3556 tg := testgo(t) 3557 defer tg.cleanup() 3558 tg.parallel() 3559 tg.makeTempdir() 3560 tg.setenv("GOPATH", tg.path(".")) 3561 3562 tg.tempFile("src/p1/p1.go", `//go:binary-only-package 3563 3564 package p1 3565 `) 3566 tg.wantStale("p1", "cannot access install target", "p1 is binary-only but has no binary, should be stale") 3567 tg.runFail("install", "p1") 3568 tg.grepStderr("missing or invalid package binary", "did not report attempt to compile binary-only package") 3569 3570 tg.tempFile("src/p1/p1.go", ` 3571 package p1 3572 import "fmt" 3573 func F(b bool) { fmt.Printf("hello from p1\n"); if b { F(false) } } 3574 `) 3575 tg.run("install", "p1") 3576 os.Remove(tg.path("src/p1/p1.go")) 3577 tg.mustNotExist(tg.path("src/p1/p1.go")) 3578 3579 tg.tempFile("src/p2/p2.go", `//go:binary-only-packages-are-not-great 3580 3581 package p2 3582 import "p1" 3583 func F() { p1.F(true) } 3584 `) 3585 tg.runFail("install", "p2") 3586 tg.grepStderr("no Go files", "did not complain about missing sources") 3587 3588 tg.tempFile("src/p1/missing.go", `//go:binary-only-package 3589 3590 package p1 3591 func G() 3592 `) 3593 tg.wantNotStale("p1", "no source code", "should NOT want to rebuild p1 (first)") 3594 tg.run("install", "-x", "p1") // no-op, up to date 3595 tg.grepBothNot("/compile", "should not have run compiler") 3596 tg.run("install", "p2") // does not rebuild p1 (or else p2 will fail) 3597 tg.wantNotStale("p2", "", "should NOT want to rebuild p2") 3598 3599 // changes to the non-source-code do not matter, 3600 // and only one file needs the special comment. 3601 tg.tempFile("src/p1/missing2.go", ` 3602 package p1 3603 func H() 3604 `) 3605 tg.wantNotStale("p1", "no source code", "should NOT want to rebuild p1 (second)") 3606 tg.wantNotStale("p2", "", "should NOT want to rebuild p2") 3607 3608 tg.tempFile("src/p3/p3.go", ` 3609 package main 3610 import ( 3611 "p1" 3612 "p2" 3613 ) 3614 func main() { 3615 p1.F(false) 3616 p2.F() 3617 } 3618 `) 3619 tg.run("install", "p3") 3620 3621 tg.run("run", tg.path("src/p3/p3.go")) 3622 tg.grepStdout("hello from p1", "did not see message from p1") 3623 3624 tg.tempFile("src/p4/p4.go", `package main`) 3625 tg.tempFile("src/p4/p4not.go", `//go:binary-only-package 3626 3627 // +build asdf 3628 3629 package main 3630 `) 3631 tg.run("list", "-f", "{{.BinaryOnly}}", "p4") 3632 tg.grepStdout("false", "did not see BinaryOnly=false for p4") 3633 } 3634 3635 // Issue 16050. 3636 func TestAlwaysLinkSysoFiles(t *testing.T) { 3637 tg := testgo(t) 3638 defer tg.cleanup() 3639 tg.parallel() 3640 tg.tempDir("src/syso") 3641 tg.tempFile("src/syso/a.syso", ``) 3642 tg.tempFile("src/syso/b.go", `package syso`) 3643 tg.setenv("GOPATH", tg.path(".")) 3644 3645 // We should see the .syso file regardless of the setting of 3646 // CGO_ENABLED. 3647 3648 tg.setenv("CGO_ENABLED", "1") 3649 tg.run("list", "-f", "{{.SysoFiles}}", "syso") 3650 tg.grepStdout("a.syso", "missing syso file with CGO_ENABLED=1") 3651 3652 tg.setenv("CGO_ENABLED", "0") 3653 tg.run("list", "-f", "{{.SysoFiles}}", "syso") 3654 tg.grepStdout("a.syso", "missing syso file with CGO_ENABLED=0") 3655 } 3656 3657 // Issue 16120. 3658 func TestGenerateUsesBuildContext(t *testing.T) { 3659 if runtime.GOOS == "windows" { 3660 t.Skip("this test won't run under Windows") 3661 } 3662 3663 tg := testgo(t) 3664 defer tg.cleanup() 3665 tg.parallel() 3666 tg.tempDir("src/gen") 3667 tg.tempFile("src/gen/gen.go", "package gen\n//go:generate echo $GOOS $GOARCH\n") 3668 tg.setenv("GOPATH", tg.path(".")) 3669 3670 tg.setenv("GOOS", "linux") 3671 tg.setenv("GOARCH", "amd64") 3672 tg.run("generate", "gen") 3673 tg.grepStdout("linux amd64", "unexpected GOOS/GOARCH combination") 3674 3675 tg.setenv("GOOS", "darwin") 3676 tg.setenv("GOARCH", "386") 3677 tg.run("generate", "gen") 3678 tg.grepStdout("darwin 386", "unexpected GOOS/GOARCH combination") 3679 } 3680 3681 // Issue 14450: go get -u .../ tried to import not downloaded package 3682 func TestGoGetUpdateWithWildcard(t *testing.T) { 3683 testenv.MustHaveExternalNetwork(t) 3684 3685 tg := testgo(t) 3686 defer tg.cleanup() 3687 tg.parallel() 3688 tg.makeTempdir() 3689 tg.setenv("GOPATH", tg.path(".")) 3690 const aPkgImportPath = "github.com/tmwh/go-get-issue-14450/a" 3691 tg.run("get", aPkgImportPath) 3692 tg.run("get", "-u", ".../") 3693 tg.grepStderrNot("cannot find package", "did not update packages given wildcard path") 3694 3695 var expectedPkgPaths = []string{ 3696 "src/github.com/tmwh/go-get-issue-14450/b", 3697 "src/github.com/tmwh/go-get-issue-14450-b-dependency/c", 3698 "src/github.com/tmwh/go-get-issue-14450-b-dependency/d", 3699 } 3700 3701 for _, importPath := range expectedPkgPaths { 3702 _, err := os.Stat(tg.path(importPath)) 3703 tg.must(err) 3704 } 3705 const notExpectedPkgPath = "src/github.com/tmwh/go-get-issue-14450-c-dependency/e" 3706 tg.mustNotExist(tg.path(notExpectedPkgPath)) 3707 } 3708 3709 func TestGoEnv(t *testing.T) { 3710 tg := testgo(t) 3711 tg.parallel() 3712 defer tg.cleanup() 3713 tg.setenv("GOARCH", "arm") 3714 tg.run("env", "GOARCH") 3715 tg.grepStdout("^arm$", "GOARCH not honored") 3716 3717 tg.run("env", "GCCGO") 3718 tg.grepStdout(".", "GCCGO unexpectedly empty") 3719 3720 tg.run("env", "CGO_CFLAGS") 3721 tg.grepStdout(".", "default CGO_CFLAGS unexpectedly empty") 3722 3723 tg.setenv("CGO_CFLAGS", "-foobar") 3724 tg.run("env", "CGO_CFLAGS") 3725 tg.grepStdout("^-foobar$", "CGO_CFLAGS not honored") 3726 3727 tg.setenv("CC", "gcc -fmust -fgo -ffaster") 3728 tg.run("env", "CC") 3729 tg.grepStdout("gcc", "CC not found") 3730 tg.run("env", "GOGCCFLAGS") 3731 tg.grepStdout("-ffaster", "CC arguments not found") 3732 } 3733 3734 const ( 3735 noMatchesPattern = `(?m)^ok.*\[no tests to run\]` 3736 okPattern = `(?m)^ok` 3737 ) 3738 3739 func TestMatchesNoTests(t *testing.T) { 3740 tg := testgo(t) 3741 defer tg.cleanup() 3742 // TODO: tg.parallel() 3743 tg.run("test", "-run", "ThisWillNotMatch", "testdata/standalone_test.go") 3744 tg.grepBoth(noMatchesPattern, "go test did not say [no tests to run]") 3745 } 3746 3747 func TestMatchesNoTestsDoesNotOverrideBuildFailure(t *testing.T) { 3748 tg := testgo(t) 3749 defer tg.cleanup() 3750 tg.parallel() 3751 tg.setenv("GOPATH", filepath.Join(tg.pwd(), "testdata")) 3752 tg.runFail("test", "-run", "ThisWillNotMatch", "syntaxerror") 3753 tg.grepBothNot(noMatchesPattern, "go test did say [no tests to run]") 3754 tg.grepBoth("FAIL", "go test did not say FAIL") 3755 } 3756 3757 func TestMatchesNoBenchmarksIsOK(t *testing.T) { 3758 tg := testgo(t) 3759 defer tg.cleanup() 3760 // TODO: tg.parallel() 3761 tg.run("test", "-run", "^$", "-bench", "ThisWillNotMatch", "testdata/standalone_benchmark_test.go") 3762 tg.grepBothNot(noMatchesPattern, "go test did say [no tests to run]") 3763 tg.grepBoth(okPattern, "go test did not say ok") 3764 } 3765 3766 func TestMatchesOnlyExampleIsOK(t *testing.T) { 3767 tg := testgo(t) 3768 defer tg.cleanup() 3769 // TODO: tg.parallel() 3770 tg.run("test", "-run", "Example", "testdata/example1_test.go") 3771 tg.grepBothNot(noMatchesPattern, "go test did say [no tests to run]") 3772 tg.grepBoth(okPattern, "go test did not say ok") 3773 } 3774 3775 func TestMatchesOnlyBenchmarkIsOK(t *testing.T) { 3776 tg := testgo(t) 3777 defer tg.cleanup() 3778 // TODO: tg.parallel() 3779 tg.run("test", "-run", "^$", "-bench", ".", "testdata/standalone_benchmark_test.go") 3780 tg.grepBothNot(noMatchesPattern, "go test did say [no tests to run]") 3781 tg.grepBoth(okPattern, "go test did not say ok") 3782 } 3783 3784 func TestBenchmarkLabels(t *testing.T) { 3785 tg := testgo(t) 3786 defer tg.cleanup() 3787 // TODO: tg.parallel() 3788 tg.setenv("GOPATH", filepath.Join(tg.pwd(), "testdata")) 3789 tg.run("test", "-run", "^$", "-bench", ".", "bench") 3790 tg.grepStdout(`(?m)^goos: `+runtime.GOOS, "go test did not print goos") 3791 tg.grepStdout(`(?m)^goarch: `+runtime.GOARCH, "go test did not print goarch") 3792 tg.grepStdout(`(?m)^pkg: bench`, "go test did not say pkg: bench") 3793 tg.grepBothNot(`(?s)pkg:.*pkg:`, "go test said pkg multiple times") 3794 } 3795 3796 func TestBenchmarkLabelsOutsideGOPATH(t *testing.T) { 3797 tg := testgo(t) 3798 defer tg.cleanup() 3799 // TODO: tg.parallel() 3800 tg.run("test", "-run", "^$", "-bench", ".", "testdata/standalone_benchmark_test.go") 3801 tg.grepStdout(`(?m)^goos: `+runtime.GOOS, "go test did not print goos") 3802 tg.grepStdout(`(?m)^goarch: `+runtime.GOARCH, "go test did not print goarch") 3803 tg.grepBothNot(`(?m)^pkg:`, "go test did say pkg:") 3804 } 3805 3806 func TestMatchesOnlyTestIsOK(t *testing.T) { 3807 tg := testgo(t) 3808 defer tg.cleanup() 3809 // TODO: tg.parallel() 3810 tg.run("test", "-run", "Test", "testdata/standalone_test.go") 3811 tg.grepBothNot(noMatchesPattern, "go test did say [no tests to run]") 3812 tg.grepBoth(okPattern, "go test did not say ok") 3813 } 3814 3815 func TestMatchesNoTestsWithSubtests(t *testing.T) { 3816 tg := testgo(t) 3817 defer tg.cleanup() 3818 tg.run("test", "-run", "ThisWillNotMatch", "testdata/standalone_sub_test.go") 3819 tg.grepBoth(noMatchesPattern, "go test did not say [no tests to run]") 3820 } 3821 3822 func TestMatchesNoSubtestsMatch(t *testing.T) { 3823 tg := testgo(t) 3824 defer tg.cleanup() 3825 tg.run("test", "-run", "Test/ThisWillNotMatch", "testdata/standalone_sub_test.go") 3826 tg.grepBoth(noMatchesPattern, "go test did not say [no tests to run]") 3827 } 3828 3829 func TestMatchesNoSubtestsDoesNotOverrideFailure(t *testing.T) { 3830 tg := testgo(t) 3831 defer tg.cleanup() 3832 tg.runFail("test", "-run", "TestThatFails/ThisWillNotMatch", "testdata/standalone_fail_sub_test.go") 3833 tg.grepBothNot(noMatchesPattern, "go test did say [no tests to run]") 3834 tg.grepBoth("FAIL", "go test did not say FAIL") 3835 } 3836 3837 func TestMatchesOnlySubtestIsOK(t *testing.T) { 3838 tg := testgo(t) 3839 defer tg.cleanup() 3840 tg.run("test", "-run", "Test/Sub", "testdata/standalone_sub_test.go") 3841 tg.grepBothNot(noMatchesPattern, "go test did say [no tests to run]") 3842 tg.grepBoth(okPattern, "go test did not say ok") 3843 } 3844 3845 func TestMatchesNoSubtestsParallel(t *testing.T) { 3846 tg := testgo(t) 3847 defer tg.cleanup() 3848 tg.run("test", "-run", "Test/Sub/ThisWillNotMatch", "testdata/standalone_parallel_sub_test.go") 3849 tg.grepBoth(noMatchesPattern, "go test did not say [no tests to run]") 3850 } 3851 3852 func TestMatchesOnlySubtestParallelIsOK(t *testing.T) { 3853 tg := testgo(t) 3854 defer tg.cleanup() 3855 tg.run("test", "-run", "Test/Sub/Nested", "testdata/standalone_parallel_sub_test.go") 3856 tg.grepBothNot(noMatchesPattern, "go test did say [no tests to run]") 3857 tg.grepBoth(okPattern, "go test did not say ok") 3858 } 3859 3860 // Issue 18845 3861 func TestBenchTimeout(t *testing.T) { 3862 tg := testgo(t) 3863 defer tg.cleanup() 3864 tg.run("test", "-bench", ".", "-timeout", "750ms", "testdata/timeoutbench_test.go") 3865 } 3866 3867 func TestLinkXImportPathEscape(t *testing.T) { 3868 // golang.org/issue/16710 3869 tg := testgo(t) 3870 defer tg.cleanup() 3871 tg.parallel() 3872 tg.setenv("GOPATH", filepath.Join(tg.pwd(), "testdata")) 3873 exe := "./linkx" + exeSuffix 3874 tg.creatingTemp(exe) 3875 tg.run("build", "-o", exe, "-ldflags", "-X=my.pkg.Text=linkXworked", "my.pkg/main") 3876 out, err := exec.Command(exe).CombinedOutput() 3877 if err != nil { 3878 tg.t.Fatal(err) 3879 } 3880 if string(out) != "linkXworked\n" { 3881 tg.t.Log(string(out)) 3882 tg.t.Fatal(`incorrect output: expected "linkXworked\n"`) 3883 } 3884 } 3885 3886 // Issue 18044. 3887 func TestLdBindNow(t *testing.T) { 3888 tg := testgo(t) 3889 defer tg.cleanup() 3890 tg.parallel() 3891 tg.setenv("LD_BIND_NOW", "1") 3892 tg.run("help") 3893 } 3894 3895 // Issue 18225. 3896 // This is really a cmd/asm issue but this is a convenient place to test it. 3897 func TestConcurrentAsm(t *testing.T) { 3898 tg := testgo(t) 3899 defer tg.cleanup() 3900 tg.parallel() 3901 asm := `DATA ·constants<>+0x0(SB)/8,$0 3902 GLOBL ·constants<>(SB),8,$8 3903 ` 3904 tg.tempFile("go/src/p/a.s", asm) 3905 tg.tempFile("go/src/p/b.s", asm) 3906 tg.tempFile("go/src/p/p.go", `package p`) 3907 tg.setenv("GOPATH", tg.path("go")) 3908 tg.run("build", "p") 3909 } 3910 3911 // Issue 18778. 3912 func TestDotDotDotOutsideGOPATH(t *testing.T) { 3913 tg := testgo(t) 3914 defer tg.cleanup() 3915 3916 tg.tempFile("pkgs/a.go", `package x`) 3917 tg.tempFile("pkgs/a_test.go", `package x_test 3918 import "testing" 3919 func TestX(t *testing.T) {}`) 3920 3921 tg.tempFile("pkgs/a/a.go", `package a`) 3922 tg.tempFile("pkgs/a/a_test.go", `package a_test 3923 import "testing" 3924 func TestA(t *testing.T) {}`) 3925 3926 tg.cd(tg.path("pkgs")) 3927 tg.run("build", "./...") 3928 tg.run("test", "./...") 3929 tg.run("list", "./...") 3930 tg.grepStdout("pkgs$", "expected package not listed") 3931 tg.grepStdout("pkgs/a", "expected package not listed") 3932 } 3933 3934 // Issue 18975. 3935 func TestFFLAGS(t *testing.T) { 3936 if !canCgo { 3937 t.Skip("skipping because cgo not enabled") 3938 } 3939 3940 tg := testgo(t) 3941 defer tg.cleanup() 3942 tg.parallel() 3943 3944 tg.tempFile("p/src/p/main.go", `package main 3945 // #cgo FFLAGS: -no-such-fortran-flag 3946 import "C" 3947 func main() {} 3948 `) 3949 tg.tempFile("p/src/p/a.f", `! comment`) 3950 tg.setenv("GOPATH", tg.path("p")) 3951 3952 // This should normally fail because we are passing an unknown flag, 3953 // but issue #19080 points to Fortran compilers that succeed anyhow. 3954 // To work either way we call doRun directly rather than run or runFail. 3955 tg.doRun([]string{"build", "-x", "p"}) 3956 3957 tg.grepStderr("no-such-fortran-flag", `missing expected "-no-such-fortran-flag"`) 3958 } 3959 3960 // Issue 19198. 3961 // This is really a cmd/link issue but this is a convenient place to test it. 3962 func TestDuplicateGlobalAsmSymbols(t *testing.T) { 3963 if runtime.GOARCH != "386" && runtime.GOARCH != "amd64" { 3964 t.Skipf("skipping test on %s", runtime.GOARCH) 3965 } 3966 if !canCgo { 3967 t.Skip("skipping because cgo not enabled") 3968 } 3969 3970 tg := testgo(t) 3971 defer tg.cleanup() 3972 tg.parallel() 3973 3974 asm := ` 3975 #include "textflag.h" 3976 3977 DATA sym<>+0x0(SB)/8,$0 3978 GLOBL sym<>(SB),(NOPTR+RODATA),$8 3979 3980 TEXT ·Data(SB),NOSPLIT,$0 3981 MOVB sym<>(SB), AX 3982 MOVB AX, ret+0(FP) 3983 RET 3984 ` 3985 tg.tempFile("go/src/a/a.s", asm) 3986 tg.tempFile("go/src/a/a.go", `package a; func Data() uint8`) 3987 tg.tempFile("go/src/b/b.s", asm) 3988 tg.tempFile("go/src/b/b.go", `package b; func Data() uint8`) 3989 tg.tempFile("go/src/p/p.go", ` 3990 package main 3991 import "a" 3992 import "b" 3993 import "C" 3994 func main() { 3995 _ = a.Data() + b.Data() 3996 } 3997 `) 3998 tg.setenv("GOPATH", tg.path("go")) 3999 exe := filepath.Join(tg.tempdir, "p.exe") 4000 tg.creatingTemp(exe) 4001 tg.run("build", "-o", exe, "p") 4002 } 4003 4004 func TestBuildTagsNoComma(t *testing.T) { 4005 tg := testgo(t) 4006 defer tg.cleanup() 4007 tg.makeTempdir() 4008 tg.setenv("GOPATH", tg.path("go")) 4009 tg.run("install", "-tags", "tag1 tag2", "math") 4010 tg.runFail("install", "-tags", "tag1,tag2", "math") 4011 tg.grepBoth("space-separated list contains comma", "-tags with a comma-separated list didn't error") 4012 tg.runFail("build", "-tags", "tag1,tag2", "math") 4013 tg.grepBoth("space-separated list contains comma", "-tags with a comma-separated list didn't error") 4014 } 4015 4016 func copyFile(src, dst string, perm os.FileMode) error { 4017 sf, err := os.Open(src) 4018 if err != nil { 4019 return err 4020 } 4021 defer sf.Close() 4022 4023 df, err := os.OpenFile(dst, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, perm) 4024 if err != nil { 4025 return err 4026 } 4027 4028 _, err = io.Copy(df, sf) 4029 err2 := df.Close() 4030 if err != nil { 4031 return err 4032 } 4033 return err2 4034 } 4035 4036 func TestExecutableGOROOT(t *testing.T) { 4037 if runtime.GOOS == "openbsd" { 4038 t.Skipf("test case does not work on %s, missing os.Executable", runtime.GOOS) 4039 } 4040 4041 // Env with no GOROOT. 4042 var env []string 4043 for _, e := range os.Environ() { 4044 if !strings.HasPrefix(e, "GOROOT=") { 4045 env = append(env, e) 4046 } 4047 } 4048 4049 check := func(t *testing.T, exe, want string) { 4050 cmd := exec.Command(exe, "env", "GOROOT") 4051 cmd.Env = env 4052 out, err := cmd.CombinedOutput() 4053 if err != nil { 4054 t.Fatalf("%s env GOROOT: %v, %s", exe, err, out) 4055 } 4056 goroot, err := filepath.EvalSymlinks(strings.TrimSpace(string(out))) 4057 if err != nil { 4058 t.Fatal(err) 4059 } 4060 want, err = filepath.EvalSymlinks(want) 4061 if err != nil { 4062 t.Fatal(err) 4063 } 4064 if !strings.EqualFold(goroot, want) { 4065 t.Errorf("go env GOROOT:\nhave %s\nwant %s", goroot, want) 4066 } else { 4067 t.Logf("go env GOROOT: %s", goroot) 4068 } 4069 } 4070 4071 // Note: Must not call tg methods inside subtests: tg is attached to outer t. 4072 tg := testgo(t) 4073 defer tg.cleanup() 4074 4075 tg.makeTempdir() 4076 tg.tempDir("new/bin") 4077 newGoTool := tg.path("new/bin/go" + exeSuffix) 4078 tg.must(copyFile(tg.goTool(), newGoTool, 0775)) 4079 newRoot := tg.path("new") 4080 4081 t.Run("RelocatedExe", func(t *testing.T) { 4082 t.Skip("TODO: skipping known broken test; see golang.org/issue/20284") 4083 4084 // Should fall back to default location in binary. 4085 // No way to dig out other than look at source code. 4086 data, err := ioutil.ReadFile("../../runtime/internal/sys/zversion.go") 4087 if err != nil { 4088 t.Fatal(err) 4089 } 4090 m := regexp.MustCompile("const DefaultGoroot = `([^`]+)`").FindStringSubmatch(string(data)) 4091 if m == nil { 4092 t.Fatal("cannot find DefaultGoroot in ../../runtime/internal/sys/zversion.go") 4093 } 4094 check(t, newGoTool, m[1]) 4095 }) 4096 4097 // If the binary is sitting in a bin dir next to ../pkg/tool, that counts as a GOROOT, 4098 // so it should find the new tree. 4099 tg.tempDir("new/pkg/tool") 4100 t.Run("RelocatedTree", func(t *testing.T) { 4101 check(t, newGoTool, newRoot) 4102 }) 4103 4104 tg.tempDir("other/bin") 4105 symGoTool := tg.path("other/bin/go" + exeSuffix) 4106 4107 // Symlink into go tree should still find go tree. 4108 t.Run("SymlinkedExe", func(t *testing.T) { 4109 testenv.MustHaveSymlink(t) 4110 if err := os.Symlink(newGoTool, symGoTool); err != nil { 4111 t.Fatal(err) 4112 } 4113 check(t, symGoTool, newRoot) 4114 }) 4115 } 4116 4117 func TestNeedVersion(t *testing.T) { 4118 tg := testgo(t) 4119 defer tg.cleanup() 4120 tg.parallel() 4121 tg.tempFile("goversion.go", `package main; func main() {}`) 4122 path := tg.path("goversion.go") 4123 tg.setenv("TESTGO_VERSION", "go1.testgo") 4124 tg.runFail("run", path) 4125 tg.grepStderr("compile", "does not match go tool version") 4126 } 4127 4128 // Test that user can override default code generation flags. 4129 func TestUserOverrideFlags(t *testing.T) { 4130 if !canCgo { 4131 t.Skip("skipping because cgo not enabled") 4132 } 4133 if runtime.GOOS != "linux" { 4134 // We are testing platform-independent code, so it's 4135 // OK to skip cases that work differently. 4136 t.Skipf("skipping on %s because test only works if c-archive implies -shared", runtime.GOOS) 4137 } 4138 4139 tg := testgo(t) 4140 defer tg.cleanup() 4141 tg.parallel() 4142 tg.tempFile("override.go", `package main 4143 4144 import "C" 4145 4146 //export GoFunc 4147 func GoFunc() {} 4148 4149 func main() {}`) 4150 tg.creatingTemp("override.a") 4151 tg.creatingTemp("override.h") 4152 tg.run("build", "-x", "-buildmode=c-archive", "-gcflags=-shared=false", tg.path("override.go")) 4153 tg.grepStderr("compile .*-shared .*-shared=false", "user can not override code generation flag") 4154 } 4155 4156 func TestCgoFlagContainsSpace(t *testing.T) { 4157 if !canCgo { 4158 t.Skip("skipping because cgo not enabled") 4159 } 4160 4161 tg := testgo(t) 4162 defer tg.cleanup() 4163 4164 ccName := filepath.Base(testCC) 4165 4166 tg.tempFile(fmt.Sprintf("src/%s/main.go", ccName), fmt.Sprintf(`package main 4167 import ( 4168 "os" 4169 "os/exec" 4170 "strings" 4171 ) 4172 4173 func main() { 4174 cmd := exec.Command(%q, os.Args[1:]...) 4175 cmd.Stdin = os.Stdin 4176 cmd.Stdout = os.Stdout 4177 cmd.Stderr = os.Stderr 4178 err := cmd.Run() 4179 if err != nil { 4180 panic(err) 4181 } 4182 4183 if os.Args[len(os.Args)-1] == "trivial.c" { 4184 return 4185 } 4186 4187 var success bool 4188 for _, arg := range os.Args { 4189 switch { 4190 case strings.Contains(arg, "c flags"): 4191 if success { 4192 panic("duplicate CFLAGS") 4193 } 4194 success = true 4195 case strings.Contains(arg, "ld flags"): 4196 if success { 4197 panic("duplicate LDFLAGS") 4198 } 4199 success = true 4200 } 4201 } 4202 if !success { 4203 panic("args should contains '-Ic flags' or '-Lld flags'") 4204 } 4205 } 4206 `, testCC)) 4207 tg.cd(tg.path(fmt.Sprintf("src/%s", ccName))) 4208 tg.run("build") 4209 tg.setenv("CC", tg.path(fmt.Sprintf("src/%s/%s", ccName, ccName))) 4210 4211 tg.tempFile("src/cgo/main.go", `package main 4212 // #cgo CFLAGS: -I"c flags" 4213 // #cgo LDFLAGS: -L"ld flags" 4214 import "C" 4215 func main() {} 4216 `) 4217 tg.cd(tg.path("src/cgo")) 4218 tg.run("run", "main.go") 4219 } 4220 4221 // Issue #20435. 4222 func TestGoTestRaceCoverModeFailures(t *testing.T) { 4223 if !canRace { 4224 t.Skip("skipping because race detector not supported") 4225 } 4226 4227 tg := testgo(t) 4228 tg.parallel() 4229 defer tg.cleanup() 4230 tg.setenv("GOPATH", filepath.Join(tg.pwd(), "testdata")) 4231 4232 tg.run("test", "testrace") 4233 4234 tg.runFail("test", "-race", "-covermode=set", "testrace") 4235 tg.grepStderr(`-covermode must be "atomic", not "set", when -race is enabled`, "-race -covermode=set was allowed") 4236 tg.grepBothNot("PASS", "something passed") 4237 } 4238 4239 // Issue 9737: verify that GOARM and GO386 affect the computed build ID. 4240 func TestBuildIDContainsArchModeEnv(t *testing.T) { 4241 if testing.Short() { 4242 t.Skip("skipping in short mode") 4243 } 4244 4245 var tg *testgoData 4246 testWith := func(before, after func()) func(*testing.T) { 4247 return func(t *testing.T) { 4248 tg = testgo(t) 4249 defer tg.cleanup() 4250 tg.tempFile("src/mycmd/x.go", `package main 4251 func main() {}`) 4252 tg.setenv("GOPATH", tg.path(".")) 4253 4254 tg.cd(tg.path("src/mycmd")) 4255 tg.setenv("GOOS", "linux") 4256 before() 4257 tg.run("install", "mycmd") 4258 after() 4259 tg.wantStale("mycmd", "build ID mismatch", "should be stale after environment variable change") 4260 } 4261 } 4262 4263 t.Run("386", testWith(func() { 4264 tg.setenv("GOARCH", "386") 4265 tg.setenv("GO386", "387") 4266 }, func() { 4267 tg.setenv("GO386", "sse2") 4268 })) 4269 4270 t.Run("arm", testWith(func() { 4271 tg.setenv("GOARCH", "arm") 4272 tg.setenv("GOARM", "5") 4273 }, func() { 4274 tg.setenv("GOARM", "7") 4275 })) 4276 } 4277 4278 func TestTestRegexps(t *testing.T) { 4279 tg := testgo(t) 4280 defer tg.cleanup() 4281 tg.setenv("GOPATH", filepath.Join(tg.pwd(), "testdata")) 4282 tg.run("test", "-cpu=1", "-run=X/Y", "-bench=X/Y", "-count=2", "-v", "testregexp") 4283 var lines []string 4284 for _, line := range strings.SplitAfter(tg.getStdout(), "\n") { 4285 if strings.Contains(line, "=== RUN") || strings.Contains(line, "--- BENCH") || strings.Contains(line, "LOG") { 4286 lines = append(lines, line) 4287 } 4288 } 4289 4290 // Important parts: 4291 // TestX is run, twice 4292 // TestX/Y is run, twice 4293 // TestXX is run, twice 4294 // TestZ is not run 4295 // BenchmarkX is run but only with N=1, once 4296 // BenchmarkXX is run but only with N=1, once 4297 // BenchmarkX/Y is run in full, twice 4298 want := `=== RUN TestX 4299 === RUN TestX/Y 4300 x_test.go:6: LOG: X running 4301 x_test.go:8: LOG: Y running 4302 === RUN TestXX 4303 z_test.go:10: LOG: XX running 4304 === RUN TestX 4305 === RUN TestX/Y 4306 x_test.go:6: LOG: X running 4307 x_test.go:8: LOG: Y running 4308 === RUN TestXX 4309 z_test.go:10: LOG: XX running 4310 --- BENCH: BenchmarkX/Y 4311 x_test.go:15: LOG: Y running N=1 4312 x_test.go:15: LOG: Y running N=100 4313 x_test.go:15: LOG: Y running N=10000 4314 x_test.go:15: LOG: Y running N=1000000 4315 x_test.go:15: LOG: Y running N=100000000 4316 x_test.go:15: LOG: Y running N=2000000000 4317 --- BENCH: BenchmarkX/Y 4318 x_test.go:15: LOG: Y running N=1 4319 x_test.go:15: LOG: Y running N=100 4320 x_test.go:15: LOG: Y running N=10000 4321 x_test.go:15: LOG: Y running N=1000000 4322 x_test.go:15: LOG: Y running N=100000000 4323 x_test.go:15: LOG: Y running N=2000000000 4324 --- BENCH: BenchmarkX 4325 x_test.go:13: LOG: X running N=1 4326 --- BENCH: BenchmarkXX 4327 z_test.go:18: LOG: XX running N=1 4328 ` 4329 4330 have := strings.Join(lines, "") 4331 if have != want { 4332 t.Errorf("reduced output:<<<\n%s>>> want:<<<\n%s>>>", have, want) 4333 } 4334 } 4335 4336 func TestListTests(t *testing.T) { 4337 var tg *testgoData 4338 testWith := func(listName, expected string) func(*testing.T) { 4339 return func(t *testing.T) { 4340 tg = testgo(t) 4341 defer tg.cleanup() 4342 tg.run("test", "./testdata/src/testlist/...", fmt.Sprintf("-list=%s", listName)) 4343 tg.grepStdout(expected, fmt.Sprintf("-test.list=%s returned %q, expected %s", listName, tg.getStdout(), expected)) 4344 } 4345 } 4346 4347 t.Run("Test", testWith("Test", "TestSimple")) 4348 t.Run("Bench", testWith("Benchmark", "BenchmarkSimple")) 4349 t.Run("Example1", testWith("Example", "ExampleSimple")) 4350 t.Run("Example2", testWith("Example", "ExampleWithEmptyOutput")) 4351 } 4352 4353 func TestBadCommandLines(t *testing.T) { 4354 tg := testgo(t) 4355 defer tg.cleanup() 4356 4357 tg.tempFile("src/x/x.go", "package x\n") 4358 tg.setenv("GOPATH", tg.path(".")) 4359 4360 tg.run("build", "x") 4361 4362 tg.tempFile("src/x/@y.go", "package x\n") 4363 tg.runFail("build", "x") 4364 tg.grepStderr("invalid input file name \"@y.go\"", "did not reject @y.go") 4365 tg.must(os.Remove(tg.path("src/x/@y.go"))) 4366 4367 tg.tempFile("src/x/-y.go", "package x\n") 4368 tg.runFail("build", "x") 4369 tg.grepStderr("invalid input file name \"-y.go\"", "did not reject -y.go") 4370 tg.must(os.Remove(tg.path("src/x/-y.go"))) 4371 4372 tg.runFail("build", "-gcflags=@x", "x") 4373 tg.grepStderr("invalid command-line argument @x in command", "did not reject @x during exec") 4374 4375 tg.tempFile("src/@x/x.go", "package x\n") 4376 tg.setenv("GOPATH", tg.path(".")) 4377 tg.runFail("build", "@x") 4378 tg.grepStderr("invalid input directory name \"@x\"", "did not reject @x directory") 4379 4380 tg.tempFile("src/@x/y/y.go", "package y\n") 4381 tg.setenv("GOPATH", tg.path(".")) 4382 tg.runFail("build", "@x/y") 4383 tg.grepStderr("invalid import path \"@x/y\"", "did not reject @x/y import path") 4384 4385 tg.tempFile("src/-x/x.go", "package x\n") 4386 tg.setenv("GOPATH", tg.path(".")) 4387 tg.runFail("build", "--", "-x") 4388 tg.grepStderr("invalid input directory name \"-x\"", "did not reject -x directory") 4389 4390 tg.tempFile("src/-x/y/y.go", "package y\n") 4391 tg.setenv("GOPATH", tg.path(".")) 4392 tg.runFail("build", "--", "-x/y") 4393 tg.grepStderr("invalid import path \"-x/y\"", "did not reject -x/y import path") 4394 } 4395 4396 func TestBadCgoDirectives(t *testing.T) { 4397 if !canCgo { 4398 t.Skip("no cgo") 4399 } 4400 tg := testgo(t) 4401 defer tg.cleanup() 4402 4403 tg.tempFile("src/x/x.go", "package x\n") 4404 tg.setenv("GOPATH", tg.path(".")) 4405 4406 tg.tempFile("src/x/x.go", `package x 4407 4408 //go:cgo_ldflag "-fplugin=foo.so" 4409 4410 `) 4411 tg.runFail("build", "x") 4412 tg.grepStderr("//go:cgo_ldflag .* only allowed in cgo-generated code", "did not reject //go:cgo_ldflag directive") 4413 4414 tg.must(os.Remove(tg.path("src/x/x.go"))) 4415 tg.runFail("build", "x") 4416 tg.grepStderr("no Go files", "did not report missing source code") 4417 tg.tempFile("src/x/_cgo_yy.go", `package x 4418 4419 //go:cgo_ldflag "-fplugin=foo.so" 4420 4421 `) 4422 tg.runFail("build", "x") 4423 tg.grepStderr("no Go files", "did not report missing source code") // _* files are ignored... 4424 4425 tg.runFail("build", tg.path("src/x/_cgo_yy.go")) // ... but if forced, the comment is rejected 4426 // Actually, today there is a separate issue that _ files named 4427 // on the command-line are ignored. Once that is fixed, 4428 // we want to see the cgo_ldflag error. 4429 tg.grepStderr("//go:cgo_ldflag only allowed in cgo-generated code|no Go files", "did not reject //go:cgo_ldflag directive") 4430 tg.must(os.Remove(tg.path("src/x/_cgo_yy.go"))) 4431 4432 tg.tempFile("src/x/x.go", "package x\n") 4433 tg.tempFile("src/x/y.go", `package x 4434 // #cgo CFLAGS: -fplugin=foo.so 4435 import "C" 4436 `) 4437 tg.runFail("build", "x") 4438 tg.grepStderr("invalid flag in #cgo CFLAGS: -fplugin=foo.so", "did not reject -fplugin") 4439 4440 tg.tempFile("src/x/y.go", `package x 4441 // #cgo CFLAGS: -Ibar -fplugin=foo.so 4442 import "C" 4443 `) 4444 tg.runFail("build", "x") 4445 tg.grepStderr("invalid flag in #cgo CFLAGS: -fplugin=foo.so", "did not reject -fplugin") 4446 4447 tg.tempFile("src/x/y.go", `package x 4448 // #cgo pkg-config: -foo 4449 import "C" 4450 `) 4451 tg.runFail("build", "x") 4452 tg.grepStderr("invalid pkg-config package name: -foo", "did not reject pkg-config: -foo") 4453 4454 tg.tempFile("src/x/y.go", `package x 4455 // #cgo pkg-config: @foo 4456 import "C" 4457 `) 4458 tg.runFail("build", "x") 4459 tg.grepStderr("invalid pkg-config package name: @foo", "did not reject pkg-config: -foo") 4460 4461 tg.tempFile("src/x/y.go", `package x 4462 // #cgo CFLAGS: @foo 4463 import "C" 4464 `) 4465 tg.runFail("build", "x") 4466 tg.grepStderr("invalid flag in #cgo CFLAGS: @foo", "did not reject @foo flag") 4467 4468 tg.tempFile("src/x/y.go", `package x 4469 // #cgo CFLAGS: -D 4470 import "C" 4471 `) 4472 tg.runFail("build", "x") 4473 tg.grepStderr("invalid flag in #cgo CFLAGS: -D without argument", "did not reject trailing -I flag") 4474 4475 // Note that -I @foo is allowed because we rewrite it into -I /path/to/src/@foo 4476 // before the check is applied. There's no such rewrite for -D. 4477 4478 tg.tempFile("src/x/y.go", `package x 4479 // #cgo CFLAGS: -D @foo 4480 import "C" 4481 `) 4482 tg.runFail("build", "x") 4483 tg.grepStderr("invalid flag in #cgo CFLAGS: -D @foo", "did not reject -D @foo flag") 4484 4485 tg.tempFile("src/x/y.go", `package x 4486 // #cgo CFLAGS: -D@foo 4487 import "C" 4488 `) 4489 tg.runFail("build", "x") 4490 tg.grepStderr("invalid flag in #cgo CFLAGS: -D@foo", "did not reject -D@foo flag") 4491 4492 tg.setenv("CGO_CFLAGS", "-D@foo") 4493 tg.tempFile("src/x/y.go", `package x 4494 import "C" 4495 `) 4496 tg.run("build", "-n", "x") 4497 tg.grepStderr("-D@foo", "did not find -D@foo in commands") 4498 }