...
Run Format

Source file src/internal/testenv/testenv.go

Documentation: internal/testenv

  // Copyright 2015 The Go Authors. All rights reserved.
  // Use of this source code is governed by a BSD-style
  // license that can be found in the LICENSE file.
  
  // Package testenv provides information about what functionality
  // is available in different testing environments run by the Go team.
  //
  // It is an internal package because these details are specific
  // to the Go team's test setup (on build.golang.org) and not
  // fundamental to tests in general.
  package testenv
  
  import (
  	"errors"
  	"flag"
  	"os"
  	"os/exec"
  	"path/filepath"
  	"runtime"
  	"strconv"
  	"strings"
  	"testing"
  )
  
  // Builder reports the name of the builder running this test
  // (for example, "linux-amd64" or "windows-386-gce").
  // If the test is not running on the build infrastructure,
  // Builder returns the empty string.
  func Builder() string {
  	return os.Getenv("GO_BUILDER_NAME")
  }
  
  // HasGoBuild reports whether the current system can build programs with ``go build''
  // and then run them with os.StartProcess or exec.Command.
  func HasGoBuild() bool {
  	switch runtime.GOOS {
  	case "android", "nacl":
  		return false
  	case "darwin":
  		if strings.HasPrefix(runtime.GOARCH, "arm") {
  			return false
  		}
  	}
  	return true
  }
  
  // MustHaveGoBuild checks that the current system can build programs with ``go build''
  // and then run them with os.StartProcess or exec.Command.
  // If not, MustHaveGoBuild calls t.Skip with an explanation.
  func MustHaveGoBuild(t *testing.T) {
  	if !HasGoBuild() {
  		t.Skipf("skipping test: 'go build' not available on %s/%s", runtime.GOOS, runtime.GOARCH)
  	}
  }
  
  // HasGoRun reports whether the current system can run programs with ``go run.''
  func HasGoRun() bool {
  	// For now, having go run and having go build are the same.
  	return HasGoBuild()
  }
  
  // MustHaveGoRun checks that the current system can run programs with ``go run.''
  // If not, MustHaveGoRun calls t.Skip with an explanation.
  func MustHaveGoRun(t *testing.T) {
  	if !HasGoRun() {
  		t.Skipf("skipping test: 'go run' not available on %s/%s", runtime.GOOS, runtime.GOARCH)
  	}
  }
  
  // GoToolPath reports the path to the Go tool.
  // It is a convenience wrapper around GoTool.
  // If the tool is unavailable GoToolPath calls t.Skip.
  // If the tool should be available and isn't, GoToolPath calls t.Fatal.
  func GoToolPath(t *testing.T) string {
  	MustHaveGoBuild(t)
  	path, err := GoTool()
  	if err != nil {
  		t.Fatal(err)
  	}
  	return path
  }
  
  // GoTool reports the path to the Go tool.
  func GoTool() (string, error) {
  	if !HasGoBuild() {
  		return "", errors.New("platform cannot run go tool")
  	}
  	var exeSuffix string
  	if runtime.GOOS == "windows" {
  		exeSuffix = ".exe"
  	}
  	path := filepath.Join(runtime.GOROOT(), "bin", "go"+exeSuffix)
  	if _, err := os.Stat(path); err == nil {
  		return path, nil
  	}
  	goBin, err := exec.LookPath("go" + exeSuffix)
  	if err != nil {
  		return "", errors.New("cannot find go tool: " + err.Error())
  	}
  	return goBin, nil
  }
  
  // HasExec reports whether the current system can start new processes
  // using os.StartProcess or (more commonly) exec.Command.
  func HasExec() bool {
  	switch runtime.GOOS {
  	case "nacl":
  		return false
  	case "darwin":
  		if strings.HasPrefix(runtime.GOARCH, "arm") {
  			return false
  		}
  	}
  	return true
  }
  
  // HasSrc reports whether the entire source tree is available under GOROOT.
  func HasSrc() bool {
  	switch runtime.GOOS {
  	case "nacl":
  		return false
  	case "darwin":
  		if strings.HasPrefix(runtime.GOARCH, "arm") {
  			return false
  		}
  	}
  	return true
  }
  
  // MustHaveExec checks that the current system can start new processes
  // using os.StartProcess or (more commonly) exec.Command.
  // If not, MustHaveExec calls t.Skip with an explanation.
  func MustHaveExec(t *testing.T) {
  	if !HasExec() {
  		t.Skipf("skipping test: cannot exec subprocess on %s/%s", runtime.GOOS, runtime.GOARCH)
  	}
  }
  
  // HasExternalNetwork reports whether the current system can use
  // external (non-localhost) networks.
  func HasExternalNetwork() bool {
  	return !testing.Short()
  }
  
  // MustHaveExternalNetwork checks that the current system can use
  // external (non-localhost) networks.
  // If not, MustHaveExternalNetwork calls t.Skip with an explanation.
  func MustHaveExternalNetwork(t *testing.T) {
  	if testing.Short() {
  		t.Skipf("skipping test: no external network in -short mode")
  	}
  }
  
  var haveCGO bool
  
  // MustHaveCGO calls t.Skip if cgo is not available.
  func MustHaveCGO(t *testing.T) {
  	if !haveCGO {
  		t.Skipf("skipping test: no cgo")
  	}
  }
  
  // HasSymlink reports whether the current system can use os.Symlink.
  func HasSymlink() bool {
  	ok, _ := hasSymlink()
  	return ok
  }
  
  // MustHaveSymlink reports whether the current system can use os.Symlink.
  // If not, MustHaveSymlink calls t.Skip with an explanation.
  func MustHaveSymlink(t *testing.T) {
  	ok, reason := hasSymlink()
  	if !ok {
  		t.Skipf("skipping test: cannot make symlinks on %s/%s%s", runtime.GOOS, runtime.GOARCH, reason)
  	}
  }
  
  // HasLink reports whether the current system can use os.Link.
  func HasLink() bool {
  	// From Android release M (Marshmallow), hard linking files is blocked
  	// and an attempt to call link() on a file will return EACCES.
  	// - https://code.google.com/p/android-developer-preview/issues/detail?id=3150
  	return runtime.GOOS != "plan9" && runtime.GOOS != "android"
  }
  
  // MustHaveLink reports whether the current system can use os.Link.
  // If not, MustHaveLink calls t.Skip with an explanation.
  func MustHaveLink(t *testing.T) {
  	if !HasLink() {
  		t.Skipf("skipping test: hardlinks are not supported on %s/%s", runtime.GOOS, runtime.GOARCH)
  	}
  }
  
  var flaky = flag.Bool("flaky", false, "run known-flaky tests too")
  
  func SkipFlaky(t *testing.T, issue int) {
  	if !*flaky {
  		t.Skipf("skipping known flaky test without the -flaky flag; see golang.org/issue/%d", issue)
  	}
  }
  
  func SkipFlakyNet(t *testing.T) {
  	if v, _ := strconv.ParseBool(os.Getenv("GO_BUILDER_FLAKY_NET")); v {
  		t.Skip("skipping test on builder known to have frequent network failures")
  	}
  }
  

View as plain text