func TestTestPackage(t *testing.T) {
gb.Verbose = false
defer func() { gb.Verbose = false }()
tests := []struct {
pkg string
testArgs []string
ldflags string
err error
}{
{
pkg: "a",
err: nil,
}, {
pkg: "b",
err: nil,
}, {
pkg: "c",
err: nil,
}, {
pkg: "e",
err: nil,
}, {
pkg: "cmd/f",
err: nil,
}, {
pkg: "extest", // test external tests
err: nil,
}, {
pkg: "g", // test that _test files can modify the internal package under test
err: nil,
}, {
pkg: "ldflags",
ldflags: "-X ldflags.gitTagInfo banana -X ldflags.gitRevision f7926af2",
}, {
pkg: "cgotest",
}, {
pkg: "testflags",
testArgs: []string{"-debug"},
}}
for _, tt := range tests {
ctx := testContext(t, gb.Ldflags(tt.ldflags))
// TODO(dfc) can we resolve the duplication here ?
pkg, err := ctx.ResolvePackageWithTests(tt.pkg)
if err != nil {
t.Errorf("ResolvePackage(%v): want %v, got %v", tt.pkg, tt.err, err)
continue
}
if err := Test(tt.testArgs, pkg); err != tt.err {
t.Errorf("Test(%v): want %v, got %v", tt.pkg, tt.err, err)
time.Sleep(500 * time.Millisecond)
}
ctx.Destroy()
}
}
func TestTest(t *testing.T) {
tests := []struct {
pkg string
testArgs []string
ldflags []string
err error
}{
{
pkg: "a",
err: nil,
}, {
pkg: "b",
err: nil,
}, {
pkg: "c",
err: nil,
}, {
pkg: "e",
err: nil,
}, {
pkg: "cmd/f",
err: nil,
}, {
pkg: "extest", // test external tests
err: nil,
}, {
pkg: "external_only_test", // issue 312
err: nil,
}, {
pkg: "notestfiles",
err: nil,
}, {
pkg: "cgoonlynotest",
err: nil,
}, {
pkg: "testonly",
err: nil,
}, {
pkg: "extestonly",
err: nil,
}, {
pkg: "g", // test that _test files can modify the internal package under test
err: nil,
}, {
pkg: "ldflags",
ldflags: []string{"-X", "ldflags.gitTagInfo", "banana", "-X", "ldflags.gitRevision", "f7926af2"},
}, {
pkg: "cgotest",
}, {
pkg: "testflags",
testArgs: []string{"-debug"},
}, {
pkg: "main", // issue 375, a package called main
}}
for _, tt := range tests {
ctx := testContext(t, gb.Ldflags(tt.ldflags...))
defer ctx.Destroy()
r := TestResolver(ctx)
pkg, err := r.ResolvePackage(tt.pkg)
if err != nil {
t.Errorf("ResolvePackage(%v): want %v, got %v", tt.pkg, tt.err, err)
continue
}
if err := Test(tt.testArgs, pkg); err != tt.err {
t.Errorf("Test(%v): want %v, got %v", tt.pkg, tt.err, err)
time.Sleep(500 * time.Millisecond)
}
}
}
func main() {
fatalf := func(format string, args ...interface{}) {
fmt.Fprintf(os.Stderr, "FATAL: "+format+"\n", args...)
os.Exit(1)
}
args := os.Args
if len(args) < 2 || args[1] == "-h" {
fs.Usage()
os.Exit(1)
}
name := args[1]
if name == "help" {
help(args[2:])
return
}
command, ok := commands[name]
if (command != nil && !command.Runnable()) || !ok {
plugin, err := lookupPlugin(name)
if err != nil {
fmt.Fprintf(os.Stderr, "FATAL: unknown command %q\n", name)
fs.Usage()
os.Exit(1)
}
command = &cmd.Command{
Run: func(ctx *gb.Context, args []string) error {
args = append([]string{plugin}, args...)
env := cmd.MergeEnv(os.Environ(), map[string]string{
"GB_PROJECT_DIR": ctx.Projectdir(),
})
cmd := exec.Cmd{
Path: plugin,
Args: args,
Env: env,
Stdin: os.Stdin,
Stdout: os.Stdout,
Stderr: os.Stderr,
}
return cmd.Run()
},
// plugin should not interpret arguments
ParseArgs: func(_ *gb.Context, _ string, args []string) []string { return args },
}
}
// add extra flags if necessary
if command.AddFlags != nil {
command.AddFlags(fs)
}
var err error
if command.FlagParse != nil {
err = command.FlagParse(fs, args)
} else {
err = fs.Parse(args[2:])
}
if err != nil {
fatalf("could not parse flags: %v", err)
}
args = fs.Args() // reset args to the leftovers from fs.Parse
if command == commands["plugin"] {
args = append([]string{name}, args...)
}
cwd, err := filepath.Abs(cwd) // if cwd was passed in via -R, make sure it is absolute
if err != nil {
fatalf("could not make project root absolute: %v", err)
}
ctx, err := cmd.NewContext(
cwd, // project root
gb.GcToolchain(),
gb.Gcflags(gcflags...),
gb.Ldflags(ldflags...),
gb.Tags(buildtags...),
)
if err != nil {
fatalf("unable to construct context: %v", err)
}
if !noDestroyContext {
defer ctx.Destroy()
}
if command.ParseArgs != nil {
args = command.ParseArgs(ctx, ctx.Projectdir(), args)
} else {
args = cmd.ImportPaths(ctx, cwd, args)
}
debug.Debugf("args: %v", args)
if err := command.Run(ctx, args); err != nil {
if !noDestroyContext {
ctx.Destroy()
}
fatalf("command %q failed: %v", name, err)
}
}
func main() {
args := os.Args
if len(args) < 2 || args[1] == "-h" {
fs.Usage() // usage calles exit(2)
}
name := args[1]
if name == "help" {
help(args[2:])
exit(0)
}
command, ok := commands[name]
if (command != nil && !command.Runnable()) || !ok {
plugin, err := lookupPlugin(name)
if err != nil {
fmt.Fprintf(os.Stderr, "FATAL: unknown command %q\n", name)
fs.Usage() // usage calles exit(2)
}
command = &cmd.Command{
Run: func(ctx *gb.Context, args []string) error {
args = append([]string{plugin}, args...)
env := cmd.MergeEnv(os.Environ(), map[string]string{
"GB_PROJECT_DIR": ctx.Projectdir(),
})
cmd := exec.Cmd{
Path: plugin,
Args: args,
Env: env,
Stdin: os.Stdin,
Stdout: os.Stdout,
Stderr: os.Stderr,
}
return cmd.Run()
},
// plugin should not interpret arguments
SkipParseArgs: true,
}
}
// add extra flags if necessary
if command.AddFlags != nil {
command.AddFlags(fs)
}
var err error
if command.FlagParse != nil {
err = command.FlagParse(fs, args)
} else {
err = fs.Parse(args[2:])
}
if err != nil {
fatalf("could not parse flags: %v", err)
}
args = fs.Args() // reset args to the leftovers from fs.Parse
debug.Debugf("args: %v", args)
if command == commands["plugin"] {
args = append([]string{name}, args...)
}
cwd, err := filepath.Abs(cwd) // if cwd was passed in via -R, make sure it is absolute
if err != nil {
fatalf("could not make project root absolute: %v", err)
}
ctx, err := cmd.NewContext(
cwd, // project root
gb.GcToolchain(),
gb.Gcflags(gcflags...),
gb.Ldflags(ldflags...),
gb.Tags(buildtags...),
func(c *gb.Context) error {
if !race {
return nil
}
// check this is a supported platform
if runtime.GOARCH != "amd64" {
fatalf("race detector not supported on %s/%s", runtime.GOOS, runtime.GOARCH)
}
switch runtime.GOOS {
case "linux", "windows", "darwin", "freebsd":
// supported
default:
fatalf("race detector not supported on %s/%s", runtime.GOOS, runtime.GOARCH)
}
// check the race runtime is built
_, err := os.Stat(filepath.Join(runtime.GOROOT(), "pkg", fmt.Sprintf("%s_%s_race", runtime.GOOS, runtime.GOARCH), "runtime.a"))
if os.IsNotExist(err) || err != nil {
fatalf("go installation at %s is missing race support. See https://getgb.io/faq/#missing-race-support", runtime.GOROOT())
}
return gb.WithRace(c)
},
)
if err != nil {
fatalf("unable to construct context: %v", err)
}
if !command.SkipParseArgs {
args = cmd.ImportPaths(ctx, cwd, args)
}
debug.Debugf("args: %v", args)
if destroyContext {
atExit = append(atExit, ctx.Destroy)
}
if err := command.Run(ctx, args); err != nil {
fatalf("command %q failed: %v", name, err)
}
exit(0)
}
func main() {
args := os.Args
if len(args) < 2 || args[1] == "-h" {
fs.Usage()
os.Exit(1)
}
name := args[1]
if name == "help" {
help(args[2:])
return
}
command, ok := commands[name]
if (command != nil && !command.Runnable()) || !ok {
if _, err := lookupPlugin(name); err != nil {
gb.Errorf("unknown command %q", name)
fs.Usage()
os.Exit(1)
}
command = commands["plugin"]
}
// add extra flags if necessary
if command.AddFlags != nil {
command.AddFlags(fs)
}
var err error
if command.FlagParse != nil {
err = command.FlagParse(fs, args)
} else {
err = fs.Parse(args[2:])
}
if err != nil {
gb.Fatalf("could not parse flags: %v", err)
}
args = fs.Args() // reset args to the leftovers from fs.Parse
if command == commands["plugin"] {
args = append([]string{name}, args...)
}
cwd, err := filepath.Abs(cwd) // if cwd was passed in via -R, make sure it is absolute
if err != nil {
gb.Fatalf("could not make project root absolute: %v", err)
}
ctx, err := cmd.NewContext(
cwd, // project root
gb.GcToolchain(),
gb.Gcflags(gcflags),
gb.Ldflags(ldflags),
)
if err != nil {
gb.Fatalf("unable to construct context: %v", err)
}
if !noDestroyContext {
defer ctx.Destroy()
}
if command.ParseArgs != nil {
args = command.ParseArgs(ctx, ctx.Projectdir(), args)
} else {
args = cmd.ImportPaths(ctx, cwd, args)
}
gb.Debugf("args: %v", args)
if err := command.Run(ctx, args); err != nil {
gb.Fatalf("command %q failed: %v", name, err)
}
}
func TestTest(t *testing.T) {
tests := []struct {
pkg string
testArgs []string
ldflags []string
err error
minversion float64 // minimum go version that supports this feature
maxversion float64 // maximum go version that supports this feature
}{
{
pkg: "a",
err: nil,
}, {
pkg: "b",
err: nil,
}, {
pkg: "c",
err: nil,
}, {
pkg: "e",
err: nil,
}, {
pkg: "cmd/f",
err: nil,
}, {
pkg: "extest", // test external tests
err: nil,
}, {
pkg: "external_only_test", // issue 312
err: nil,
}, {
pkg: "notestfiles",
err: nil,
}, {
pkg: "cgoonlynotest",
err: nil,
}, {
pkg: "testonly",
err: nil,
}, {
pkg: "extestonly",
err: nil,
}, {
pkg: "g", // test that _test files can modify the internal package under test
err: nil,
}, {
pkg: "ldflags",
ldflags: []string{"-X", "ldflags.gitTagInfo=banana", "-X", "ldflags.gitRevision=f7926af2"},
minversion: 1.5,
}, {
pkg: "ldflags",
ldflags: []string{"-X", "ldflags.gitTagInfo", "banana", "-X", "ldflags.gitRevision", "f7926af2"},
maxversion: 1.5,
}, {
pkg: "cgotest",
}, {
pkg: "testflags",
testArgs: []string{"-debug"},
}, {
pkg: "main", // issue 375, a package called main
}}
for _, tt := range tests {
if tt.minversion != 0 && goversion < tt.minversion {
t.Logf("skipping test, goversion %f is below mingoversion %f", goversion, tt.minversion)
continue
}
if tt.maxversion != 0 && goversion > tt.maxversion {
t.Logf("skipping test, goversion %f is above maxgoversion %f", goversion, tt.maxversion)
continue
}
ctx := testContext(t, gb.Ldflags(tt.ldflags...))
defer ctx.Destroy()
r := TestResolver(ctx)
pkg, err := r.ResolvePackage(tt.pkg)
if err != nil {
t.Errorf("ResolvePackage(%v): want %v, got %v", tt.pkg, tt.err, err)
continue
}
if err := Test(tt.testArgs, pkg); err != tt.err {
t.Errorf("Test(%v): want %v, got %v", tt.pkg, tt.err, err)
time.Sleep(500 * time.Millisecond)
}
}
}
