"cmd/go/internal/cache"
"cmd/go/internal/cfg"
+ "cmd/go/internal/robustio"
"cmd/internal/sys"
)
if tg.wd != "" && !filepath.IsAbs(path) {
path = filepath.Join(tg.pwd(), path)
}
- tg.must(os.RemoveAll(path))
+ tg.must(robustio.RemoveAll(path))
tg.temps = append(tg.temps, path)
}
}
return nil
})
- return os.RemoveAll(dir)
+ return robustio.RemoveAll(dir)
}
// failSSH puts an ssh executable in the PATH that always fails.
case "svn":
// SVN doesn't believe in text files so we can't just edit the config.
// Check out a different repo into the wrong place.
- tg.must(os.RemoveAll(tg.path("src/code.google.com/p/rsc-svn")))
+ tg.must(robustio.RemoveAll(tg.path("src/code.google.com/p/rsc-svn")))
tg.run("get", "-d", "-u", "code.google.com/p/rsc-svn2/trunk")
tg.must(os.Rename(tg.path("src/code.google.com/p/rsc-svn2"), tg.path("src/code.google.com/p/rsc-svn")))
default:
}
func TestMoveGit(t *testing.T) {
+ testenv.MustHaveExecPath(t, "git")
testMove(t, "git", "rsc.io/pdf", "pdf", "rsc.io/pdf/.git/config")
}
func TestMoveHG(t *testing.T) {
+ testenv.MustHaveExecPath(t, "hg")
testMove(t, "hg", "vcs-test.golang.org/go/custom-hg-hello", "custom-hg-hello", "vcs-test.golang.org/go/custom-hg-hello/.hg/hgrc")
}
// cmd/go: custom import path checking should not apply to Go packages without import comment.
func TestIssue10952(t *testing.T) {
testenv.MustHaveExternalNetwork(t)
- if _, err := exec.LookPath("git"); err != nil {
- t.Skip("skipping because git binary not found")
- }
+ testenv.MustHaveExecPath(t, "git")
tg := testgo(t)
defer tg.cleanup()
func TestIssue16471(t *testing.T) {
testenv.MustHaveExternalNetwork(t)
- if _, err := exec.LookPath("git"); err != nil {
- t.Skip("skipping because git binary not found")
- }
+ testenv.MustHaveExecPath(t, "git")
tg := testgo(t)
defer tg.cleanup()
// Test git clone URL that uses SCP-like syntax and custom import path checking.
func TestIssue11457(t *testing.T) {
testenv.MustHaveExternalNetwork(t)
- if _, err := exec.LookPath("git"); err != nil {
- t.Skip("skipping because git binary not found")
- }
+ testenv.MustHaveExecPath(t, "git")
tg := testgo(t)
defer tg.cleanup()
func TestGetGitDefaultBranch(t *testing.T) {
testenv.MustHaveExternalNetwork(t)
- if _, err := exec.LookPath("git"); err != nil {
- t.Skip("skipping because git binary not found")
- }
+ testenv.MustHaveExecPath(t, "git")
tg := testgo(t)
defer tg.cleanup()
// Security issue. Don't disable. See golang.org/issue/22125.
func TestAccidentalGitCheckout(t *testing.T) {
testenv.MustHaveExternalNetwork(t)
- if _, err := exec.LookPath("git"); err != nil {
- t.Skip("skipping because git binary not found")
- }
+ testenv.MustHaveExecPath(t, "git")
tg := testgo(t)
defer tg.cleanup()
func TestGoGetNonPkg(t *testing.T) {
testenv.MustHaveExternalNetwork(t)
+ testenv.MustHaveExecPath(t, "git")
tg := testgo(t)
defer tg.cleanup()
func TestGoGetTestOnlyPkg(t *testing.T) {
testenv.MustHaveExternalNetwork(t)
+ testenv.MustHaveExecPath(t, "git")
tg := testgo(t)
defer tg.cleanup()
goarch := strings.TrimSpace(tg.getStdout())
tg.setenv("GOARCH", goarch)
fixbin := filepath.Join(goroot, "pkg", "tool", goos+"_"+goarch, "fix") + exeSuffix
- tg.must(os.RemoveAll(fixbin))
+ tg.must(robustio.RemoveAll(fixbin))
tg.run("install", "cmd/fix")
tg.wantExecutable(fixbin, "did not install cmd/fix to $GOROOT/pkg/tool")
tg.must(os.Remove(fixbin))
func TestDefaultGOPATHGet(t *testing.T) {
testenv.MustHaveExternalNetwork(t)
+ testenv.MustHaveExecPath(t, "git")
tg := testgo(t)
defer tg.cleanup()
tg.grepStderr("created GOPATH="+regexp.QuoteMeta(tg.path("home/go"))+"; see 'go help gopath'", "did not create GOPATH")
// no warning if directory already exists
- tg.must(os.RemoveAll(tg.path("home/go")))
+ tg.must(robustio.RemoveAll(tg.path("home/go")))
tg.tempDir("home/go")
tg.run("get", "github.com/golang/example/hello")
tg.grepStderrNot(".", "expected no output on standard error")
// error if $HOME/go is a file
- tg.must(os.RemoveAll(tg.path("home/go")))
+ tg.must(robustio.RemoveAll(tg.path("home/go")))
tg.tempFile("home/go", "")
tg.runFail("get", "github.com/golang/example/hello")
tg.grepStderr(`mkdir .*[/\\]go: .*(not a directory|cannot find the path)`, "expected error because $HOME/go is a file")
// Issue 8181.
func TestGoGetDashTIssue8181(t *testing.T) {
testenv.MustHaveExternalNetwork(t)
+ testenv.MustHaveExecPath(t, "git")
tg := testgo(t)
defer tg.cleanup()
func TestIssue11307(t *testing.T) {
// go get -u was not working except in checkout directory
testenv.MustHaveExternalNetwork(t)
+ testenv.MustHaveExecPath(t, "git")
tg := testgo(t)
defer tg.cleanup()
files, err := filepath.Glob(filepath.Join(runtime.GOROOT(), "pkg", "*_race"))
tg.must(err)
for _, file := range files {
- tg.check(os.RemoveAll(file))
+ tg.check(robustio.RemoveAll(file))
}
tg.tempFile("src/foo/foo.go", `
package foo
tg.run("env", "PKG_CONFIG")
pkgConfig := strings.TrimSpace(tg.getStdout())
+ testenv.MustHaveExecPath(t, pkgConfig)
if out, err := exec.Command(pkgConfig, "--atleast-pkgconfig-version", "0.24").CombinedOutput(); err != nil {
t.Skipf("%s --atleast-pkgconfig-version 0.24: %v\n%s", pkgConfig, err, out)
}
if !canCgo {
t.Skip("skipping because cgo not enabled")
}
- if _, err := exec.LookPath("gccgo"); err != nil {
- t.Skip("skipping because no gccgo compiler found")
- }
+ testenv.MustHaveExecPath(t, "gccgo")
tg := testgo(t)
defer tg.cleanup()
func TestGoGetCustomDomainWildcard(t *testing.T) {
testenv.MustHaveExternalNetwork(t)
+ testenv.MustHaveExecPath(t, "git")
tg := testgo(t)
defer tg.cleanup()
func TestGoGetInternalWildcard(t *testing.T) {
testenv.MustHaveExternalNetwork(t)
+ testenv.MustHaveExecPath(t, "git")
tg := testgo(t)
defer tg.cleanup()
// Issue 9767, 19769.
func TestGoGetDotSlashDownload(t *testing.T) {
testenv.MustHaveExternalNetwork(t)
+ testenv.MustHaveExecPath(t, "git")
tg := testgo(t)
defer tg.cleanup()
func TestGoGetInsecure(t *testing.T) {
test := func(t *testing.T, modules bool) {
testenv.MustHaveExternalNetwork(t)
+ testenv.MustHaveExecPath(t, "git")
tg := testgo(t)
defer tg.cleanup()
func TestGoGetUpdateInsecure(t *testing.T) {
testenv.MustHaveExternalNetwork(t)
+ testenv.MustHaveExecPath(t, "git")
tg := testgo(t)
defer tg.cleanup()
func TestGoGetUpdateUnknownProtocol(t *testing.T) {
testenv.MustHaveExternalNetwork(t)
+ testenv.MustHaveExecPath(t, "git")
tg := testgo(t)
defer tg.cleanup()
func TestGoGetInsecureCustomDomain(t *testing.T) {
testenv.MustHaveExternalNetwork(t)
+ testenv.MustHaveExecPath(t, "git")
tg := testgo(t)
defer tg.cleanup()
// former dependencies, not current ones.
testenv.MustHaveExternalNetwork(t)
+ testenv.MustHaveExecPath(t, "git")
tg := testgo(t)
defer tg.cleanup()
// Issue #20512.
func TestGoGetRace(t *testing.T) {
testenv.MustHaveExternalNetwork(t)
+ testenv.MustHaveExecPath(t, "git")
if !canRace {
t.Skip("skipping because race detector not supported")
}
// go get foo.io (not foo.io/subdir) was not working consistently.
testenv.MustHaveExternalNetwork(t)
+ testenv.MustHaveExecPath(t, "git")
tg := testgo(t)
defer tg.cleanup()
tg.run("get", "go-get-issue-9357.appspot.com")
tg.run("get", "-u", "go-get-issue-9357.appspot.com")
- tg.must(os.RemoveAll(tg.path("src/go-get-issue-9357.appspot.com")))
+ tg.must(robustio.RemoveAll(tg.path("src/go-get-issue-9357.appspot.com")))
tg.run("get", "go-get-issue-9357.appspot.com")
- tg.must(os.RemoveAll(tg.path("src/go-get-issue-9357.appspot.com")))
+ tg.must(robustio.RemoveAll(tg.path("src/go-get-issue-9357.appspot.com")))
tg.run("get", "-u", "go-get-issue-9357.appspot.com")
}
// Issue 14450: go get -u .../ tried to import not downloaded package
func TestGoGetUpdateWithWildcard(t *testing.T) {
testenv.MustHaveExternalNetwork(t)
+ testenv.MustHaveExecPath(t, "git")
tg := testgo(t)
defer tg.cleanup()
tg := testgo(t)
defer tg.cleanup()
tg.parallel()
+ tg.makeTempdir()
tg.setenv("GOPATH", filepath.Join(tg.pwd(), "testdata"))
- exe := "./linkx" + exeSuffix
+ exe := tg.path("linkx" + exeSuffix)
tg.creatingTemp(exe)
tg.run("build", "-o", exe, "-ldflags", "-X=my.pkg.Text=linkXworked", "my.pkg/main")
out, err := exec.Command(exe).CombinedOutput()
check(t, symGoTool, newRoot)
})
- tg.must(os.RemoveAll(tg.path("new/pkg")))
+ tg.must(robustio.RemoveAll(tg.path("new/pkg")))
// Binaries built in the new tree should report the
// new tree when they call runtime.GOROOT.
t.Skip("skipping because cgo not enabled")
}
- if runtime.GOOS == "plan9" || runtime.GOOS == "windows" {
- t.Skipf("skipping because unix shell is not supported on %s", runtime.GOOS)
- }
+ testenv.MustHaveExecPath(t, "/usr/bin/env")
+ testenv.MustHaveExecPath(t, "bash")
tg := testgo(t)
defer tg.cleanup()
if len(matches) == 0 {
t.Fatal("no WORK directory")
}
- tg.must(os.RemoveAll(matches[1]))
+ tg.must(robustio.RemoveAll(matches[1]))
}
func TestParallelNumber(t *testing.T) {
t.Skipf("skipping upx test on %s/%s", runtime.GOOS, runtime.GOARCH)
}
+ testenv.MustHaveExecPath(t, "upx")
out, err := exec.Command("upx", "--version").CombinedOutput()
if err != nil {
- t.Skip("skipping because upx is not available")
+ t.Fatalf("upx --version failed: %v", err)
}
// upx --version prints `upx <version>` in the first line of output:
re := regexp.MustCompile(`([[:digit:]]+)\.([[:digit:]]+)`)
upxVersion := re.FindStringSubmatch(string(out))
if len(upxVersion) != 3 {
- t.Errorf("bad upx version string: %s", upxVersion)
+ t.Fatalf("bad upx version string: %s", upxVersion)
}
major, err1 := strconv.Atoi(upxVersion[1])
minor, err2 := strconv.Atoi(upxVersion[2])
if err1 != nil || err2 != nil {
- t.Errorf("bad upx version string: %s", upxVersion[0])
+ t.Fatalf("bad upx version string: %s", upxVersion[0])
}
// Anything below 3.94 is known not to work with go binaries
src, obj := tg.path("main.go"), tg.path("main")
for _, arch := range testArchs {
- out, err := exec.Command("qemu-"+arch.qemu, "--version").CombinedOutput()
- if err != nil {
- t.Logf("Skipping %s test (qemu-%s not available)", arch.g, arch.qemu)
- continue
- }
+ arch := arch
+ t.Run(arch.g, func(t *testing.T) {
+ qemu := "qemu-" + arch.qemu
+ testenv.MustHaveExecPath(t, qemu)
- tg.setenv("GOARCH", arch.g)
- tg.run("build", "-o", obj, src)
+ out, err := exec.Command(qemu, "--version").CombinedOutput()
+ if err != nil {
+ t.Fatalf("%s --version failed: %v", qemu, err)
+ }
- out, err = exec.Command("qemu-"+arch.qemu, obj).CombinedOutput()
- if err != nil {
- t.Logf("qemu-%s output:\n%s\n", arch.qemu, out)
- t.Errorf("qemu-%s failed with %v", arch.qemu, err)
- continue
- }
- if want := "hello qemu-user"; string(out) != want {
- t.Errorf("bad output from qemu-%s:\ngot %s; want %s", arch.qemu, out, want)
- }
- }
+ tg.setenv("GOARCH", arch.g)
+ tg.run("build", "-o", obj, src)
+ out, err = exec.Command(qemu, obj).CombinedOutput()
+ if err != nil {
+ t.Logf("%s output:\n%s\n", qemu, out)
+ t.Fatalf("%s failed with %v", qemu, err)
+ }
+ if want := "hello qemu-user"; string(out) != want {
+ t.Errorf("bad output from %s:\ngot %s; want %s", qemu, out, want)
+ }
+ })
+ }
}
func TestCacheListStale(t *testing.T) {