func init() {
onWindows := (runtime.GOOS == "windows")
onOSX := (runtime.GOOS == "darwin")
config.Flags("", false)
flag.IntVar(&(numCPU), "nodes", 1, "The number of parallel test nodes to run")
flag.BoolVar(&(parallelStream), "stream", !onWindows, "Aggregate parallel test output into one coherent stream (default: true)")
flag.BoolVar(&(recurse), "r", false, "Find and run test suites under the current directory recursively")
flag.BoolVar(&(runMagicI), "i", false, "Run go test -i first, then run the test suite")
flag.BoolVar(&(race), "race", false, "Run tests with race detection enabled")
flag.BoolVar(&(cover), "cover", false, "Run tests with coverage analysis, will generate coverage profiles with the package name in the current directory")
flag.BoolVar(&(watch), "watch", false, "Monitor the target packages for changes, then run tests when changes are detected")
if onOSX {
flag.BoolVar(&(notify), "notify", false, "Send desktop notifications when a test run completes")
}
flag.BoolVar(&(keepGoing), "keepGoing", false, "When true, failures from earlier test suites do not prevent later test suites from running")
flag.BoolVar(&(untilItFails), "untilItFails", false, "When true, Ginkgo will keep rerunning tests until a failure occurs")
flag.Usage = func() {
fmt.Fprintf(os.Stderr, "Usage of ginkgo:\n\n")
fmt.Fprintf(os.Stderr, "ginkgo <FLAGS> <DIRECTORY> ...\n Run the tests in the passed in <DIRECTORY> (or the current directory if left blank).\n ginkgo accepts the following flags:\n")
fmt.Fprintf(os.Stderr, "\n")
flag.PrintDefaults()
fmt.Fprintf(os.Stderr, "\n")
fmt.Fprintf(os.Stderr, "\n")
fmt.Fprintf(os.Stderr, "ginkgo bootstrap\n Bootstrap a test suite for the current package.\n\n")
fmt.Fprintf(os.Stderr, "ginkgo generate <SUBJECT>\n Generate a test file for SUBJECT, the file will be named SUBJECT_test.go\n If omitted, a file named after the package will be created.\n\n")
fmt.Fprintf(os.Stderr, "ginkgo unfocus\n Unfocuses any focused tests.\n\n")
fmt.Fprintf(os.Stderr, "ginkgo version\n Print ginkgo's version.\n\n")
fmt.Fprintf(os.Stderr, "ginkgo help\n Print this usage information.\n")
}
flag.Parse()
}
func (c *RunWatchAndBuildCommandFlags) flags(mode int) {
onWindows := (runtime.GOOS == "windows")
onOSX := (runtime.GOOS == "darwin")
c.FlagSet.BoolVar(&(c.Recurse), "r", false, "Find and run test suites under the current directory recursively")
c.FlagSet.BoolVar(&(c.Race), "race", false, "Run tests with race detection enabled")
c.FlagSet.BoolVar(&(c.Cover), "cover", false, "Run tests with coverage analysis, will generate coverage profiles with the package name in the current directory")
c.FlagSet.StringVar(&(c.SkipPackage), "skipPackage", "", "A comma-separated list of package names to be skipped. If any part of the package's path matches, that package is ignored.")
c.FlagSet.StringVar(&(c.Tags), "tags", "", "A list of build tags to consider satisfied during the build")
if mode == runMode || mode == watchMode {
config.Flags(c.FlagSet, "", false)
c.FlagSet.IntVar(&(c.NumCPU), "nodes", 1, "The number of parallel test nodes to run")
c.FlagSet.IntVar(&(c.NumCompilers), "compilers", 0, "The number of concurrent compilations to run (0 will autodetect)")
c.FlagSet.BoolVar(&(c.AutoNodes), "p", false, "Run in parallel with auto-detected number of nodes")
c.FlagSet.BoolVar(&(c.ParallelStream), "stream", onWindows, "stream parallel test output in real time: less coherent, but useful for debugging")
if onOSX {
c.FlagSet.BoolVar(&(c.Notify), "notify", false, "Send desktop notifications when a test run completes")
}
}
if mode == runMode {
c.FlagSet.BoolVar(&(c.KeepGoing), "keepGoing", false, "When true, failures from earlier test suites do not prevent later test suites from running")
c.FlagSet.BoolVar(&(c.UntilItFails), "untilItFails", false, "When true, Ginkgo will keep rerunning tests until a failure occurs")
c.FlagSet.BoolVar(&(c.RandomizeSuites), "randomizeSuites", false, "When true, Ginkgo will randomize the order in which test suites run")
}
if mode == watchMode {
c.FlagSet.IntVar(&(c.Depth), "depth", 1, "Ginkgo will watch dependencies down to this depth in the dependency tree")
}
}
func (c *RunWatchAndBuildCommandFlags) flags(mode int) {
c.GoOpts = make(map[string]interface{})
onWindows := (runtime.GOOS == "windows")
c.FlagSet.BoolVar(&(c.Recurse), "r", false, "Find and run test suites under the current directory recursively.")
c.FlagSet.BoolVar(c.boolSlot("race"), "race", false, "Run tests with race detection enabled.")
c.FlagSet.BoolVar(c.boolSlot("cover"), "cover", false, "Run tests with coverage analysis, will generate coverage profiles with the package name in the current directory.")
c.FlagSet.StringVar(c.stringSlot("coverpkg"), "coverpkg", "", "Run tests with coverage on the given external modules.")
c.FlagSet.StringVar(&(c.SkipPackage), "skipPackage", "", "A comma-separated list of package names to be skipped. If any part of the package's path matches, that package is ignored.")
c.FlagSet.StringVar(c.stringSlot("tags"), "tags", "", "A list of build tags to consider satisfied during the build.")
c.FlagSet.StringVar(c.stringSlot("gcflags"), "gcflags", "", "Arguments to pass on each go tool compile invocation.")
c.FlagSet.StringVar(c.stringSlot("covermode"), "covermode", "", "Set the mode for coverage analysis.")
c.FlagSet.BoolVar(c.boolSlot("a"), "a", false, "Force rebuilding of packages that are already up-to-date.")
c.FlagSet.BoolVar(c.boolSlot("n"), "n", false, "Have `go test` print the commands but do not run them.")
c.FlagSet.BoolVar(c.boolSlot("msan"), "msan", false, "Enable interoperation with memory sanitizer.")
c.FlagSet.BoolVar(c.boolSlot("x"), "x", false, "Have `go test` print the commands.")
c.FlagSet.BoolVar(c.boolSlot("work"), "work", false, "Print the name of the temporary work directory and do not delete it when exiting.")
c.FlagSet.StringVar(c.stringSlot("asmflags"), "asmflags", "", "Arguments to pass on each go tool asm invocation.")
c.FlagSet.StringVar(c.stringSlot("buildmode"), "buildmode", "", "Build mode to use. See 'go help buildmode' for more.")
c.FlagSet.StringVar(c.stringSlot("compiler"), "compiler", "", "Name of compiler to use, as in runtime.Compiler (gccgo or gc).")
c.FlagSet.StringVar(c.stringSlot("gccgoflags"), "gccgoflags", "", "Arguments to pass on each gccgo compiler/linker invocation.")
c.FlagSet.StringVar(c.stringSlot("installsuffix"), "installsuffix", "", "A suffix to use in the name of the package installation directory.")
c.FlagSet.StringVar(c.stringSlot("ldflags"), "ldflags", "", "Arguments to pass on each go tool link invocation.")
c.FlagSet.BoolVar(c.boolSlot("linkshared"), "linkshared", false, "Link against shared libraries previously created with -buildmode=shared.")
c.FlagSet.StringVar(c.stringSlot("pkgdir"), "pkgdir", "", "install and load all packages from the given dir instead of the usual locations.")
c.FlagSet.StringVar(c.stringSlot("toolexec"), "toolexec", "", "a program to use to invoke toolchain programs like vet and asm.")
c.FlagSet.IntVar(c.intSlot("blockprofilerate"), "blockprofilerate", 1, "Control the detail provided in goroutine blocking profiles by calling runtime.SetBlockProfileRate with the given value.")
c.FlagSet.StringVar(c.stringSlot("coverprofile"), "coverprofile", "", "Write a coverage profile to the specified file after all tests have passed.")
c.FlagSet.StringVar(c.stringSlot("cpuprofile"), "cpuprofile", "", "Write a CPU profile to the specified file before exiting.")
c.FlagSet.StringVar(c.stringSlot("memprofile"), "memprofile", "", "Write a memory profile to the specified file after all tests have passed.")
c.FlagSet.IntVar(c.intSlot("memprofilerate"), "memprofilerate", 0, "Enable more precise (and expensive) memory profiles by setting runtime.MemProfileRate.")
c.FlagSet.StringVar(c.stringSlot("outputdir"), "outputdir", "", "Place output files from profiling in the specified directory.")
if mode == runMode || mode == watchMode {
config.Flags(c.FlagSet, "", false)
c.FlagSet.IntVar(&(c.NumCPU), "nodes", 1, "The number of parallel test nodes to run")
c.FlagSet.IntVar(&(c.NumCompilers), "compilers", 0, "The number of concurrent compilations to run (0 will autodetect)")
c.FlagSet.BoolVar(&(c.AutoNodes), "p", false, "Run in parallel with auto-detected number of nodes")
c.FlagSet.BoolVar(&(c.ParallelStream), "stream", onWindows, "stream parallel test output in real time: less coherent, but useful for debugging")
if !onWindows {
c.FlagSet.BoolVar(&(c.Notify), "notify", false, "Send desktop notifications when a test run completes")
}
c.FlagSet.StringVar(&(c.AfterSuiteHook), "afterSuiteHook", "", "Run a command when a suite test run completes")
}
if mode == runMode {
c.FlagSet.BoolVar(&(c.KeepGoing), "keepGoing", false, "When true, failures from earlier test suites do not prevent later test suites from running")
c.FlagSet.BoolVar(&(c.UntilItFails), "untilItFails", false, "When true, Ginkgo will keep rerunning tests until a failure occurs")
c.FlagSet.BoolVar(&(c.RandomizeSuites), "randomizeSuites", false, "When true, Ginkgo will randomize the order in which test suites run")
}
if mode == watchMode {
c.FlagSet.IntVar(&(c.Depth), "depth", 1, "Ginkgo will watch dependencies down to this depth in the dependency tree")
}
}
func (c *RunAndWatchCommandFlags) flags(forWatchCommand bool) {
onWindows := (runtime.GOOS == "windows")
onOSX := (runtime.GOOS == "darwin")
config.Flags(c.FlagSet, "", false)
c.FlagSet.IntVar(&(c.NumCPU), "nodes", 1, "The number of parallel test nodes to run")
c.FlagSet.BoolVar(&(c.ParallelStream), "stream", onWindows, "stream parallel test output in real time: less coherent, but useful for debugging")
c.FlagSet.BoolVar(&(c.Recurse), "r", false, "Find and run test suites under the current directory recursively")
c.FlagSet.BoolVar(&(c.Race), "race", false, "Run tests with race detection enabled")
c.FlagSet.BoolVar(&(c.Cover), "cover", false, "Run tests with coverage analysis, will generate coverage profiles with the package name in the current directory")
c.FlagSet.StringVar(&(c.SkipPackage), "skipPackage", "", "Packages with names matching this regular expression will be skipped")
if onOSX {
c.FlagSet.BoolVar(&(c.Notify), "notify", false, "Send desktop notifications when a test run completes")
}
if !forWatchCommand {
c.FlagSet.BoolVar(&(c.KeepGoing), "keepGoing", false, "When true, failures from earlier test suites do not prevent later test suites from running")
c.FlagSet.BoolVar(&(c.UntilItFails), "untilItFails", false, "When true, Ginkgo will keep rerunning tests until a failure occurs")
}
}
func init() {
config.Flags("", false)
flag.IntVar(&(numCPU), "nodes", 1, "The number of parallel test nodes to run")
flag.BoolVar(&(recurse), "r", false, "Find and run test suites under the current directory recursively")
flag.BoolVar(&(runMagicI), "i", false, "Run go test -i first, then run the test suite")
flag.BoolVar(&(race), "race", false, "Run tests with race detection enabled")
flag.BoolVar(&(cover), "cover", false, "Run tests with coverage analysis, will generate coverage profiles with the package name in the current directory")
flag.Usage = func() {
fmt.Fprintf(os.Stderr, "Usage of ginkgo:\n\n")
fmt.Fprintf(os.Stderr, "ginkgo\n Run the tests in the current directory. The following flags are available:\n")
flag.PrintDefaults()
fmt.Fprintf(os.Stderr, "\n")
fmt.Fprintf(os.Stderr, "ginkgo bootstrap\n Bootstrap a test suite for the current package.\n\n")
fmt.Fprintf(os.Stderr, "ginkgo generate <SUBJECT>\n Generate a test file for SUBJECT, the file will be named SUBJECT_test.go\n If omitted, a file named after the package will be created.\n\n")
fmt.Fprintf(os.Stderr, "ginkgo version\n Print ginkgo's version.\n\n")
fmt.Fprintf(os.Stderr, "ginkgo help\n Print this usage information.\n")
}
flag.Parse()
}
func init() {
config.Flags("", false)
flag.IntVar(&(numCPU), "nodes", 1, "The number of parallel test nodes to run")
flag.BoolVar(&(parallelStream), "stream", true, "Aggregate parallel test output into one coherent stream (default: true)")
flag.BoolVar(&(recurse), "r", false, "Find and run test suites under the current directory recursively")
flag.BoolVar(&(runMagicI), "i", false, "Run go test -i first, then run the test suite")
flag.BoolVar(&(race), "race", false, "Run tests with race detection enabled")
flag.BoolVar(&(cover), "cover", false, "Run tests with coverage analysis, will generate coverage profiles with the package name in the current directory")
flag.Usage = func() {
fmt.Fprintf(os.Stderr, "Usage of ginkgo:\n\n")
fmt.Fprintf(os.Stderr, "ginkgo <FLAGS> <DIRECTORY> ...\n Run the tests in the passed in <DIRECTORY> (or the current directory if left blank).\n ginkgo accepts the following flags:\n")
flag.PrintDefaults()
fmt.Fprintf(os.Stderr, "\n")
fmt.Fprintf(os.Stderr, "ginkgo bootstrap\n Bootstrap a test suite for the current package.\n\n")
fmt.Fprintf(os.Stderr, "ginkgo generate <SUBJECT>\n Generate a test file for SUBJECT, the file will be named SUBJECT_test.go\n If omitted, a file named after the package will be created.\n\n")
fmt.Fprintf(os.Stderr, "ginkgo unfocus\n Unfocuses any focused tests.\n\n")
fmt.Fprintf(os.Stderr, "ginkgo version\n Print ginkgo's version.\n\n")
fmt.Fprintf(os.Stderr, "ginkgo help\n Print this usage information.\n")
}
flag.Parse()
}
func init() {
config.Flags(flag.CommandLine, "ginkgo", true)
GinkgoWriter = writer.New(os.Stdout)
globalFailer = failer.New()
globalSuite = suite.New(globalFailer)
}
func init() {
config.Flags("ginkgo", true)
globalSuite = newSuite()
}
func init() {
config.Flags("ginkgo", true)
GinkgoWriter = newGinkgoWriter(os.Stdout)
globalSuite = newSuite()
}