Merge pull request #11 from 8thlight/update-deps

Update locked dependencies

.gitignore

@@ -1,2 +1,3 @@
 .idea
 test_data_dir/
+vendor/

Gopkg.lock

@@ -1,6 +1,24 @@
 # This file is autogenerated, do not edit; changes may be undone by the next 'dep ensure'.
 
 
+[[projects]]
+  branch = "master"
+  name = "github.com/btcsuite/btcd"
+  packages = ["btcec"]
+  revision = "c7588cbf7690cd9f047a28efa2dcd8f2435a4e5e"
+
+[[projects]]
+  name = "github.com/ethereum/go-ethereum"
+  packages = [".","common","common/hexutil","common/math","core/types","crypto","crypto/secp256k1","crypto/sha3","ethclient","log","params","rlp","rpc","trie"]
+  revision = "1db4ecdc0b9e828ff65777fb466fc7c1d04e0de9"
+  version = "v1.7.2"
+
+[[projects]]
+  name = "github.com/go-stack/stack"
+  packages = ["."]
+  revision = "817915b46b97fd7bb80e8ab6b69f01a53ac3eebf"
+  version = "v1.6.0"
+
 [[projects]]
   name = "github.com/onsi/ginkgo"
   packages = [".","config","internal/codelocation","internal/containernode","internal/failer","internal/leafnodes","internal/remote","internal/spec","internal/spec_iterator","internal/specrunner","internal/suite","internal/testingtproxy","internal/writer","reporters","reporters/stenographer","reporters/stenographer/support/go-colorable","reporters/stenographer/support/go-isatty","types"]
@@ -13,10 +31,22 @@
   revision = "c893efa28eb45626cdaa76c9f653b62488858837"
   version = "v1.2.0"
 
+[[projects]]
+  branch = "master"
+  name = "github.com/rcrowley/go-metrics"
+  packages = ["."]
+  revision = "1f30fe9094a513ce4c700b9a54458bbb0c96996c"
+
+[[projects]]
+  name = "github.com/rs/cors"
+  packages = ["."]
+  revision = "7af7a1e09ba336d2ea14b1ce73bf693c6837dbf6"
+  version = "v1.2"
+
 [[projects]]
   branch = "master"
   name = "golang.org/x/net"
-  packages = ["html","html/atom","html/charset"]
+  packages = ["context","html","html/atom","html/charset","websocket"]
   revision = "1087133bc4af3073e18add999345c6ae75918503"
 
 [[projects]]
@@ -31,6 +61,24 @@
   packages = ["encoding","encoding/charmap","encoding/htmlindex","encoding/internal","encoding/internal/identifier","encoding/japanese","encoding/korean","encoding/simplifiedchinese","encoding/traditionalchinese","encoding/unicode","internal/gen","internal/tag","internal/utf8internal","language","runes","transform","unicode/cldr"]
   revision = "c01e4764d870b77f8abe5096ee19ad20d80e8075"
 
+[[projects]]
+  name = "gopkg.in/fatih/set.v0"
+  packages = ["."]
+  revision = "57907de300222151a123d29255ed17f5ed43fad3"
+  version = "v0.1.0"
+
+[[projects]]
+  branch = "v2"
+  name = "gopkg.in/karalabe/cookiejar.v2"
+  packages = ["collections/prque"]
+  revision = "8dcd6a7f4951f6ff3ee9cbb919a06d8925822e57"
+
+[[projects]]
+  branch = "v2"
+  name = "gopkg.in/natefinch/npipe.v2"
+  packages = ["."]
+  revision = "c1b8fa8bdccecb0b8db834ee0b92fdbcfa606dd6"
+
 [[projects]]
   branch = "v2"
   name = "gopkg.in/yaml.v2"
@@ -40,6 +88,6 @@
 [solve-meta]
   analyzer-name = "dep"
   analyzer-version = 1
-  inputs-digest = "a5f582949e466f1feb19df216895b5a917d893bcb6b3a59b2ffe50699686a410"
+  inputs-digest = "1f89d2d001b1d5929ecd9f83d34d67edc4c1ae8baea497f4b5b76d9f6cc7f8d5"
   solver-name = "gps-cdcl"
   solver-version = 1

Gopkg.toml

@@ -24,3 +24,7 @@
 [[constraint]]
   name = "github.com/onsi/ginkgo"
   version = "1.4.0"
+
+[[constraint]]
+  branch = "master"
+  name = "github.com/jmoiron/sqlx"

vendor/github.com/onsi/ginkgo/.gitignore

@@ -1,5 +0,0 @@
-.DS_Store
-TODO
-tmp/**/*
-*.coverprofile
-.vscode

vendor/github.com/onsi/ginkgo/.travis.yml

@@ -1,15 +0,0 @@
-language: go
-go:
-  - 1.5.x
-  - 1.6.x
-  - 1.7.x
-  - 1.8.x
-
-install:
-  - go get -v -t ./...
-  - go get golang.org/x/tools/cmd/cover
-  - go get github.com/onsi/gomega
-  - go install github.com/onsi/ginkgo/ginkgo
-  - export PATH=$PATH:$HOME/gopath/bin
-
-script: $HOME/gopath/bin/ginkgo -r --randomizeAllSpecs --randomizeSuites --race --trace

vendor/github.com/onsi/ginkgo/CHANGELOG.md

@@ -1,152 +0,0 @@
-## 1.4.0 7/16/2017
-
-- `ginkgo` now provides a hint if you accidentally forget to run `ginkgo bootstrap` to generate a `*_suite_test.go` file that actually invokes the Ginkgo test runner. [#345](https://github.com/onsi/ginkgo/pull/345)
-- thanks to improvements in `go test -c` `ginkgo` no longer needs to fix Go's compilation output to ensure compilation errors are expressed relative to the CWD. [#357]
-- `ginkgo watch -watchRegExp=...` allows you to specify a custom regular expression to watch.  Only files matching the regular expression are watched for changes (the default is `\.go$`) [#356]
-- `ginkgo` now always emits compilation output.  Previously, only failed compilation output was printed out. [#277]
-- `ginkgo -requireSuite` now fails the test run if there are `*_test.go` files but `go test` fails to detect any tests.  Typically this means you forgot to run `ginkgo bootstrap` to generate a suite file. [#344]
-- `ginkgo -timeout=DURATION` allows you to adjust the timeout for the entire test suite (default is 24 hours) [#248]
-
-## 1.3.0 3/28/2017
-
-Improvements:
-
-- Significantly improved parallel test distribution.  Now instead of pre-sharding test cases across workers (which can result in idle workers and poor test performance) Ginkgo uses a shared queue to keep all workers busy until all tests are complete.  This improves test-time performance and consistency.
-- `Skip(message)` can be used to skip the current test.
-- Added `extensions/table` - a Ginkgo DSL for [Table Driven Tests](http://onsi.github.io/ginkgo/#table-driven-tests)
-- Add `GinkgoRandomSeed()` - shorthand for `config.GinkgoConfig.RandomSeed`
-- Support for retrying flaky tests with `--flakeAttempts`
-- `ginkgo ./...` now recurses as you'd expect
-- Added `Specify` a synonym for `It`
-- Support colorise on Windows
-- Broader support for various go compilation flags in the `ginkgo` CLI
-
-Bug Fixes:
-
-- Ginkgo tests now fail when you `panic(nil)` (#167)
-
-## 1.2.0 5/31/2015
-
-Improvements
-
-- `ginkgo -coverpkg` calls down to `go test -coverpkg` (#160)
-- `ginkgo -afterSuiteHook COMMAND` invokes the passed-in `COMMAND` after a test suite completes (#152)
-- Relaxed requirement for Go 1.4+.  `ginkgo` now works with Go v1.3+ (#166)
-
-## 1.2.0-beta
-
-Ginkgo now requires Go 1.4+
-
-Improvements:
-
-- Call reporters in reverse order when announcing spec completion -- allows custom reporters to emit output before the default reporter does.
-- Improved focus behavior.  Now, this:
-
-    ```golang
-    FDescribe("Some describe", func() {
-        It("A", func() {})
-
-        FIt("B", func() {})
-    })
-    ```
-
-  will run `B` but *not* `A`.  This tends to be a common usage pattern when in the thick of writing and debugging tests.
-- When `SIGINT` is received, Ginkgo will emit the contents of the `GinkgoWriter` before running the `AfterSuite`.  Useful for debugging stuck tests.
-- When `--progress` is set, Ginkgo will write test progress (in particular, Ginkgo will say when it is about to run a BeforeEach, AfterEach, It, etc...) to the `GinkgoWriter`.  This is useful for debugging stuck tests and tests that generate many logs.
-- Improved output when an error occurs in a setup or teardown block.
-- When `--dryRun` is set, Ginkgo will walk the spec tree and emit to its reporter *without* actually running anything.  Best paired with `-v` to understand which specs will run in which order.
-- Add `By` to help document long `It`s.  `By` simply writes to the `GinkgoWriter`.
-- Add support for precompiled tests:
-    - `ginkgo build <path-to-package>` will now compile the package, producing a file named `package.test`
-    - The compiled `package.test` file can be run directly.  This runs the tests in series.
-    - To run precompiled tests in parallel, you can run: `ginkgo -p package.test`
-- Support `bootstrap`ping and `generate`ing [Agouti](http://agouti.org) specs.
-- `ginkgo generate` and `ginkgo bootstrap` now honor the package name already defined in a given directory
-- The `ginkgo` CLI ignores `SIGQUIT`.  Prevents its stack dump from interlacing with the underlying test suite's stack dump.
-- The `ginkgo` CLI now compiles tests into a temporary directory instead of the package directory.  This necessitates upgrading to Go v1.4+.
-- `ginkgo -notify` now works on Linux
-
-Bug Fixes:
-
-- If --skipPackages is used and all packages are skipped, Ginkgo should exit 0.
-- Fix tempfile leak when running in parallel
-- Fix incorrect failure message when a panic occurs during a parallel test run
-- Fixed an issue where a pending test within a focused context (or a focused test within a pending context) would skip all other tests.
-- Be more consistent about handling SIGTERM as well as SIGINT
-- When interupted while concurrently compiling test suites in the background, Ginkgo now cleans up the compiled artifacts.
-- Fixed a long standing bug where `ginkgo -p` would hang if a process spawned by one of the Ginkgo parallel nodes does not exit. (Hooray!)
-
-## 1.1.0 (8/2/2014)
-
-No changes, just dropping the beta.
-
-## 1.1.0-beta (7/22/2014)
-New Features:
-
-- `ginkgo watch` now monitors packages *and their dependencies* for changes.  The depth of the dependency tree can be modified with the `-depth` flag.
-- Test suites with a programmatic focus (`FIt`, `FDescribe`, etc...) exit with non-zero status code, even when they pass.  This allows CI systems to detect accidental commits of focused test suites.
-- `ginkgo -p` runs the testsuite in parallel with an auto-detected number of nodes.
-- `ginkgo -tags=TAG_LIST` passes a list of tags down to the `go build` command.
-- `ginkgo --failFast` aborts the test suite after the first failure.
-- `ginkgo generate file_1 file_2` can take multiple file arguments.
-- Ginkgo now summarizes any spec failures that occured at the end of the test run. 
-- `ginkgo --randomizeSuites` will run tests *suites* in random order using the generated/passed-in seed.
-
-Improvements:
-
-- `ginkgo -skipPackage` now takes a comma-separated list of strings.  If the *relative path* to a package matches one of the entries in the comma-separated list, that package is skipped.
-- `ginkgo --untilItFails` no longer recompiles between attempts.
-- Ginkgo now panics when a runnable node (`It`, `BeforeEach`, `JustBeforeEach`, `AfterEach`, `Measure`) is nested within another runnable node.  This is always a mistake.  Any test suites that panic because of this change should be fixed.
-
-Bug Fixes:
-
-- `ginkgo boostrap` and `ginkgo generate` no longer fail when dealing with `hyphen-separated-packages`.
-- parallel specs are now better distributed across nodes - fixed a crashing bug where (for example) distributing 11 tests across 7 nodes would panic
-
-## 1.0.0 (5/24/2014)
-New Features:
-
-- Add `GinkgoParallelNode()` - shorthand for `config.GinkgoConfig.ParallelNode`
-
-Improvements:
-
-- When compilation fails, the compilation output is rewritten to present a correct *relative* path.  Allows ⌘-clicking in iTerm open the file in your text editor.
-- `--untilItFails` and `ginkgo watch` now generate new random seeds between test runs, unless a particular random seed is specified.
-
-Bug Fixes:
-
-- `-cover` now generates a correctly combined coverprofile when running with in parallel with multiple `-node`s.
-- Print out the contents of the `GinkgoWriter` when `BeforeSuite` or `AfterSuite` fail.
-- Fix all remaining race conditions in Ginkgo's test suite.
-
-## 1.0.0-beta (4/14/2014)
-Breaking changes:
-
-- `thirdparty/gomocktestreporter` is gone.  Use `GinkgoT()` instead
-- Modified the Reporter interface 
-- `watch` is now a subcommand, not a flag.
-
-DSL changes:
-
-- `BeforeSuite` and `AfterSuite` for setting up and tearing down test suites.
-- `AfterSuite` is triggered on interrupt (`^C`) as well as exit.
-- `SynchronizedBeforeSuite` and `SynchronizedAfterSuite` for setting up and tearing down singleton resources across parallel nodes.
-
-CLI changes:
-
-- `watch` is now a subcommand, not a flag
-- `--nodot` flag can be passed to `ginkgo generate` and `ginkgo bootstrap` to avoid dot imports.  This explicitly imports all exported identifiers in Ginkgo and Gomega.  Refreshing this list can be done by running `ginkgo nodot`
-- Additional arguments can be passed to specs.  Pass them after the `--` separator
-- `--skipPackage` flag takes a regexp and ignores any packages with package names passing said regexp.
-- `--trace` flag prints out full stack traces when errors occur, not just the line at which the error occurs.
-
-Misc:
-
-- Start using semantic versioning
-- Start maintaining changelog
-
-Major refactor:
-
-- Pull out Ginkgo's internal to `internal`
-- Rename `example` everywhere to `spec`
-- Much more!

vendor/github.com/onsi/ginkgo/CONTRIBUTING.md

@@ -1,12 +0,0 @@
-# Contributing to Ginkgo
-
-Your contributions to Ginkgo are essential for its long-term maintenance and improvement.  To make a contribution:
-
-- Please **open an issue first** - describe what problem you are trying to solve and give the community a forum for input and feedback ahead of investing time in writing code!
-- Ensure adequate test coverage:
-    - If you're adding functionality to the Ginkgo library, make sure to add appropriate unit and/or integration tests (under the `integration` folder).
-    - If you're adding functionality to the Ginkgo CLI note that there are very few unit tests.  Please add an integration test.
-    - Please run all tests locally (`ginkgo -r -p`) and make sure they go green before submitting the PR
-- Update the documentation.  In addition to standard `godoc` comments Ginkgo has extensive documentation on the `gh-pages` branch.  If relevant, please submit a docs PR to that branch alongside your code PR.
-
-Thanks for supporting Ginkgo!

vendor/github.com/onsi/ginkgo/LICENSE

@@ -1,20 +0,0 @@
-Copyright (c) 2013-2014 Onsi Fakhouri
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

vendor/github.com/onsi/ginkgo/README.md

@@ -1,117 +0,0 @@
-![Ginkgo: A Golang BDD Testing Framework](http://onsi.github.io/ginkgo/images/ginkgo.png)
-
-[![Build Status](https://travis-ci.org/onsi/ginkgo.svg)](https://travis-ci.org/onsi/ginkgo)
-
-Jump to the [docs](http://onsi.github.io/ginkgo/) to learn more.  To start rolling your Ginkgo tests *now* [keep reading](#set-me-up)!
-
-If you have a question, comment, bug report, feature request, etc. please open a GitHub issue.
-
-## Feature List
-
-- Ginkgo uses Go's `testing` package and can live alongside your existing `testing` tests.  It's easy to [bootstrap](http://onsi.github.io/ginkgo/#bootstrapping-a-suite) and start writing your [first tests](http://onsi.github.io/ginkgo/#adding-specs-to-a-suite)
-
-- Structure your BDD-style tests expressively:
-    - Nestable [`Describe` and `Context` container blocks](http://onsi.github.io/ginkgo/#organizing-specs-with-containers-describe-and-context)
-    - [`BeforeEach` and `AfterEach` blocks](http://onsi.github.io/ginkgo/#extracting-common-setup-beforeeach) for setup and teardown
-    - [`It` blocks](http://onsi.github.io/ginkgo/#individual-specs-) that hold your assertions
-    - [`JustBeforeEach` blocks](http://onsi.github.io/ginkgo/#separating-creation-and-configuration-justbeforeeach) that separate creation from configuration (also known as the subject action pattern).
-    - [`BeforeSuite` and `AfterSuite` blocks](http://onsi.github.io/ginkgo/#global-setup-and-teardown-beforesuite-and-aftersuite) to prep for and cleanup after a suite.
-
-- A comprehensive test runner that lets you:
-    - Mark specs as [pending](http://onsi.github.io/ginkgo/#pending-specs)
-    - [Focus](http://onsi.github.io/ginkgo/#focused-specs) individual specs, and groups of specs, either programmatically or on the command line
-    - Run your tests in [random order](http://onsi.github.io/ginkgo/#spec-permutation), and then reuse random seeds to replicate the same order.
-    - Break up your test suite into parallel processes for straightforward [test parallelization](http://onsi.github.io/ginkgo/#parallel-specs)
-
-- `ginkgo`: a command line interface with plenty of handy command line arguments for [running your tests](http://onsi.github.io/ginkgo/#running-tests) and [generating](http://onsi.github.io/ginkgo/#generators) test files.  Here are a few choice examples:
-    - `ginkgo -nodes=N` runs your tests in `N` parallel processes and print out coherent output in realtime
-    - `ginkgo -cover` runs your tests using Golang's code coverage tool
-    - `ginkgo convert` converts an XUnit-style `testing` package to a Ginkgo-style package
-    - `ginkgo -focus="REGEXP"` and `ginkgo -skip="REGEXP"` allow you to specify a subset of tests to run via regular expression
-    - `ginkgo -r` runs all tests suites under the current directory
-    - `ginkgo -v` prints out identifying information for each tests just before it runs
-
-    And much more: run `ginkgo help` for details!
-
-    The `ginkgo` CLI is convenient, but purely optional -- Ginkgo works just fine with `go test`
-
-- `ginkgo watch` [watches](https://onsi.github.io/ginkgo/#watching-for-changes) packages *and their dependencies* for changes, then reruns tests.  Run tests immediately as you develop!
-
-- Built-in support for testing [asynchronicity](http://onsi.github.io/ginkgo/#asynchronous-tests)
-
-- Built-in support for [benchmarking](http://onsi.github.io/ginkgo/#benchmark-tests) your code.  Control the number of benchmark samples as you gather runtimes and other, arbitrary, bits of numerical information about your code. 
-
-- [Completions for Sublime Text](https://github.com/onsi/ginkgo-sublime-completions): just use [Package Control](https://sublime.wbond.net/) to install `Ginkgo Completions`.
-
-- [Completions for VSCode](https://github.com/onsi/vscode-ginkgo): just use VSCode's extension installer to install `vscode-ginkgo`.
-
-- Straightforward support for third-party testing libraries such as [Gomock](https://code.google.com/p/gomock/) and [Testify](https://github.com/stretchr/testify).  Check out the [docs](http://onsi.github.io/ginkgo/#third-party-integrations) for details.
-
-- A modular architecture that lets you easily:
-    - Write [custom reporters](http://onsi.github.io/ginkgo/#writing-custom-reporters) (for example, Ginkgo comes with a [JUnit XML reporter](http://onsi.github.io/ginkgo/#generating-junit-xml-output) and a TeamCity reporter).
-    - [Adapt an existing matcher library (or write your own!)](http://onsi.github.io/ginkgo/#using-other-matcher-libraries) to work with Ginkgo
-
-## [Gomega](http://github.com/onsi/gomega): Ginkgo's Preferred Matcher Library
-
-Ginkgo is best paired with Gomega.  Learn more about Gomega [here](http://onsi.github.io/gomega/)
-
-## [Agouti](http://github.com/sclevine/agouti): A Golang Acceptance Testing Framework
-
-Agouti allows you run WebDriver integration tests.  Learn more about Agouti [here](http://agouti.org)
-
-## Set Me Up!
-
-You'll need Golang v1.3+ (Ubuntu users: you probably have Golang v1.0 -- you'll need to upgrade!)
-
-```bash
-
-go get github.com/onsi/ginkgo/ginkgo  # installs the ginkgo CLI
-go get github.com/onsi/gomega         # fetches the matcher library
-
-cd path/to/package/you/want/to/test
-
-ginkgo bootstrap # set up a new ginkgo suite
-ginkgo generate  # will create a sample test file.  edit this file and add your tests then...
-
-go test # to run your tests
-
-ginkgo  # also runs your tests
-
-```
-
-## I'm new to Go: What are my testing options?
-
-Of course, I heartily recommend [Ginkgo](https://github.com/onsi/ginkgo) and [Gomega](https://github.com/onsi/gomega).  Both packages are seeing heavy, daily, production use on a number of projects and boast a mature and comprehensive feature-set.
-
-With that said, it's great to know what your options are :)
-
-### What Golang gives you out of the box
-
-Testing is a first class citizen in Golang, however Go's built-in testing primitives are somewhat limited: The [testing](http://golang.org/pkg/testing) package provides basic XUnit style tests and no assertion library.
-
-### Matcher libraries for Golang's XUnit style tests
-
-A number of matcher libraries have been written to augment Go's built-in XUnit style tests.  Here are two that have gained traction:
-
-- [testify](https://github.com/stretchr/testify)
-- [gocheck](http://labix.org/gocheck)
-
-You can also use Ginkgo's matcher library [Gomega](https://github.com/onsi/gomega) in [XUnit style tests](http://onsi.github.io/gomega/#using-gomega-with-golangs-xunitstyle-tests)
-
-### BDD style testing frameworks
-
-There are a handful of BDD-style testing frameworks written for Golang.  Here are a few:
-
-- [Ginkgo](https://github.com/onsi/ginkgo) ;)
-- [GoConvey](https://github.com/smartystreets/goconvey) 
-- [Goblin](https://github.com/franela/goblin)
-- [Mao](https://github.com/azer/mao)
-- [Zen](https://github.com/pranavraja/zen)
-
-Finally, @shageman has [put together](https://github.com/shageman/gotestit) a comprehensive comparison of golang testing libraries.
-
-Go explore!
-
-## License
-
-Ginkgo is MIT-Licensed

vendor/github.com/onsi/ginkgo/config/config.go

@@ -1,187 +0,0 @@
-/*
-Ginkgo accepts a number of configuration options.
-
-These are documented [here](http://onsi.github.io/ginkgo/#the_ginkgo_cli)
-
-You can also learn more via
-
-	ginkgo help
-
-or (I kid you not):
-
-	go test -asdf
-*/
-package config
-
-import (
-	"flag"
-	"time"
-
-	"fmt"
-)
-
-const VERSION = "1.4.0"
-
-type GinkgoConfigType struct {
-	RandomSeed         int64
-	RandomizeAllSpecs  bool
-	RegexScansFilePath bool
-	FocusString        string
-	SkipString         string
-	SkipMeasurements   bool
-	FailOnPending      bool
-	FailFast           bool
-	FlakeAttempts      int
-	EmitSpecProgress   bool
-	DryRun             bool
-
-	ParallelNode  int
-	ParallelTotal int
-	SyncHost      string
-	StreamHost    string
-}
-
-var GinkgoConfig = GinkgoConfigType{}
-
-type DefaultReporterConfigType struct {
-	NoColor           bool
-	SlowSpecThreshold float64
-	NoisyPendings     bool
-	Succinct          bool
-	Verbose           bool
-	FullTrace         bool
-}
-
-var DefaultReporterConfig = DefaultReporterConfigType{}
-
-func processPrefix(prefix string) string {
-	if prefix != "" {
-		prefix = prefix + "."
-	}
-	return prefix
-}
-
-func Flags(flagSet *flag.FlagSet, prefix string, includeParallelFlags bool) {
-	prefix = processPrefix(prefix)
-	flagSet.Int64Var(&(GinkgoConfig.RandomSeed), prefix+"seed", time.Now().Unix(), "The seed used to randomize the spec suite.")
-	flagSet.BoolVar(&(GinkgoConfig.RandomizeAllSpecs), prefix+"randomizeAllSpecs", false, "If set, ginkgo will randomize all specs together.  By default, ginkgo only randomizes the top level Describe/Context groups.")
-	flagSet.BoolVar(&(GinkgoConfig.SkipMeasurements), prefix+"skipMeasurements", false, "If set, ginkgo will skip any measurement specs.")
-	flagSet.BoolVar(&(GinkgoConfig.FailOnPending), prefix+"failOnPending", false, "If set, ginkgo will mark the test suite as failed if any specs are pending.")
-	flagSet.BoolVar(&(GinkgoConfig.FailFast), prefix+"failFast", false, "If set, ginkgo will stop running a test suite after a failure occurs.")
-
-	flagSet.BoolVar(&(GinkgoConfig.DryRun), prefix+"dryRun", false, "If set, ginkgo will walk the test hierarchy without actually running anything.  Best paired with -v.")
-
-	flagSet.StringVar(&(GinkgoConfig.FocusString), prefix+"focus", "", "If set, ginkgo will only run specs that match this regular expression.")
-	flagSet.StringVar(&(GinkgoConfig.SkipString), prefix+"skip", "", "If set, ginkgo will only run specs that do not match this regular expression.")
-
-	flagSet.BoolVar(&(GinkgoConfig.RegexScansFilePath), prefix+"regexScansFilePath", false, "If set, ginkgo regex matching also will look at the file path (code location).")
-
-	flagSet.IntVar(&(GinkgoConfig.FlakeAttempts), prefix+"flakeAttempts", 1, "Make up to this many attempts to run each spec. Please note that if any of the attempts succeed, the suite will not be failed. But any failures will still be recorded.")
-
-	flagSet.BoolVar(&(GinkgoConfig.EmitSpecProgress), prefix+"progress", false, "If set, ginkgo will emit progress information as each spec runs to the GinkgoWriter.")
-
-	if includeParallelFlags {
-		flagSet.IntVar(&(GinkgoConfig.ParallelNode), prefix+"parallel.node", 1, "This worker node's (one-indexed) node number.  For running specs in parallel.")
-		flagSet.IntVar(&(GinkgoConfig.ParallelTotal), prefix+"parallel.total", 1, "The total number of worker nodes.  For running specs in parallel.")
-		flagSet.StringVar(&(GinkgoConfig.SyncHost), prefix+"parallel.synchost", "", "The address for the server that will synchronize the running nodes.")
-		flagSet.StringVar(&(GinkgoConfig.StreamHost), prefix+"parallel.streamhost", "", "The address for the server that the running nodes should stream data to.")
-	}
-
-	flagSet.BoolVar(&(DefaultReporterConfig.NoColor), prefix+"noColor", false, "If set, suppress color output in default reporter.")
-	flagSet.Float64Var(&(DefaultReporterConfig.SlowSpecThreshold), prefix+"slowSpecThreshold", 5.0, "(in seconds) Specs that take longer to run than this threshold are flagged as slow by the default reporter.")
-	flagSet.BoolVar(&(DefaultReporterConfig.NoisyPendings), prefix+"noisyPendings", true, "If set, default reporter will shout about pending tests.")
-	flagSet.BoolVar(&(DefaultReporterConfig.Verbose), prefix+"v", false, "If set, default reporter print out all specs as they begin.")
-	flagSet.BoolVar(&(DefaultReporterConfig.Succinct), prefix+"succinct", false, "If set, default reporter prints out a very succinct report")
-	flagSet.BoolVar(&(DefaultReporterConfig.FullTrace), prefix+"trace", false, "If set, default reporter prints out the full stack trace when a failure occurs")
-}
-
-func BuildFlagArgs(prefix string, ginkgo GinkgoConfigType, reporter DefaultReporterConfigType) []string {
-	prefix = processPrefix(prefix)
-	result := make([]string, 0)
-
-	if ginkgo.RandomSeed > 0 {
-		result = append(result, fmt.Sprintf("--%sseed=%d", prefix, ginkgo.RandomSeed))
-	}
-
-	if ginkgo.RandomizeAllSpecs {
-		result = append(result, fmt.Sprintf("--%srandomizeAllSpecs", prefix))
-	}
-
-	if ginkgo.SkipMeasurements {
-		result = append(result, fmt.Sprintf("--%sskipMeasurements", prefix))
-	}
-
-	if ginkgo.FailOnPending {
-		result = append(result, fmt.Sprintf("--%sfailOnPending", prefix))
-	}
-
-	if ginkgo.FailFast {
-		result = append(result, fmt.Sprintf("--%sfailFast", prefix))
-	}
-
-	if ginkgo.DryRun {
-		result = append(result, fmt.Sprintf("--%sdryRun", prefix))
-	}
-
-	if ginkgo.FocusString != "" {
-		result = append(result, fmt.Sprintf("--%sfocus=%s", prefix, ginkgo.FocusString))
-	}
-
-	if ginkgo.SkipString != "" {
-		result = append(result, fmt.Sprintf("--%sskip=%s", prefix, ginkgo.SkipString))
-	}
-
-	if ginkgo.FlakeAttempts > 1 {
-		result = append(result, fmt.Sprintf("--%sflakeAttempts=%d", prefix, ginkgo.FlakeAttempts))
-	}
-
-	if ginkgo.EmitSpecProgress {
-		result = append(result, fmt.Sprintf("--%sprogress", prefix))
-	}
-
-	if ginkgo.ParallelNode != 0 {
-		result = append(result, fmt.Sprintf("--%sparallel.node=%d", prefix, ginkgo.ParallelNode))
-	}
-
-	if ginkgo.ParallelTotal != 0 {
-		result = append(result, fmt.Sprintf("--%sparallel.total=%d", prefix, ginkgo.ParallelTotal))
-	}
-
-	if ginkgo.StreamHost != "" {
-		result = append(result, fmt.Sprintf("--%sparallel.streamhost=%s", prefix, ginkgo.StreamHost))
-	}
-
-	if ginkgo.SyncHost != "" {
-		result = append(result, fmt.Sprintf("--%sparallel.synchost=%s", prefix, ginkgo.SyncHost))
-	}
-
-	if ginkgo.RegexScansFilePath {
-		result = append(result, fmt.Sprintf("--%sregexScansFilePath", prefix))
-	}
-
-	if reporter.NoColor {
-		result = append(result, fmt.Sprintf("--%snoColor", prefix))
-	}
-
-	if reporter.SlowSpecThreshold > 0 {
-		result = append(result, fmt.Sprintf("--%sslowSpecThreshold=%.5f", prefix, reporter.SlowSpecThreshold))
-	}
-
-	if !reporter.NoisyPendings {
-		result = append(result, fmt.Sprintf("--%snoisyPendings=false", prefix))
-	}
-
-	if reporter.Verbose {
-		result = append(result, fmt.Sprintf("--%sv", prefix))
-	}
-
-	if reporter.Succinct {
-		result = append(result, fmt.Sprintf("--%ssuccinct", prefix))
-	}
-
-	if reporter.FullTrace {
-		result = append(result, fmt.Sprintf("--%strace", prefix))
-	}
-
-	return result
-}

vendor/github.com/onsi/ginkgo/extensions/table/table.go

@@ -1,98 +0,0 @@
-/*
-
-Table provides a simple DSL for Ginkgo-native Table-Driven Tests
-
-The godoc documentation describes Table's API.  More comprehensive documentation (with examples!) is available at http://onsi.github.io/ginkgo#table-driven-tests
-
-*/
-
-package table
-
-import (
-	"fmt"
-	"reflect"
-
-	"github.com/onsi/ginkgo"
-)
-
-/*
-DescribeTable describes a table-driven test.
-
-For example:
-
-    DescribeTable("a simple table",
-        func(x int, y int, expected bool) {
-            Ω(x > y).Should(Equal(expected))
-        },
-        Entry("x > y", 1, 0, true),
-        Entry("x == y", 0, 0, false),
-        Entry("x < y", 0, 1, false),
-    )
-
-The first argument to `DescribeTable` is a string description.
-The second argument is a function that will be run for each table entry.  Your assertions go here - the function is equivalent to a Ginkgo It.
-The subsequent arguments must be of type `TableEntry`.  We recommend using the `Entry` convenience constructors.
-
-The `Entry` constructor takes a string description followed by an arbitrary set of parameters.  These parameters are passed into your function.
-
-Under the hood, `DescribeTable` simply generates a new Ginkgo `Describe`.  Each `Entry` is turned into an `It` within the `Describe`.
-
-It's important to understand that the `Describe`s and `It`s are generated at evaluation time (i.e. when Ginkgo constructs the tree of tests and before the tests run).
-
-Individual Entries can be focused (with FEntry) or marked pending (with PEntry or XEntry).  In addition, the entire table can be focused or marked pending with FDescribeTable and PDescribeTable/XDescribeTable.
-*/
-func DescribeTable(description string, itBody interface{}, entries ...TableEntry) bool {
-	describeTable(description, itBody, entries, false, false)
-	return true
-}
-
-/*
-You can focus a table with `FDescribeTable`.  This is equivalent to `FDescribe`.
-*/
-func FDescribeTable(description string, itBody interface{}, entries ...TableEntry) bool {
-	describeTable(description, itBody, entries, false, true)
-	return true
-}
-
-/*
-You can mark a table as pending with `PDescribeTable`.  This is equivalent to `PDescribe`.
-*/
-func PDescribeTable(description string, itBody interface{}, entries ...TableEntry) bool {
-	describeTable(description, itBody, entries, true, false)
-	return true
-}
-
-/*
-You can mark a table as pending with `XDescribeTable`.  This is equivalent to `XDescribe`.
-*/
-func XDescribeTable(description string, itBody interface{}, entries ...TableEntry) bool {
-	describeTable(description, itBody, entries, true, false)
-	return true
-}
-
-func describeTable(description string, itBody interface{}, entries []TableEntry, pending bool, focused bool) {
-	itBodyValue := reflect.ValueOf(itBody)
-	if itBodyValue.Kind() != reflect.Func {
-		panic(fmt.Sprintf("DescribeTable expects a function, got %#v", itBody))
-	}
-
-	if pending {
-		ginkgo.PDescribe(description, func() {
-			for _, entry := range entries {
-				entry.generateIt(itBodyValue)
-			}
-		})
-	} else if focused {
-		ginkgo.FDescribe(description, func() {
-			for _, entry := range entries {
-				entry.generateIt(itBodyValue)
-			}
-		})
-	} else {
-		ginkgo.Describe(description, func() {
-			for _, entry := range entries {
-				entry.generateIt(itBodyValue)
-			}
-		})
-	}
-}

vendor/github.com/onsi/ginkgo/extensions/table/table_entry.go

@@ -1,81 +0,0 @@
-package table
-
-import (
-	"reflect"
-
-	"github.com/onsi/ginkgo"
-)
-
-/*
-TableEntry represents an entry in a table test.  You generally use the `Entry` constructor.
-*/
-type TableEntry struct {
-	Description string
-	Parameters  []interface{}
-	Pending     bool
-	Focused     bool
-}
-
-func (t TableEntry) generateIt(itBody reflect.Value) {
-	if t.Pending {
-		ginkgo.PIt(t.Description)
-		return
-	}
-
-	values := []reflect.Value{}
-	for i, param := range t.Parameters {
-		var value reflect.Value
-
-		if param == nil {
-			inType := itBody.Type().In(i)
-			value = reflect.Zero(inType)
-		} else {
-			value = reflect.ValueOf(param)
-		}
-
-		values = append(values, value)
-	}
-
-	body := func() {
-		itBody.Call(values)
-	}
-
-	if t.Focused {
-		ginkgo.FIt(t.Description, body)
-	} else {
-		ginkgo.It(t.Description, body)
-	}
-}
-
-/*
-Entry constructs a TableEntry.
-
-The first argument is a required description (this becomes the content of the generated Ginkgo `It`).
-Subsequent parameters are saved off and sent to the callback passed in to `DescribeTable`.
-
-Each Entry ends up generating an individual Ginkgo It.
-*/
-func Entry(description string, parameters ...interface{}) TableEntry {
-	return TableEntry{description, parameters, false, false}
-}
-
-/*
-You can focus a particular entry with FEntry.  This is equivalent to FIt.
-*/
-func FEntry(description string, parameters ...interface{}) TableEntry {
-	return TableEntry{description, parameters, false, true}
-}
-
-/*
-You can mark a particular entry as pending with PEntry.  This is equivalent to PIt.
-*/
-func PEntry(description string, parameters ...interface{}) TableEntry {
-	return TableEntry{description, parameters, true, false}
-}
-
-/*
-You can mark a particular entry as pending with XEntry.  This is equivalent to XIt.
-*/
-func XEntry(description string, parameters ...interface{}) TableEntry {
-	return TableEntry{description, parameters, true, false}
-}

vendor/github.com/onsi/ginkgo/extensions/table/table_suite_test.go

@@ -1,13 +0,0 @@
-package table_test
-
-import (
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-
-	"testing"
-)
-
-func TestTable(t *testing.T) {
-	RegisterFailHandler(Fail)
-	RunSpecs(t, "Table Suite")
-}

vendor/github.com/onsi/ginkgo/extensions/table/table_test.go

@@ -1,64 +0,0 @@
-package table_test
-
-import (
-	"strings"
-
-	. "github.com/onsi/ginkgo/extensions/table"
-
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-)
-
-var _ = Describe("Table", func() {
-	DescribeTable("a simple table",
-		func(x int, y int, expected bool) {
-			Ω(x > y).Should(Equal(expected))
-		},
-		Entry("x > y", 1, 0, true),
-		Entry("x == y", 0, 0, false),
-		Entry("x < y", 0, 1, false),
-	)
-
-	type ComplicatedThings struct {
-		Superstructure string
-		Substructure   string
-		Count          int
-	}
-
-	DescribeTable("a more complicated table",
-		func(c ComplicatedThings) {
-			Ω(strings.Count(c.Superstructure, c.Substructure)).Should(BeNumerically("==", c.Count))
-		},
-		Entry("with no matching substructures", ComplicatedThings{
-			Superstructure: "the sixth sheikh's sixth sheep's sick",
-			Substructure:   "emir",
-			Count:          0,
-		}),
-		Entry("with one matching substructure", ComplicatedThings{
-			Superstructure: "the sixth sheikh's sixth sheep's sick",
-			Substructure:   "sheep",
-			Count:          1,
-		}),
-		Entry("with many matching substructures", ComplicatedThings{
-			Superstructure: "the sixth sheikh's sixth sheep's sick",
-			Substructure:   "si",
-			Count:          3,
-		}),
-	)
-
-	PDescribeTable("a failure",
-		func(value bool) {
-			Ω(value).Should(BeFalse())
-		},
-		Entry("when true", true),
-		Entry("when false", false),
-		Entry("when malformed", 2),
-	)
-
-	DescribeTable("an untyped nil as an entry",
-		func(x interface{}) {
-			Expect(x).To(BeNil())
-		},
-		Entry("nil", nil),
-	)
-})

vendor/github.com/onsi/ginkgo/ginkgo/bootstrap_command.go

@@ -1,202 +0,0 @@
-package main
-
-import (
-	"bytes"
-	"flag"
-	"fmt"
-	"io/ioutil"
-	"os"
-	"path/filepath"
-	"strings"
-	"text/template"
-
-	"go/build"
-
-	"github.com/onsi/ginkgo/ginkgo/nodot"
-)
-
-func BuildBootstrapCommand() *Command {
-	var (
-		agouti, noDot, internal bool
-		customBootstrapFile     string
-	)
-	flagSet := flag.NewFlagSet("bootstrap", flag.ExitOnError)
-	flagSet.BoolVar(&agouti, "agouti", false, "If set, bootstrap will generate a bootstrap file for writing Agouti tests")
-	flagSet.BoolVar(&noDot, "nodot", false, "If set, bootstrap will generate a bootstrap file that does not . import ginkgo and gomega")
-	flagSet.BoolVar(&internal, "internal", false, "If set, generate will generate a test file that uses the regular package name")
-	flagSet.StringVar(&customBootstrapFile, "template", "", "If specified, generate will use the contents of the file passed as the bootstrap template")
-
-	return &Command{
-		Name:         "bootstrap",
-		FlagSet:      flagSet,
-		UsageCommand: "ginkgo bootstrap <FLAGS>",
-		Usage: []string{
-			"Bootstrap a test suite for the current package",
-			"Accepts the following flags:",
-		},
-		Command: func(args []string, additionalArgs []string) {
-			generateBootstrap(agouti, noDot, internal, customBootstrapFile)
-		},
-	}
-}
-
-var bootstrapText = `package {{.Package}}
-
-import (
-	{{.GinkgoImport}}
-	{{.GomegaImport}}
-
-	"testing"
-)
-
-func Test{{.FormattedName}}(t *testing.T) {
-	RegisterFailHandler(Fail)
-	RunSpecs(t, "{{.FormattedName}} Suite")
-}
-`
-
-var agoutiBootstrapText = `package {{.Package}}
-
-import (
-	{{.GinkgoImport}}
-	{{.GomegaImport}}
-	"github.com/sclevine/agouti"
-
-	"testing"
-)
-
-func Test{{.FormattedName}}(t *testing.T) {
-	RegisterFailHandler(Fail)
-	RunSpecs(t, "{{.FormattedName}} Suite")
-}
-
-var agoutiDriver *agouti.WebDriver
-
-var _ = BeforeSuite(func() {
-	// Choose a WebDriver:
-
-	agoutiDriver = agouti.PhantomJS()
-	// agoutiDriver = agouti.Selenium()
-	// agoutiDriver = agouti.ChromeDriver()
-
-	Expect(agoutiDriver.Start()).To(Succeed())
-})
-
-var _ = AfterSuite(func() {
-	Expect(agoutiDriver.Stop()).To(Succeed())
-})
-`
-
-type bootstrapData struct {
-	Package       string
-	FormattedName string
-	GinkgoImport  string
-	GomegaImport  string
-}
-
-func getPackageAndFormattedName() (string, string, string) {
-	path, err := os.Getwd()
-	if err != nil {
-		complainAndQuit("Could not get current working directory: \n" + err.Error())
-	}
-
-	dirName := strings.Replace(filepath.Base(path), "-", "_", -1)
-	dirName = strings.Replace(dirName, " ", "_", -1)
-
-	pkg, err := build.ImportDir(path, 0)
-	packageName := pkg.Name
-	if err != nil {
-		packageName = dirName
-	}
-
-	formattedName := prettifyPackageName(filepath.Base(path))
-	return packageName, dirName, formattedName
-}
-
-func prettifyPackageName(name string) string {
-	name = strings.Replace(name, "-", " ", -1)
-	name = strings.Replace(name, "_", " ", -1)
-	name = strings.Title(name)
-	name = strings.Replace(name, " ", "", -1)
-	return name
-}
-
-func determinePackageName(name string, internal bool) string {
-	if internal {
-		return name
-	}
-
-	return name + "_test"
-}
-
-func fileExists(path string) bool {
-	_, err := os.Stat(path)
-	if err == nil {
-		return true
-	}
-	return false
-}
-
-func generateBootstrap(agouti, noDot, internal bool, customBootstrapFile string) {
-	packageName, bootstrapFilePrefix, formattedName := getPackageAndFormattedName()
-	data := bootstrapData{
-		Package:       determinePackageName(packageName, internal),
-		FormattedName: formattedName,
-		GinkgoImport:  `. "github.com/onsi/ginkgo"`,
-		GomegaImport:  `. "github.com/onsi/gomega"`,
-	}
-
-	if noDot {
-		data.GinkgoImport = `"github.com/onsi/ginkgo"`
-		data.GomegaImport = `"github.com/onsi/gomega"`
-	}
-
-	targetFile := fmt.Sprintf("%s_suite_test.go", bootstrapFilePrefix)
-	if fileExists(targetFile) {
-		fmt.Printf("%s already exists.\n\n", targetFile)
-		os.Exit(1)
-	} else {
-		fmt.Printf("Generating ginkgo test suite bootstrap for %s in:\n\t%s\n", packageName, targetFile)
-	}
-
-	f, err := os.Create(targetFile)
-	if err != nil {
-		complainAndQuit("Could not create file: " + err.Error())
-		panic(err.Error())
-	}
-	defer f.Close()
-
-	var templateText string
-	if customBootstrapFile != "" {
-		tpl, err := ioutil.ReadFile(customBootstrapFile)
-		if err != nil {
-			panic(err.Error())
-		}
-		templateText = string(tpl)
-	} else if agouti {
-		templateText = agoutiBootstrapText
-	} else {
-		templateText = bootstrapText
-	}
-
-	bootstrapTemplate, err := template.New("bootstrap").Parse(templateText)
-	if err != nil {
-		panic(err.Error())
-	}
-
-	buf := &bytes.Buffer{}
-	bootstrapTemplate.Execute(buf, data)
-
-	if noDot {
-		contents, err := nodot.ApplyNoDot(buf.Bytes())
-		if err != nil {
-			complainAndQuit("Failed to import nodot declarations: " + err.Error())
-		}
-		fmt.Println("To update the nodot declarations in the future, switch to this directory and run:\n\tginkgo nodot")
-		buf = bytes.NewBuffer(contents)
-	}
-
-	buf.WriteTo(f)
-
-	goFmt(targetFile)
-}

vendor/github.com/onsi/ginkgo/ginkgo/build_command.go

@@ -1,68 +0,0 @@
-package main
-
-import (
-	"flag"
-	"fmt"
-	"os"
-	"path/filepath"
-
-	"github.com/onsi/ginkgo/ginkgo/interrupthandler"
-	"github.com/onsi/ginkgo/ginkgo/testrunner"
-)
-
-func BuildBuildCommand() *Command {
-	commandFlags := NewBuildCommandFlags(flag.NewFlagSet("build", flag.ExitOnError))
-	interruptHandler := interrupthandler.NewInterruptHandler()
-	builder := &SpecBuilder{
-		commandFlags:     commandFlags,
-		interruptHandler: interruptHandler,
-	}
-
-	return &Command{
-		Name:         "build",
-		FlagSet:      commandFlags.FlagSet,
-		UsageCommand: "ginkgo build <FLAGS> <PACKAGES>",
-		Usage: []string{
-			"Build the passed in <PACKAGES> (or the package in the current directory if left blank).",
-			"Accepts the following flags:",
-		},
-		Command: builder.BuildSpecs,
-	}
-}
-
-type SpecBuilder struct {
-	commandFlags     *RunWatchAndBuildCommandFlags
-	interruptHandler *interrupthandler.InterruptHandler
-}
-
-func (r *SpecBuilder) BuildSpecs(args []string, additionalArgs []string) {
-	r.commandFlags.computeNodes()
-
-	suites, _ := findSuites(args, r.commandFlags.Recurse, r.commandFlags.SkipPackage, false)
-
-	if len(suites) == 0 {
-		complainAndQuit("Found no test suites")
-	}
-
-	passed := true
-	for _, suite := range suites {
-		runner := testrunner.New(suite, 1, false, 0, r.commandFlags.GoOpts, nil)
-		fmt.Printf("Compiling %s...\n", suite.PackageName)
-
-		path, _ := filepath.Abs(filepath.Join(suite.Path, fmt.Sprintf("%s.test", suite.PackageName)))
-		err := runner.CompileTo(path)
-		if err != nil {
-			fmt.Println(err.Error())
-			passed = false
-		} else {
-			fmt.Printf("    compiled %s.test\n", suite.PackageName)
-		}
-
-		runner.CleanUp()
-	}
-
-	if passed {
-		os.Exit(0)
-	}
-	os.Exit(1)
-}

vendor/github.com/onsi/ginkgo/ginkgo/convert/ginkgo_ast_nodes.go

@@ -1,123 +0,0 @@
-package convert
-
-import (
-	"fmt"
-	"go/ast"
-	"strings"
-	"unicode"
-)
-
-/*
- * Creates a func init() node
- */
-func createVarUnderscoreBlock() *ast.ValueSpec {
-	valueSpec := &ast.ValueSpec{}
-	object := &ast.Object{Kind: 4, Name: "_", Decl: valueSpec, Data: 0}
-	ident := &ast.Ident{Name: "_", Obj: object}
-	valueSpec.Names = append(valueSpec.Names, ident)
-	return valueSpec
-}
-
-/*
- * Creates a Describe("Testing with ginkgo", func() { }) node
- */
-func createDescribeBlock() *ast.CallExpr {
-	blockStatement := &ast.BlockStmt{List: []ast.Stmt{}}
-
-	fieldList := &ast.FieldList{}
-	funcType := &ast.FuncType{Params: fieldList}
-	funcLit := &ast.FuncLit{Type: funcType, Body: blockStatement}
-	basicLit := &ast.BasicLit{Kind: 9, Value: "\"Testing with Ginkgo\""}
-	describeIdent := &ast.Ident{Name: "Describe"}
-	return &ast.CallExpr{Fun: describeIdent, Args: []ast.Expr{basicLit, funcLit}}
-}
-
-/*
- * Convenience function to return the name of the *testing.T param
- * for a Test function that will be rewritten. This is useful because
- * we will want to replace the usage of this named *testing.T inside the
- * body of the function with a GinktoT.
- */
-func namedTestingTArg(node *ast.FuncDecl) string {
-	return node.Type.Params.List[0].Names[0].Name // *exhale*
-}
-
-/*
- * Convenience function to return the block statement node for a Describe statement
- */
-func blockStatementFromDescribe(desc *ast.CallExpr) *ast.BlockStmt {
-	var funcLit *ast.FuncLit
-	var found = false
-
-	for _, node := range desc.Args {
-		switch node := node.(type) {
-		case *ast.FuncLit:
-			found = true
-			funcLit = node
-			break
-		}
-	}
-
-	if !found {
-		panic("Error finding ast.FuncLit inside describe statement. Somebody done goofed.")
-	}
-
-	return funcLit.Body
-}
-
-/* convenience function for creating an It("TestNameHere")
- * with all the body of the test function inside the anonymous
- * func passed to It()
- */
-func createItStatementForTestFunc(testFunc *ast.FuncDecl) *ast.ExprStmt {
-	blockStatement := &ast.BlockStmt{List: testFunc.Body.List}
-	fieldList := &ast.FieldList{}
-	funcType := &ast.FuncType{Params: fieldList}
-	funcLit := &ast.FuncLit{Type: funcType, Body: blockStatement}
-
-	testName := rewriteTestName(testFunc.Name.Name)
-	basicLit := &ast.BasicLit{Kind: 9, Value: fmt.Sprintf("\"%s\"", testName)}
-	itBlockIdent := &ast.Ident{Name: "It"}
-	callExpr := &ast.CallExpr{Fun: itBlockIdent, Args: []ast.Expr{basicLit, funcLit}}
-	return &ast.ExprStmt{X: callExpr}
-}
-
-/*
-* rewrite test names to be human readable
-* eg: rewrites "TestSomethingAmazing" as "something amazing"
- */
-func rewriteTestName(testName string) string {
-	nameComponents := []string{}
-	currentString := ""
-	indexOfTest := strings.Index(testName, "Test")
-	if indexOfTest != 0 {
-		return testName
-	}
-
-	testName = strings.Replace(testName, "Test", "", 1)
-	first, rest := testName[0], testName[1:]
-	testName = string(unicode.ToLower(rune(first))) + rest
-
-	for _, rune := range testName {
-		if unicode.IsUpper(rune) {
-			nameComponents = append(nameComponents, currentString)
-			currentString = string(unicode.ToLower(rune))
-		} else {
-			currentString += string(rune)
-		}
-	}
-
-	return strings.Join(append(nameComponents, currentString), " ")
-}
-
-func newGinkgoTFromIdent(ident *ast.Ident) *ast.CallExpr {
-	return &ast.CallExpr{
-		Lparen: ident.NamePos + 1,
-		Rparen: ident.NamePos + 2,
-		Fun:    &ast.Ident{Name: "GinkgoT"},
-	}
-}
-
-func newGinkgoTInterface() *ast.Ident {
-	return &ast.Ident{Name: "GinkgoTInterface"}
-}

vendor/github.com/onsi/ginkgo/ginkgo/convert/import.go

@@ -1,91 +0,0 @@
-package convert
-
-import (
-	"errors"
-	"fmt"
-	"go/ast"
-)
-
-/*
- * Given the root node of an AST, returns the node containing the
- * import statements for the file.
- */
-func importsForRootNode(rootNode *ast.File) (imports *ast.GenDecl, err error) {
-	for _, declaration := range rootNode.Decls {
-		decl, ok := declaration.(*ast.GenDecl)
-		if !ok || len(decl.Specs) == 0 {
-			continue
-		}
-
-		_, ok = decl.Specs[0].(*ast.ImportSpec)
-		if ok {
-			imports = decl
-			return
-		}
-	}
-
-	err = errors.New(fmt.Sprintf("Could not find imports for root node:\n\t%#v\n", rootNode))
-	return
-}
-
-/*
- * Removes "testing" import, if present
- */
-func removeTestingImport(rootNode *ast.File) {
-	importDecl, err := importsForRootNode(rootNode)
-	if err != nil {
-		panic(err.Error())
-	}
-
-	var index int
-	for i, importSpec := range importDecl.Specs {
-		importSpec := importSpec.(*ast.ImportSpec)
-		if importSpec.Path.Value == "\"testing\"" {
-			index = i
-			break
-		}
-	}
-
-	importDecl.Specs = append(importDecl.Specs[:index], importDecl.Specs[index+1:]...)
-}
-
-/*
- * Adds import statements for onsi/ginkgo, if missing
- */
-func addGinkgoImports(rootNode *ast.File) {
-	importDecl, err := importsForRootNode(rootNode)
-	if err != nil {
-		panic(err.Error())
-	}
-
-	if len(importDecl.Specs) == 0 {
-		// TODO: might need to create a import decl here
-		panic("unimplemented : expected to find an imports block")
-	}
-
-	needsGinkgo := true
-	for _, importSpec := range importDecl.Specs {
-		importSpec, ok := importSpec.(*ast.ImportSpec)
-		if !ok {
-			continue
-		}
-
-		if importSpec.Path.Value == "\"github.com/onsi/ginkgo\"" {
-			needsGinkgo = false
-		}
-	}
-
-	if needsGinkgo {
-		importDecl.Specs = append(importDecl.Specs, createImport(".", "\"github.com/onsi/ginkgo\""))
-	}
-}
-
-/*
- * convenience function to create an import statement
- */
-func createImport(name, path string) *ast.ImportSpec {
-	return &ast.ImportSpec{
-		Name: &ast.Ident{Name: name},
-		Path: &ast.BasicLit{Kind: 9, Value: path},
-	}
-}

vendor/github.com/onsi/ginkgo/ginkgo/convert/package_rewriter.go

@@ -1,127 +0,0 @@
-package convert
-
-import (
-	"fmt"
-	"go/build"
-	"io/ioutil"
-	"os"
-	"os/exec"
-	"path/filepath"
-	"regexp"
-)
-
-/*
- * RewritePackage takes a name (eg: my-package/tools), finds its test files using
- * Go's build package, and then rewrites them. A ginkgo test suite file will
- * also be added for this package, and all of its child packages.
- */
-func RewritePackage(packageName string) {
-	pkg, err := packageWithName(packageName)
-	if err != nil {
-		panic(fmt.Sprintf("unexpected error reading package: '%s'\n%s\n", packageName, err.Error()))
-	}
-
-	for _, filename := range findTestsInPackage(pkg) {
-		rewriteTestsInFile(filename)
-	}
-	return
-}
-
-/*
- * Given a package, findTestsInPackage reads the test files in the directory,
- * and then recurses on each child package, returning a slice of all test files
- * found in this process.
- */
-func findTestsInPackage(pkg *build.Package) (testfiles []string) {
-	for _, file := range append(pkg.TestGoFiles, pkg.XTestGoFiles...) {
-		testfiles = append(testfiles, filepath.Join(pkg.Dir, file))
-	}
-
-	dirFiles, err := ioutil.ReadDir(pkg.Dir)
-	if err != nil {
-		panic(fmt.Sprintf("unexpected error reading dir: '%s'\n%s\n", pkg.Dir, err.Error()))
-	}
-
-	re := regexp.MustCompile(`^[._]`)
-
-	for _, file := range dirFiles {
-		if !file.IsDir() {
-			continue
-		}
-
-		if re.Match([]byte(file.Name())) {
-			continue
-		}
-
-		packageName := filepath.Join(pkg.ImportPath, file.Name())
-		subPackage, err := packageWithName(packageName)
-		if err != nil {
-			panic(fmt.Sprintf("unexpected error reading package: '%s'\n%s\n", packageName, err.Error()))
-		}
-
-		testfiles = append(testfiles, findTestsInPackage(subPackage)...)
-	}
-
-	addGinkgoSuiteForPackage(pkg)
-	goFmtPackage(pkg)
-	return
-}
-
-/*
- * Shells out to `ginkgo bootstrap` to create a test suite file
- */
-func addGinkgoSuiteForPackage(pkg *build.Package) {
-	originalDir, err := os.Getwd()
-	if err != nil {
-		panic(err)
-	}
-
-	suite_test_file := filepath.Join(pkg.Dir, pkg.Name+"_suite_test.go")
-
-	_, err = os.Stat(suite_test_file)
-	if err == nil {
-		return // test file already exists, this should be a no-op
-	}
-
-	err = os.Chdir(pkg.Dir)
-	if err != nil {
-		panic(err)
-	}
-
-	output, err := exec.Command("ginkgo", "bootstrap").Output()
-
-	if err != nil {
-		panic(fmt.Sprintf("error running 'ginkgo bootstrap'.\nstdout: %s\n%s\n", output, err.Error()))
-	}
-
-	err = os.Chdir(originalDir)
-	if err != nil {
-		panic(err)
-	}
-}
-
-/*
- * Shells out to `go fmt` to format the package
- */
-func goFmtPackage(pkg *build.Package) {
-	output, err := exec.Command("go", "fmt", pkg.ImportPath).Output()
-
-	if err != nil {
-		fmt.Printf("Warning: Error running 'go fmt %s'.\nstdout: %s\n%s\n", pkg.ImportPath, output, err.Error())
-	}
-}
-
-/*
- * Attempts to return a package with its test files already read.
- * The ImportMode arg to build.Import lets you specify if you want go to read the
- * buildable go files inside the package, but it fails if the package has no go files
- */
-func packageWithName(name string) (pkg *build.Package, err error) {
-	pkg, err = build.Default.Import(name, ".", build.ImportMode(0))
-	if err == nil {
-		return
-	}
-
-	pkg, err = build.Default.Import(name, ".", build.ImportMode(1))
-	return
-}

vendor/github.com/onsi/ginkgo/ginkgo/convert/test_finder.go

@@ -1,56 +0,0 @@
-package convert
-
-import (
-	"go/ast"
-	"regexp"
-)
-
-/*
- * Given a root node, walks its top level statements and returns
- * points to function nodes to rewrite as It statements.
- * These functions, according to Go testing convention, must be named
- * TestWithCamelCasedName and receive a single *testing.T argument.
- */
-func findTestFuncs(rootNode *ast.File) (testsToRewrite []*ast.FuncDecl) {
-	testNameRegexp := regexp.MustCompile("^Test[0-9A-Z].+")
-
-	ast.Inspect(rootNode, func(node ast.Node) bool {
-		if node == nil {
-			return false
-		}
-
-		switch node := node.(type) {
-		case *ast.FuncDecl:
-			matches := testNameRegexp.MatchString(node.Name.Name)
-
-			if matches && receivesTestingT(node) {
-				testsToRewrite = append(testsToRewrite, node)
-			}
-		}
-
-		return true
-	})
-
-	return
-}
-
-/*
- * convenience function that looks at args to a function and determines if its
- * params include an argument of type  *testing.T
- */
-func receivesTestingT(node *ast.FuncDecl) bool {
-	if len(node.Type.Params.List) != 1 {
-		return false
-	}
-
-	base, ok := node.Type.Params.List[0].Type.(*ast.StarExpr)
-	if !ok {
-		return false
-	}
-
-	intermediate := base.X.(*ast.SelectorExpr)
-	isTestingPackage := intermediate.X.(*ast.Ident).Name == "testing"
-	isTestingT := intermediate.Sel.Name == "T"
-
-	return isTestingPackage && isTestingT
-}

vendor/github.com/onsi/ginkgo/ginkgo/convert/testfile_rewriter.go

@@ -1,163 +0,0 @@
-package convert
-
-import (
-	"bytes"
-	"fmt"
-	"go/ast"
-	"go/format"
-	"go/parser"
-	"go/token"
-	"io/ioutil"
-	"os"
-)
-
-/*
- * Given a file path, rewrites any tests in the Ginkgo format.
- * First, we parse the AST, and update the imports declaration.
- * Then, we walk the first child elements in the file, returning tests to rewrite.
- * A top level init func is declared, with a single Describe func inside.
- * Then the test functions to rewrite are inserted as It statements inside the Describe.
- * Finally we walk the rest of the file, replacing other usages of *testing.T
- * Once that is complete, we write the AST back out again to its file.
- */
-func rewriteTestsInFile(pathToFile string) {
-	fileSet := token.NewFileSet()
-	rootNode, err := parser.ParseFile(fileSet, pathToFile, nil, 0)
-	if err != nil {
-		panic(fmt.Sprintf("Error parsing test file '%s':\n%s\n", pathToFile, err.Error()))
-	}
-
-	addGinkgoImports(rootNode)
-	removeTestingImport(rootNode)
-
-	varUnderscoreBlock := createVarUnderscoreBlock()
-	describeBlock := createDescribeBlock()
-	varUnderscoreBlock.Values = []ast.Expr{describeBlock}
-
-	for _, testFunc := range findTestFuncs(rootNode) {
-		rewriteTestFuncAsItStatement(testFunc, rootNode, describeBlock)
-	}
-
-	underscoreDecl := &ast.GenDecl{
-		Tok:    85, // gah, magick numbers are needed to make this work
-		TokPos: 14, // this tricks Go into writing "var _ = Describe"
-		Specs:  []ast.Spec{varUnderscoreBlock},
-	}
-
-	imports := rootNode.Decls[0]
-	tail := rootNode.Decls[1:]
-	rootNode.Decls = append(append([]ast.Decl{imports}, underscoreDecl), tail...)
-	rewriteOtherFuncsToUseGinkgoT(rootNode.Decls)
-	walkNodesInRootNodeReplacingTestingT(rootNode)
-
-	var buffer bytes.Buffer
-	if err = format.Node(&buffer, fileSet, rootNode); err != nil {
-		panic(fmt.Sprintf("Error formatting ast node after rewriting tests.\n%s\n", err.Error()))
-	}
-
-	fileInfo, err := os.Stat(pathToFile)
-	if err != nil {
-		panic(fmt.Sprintf("Error stat'ing file: %s\n", pathToFile))
-	}
-
-	ioutil.WriteFile(pathToFile, buffer.Bytes(), fileInfo.Mode())
-	return
-}
-
-/*
- * Given a test func named TestDoesSomethingNeat, rewrites it as
- * It("does something neat", func() { __test_body_here__ }) and adds it
- * to the Describe's list of statements
- */
-func rewriteTestFuncAsItStatement(testFunc *ast.FuncDecl, rootNode *ast.File, describe *ast.CallExpr) {
-	var funcIndex int = -1
-	for index, child := range rootNode.Decls {
-		if child == testFunc {
-			funcIndex = index
-			break
-		}
-	}
-
-	if funcIndex < 0 {
-		panic(fmt.Sprintf("Assert failed: Error finding index for test node %s\n", testFunc.Name.Name))
-	}
-
-	var block *ast.BlockStmt = blockStatementFromDescribe(describe)
-	block.List = append(block.List, createItStatementForTestFunc(testFunc))
-	replaceTestingTsWithGinkgoT(block, namedTestingTArg(testFunc))
-
-	// remove the old test func from the root node's declarations
-	rootNode.Decls = append(rootNode.Decls[:funcIndex], rootNode.Decls[funcIndex+1:]...)
-	return
-}
-
-/*
- * walks nodes inside of a test func's statements and replaces the usage of
- * it's named *testing.T param with GinkgoT's
- */
-func replaceTestingTsWithGinkgoT(statementsBlock *ast.BlockStmt, testingT string) {
-	ast.Inspect(statementsBlock, func(node ast.Node) bool {
-		if node == nil {
-			return false
-		}
-
-		keyValueExpr, ok := node.(*ast.KeyValueExpr)
-		if ok {
-			replaceNamedTestingTsInKeyValueExpression(keyValueExpr, testingT)
-			return true
-		}
-
-		funcLiteral, ok := node.(*ast.FuncLit)
-		if ok {
-			replaceTypeDeclTestingTsInFuncLiteral(funcLiteral)
-			return true
-		}
-
-		callExpr, ok := node.(*ast.CallExpr)
-		if !ok {
-			return true
-		}
-		replaceTestingTsInArgsLists(callExpr, testingT)
-
-		funCall, ok := callExpr.Fun.(*ast.SelectorExpr)
-		if ok {
-			replaceTestingTsMethodCalls(funCall, testingT)
-		}
-
-		return true
-	})
-}
-
-/*
- * rewrite t.Fail() or any other *testing.T method by replacing with T().Fail()
- * This function receives a selector expression (eg: t.Fail()) and
- * the name of the *testing.T param from the function declaration. Rewrites the
- * selector expression in place if the target was a *testing.T
- */
-func replaceTestingTsMethodCalls(selectorExpr *ast.SelectorExpr, testingT string) {
-	ident, ok := selectorExpr.X.(*ast.Ident)
-	if !ok {
-		return
-	}
-
-	if ident.Name == testingT {
-		selectorExpr.X = newGinkgoTFromIdent(ident)
-	}
-}
-
-/*
- * replaces usages of a named *testing.T param inside of a call expression
- * with a new GinkgoT object
- */
-func replaceTestingTsInArgsLists(callExpr *ast.CallExpr, testingT string) {
-	for index, arg := range callExpr.Args {
-		ident, ok := arg.(*ast.Ident)
-		if !ok {
-			continue
-		}
-
-		if ident.Name == testingT {
-			callExpr.Args[index] = newGinkgoTFromIdent(ident)
-		}
-	}
-}

vendor/github.com/onsi/ginkgo/ginkgo/convert/testing_t_rewriter.go

@@ -1,130 +0,0 @@
-package convert
-
-import (
-	"go/ast"
-)
-
-/*
- * Rewrites any other top level funcs that receive a *testing.T param
- */
-func rewriteOtherFuncsToUseGinkgoT(declarations []ast.Decl) {
-	for _, decl := range declarations {
-		decl, ok := decl.(*ast.FuncDecl)
-		if !ok {
-			continue
-		}
-
-		for _, param := range decl.Type.Params.List {
-			starExpr, ok := param.Type.(*ast.StarExpr)
-			if !ok {
-				continue
-			}
-
-			selectorExpr, ok := starExpr.X.(*ast.SelectorExpr)
-			if !ok {
-				continue
-			}
-
-			xIdent, ok := selectorExpr.X.(*ast.Ident)
-			if !ok || xIdent.Name != "testing" {
-				continue
-			}
-
-			if selectorExpr.Sel.Name != "T" {
-				continue
-			}
-
-			param.Type = newGinkgoTInterface()
-		}
-	}
-}
-
-/*
- * Walks all of the nodes in the file, replacing *testing.T in struct
- * and func literal nodes. eg:
- *   type foo struct { *testing.T }
- *   var bar = func(t *testing.T) { }
- */
-func walkNodesInRootNodeReplacingTestingT(rootNode *ast.File) {
-	ast.Inspect(rootNode, func(node ast.Node) bool {
-		if node == nil {
-			return false
-		}
-
-		switch node := node.(type) {
-		case *ast.StructType:
-			replaceTestingTsInStructType(node)
-		case *ast.FuncLit:
-			replaceTypeDeclTestingTsInFuncLiteral(node)
-		}
-
-		return true
-	})
-}
-
-/*
- * replaces named *testing.T inside a composite literal
- */
-func replaceNamedTestingTsInKeyValueExpression(kve *ast.KeyValueExpr, testingT string) {
-	ident, ok := kve.Value.(*ast.Ident)
-	if !ok {
-		return
-	}
-
-	if ident.Name == testingT {
-		kve.Value = newGinkgoTFromIdent(ident)
-	}
-}
-
-/*
- * replaces *testing.T params in a func literal with GinkgoT
- */
-func replaceTypeDeclTestingTsInFuncLiteral(functionLiteral *ast.FuncLit) {
-	for _, arg := range functionLiteral.Type.Params.List {
-		starExpr, ok := arg.Type.(*ast.StarExpr)
-		if !ok {
-			continue
-		}
-
-		selectorExpr, ok := starExpr.X.(*ast.SelectorExpr)
-		if !ok {
-			continue
-		}
-
-		target, ok := selectorExpr.X.(*ast.Ident)
-		if !ok {
-			continue
-		}
-
-		if target.Name == "testing" && selectorExpr.Sel.Name == "T" {
-			arg.Type = newGinkgoTInterface()
-		}
-	}
-}
-
-/*
- * Replaces *testing.T types inside of a struct declaration with a GinkgoT
- * eg: type foo struct { *testing.T }
- */
-func replaceTestingTsInStructType(structType *ast.StructType) {
-	for _, field := range structType.Fields.List {
-		starExpr, ok := field.Type.(*ast.StarExpr)
-		if !ok {
-			continue
-		}
-
-		selectorExpr, ok := starExpr.X.(*ast.SelectorExpr)
-		if !ok {
-			continue
-		}
-
-		xIdent, ok := selectorExpr.X.(*ast.Ident)
-		if !ok {
-			continue
-		}
-
-		if xIdent.Name == "testing" && selectorExpr.Sel.Name == "T" {
-			field.Type = newGinkgoTInterface()
-		}
-	}
-}

vendor/github.com/onsi/ginkgo/ginkgo/convert_command.go

@@ -1,44 +0,0 @@
-package main
-
-import (
-	"flag"
-	"fmt"
-	"github.com/onsi/ginkgo/ginkgo/convert"
-	"os"
-)
-
-func BuildConvertCommand() *Command {
-	return &Command{
-		Name:         "convert",
-		FlagSet:      flag.NewFlagSet("convert", flag.ExitOnError),
-		UsageCommand: "ginkgo convert /path/to/package",
-		Usage: []string{
-			"Convert the package at the passed in path from an XUnit-style test to a Ginkgo-style test",
-		},
-		Command: convertPackage,
-	}
-}
-
-func convertPackage(args []string, additionalArgs []string) {
-	if len(args) != 1 {
-		println(fmt.Sprintf("usage: ginkgo convert /path/to/your/package"))
-		os.Exit(1)
-	}
-
-	defer func() {
-		err := recover()
-		if err != nil {
-			switch err := err.(type) {
-			case error:
-				println(err.Error())
-			case string:
-				println(err)
-			default:
-				println(fmt.Sprintf("unexpected error: %#v", err))
-			}
-			os.Exit(1)
-		}
-	}()
-
-	convert.RewritePackage(args[0])
-}

vendor/github.com/onsi/ginkgo/ginkgo/generate_command.go

@@ -1,167 +0,0 @@
-package main
-
-import (
-	"flag"
-	"fmt"
-	"os"
-	"path/filepath"
-	"strings"
-	"text/template"
-)
-
-func BuildGenerateCommand() *Command {
-	var agouti, noDot, internal bool
-	flagSet := flag.NewFlagSet("generate", flag.ExitOnError)
-	flagSet.BoolVar(&agouti, "agouti", false, "If set, generate will generate a test file for writing Agouti tests")
-	flagSet.BoolVar(&noDot, "nodot", false, "If set, generate will generate a test file that does not . import ginkgo and gomega")
-	flagSet.BoolVar(&internal, "internal", false, "If set, generate will generate a test file that uses the regular package name")
-
-	return &Command{
-		Name:         "generate",
-		FlagSet:      flagSet,
-		UsageCommand: "ginkgo generate <filename(s)>",
-		Usage: []string{
-			"Generate a test file named filename_test.go",
-			"If the optional <filenames> argument is omitted, a file named after the package in the current directory will be created.",
-			"Accepts the following flags:",
-		},
-		Command: func(args []string, additionalArgs []string) {
-			generateSpec(args, agouti, noDot, internal)
-		},
-	}
-}
-
-var specText = `package {{.Package}}
-
-import (
-	{{if .DotImportPackage}}. "{{.PackageImportPath}}"{{end}}
-
-	{{if .IncludeImports}}. "github.com/onsi/ginkgo"{{end}}
-	{{if .IncludeImports}}. "github.com/onsi/gomega"{{end}}
-)
-
-var _ = Describe("{{.Subject}}", func() {
-
-})
-`
-
-var agoutiSpecText = `package {{.Package}}_test
-
-import (
-	{{if .DotImportPackage}}. "{{.PackageImportPath}}"{{end}}
-
-	{{if .IncludeImports}}. "github.com/onsi/ginkgo"{{end}}
-	{{if .IncludeImports}}. "github.com/onsi/gomega"{{end}}
-	. "github.com/sclevine/agouti/matchers"
-	"github.com/sclevine/agouti"
-)
-
-var _ = Describe("{{.Subject}}", func() {
-	var page *agouti.Page
-
-	BeforeEach(func() {
-		var err error
-		page, err = agoutiDriver.NewPage()
-		Expect(err).NotTo(HaveOccurred())
-	})
-
-	AfterEach(func() {
-		Expect(page.Destroy()).To(Succeed())
-	})
-})
-`
-
-type specData struct {
-	Package           string
-	Subject           string
-	PackageImportPath string
-	IncludeImports    bool
-	DotImportPackage  bool
-}
-
-func generateSpec(args []string, agouti, noDot, internal bool) {
-	if len(args) == 0 {
-		err := generateSpecForSubject("", agouti, noDot, internal)
-		if err != nil {
-			fmt.Println(err.Error())
-			fmt.Println("")
-			os.Exit(1)
-		}
-		fmt.Println("")
-		return
-	}
-
-	var failed bool
-	for _, arg := range args {
-		err := generateSpecForSubject(arg, agouti, noDot, internal)
-		if err != nil {
-			failed = true
-			fmt.Println(err.Error())
-		}
-	}
-	fmt.Println("")
-	if failed {
-		os.Exit(1)
-	}
-}
-
-func generateSpecForSubject(subject string, agouti, noDot, internal bool) error {
-	packageName, specFilePrefix, formattedName := getPackageAndFormattedName()
-	if subject != "" {
-		subject = strings.Split(subject, ".go")[0]
-		subject = strings.Split(subject, "_test")[0]
-		specFilePrefix = subject
-		formattedName = prettifyPackageName(subject)
-	}
-
-	data := specData{
-		Package:           determinePackageName(packageName, internal),
-		Subject:           formattedName,
-		PackageImportPath: getPackageImportPath(),
-		IncludeImports:    !noDot,
-		DotImportPackage:  !internal,
-	}
-
-	targetFile := fmt.Sprintf("%s_test.go", specFilePrefix)
-	if fileExists(targetFile) {
-		return fmt.Errorf("%s already exists.", targetFile)
-	} else {
-		fmt.Printf("Generating ginkgo test for %s in:\n  %s\n", data.Subject, targetFile)
-	}
-
-	f, err := os.Create(targetFile)
-	if err != nil {
-		return err
-	}
-	defer f.Close()
-
-	var templateText string
-	if agouti {
-		templateText = agoutiSpecText
-	} else {
-		templateText = specText
-	}
-
-	specTemplate, err := template.New("spec").Parse(templateText)
-	if err != nil {
-		return err
-	}
-
-	specTemplate.Execute(f, data)
-	goFmt(targetFile)
-	return nil
-}
-
-func getPackageImportPath() string {
-	workingDir, err := os.Getwd()
-	if err != nil {
-		panic(err.Error())
-	}
-	sep := string(filepath.Separator)
-	paths := strings.Split(workingDir, sep+"src"+sep)
-	if len(paths) == 1 {
-		fmt.Printf("\nCouldn't identify package import path.\n\n\tginkgo generate\n\nMust be run within a package directory under $GOPATH/src/...\nYou're going to have to change UNKNOWN_PACKAGE_PATH in the generated file...\n\n")
-		return "UNKNOWN_PACKAGE_PATH"
-	}
-	return filepath.ToSlash(paths[len(paths)-1])
-}

vendor/github.com/onsi/ginkgo/ginkgo/help_command.go

@@ -1,31 +0,0 @@
-package main
-
-import (
-	"flag"
-	"fmt"
-)
-
-func BuildHelpCommand() *Command {
-	return &Command{
-		Name:         "help",
-		FlagSet:      flag.NewFlagSet("help", flag.ExitOnError),
-		UsageCommand: "ginkgo help <COMMAND>",
-		Usage: []string{
-			"Print usage information.  If a command is passed in, print usage information just for that command.",
-		},
-		Command: printHelp,
-	}
-}
-
-func printHelp(args []string, additionalArgs []string) {
-	if len(args) == 0 {
-		usage()
-	} else {
-		command, found := commandMatching(args[0])
-		if !found {
-			complainAndQuit(fmt.Sprintf("Unknown command: %s", args[0]))
-		}
-
-		usageForCommand(command, true)
-	}
-}

vendor/github.com/onsi/ginkgo/ginkgo/interrupthandler/interrupt_handler.go

@@ -1,52 +0,0 @@
-package interrupthandler
-
-import (
-	"os"
-	"os/signal"
-	"sync"
-	"syscall"
-)
-
-type InterruptHandler struct {
-	interruptCount int
-	lock           *sync.Mutex
-	C              chan bool
-}
-
-func NewInterruptHandler() *InterruptHandler {
-	h := &InterruptHandler{
-		lock: &sync.Mutex{},
-		C:    make(chan bool, 0),
-	}
-
-	go h.handleInterrupt()
-	SwallowSigQuit()
-
-	return h
-}
-
-func (h *InterruptHandler) WasInterrupted() bool {
-	h.lock.Lock()
-	defer h.lock.Unlock()
-
-	return h.interruptCount > 0
-}
-
-func (h *InterruptHandler) handleInterrupt() {
-	c := make(chan os.Signal, 1)
-	signal.Notify(c, os.Interrupt, syscall.SIGTERM)
-
-	<-c
-	signal.Stop(c)
-
-	h.lock.Lock()
-	h.interruptCount++
-	if h.interruptCount == 1 {
-		close(h.C)
-	} else if h.interruptCount > 5 {
-		os.Exit(1)
-	}
-	h.lock.Unlock()
-
-	go h.handleInterrupt()
-}

vendor/github.com/onsi/ginkgo/ginkgo/interrupthandler/sigquit_swallower_unix.go

@@ -1,14 +0,0 @@
-// +build freebsd openbsd netbsd dragonfly darwin linux solaris
-
-package interrupthandler
-
-import (
-	"os"
-	"os/signal"
-	"syscall"
-)
-
-func SwallowSigQuit() {
-	c := make(chan os.Signal, 1024)
-	signal.Notify(c, syscall.SIGQUIT)
-}

vendor/github.com/onsi/ginkgo/ginkgo/interrupthandler/sigquit_swallower_windows.go

@@ -1,7 +0,0 @@
-// +build windows
-
-package interrupthandler
-
-func SwallowSigQuit() {
-	//noop
-}

vendor/github.com/onsi/ginkgo/ginkgo/main.go

@@ -1,300 +0,0 @@
-/*
-The Ginkgo CLI
-
-The Ginkgo CLI is fully documented [here](http://onsi.github.io/ginkgo/#the_ginkgo_cli)
-
-You can also learn more by running:
-
-	ginkgo help
-
-Here are some of the more commonly used commands:
-
-To install:
-
-	go install github.com/onsi/ginkgo/ginkgo
-
-To run tests:
-
-	ginkgo
-
-To run tests in all subdirectories:
-
-	ginkgo -r
-
-To run tests in particular packages:
-
-	ginkgo <flags> /path/to/package /path/to/another/package
-
-To pass arguments/flags to your tests:
-
-	ginkgo <flags> <packages> -- <pass-throughs>
-
-To run tests in parallel
-
-	ginkgo -p
-
-this will automatically detect the optimal number of nodes to use.  Alternatively, you can specify the number of nodes with:
-
-	ginkgo -nodes=N
-
-(note that you don't need to provide -p in this case).
-
-By default the Ginkgo CLI will spin up a server that the individual test processes send test output to.  The CLI aggregates this output and then presents coherent test output, one test at a time, as each test completes.
-An alternative is to have the parallel nodes run and stream interleaved output back.  This useful for debugging, particularly in contexts where tests hang/fail to start.  To get this interleaved output:
-
-	ginkgo -nodes=N -stream=true
-
-On windows, the default value for stream is true.
-
-By default, when running multiple tests (with -r or a list of packages) Ginkgo will abort when a test fails.  To have Ginkgo run subsequent test suites instead you can:
-
-	ginkgo -keepGoing
-
-To fail if there are ginkgo tests in a directory but no test suite (missing `RunSpecs`)
-
-	ginkgo -requireSuite
-
-To monitor packages and rerun tests when changes occur:
-
-	ginkgo watch <-r> </path/to/package>
-
-passing `ginkgo watch` the `-r` flag will recursively detect all test suites under the current directory and monitor them.
-`watch` does not detect *new* packages. Moreover, changes in package X only rerun the tests for package X, tests for packages
-that depend on X are not rerun.
-
-[OSX & Linux only] To receive (desktop) notifications when a test run completes:
-
-	ginkgo -notify
-
-this is particularly useful with `ginkgo watch`.  Notifications are currently only supported on OS X and require that you `brew install terminal-notifier`
-
-Sometimes (to suss out race conditions/flakey tests, for example) you want to keep running a test suite until it fails.  You can do this with:
-
-	ginkgo -untilItFails
-
-To bootstrap a test suite:
-
-	ginkgo bootstrap
-
-To generate a test file:
-
-	ginkgo generate <test_file_name>
-
-To bootstrap/generate test files without using "." imports:
-
-	ginkgo bootstrap --nodot
-	ginkgo generate --nodot
-
-this will explicitly export all the identifiers in Ginkgo and Gomega allowing you to rename them to avoid collisions.  When you pull to the latest Ginkgo/Gomega you'll want to run
-
-	ginkgo nodot
-
-to refresh this list and pull in any new identifiers.  In particular, this will pull in any new Gomega matchers that get added.
-
-To convert an existing XUnit style test suite to a Ginkgo-style test suite:
-
-	ginkgo convert .
-
-To unfocus tests:
-
-	ginkgo unfocus
-
-or
-
-	ginkgo blur
-
-To compile a test suite:
-
-	ginkgo build <path-to-package>
-
-will output an executable file named `package.test`.  This can be run directly or by invoking
-
-	ginkgo <path-to-package.test>
-
-To print out Ginkgo's version:
-
-	ginkgo version
-
-To get more help:
-
-	ginkgo help
-*/
-package main
-
-import (
-	"flag"
-	"fmt"
-	"os"
-	"os/exec"
-	"strings"
-
-	"github.com/onsi/ginkgo/config"
-	"github.com/onsi/ginkgo/ginkgo/testsuite"
-)
-
-const greenColor = "\x1b[32m"
-const redColor = "\x1b[91m"
-const defaultStyle = "\x1b[0m"
-const lightGrayColor = "\x1b[37m"
-
-type Command struct {
-	Name                      string
-	AltName                   string
-	FlagSet                   *flag.FlagSet
-	Usage                     []string
-	UsageCommand              string
-	Command                   func(args []string, additionalArgs []string)
-	SuppressFlagDocumentation bool
-	FlagDocSubstitute         []string
-}
-
-func (c *Command) Matches(name string) bool {
-	return c.Name == name || (c.AltName != "" && c.AltName == name)
-}
-
-func (c *Command) Run(args []string, additionalArgs []string) {
-	c.FlagSet.Parse(args)
-	c.Command(c.FlagSet.Args(), additionalArgs)
-}
-
-var DefaultCommand *Command
-var Commands []*Command
-
-func init() {
-	DefaultCommand = BuildRunCommand()
-	Commands = append(Commands, BuildWatchCommand())
-	Commands = append(Commands, BuildBuildCommand())
-	Commands = append(Commands, BuildBootstrapCommand())
-	Commands = append(Commands, BuildGenerateCommand())
-	Commands = append(Commands, BuildNodotCommand())
-	Commands = append(Commands, BuildConvertCommand())
-	Commands = append(Commands, BuildUnfocusCommand())
-	Commands = append(Commands, BuildVersionCommand())
-	Commands = append(Commands, BuildHelpCommand())
-}
-
-func main() {
-	args := []string{}
-	additionalArgs := []string{}
-
-	foundDelimiter := false
-
-	for _, arg := range os.Args[1:] {
-		if !foundDelimiter {
-			if arg == "--" {
-				foundDelimiter = true
-				continue
-			}
-		}
-
-		if foundDelimiter {
-			additionalArgs = append(additionalArgs, arg)
-		} else {
-			args = append(args, arg)
-		}
-	}
-
-	if len(args) > 0 {
-		commandToRun, found := commandMatching(args[0])
-		if found {
-			commandToRun.Run(args[1:], additionalArgs)
-			return
-		}
-	}
-
-	DefaultCommand.Run(args, additionalArgs)
-}
-
-func commandMatching(name string) (*Command, bool) {
-	for _, command := range Commands {
-		if command.Matches(name) {
-			return command, true
-		}
-	}
-	return nil, false
-}
-
-func usage() {
-	fmt.Fprintf(os.Stderr, "Ginkgo Version %s\n\n", config.VERSION)
-	usageForCommand(DefaultCommand, false)
-	for _, command := range Commands {
-		fmt.Fprintf(os.Stderr, "\n")
-		usageForCommand(command, false)
-	}
-}
-
-func usageForCommand(command *Command, longForm bool) {
-	fmt.Fprintf(os.Stderr, "%s\n%s\n", command.UsageCommand, strings.Repeat("-", len(command.UsageCommand)))
-	fmt.Fprintf(os.Stderr, "%s\n", strings.Join(command.Usage, "\n"))
-	if command.SuppressFlagDocumentation && !longForm {
-		fmt.Fprintf(os.Stderr, "%s\n", strings.Join(command.FlagDocSubstitute, "\n  "))
-	} else {
-		command.FlagSet.PrintDefaults()
-	}
-}
-
-func complainAndQuit(complaint string) {
-	fmt.Fprintf(os.Stderr, "%s\nFor usage instructions:\n\tginkgo help\n", complaint)
-	os.Exit(1)
-}
-
-func findSuites(args []string, recurseForAll bool, skipPackage string, allowPrecompiled bool) ([]testsuite.TestSuite, []string) {
-	suites := []testsuite.TestSuite{}
-
-	if len(args) > 0 {
-		for _, arg := range args {
-			if allowPrecompiled {
-				suite, err := testsuite.PrecompiledTestSuite(arg)
-				if err == nil {
-					suites = append(suites, suite)
-					continue
-				}
-			}
-			recurseForSuite := recurseForAll
-			if strings.HasSuffix(arg, "/...") && arg != "/..." {
-				arg = arg[:len(arg)-4]
-				recurseForSuite = true
-			}
-			suites = append(suites, testsuite.SuitesInDir(arg, recurseForSuite)...)
-		}
-	} else {
-		suites = testsuite.SuitesInDir(".", recurseForAll)
-	}
-
-	skippedPackages := []string{}
-	if skipPackage != "" {
-		skipFilters := strings.Split(skipPackage, ",")
-		filteredSuites := []testsuite.TestSuite{}
-		for _, suite := range suites {
-			skip := false
-			for _, skipFilter := range skipFilters {
-				if strings.Contains(suite.Path, skipFilter) {
-					skip = true
-					break
-				}
-			}
-			if skip {
-				skippedPackages = append(skippedPackages, suite.Path)
-			} else {
-				filteredSuites = append(filteredSuites, suite)
-			}
-		}
-		suites = filteredSuites
-	}
-
-	return suites, skippedPackages
-}
-
-func goFmt(path string) {
-	err := exec.Command("go", "fmt", path).Run()
-	if err != nil {
-		complainAndQuit("Could not fmt: " + err.Error())
-	}
-}
-
-func pluralizedWord(singular, plural string, count int) string {
-	if count == 1 {
-		return singular
-	}
-	return plural
-}

vendor/github.com/onsi/ginkgo/ginkgo/nodot/nodot.go

@@ -1,194 +0,0 @@
-package nodot
-
-import (
-	"fmt"
-	"go/ast"
-	"go/build"
-	"go/parser"
-	"go/token"
-	"path/filepath"
-	"strings"
-)
-
-func ApplyNoDot(data []byte) ([]byte, error) {
-	sections, err := generateNodotSections()
-	if err != nil {
-		return nil, err
-	}
-
-	for _, section := range sections {
-		data = section.createOrUpdateIn(data)
-	}
-
-	return data, nil
-}
-
-type nodotSection struct {
-	name         string
-	pkg          string
-	declarations []string
-	types        []string
-}
-
-func (s nodotSection) createOrUpdateIn(data []byte) []byte {
-	renames := map[string]string{}
-
-	contents := string(data)
-
-	lines := strings.Split(contents, "\n")
-
-	comment := "// Declarations for " + s.name
-
-	newLines := []string{}
-	for _, line := range lines {
-		if line == comment {
-			continue
-		}
-
-		words := strings.Split(line, " ")
-		lastWord := words[len(words)-1]
-
-		if s.containsDeclarationOrType(lastWord) {
-			renames[lastWord] = words[1]
-			continue
-		}
-
-		newLines = append(newLines, line)
-	}
-
-	if len(newLines[len(newLines)-1]) > 0 {
-		newLines = append(newLines, "")
-	}
-
-	newLines = append(newLines, comment)
-
-	for _, typ := range s.types {
-		name, ok := renames[s.prefix(typ)]
-		if !ok {
-			name = typ
-		}
-		newLines = append(newLines, fmt.Sprintf("type %s %s", name, s.prefix(typ)))
-	}
-
-	for _, decl := range s.declarations {
-		name, ok := renames[s.prefix(decl)]
-		if !ok {
-			name = decl
-		}
-		newLines = append(newLines, fmt.Sprintf("var %s = %s", name, s.prefix(decl)))
-	}
-
-	newLines = append(newLines, "")
-
-	newContents := strings.Join(newLines, "\n")
-
-	return []byte(newContents)
-}
-
-func (s nodotSection) prefix(declOrType string) string {
-	return s.pkg + "." + declOrType
-}
-
-func (s nodotSection) containsDeclarationOrType(word string) bool {
-	for _, declaration := range s.declarations {
-		if s.prefix(declaration) == word {
-			return true
-		}
-	}
-
-	for _, typ := range s.types {
-		if s.prefix(typ) == word {
-			return true
-		}
-	}
-
-	return false
-}
-
-func generateNodotSections() ([]nodotSection, error) {
-	sections := []nodotSection{}
-
-	declarations, err := getExportedDeclerationsForPackage("github.com/onsi/ginkgo", "ginkgo_dsl.go", "GINKGO_VERSION", "GINKGO_PANIC")
-	if err != nil {
-		return nil, err
-	}
-	sections = append(sections, nodotSection{
-		name:         "Ginkgo DSL",
-		pkg:          "ginkgo",
-		declarations: declarations,
-		types:        []string{"Done", "Benchmarker"},
-	})
-
-	declarations, err = getExportedDeclerationsForPackage("github.com/onsi/gomega", "gomega_dsl.go", "GOMEGA_VERSION")
-	if err != nil {
-		return nil, err
-	}
-	sections = append(sections, nodotSection{
-		name:         "Gomega DSL",
-		pkg:          "gomega",
-		declarations: declarations,
-	})
-
-	declarations, err = getExportedDeclerationsForPackage("github.com/onsi/gomega", "matchers.go")
-	if err != nil {
-		return nil, err
-	}
-	sections = append(sections, nodotSection{
-		name:         "Gomega Matchers",
-		pkg:          "gomega",
-		declarations: declarations,
-	})
-
-	return sections, nil
-}
-
-func getExportedDeclerationsForPackage(pkgPath string, filename string, blacklist ...string) ([]string, error) {
-	pkg, err := build.Import(pkgPath, ".", 0)
-	if err != nil {
-		return []string{}, err
-	}
-
-	declarations, err := getExportedDeclarationsForFile(filepath.Join(pkg.Dir, filename))
-	if err != nil {
-		return []string{}, err
-	}
-
-	blacklistLookup := map[string]bool{}
-	for _, declaration := range blacklist {
-		blacklistLookup[declaration] = true
-	}
-
-	filteredDeclarations := []string{}
-	for _, declaration := range declarations {
-		if blacklistLookup[declaration] {
-			continue
-		}
-		filteredDeclarations = append(filteredDeclarations, declaration)
-	}
-
-	return filteredDeclarations, nil
-}
-
-func getExportedDeclarationsForFile(path string) ([]string, error) {
-	fset := token.NewFileSet()
-	tree, err := parser.ParseFile(fset, path, nil, 0)
-	if err != nil {
-		return []string{}, err
-	}
-
-	declarations := []string{}
-	ast.FileExports(tree)
-	for _, decl := range tree.Decls {
-		switch x := decl.(type) {
-		case *ast.GenDecl:
-			switch s := x.Specs[0].(type) {
-			case *ast.ValueSpec:
-				declarations = append(declarations, s.Names[0].Name)
-			}
-		case *ast.FuncDecl:
-			declarations = append(declarations, x.Name.Name)
-		}
-	}
-
-	return declarations, nil
-}

vendor/github.com/onsi/ginkgo/ginkgo/nodot/nodot_suite_test.go

@@ -1,91 +0,0 @@
-package nodot_test
-
-import (
-	"github.com/onsi/ginkgo"
-	"github.com/onsi/gomega"
-
-	"testing"
-)
-
-func TestNodot(t *testing.T) {
-	RegisterFailHandler(Fail)
-	RunSpecs(t, "Nodot Suite")
-}
-
-// Declarations for Ginkgo DSL
-type Done ginkgo.Done
-type Benchmarker ginkgo.Benchmarker
-
-var GinkgoWriter = ginkgo.GinkgoWriter
-var GinkgoParallelNode = ginkgo.GinkgoParallelNode
-var GinkgoT = ginkgo.GinkgoT
-var CurrentGinkgoTestDescription = ginkgo.CurrentGinkgoTestDescription
-var RunSpecs = ginkgo.RunSpecs
-var RunSpecsWithDefaultAndCustomReporters = ginkgo.RunSpecsWithDefaultAndCustomReporters
-var RunSpecsWithCustomReporters = ginkgo.RunSpecsWithCustomReporters
-var Fail = ginkgo.Fail
-var GinkgoRecover = ginkgo.GinkgoRecover
-var Describe = ginkgo.Describe
-var FDescribe = ginkgo.FDescribe
-var PDescribe = ginkgo.PDescribe
-var XDescribe = ginkgo.XDescribe
-var Context = ginkgo.Context
-var FContext = ginkgo.FContext
-var PContext = ginkgo.PContext
-var XContext = ginkgo.XContext
-var It = ginkgo.It
-var FIt = ginkgo.FIt
-var PIt = ginkgo.PIt
-var XIt = ginkgo.XIt
-var Measure = ginkgo.Measure
-var FMeasure = ginkgo.FMeasure
-var PMeasure = ginkgo.PMeasure
-var XMeasure = ginkgo.XMeasure
-var BeforeSuite = ginkgo.BeforeSuite
-var AfterSuite = ginkgo.AfterSuite
-var SynchronizedBeforeSuite = ginkgo.SynchronizedBeforeSuite
-var SynchronizedAfterSuite = ginkgo.SynchronizedAfterSuite
-var BeforeEach = ginkgo.BeforeEach
-var JustBeforeEach = ginkgo.JustBeforeEach
-var AfterEach = ginkgo.AfterEach
-
-// Declarations for Gomega DSL
-var RegisterFailHandler = gomega.RegisterFailHandler
-var RegisterTestingT = gomega.RegisterTestingT
-var InterceptGomegaFailures = gomega.InterceptGomegaFailures
-var Ω = gomega.Ω
-var Expect = gomega.Expect
-var ExpectWithOffset = gomega.ExpectWithOffset
-var Eventually = gomega.Eventually
-var EventuallyWithOffset = gomega.EventuallyWithOffset
-var Consistently = gomega.Consistently
-var ConsistentlyWithOffset = gomega.ConsistentlyWithOffset
-var SetDefaultEventuallyTimeout = gomega.SetDefaultEventuallyTimeout
-var SetDefaultEventuallyPollingInterval = gomega.SetDefaultEventuallyPollingInterval
-var SetDefaultConsistentlyDuration = gomega.SetDefaultConsistentlyDuration
-var SetDefaultConsistentlyPollingInterval = gomega.SetDefaultConsistentlyPollingInterval
-
-// Declarations for Gomega Matchers
-var Equal = gomega.Equal
-var BeEquivalentTo = gomega.BeEquivalentTo
-var BeNil = gomega.BeNil
-var BeTrue = gomega.BeTrue
-var BeFalse = gomega.BeFalse
-var HaveOccurred = gomega.HaveOccurred
-var MatchError = gomega.MatchError
-var BeClosed = gomega.BeClosed
-var Receive = gomega.Receive
-var MatchRegexp = gomega.MatchRegexp
-var ContainSubstring = gomega.ContainSubstring
-var MatchJSON = gomega.MatchJSON
-var BeEmpty = gomega.BeEmpty
-var HaveLen = gomega.HaveLen
-var BeZero = gomega.BeZero
-var ContainElement = gomega.ContainElement
-var ConsistOf = gomega.ConsistOf
-var HaveKey = gomega.HaveKey
-var HaveKeyWithValue = gomega.HaveKeyWithValue
-var BeNumerically = gomega.BeNumerically
-var BeTemporally = gomega.BeTemporally
-var BeAssignableToTypeOf = gomega.BeAssignableToTypeOf
-var Panic = gomega.Panic

vendor/github.com/onsi/ginkgo/ginkgo/nodot/nodot_test.go

@@ -1,81 +0,0 @@
-package nodot_test
-
-import (
-	. "github.com/onsi/ginkgo/ginkgo/nodot"
-	"strings"
-)
-
-var _ = Describe("ApplyNoDot", func() {
-	var result string
-
-	apply := func(input string) string {
-		output, err := ApplyNoDot([]byte(input))
-		Ω(err).ShouldNot(HaveOccurred())
-		return string(output)
-	}
-
-	Context("when no declarations have been imported yet", func() {
-		BeforeEach(func() {
-			result = apply("")
-		})
-
-		It("should add headings for the various declarations", func() {
-			Ω(result).Should(ContainSubstring("// Declarations for Ginkgo DSL"))
-			Ω(result).Should(ContainSubstring("// Declarations for Gomega DSL"))
-			Ω(result).Should(ContainSubstring("// Declarations for Gomega Matchers"))
-		})
-
-		It("should import Ginkgo's declarations", func() {
-			Ω(result).Should(ContainSubstring("var It = ginkgo.It"))
-			Ω(result).Should(ContainSubstring("var XDescribe = ginkgo.XDescribe"))
-		})
-
-		It("should import Ginkgo's types", func() {
-			Ω(result).Should(ContainSubstring("type Done ginkgo.Done"))
-			Ω(result).Should(ContainSubstring("type Benchmarker ginkgo.Benchmarker"))
-			Ω(strings.Count(result, "type ")).Should(Equal(2))
-		})
-
-		It("should import Gomega's DSL and matchers", func() {
-			Ω(result).Should(ContainSubstring("var Ω = gomega.Ω"))
-			Ω(result).Should(ContainSubstring("var ContainSubstring = gomega.ContainSubstring"))
-			Ω(result).Should(ContainSubstring("var Equal = gomega.Equal"))
-		})
-
-		It("should not import blacklisted things", func() {
-			Ω(result).ShouldNot(ContainSubstring("GINKGO_VERSION"))
-			Ω(result).ShouldNot(ContainSubstring("GINKGO_PANIC"))
-			Ω(result).ShouldNot(ContainSubstring("GOMEGA_VERSION"))
-		})
-	})
-
-	It("should be idempotent (module empty lines - go fmt can fix those for us)", func() {
-		first := apply("")
-		second := apply(first)
-		first = strings.Trim(first, "\n")
-		second = strings.Trim(second, "\n")
-		Ω(first).Should(Equal(second))
-	})
-
-	It("should not mess with other things in the input", func() {
-		result = apply("var MyThing = SomethingThatsMine")
-		Ω(result).Should(ContainSubstring("var MyThing = SomethingThatsMine"))
-	})
-
-	Context("when the user has redefined a name", func() {
-		It("should honor the redefinition", func() {
-			result = apply(`
-var _ = gomega.Ω
-var When = ginkgo.It
-            `)
-
-			Ω(result).Should(ContainSubstring("var _ = gomega.Ω"))
-			Ω(result).ShouldNot(ContainSubstring("var Ω = gomega.Ω"))
-
-			Ω(result).Should(ContainSubstring("var When = ginkgo.It"))
-			Ω(result).ShouldNot(ContainSubstring("var It = ginkgo.It"))
-
-			Ω(result).Should(ContainSubstring("var Context = ginkgo.Context"))
-		})
-	})
-})

vendor/github.com/onsi/ginkgo/ginkgo/nodot_command.go

@@ -1,76 +0,0 @@
-package main
-
-import (
-	"bufio"
-	"flag"
-	"github.com/onsi/ginkgo/ginkgo/nodot"
-	"io/ioutil"
-	"os"
-	"path/filepath"
-	"regexp"
-)
-
-func BuildNodotCommand() *Command {
-	return &Command{
-		Name:         "nodot",
-		FlagSet:      flag.NewFlagSet("bootstrap", flag.ExitOnError),
-		UsageCommand: "ginkgo nodot",
-		Usage: []string{
-			"Update the nodot declarations in your test suite",
-			"Any missing declarations (from, say, a recently added matcher) will be added to your bootstrap file.",
-			"If you've renamed a declaration, that name will be honored and not overwritten.",
-		},
-		Command: updateNodot,
-	}
-}
-
-func updateNodot(args []string, additionalArgs []string) {
-	suiteFile, perm := findSuiteFile()
-
-	data, err := ioutil.ReadFile(suiteFile)
-	if err != nil {
-		complainAndQuit("Failed to update nodot declarations: " + err.Error())
-	}
-
-	content, err := nodot.ApplyNoDot(data)
-	if err != nil {
-		complainAndQuit("Failed to update nodot declarations: " + err.Error())
-	}
-	ioutil.WriteFile(suiteFile, content, perm)
-
-	goFmt(suiteFile)
-}
-
-func findSuiteFile() (string, os.FileMode) {
-	workingDir, err := os.Getwd()
-	if err != nil {
-		complainAndQuit("Could not find suite file for nodot: " + err.Error())
-	}
-
-	files, err := ioutil.ReadDir(workingDir)
-	if err != nil {
-		complainAndQuit("Could not find suite file for nodot: " + err.Error())
-	}
-
-	re := regexp.MustCompile(`RunSpecs\(|RunSpecsWithDefaultAndCustomReporters\(|RunSpecsWithCustomReporters\(`)
-
-	for _, file := range files {
-		if file.IsDir() {
-			continue
-		}
-		path := filepath.Join(workingDir, file.Name())
-		f, err := os.Open(path)
-		if err != nil {
-			complainAndQuit("Could not find suite file for nodot: " + err.Error())
-		}
-		defer f.Close()
-
-		if re.MatchReader(bufio.NewReader(f)) {
-			return path, file.Mode()
-		}
-	}
-
-	complainAndQuit("Could not find a suite file for nodot: you need a bootstrap file that call's Ginkgo's RunSpecs() command.\nTry running ginkgo bootstrap first.")
-
-	return "", 0
-}

vendor/github.com/onsi/ginkgo/ginkgo/notifications.go

@@ -1,141 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"os"
-	"os/exec"
-	"regexp"
-	"runtime"
-	"strings"
-
-	"github.com/onsi/ginkgo/config"
-	"github.com/onsi/ginkgo/ginkgo/testsuite"
-)
-
-type Notifier struct {
-	commandFlags *RunWatchAndBuildCommandFlags
-}
-
-func NewNotifier(commandFlags *RunWatchAndBuildCommandFlags) *Notifier {
-	return &Notifier{
-		commandFlags: commandFlags,
-	}
-}
-
-func (n *Notifier) VerifyNotificationsAreAvailable() {
-	if n.commandFlags.Notify {
-		onLinux := (runtime.GOOS == "linux")
-		onOSX := (runtime.GOOS == "darwin")
-		if onOSX {
-
-			_, err := exec.LookPath("terminal-notifier")
-			if err != nil {
-				fmt.Printf(`--notify requires terminal-notifier, which you don't seem to have installed.
-
-OSX:
-
-To remedy this:
-
-    brew install terminal-notifier
-
-To learn more about terminal-notifier:
-
-    https://github.com/alloy/terminal-notifier
-`)
-				os.Exit(1)
-			}
-
-		} else if onLinux {
-
-			_, err := exec.LookPath("notify-send")
-			if err != nil {
-				fmt.Printf(`--notify requires terminal-notifier or notify-send, which you don't seem to have installed.
-
-Linux:
-
-Download and install notify-send for your distribution
-`)
-				os.Exit(1)
-			}
-
-		}
-	}
-}
-
-func (n *Notifier) SendSuiteCompletionNotification(suite testsuite.TestSuite, suitePassed bool) {
-	if suitePassed {
-		n.SendNotification("Ginkgo [PASS]", fmt.Sprintf(`Test suite for "%s" passed.`, suite.PackageName))
-	} else {
-		n.SendNotification("Ginkgo [FAIL]", fmt.Sprintf(`Test suite for "%s" failed.`, suite.PackageName))
-	}
-}
-
-func (n *Notifier) SendNotification(title string, subtitle string) {
-
-	if n.commandFlags.Notify {
-		onLinux := (runtime.GOOS == "linux")
-		onOSX := (runtime.GOOS == "darwin")
-
-		if onOSX {
-
-			_, err := exec.LookPath("terminal-notifier")
-			if err == nil {
-				args := []string{"-title", title, "-subtitle", subtitle, "-group", "com.onsi.ginkgo"}
-				terminal := os.Getenv("TERM_PROGRAM")
-				if terminal == "iTerm.app" {
-					args = append(args, "-activate", "com.googlecode.iterm2")
-				} else if terminal == "Apple_Terminal" {
-					args = append(args, "-activate", "com.apple.Terminal")
-				}
-
-				exec.Command("terminal-notifier", args...).Run()
-			}
-
-		} else if onLinux {
-
-			_, err := exec.LookPath("notify-send")
-			if err == nil {
-				args := []string{"-a", "ginkgo", title, subtitle}
-				exec.Command("notify-send", args...).Run()
-			}
-
-		}
-	}
-}
-
-func (n *Notifier) RunCommand(suite testsuite.TestSuite, suitePassed bool) {
-
-	command := n.commandFlags.AfterSuiteHook
-	if command != "" {
-
-		// Allow for string replacement to pass input to the command
-		passed := "[FAIL]"
-		if suitePassed {
-			passed = "[PASS]"
-		}
-		command = strings.Replace(command, "(ginkgo-suite-passed)", passed, -1)
-		command = strings.Replace(command, "(ginkgo-suite-name)", suite.PackageName, -1)
-
-		// Must break command into parts
-		splitArgs := regexp.MustCompile(`'.+'|".+"|\S+`)
-		parts := splitArgs.FindAllString(command, -1)
-
-		output, err := exec.Command(parts[0], parts[1:]...).CombinedOutput()
-		if err != nil {
-			fmt.Println("Post-suite command failed:")
-			if config.DefaultReporterConfig.NoColor {
-				fmt.Printf("\t%s\n", output)
-			} else {
-				fmt.Printf("\t%s%s%s\n", redColor, string(output), defaultStyle)
-			}
-			n.SendNotification("Ginkgo [ERROR]", fmt.Sprintf(`After suite command "%s" failed`, n.commandFlags.AfterSuiteHook))
-		} else {
-			fmt.Println("Post-suite command succeeded:")
-			if config.DefaultReporterConfig.NoColor {
-				fmt.Printf("\t%s\n", output)
-			} else {
-				fmt.Printf("\t%s%s%s\n", greenColor, string(output), defaultStyle)
-			}
-		}
-	}
-}

vendor/github.com/onsi/ginkgo/ginkgo/run_command.go

@@ -1,192 +0,0 @@
-package main
-
-import (
-	"flag"
-	"fmt"
-	"math/rand"
-	"os"
-	"time"
-
-	"github.com/onsi/ginkgo/config"
-	"github.com/onsi/ginkgo/ginkgo/interrupthandler"
-	"github.com/onsi/ginkgo/ginkgo/testrunner"
-	"github.com/onsi/ginkgo/types"
-)
-
-func BuildRunCommand() *Command {
-	commandFlags := NewRunCommandFlags(flag.NewFlagSet("ginkgo", flag.ExitOnError))
-	notifier := NewNotifier(commandFlags)
-	interruptHandler := interrupthandler.NewInterruptHandler()
-	runner := &SpecRunner{
-		commandFlags:     commandFlags,
-		notifier:         notifier,
-		interruptHandler: interruptHandler,
-		suiteRunner:      NewSuiteRunner(notifier, interruptHandler),
-	}
-
-	return &Command{
-		Name:         "",
-		FlagSet:      commandFlags.FlagSet,
-		UsageCommand: "ginkgo <FLAGS> <PACKAGES> -- <PASS-THROUGHS>",
-		Usage: []string{
-			"Run the tests in the passed in <PACKAGES> (or the package in the current directory if left blank).",
-			"Any arguments after -- will be passed to the test.",
-			"Accepts the following flags:",
-		},
-		Command: runner.RunSpecs,
-	}
-}
-
-type SpecRunner struct {
-	commandFlags     *RunWatchAndBuildCommandFlags
-	notifier         *Notifier
-	interruptHandler *interrupthandler.InterruptHandler
-	suiteRunner      *SuiteRunner
-}
-
-func (r *SpecRunner) RunSpecs(args []string, additionalArgs []string) {
-	r.commandFlags.computeNodes()
-	r.notifier.VerifyNotificationsAreAvailable()
-
-	suites, skippedPackages := findSuites(args, r.commandFlags.Recurse, r.commandFlags.SkipPackage, true)
-	if len(skippedPackages) > 0 {
-		fmt.Println("Will skip:")
-		for _, skippedPackage := range skippedPackages {
-			fmt.Println("  " + skippedPackage)
-		}
-	}
-
-	if len(skippedPackages) > 0 && len(suites) == 0 {
-		fmt.Println("All tests skipped!  Exiting...")
-		os.Exit(0)
-	}
-
-	if len(suites) == 0 {
-		complainAndQuit("Found no test suites")
-	}
-
-	r.ComputeSuccinctMode(len(suites))
-
-	t := time.Now()
-
-	runners := []*testrunner.TestRunner{}
-	for _, suite := range suites {
-		runners = append(runners, testrunner.New(suite, r.commandFlags.NumCPU, r.commandFlags.ParallelStream, r.commandFlags.Timeout, r.commandFlags.GoOpts, additionalArgs))
-	}
-
-	numSuites := 0
-	runResult := testrunner.PassingRunResult()
-	if r.commandFlags.UntilItFails {
-		iteration := 0
-		for {
-			r.UpdateSeed()
-			randomizedRunners := r.randomizeOrder(runners)
-			runResult, numSuites = r.suiteRunner.RunSuites(randomizedRunners, r.commandFlags.NumCompilers, r.commandFlags.KeepGoing, nil)
-			iteration++
-
-			if r.interruptHandler.WasInterrupted() {
-				break
-			}
-
-			if runResult.Passed {
-				fmt.Printf("\nAll tests passed...\nWill keep running them until they fail.\nThis was attempt #%d\n%s\n", iteration, orcMessage(iteration))
-			} else {
-				fmt.Printf("\nTests failed on attempt #%d\n\n", iteration)
-				break
-			}
-		}
-	} else {
-		randomizedRunners := r.randomizeOrder(runners)
-		runResult, numSuites = r.suiteRunner.RunSuites(randomizedRunners, r.commandFlags.NumCompilers, r.commandFlags.KeepGoing, nil)
-	}
-
-	for _, runner := range runners {
-		runner.CleanUp()
-	}
-
-	fmt.Printf("\nGinkgo ran %d %s in %s\n", numSuites, pluralizedWord("suite", "suites", numSuites), time.Since(t))
-
-	if runResult.Passed {
-		if runResult.HasProgrammaticFocus {
-			fmt.Printf("Test Suite Passed\n")
-			fmt.Printf("Detected Programmatic Focus - setting exit status to %d\n", types.GINKGO_FOCUS_EXIT_CODE)
-			os.Exit(types.GINKGO_FOCUS_EXIT_CODE)
-		} else {
-			fmt.Printf("Test Suite Passed\n")
-			os.Exit(0)
-		}
-	} else {
-		fmt.Printf("Test Suite Failed\n")
-		os.Exit(1)
-	}
-}
-
-func (r *SpecRunner) ComputeSuccinctMode(numSuites int) {
-	if config.DefaultReporterConfig.Verbose {
-		config.DefaultReporterConfig.Succinct = false
-		return
-	}
-
-	if numSuites == 1 {
-		return
-	}
-
-	if numSuites > 1 && !r.commandFlags.wasSet("succinct") {
-		config.DefaultReporterConfig.Succinct = true
-	}
-}
-
-func (r *SpecRunner) UpdateSeed() {
-	if !r.commandFlags.wasSet("seed") {
-		config.GinkgoConfig.RandomSeed = time.Now().Unix()
-	}
-}
-
-func (r *SpecRunner) randomizeOrder(runners []*testrunner.TestRunner) []*testrunner.TestRunner {
-	if !r.commandFlags.RandomizeSuites {
-		return runners
-	}
-
-	if len(runners) <= 1 {
-		return runners
-	}
-
-	randomizedRunners := make([]*testrunner.TestRunner, len(runners))
-	randomizer := rand.New(rand.NewSource(config.GinkgoConfig.RandomSeed))
-	permutation := randomizer.Perm(len(runners))
-	for i, j := range permutation {
-		randomizedRunners[i] = runners[j]
-	}
-	return randomizedRunners
-}
-
-func orcMessage(iteration int) string {
-	if iteration < 10 {
-		return ""
-	} else if iteration < 30 {
-		return []string{
-			"If at first you succeed...",
-			"...try, try again.",
-			"Looking good!",
-			"Still good...",
-			"I think your tests are fine....",
-			"Yep, still passing",
-			"Oh boy, here I go testin' again!",
-			"Even the gophers are getting bored",
-			"Did you try -race?",
-			"Maybe you should stop now?",
-			"I'm getting tired...",
-			"What if I just made you a sandwich?",
-			"Hit ^C, hit ^C, please hit ^C",
-			"Make it stop. Please!",
-			"Come on!  Enough is enough!",
-			"Dave, this conversation can serve no purpose anymore. Goodbye.",
-			"Just what do you think you're doing, Dave? ",
-			"I, Sisyphus",
-			"Insanity: doing the same thing over and over again and expecting different results. -Einstein",
-			"I guess Einstein never tried to churn butter",
-		}[iteration-10] + "\n"
-	} else {
-		return "No, seriously... you can probably stop now.\n"
-	}
-}

vendor/github.com/onsi/ginkgo/ginkgo/run_watch_and_build_command_flags.go

@@ -1,167 +0,0 @@
-package main
-
-import (
-	"flag"
-	"runtime"
-
-	"time"
-
-	"github.com/onsi/ginkgo/config"
-)
-
-type RunWatchAndBuildCommandFlags struct {
-	Recurse     bool
-	SkipPackage string
-	GoOpts      map[string]interface{}
-
-	//for run and watch commands
-	NumCPU         int
-	NumCompilers   int
-	ParallelStream bool
-	Notify         bool
-	AfterSuiteHook string
-	AutoNodes      bool
-	Timeout        time.Duration
-
-	//only for run command
-	KeepGoing       bool
-	UntilItFails    bool
-	RandomizeSuites bool
-
-	//only for watch command
-	Depth       int
-	WatchRegExp string
-
-	FlagSet *flag.FlagSet
-}
-
-const runMode = 1
-const watchMode = 2
-const buildMode = 3
-
-func NewRunCommandFlags(flagSet *flag.FlagSet) *RunWatchAndBuildCommandFlags {
-	c := &RunWatchAndBuildCommandFlags{
-		FlagSet: flagSet,
-	}
-	c.flags(runMode)
-	return c
-}
-
-func NewWatchCommandFlags(flagSet *flag.FlagSet) *RunWatchAndBuildCommandFlags {
-	c := &RunWatchAndBuildCommandFlags{
-		FlagSet: flagSet,
-	}
-	c.flags(watchMode)
-	return c
-}
-
-func NewBuildCommandFlags(flagSet *flag.FlagSet) *RunWatchAndBuildCommandFlags {
-	c := &RunWatchAndBuildCommandFlags{
-		FlagSet: flagSet,
-	}
-	c.flags(buildMode)
-	return c
-}
-
-func (c *RunWatchAndBuildCommandFlags) wasSet(flagName string) bool {
-	wasSet := false
-	c.FlagSet.Visit(func(f *flag.Flag) {
-		if f.Name == flagName {
-			wasSet = true
-		}
-	})
-
-	return wasSet
-}
-
-func (c *RunWatchAndBuildCommandFlags) computeNodes() {
-	if c.wasSet("nodes") {
-		return
-	}
-	if c.AutoNodes {
-		switch n := runtime.NumCPU(); {
-		case n <= 4:
-			c.NumCPU = n
-		default:
-			c.NumCPU = n - 1
-		}
-	}
-}
-
-func (c *RunWatchAndBuildCommandFlags) stringSlot(slot string) *string {
-	var opt string
-	c.GoOpts[slot] = &opt
-	return &opt
-}
-
-func (c *RunWatchAndBuildCommandFlags) boolSlot(slot string) *bool {
-	var opt bool
-	c.GoOpts[slot] = &opt
-	return &opt
-}
-
-func (c *RunWatchAndBuildCommandFlags) intSlot(slot string) *int {
-	var opt int
-	c.GoOpts[slot] = &opt
-	return &opt
-}
-
-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.")
-	c.FlagSet.BoolVar(c.boolSlot("requireSuite"), "requireSuite", false, "Fail if there are ginkgo tests in a directory but no test suite (missing RunSpecs)")
-
-	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")
-		c.FlagSet.DurationVar(&(c.Timeout), "timeout", 24*time.Hour, "Suite fails if it does not complete within the specified timeout")
-	}
-
-	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")
-		c.FlagSet.StringVar(&(c.WatchRegExp), "watchRegExp", `\.go$`, "Files matching this regular expression will be watched for changes")
-	}
-}

vendor/github.com/onsi/ginkgo/ginkgo/suite_runner.go

@@ -1,173 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"runtime"
-	"sync"
-
-	"github.com/onsi/ginkgo/config"
-	"github.com/onsi/ginkgo/ginkgo/interrupthandler"
-	"github.com/onsi/ginkgo/ginkgo/testrunner"
-	"github.com/onsi/ginkgo/ginkgo/testsuite"
-	colorable "github.com/onsi/ginkgo/reporters/stenographer/support/go-colorable"
-)
-
-type compilationInput struct {
-	runner *testrunner.TestRunner
-	result chan compilationOutput
-}
-
-type compilationOutput struct {
-	runner *testrunner.TestRunner
-	err    error
-}
-
-type SuiteRunner struct {
-	notifier         *Notifier
-	interruptHandler *interrupthandler.InterruptHandler
-}
-
-func NewSuiteRunner(notifier *Notifier, interruptHandler *interrupthandler.InterruptHandler) *SuiteRunner {
-	return &SuiteRunner{
-		notifier:         notifier,
-		interruptHandler: interruptHandler,
-	}
-}
-
-func (r *SuiteRunner) compileInParallel(runners []*testrunner.TestRunner, numCompilers int, willCompile func(suite testsuite.TestSuite)) chan compilationOutput {
-	//we return this to the consumer, it will return each runner in order as it compiles
-	compilationOutputs := make(chan compilationOutput, len(runners))
-
-	//an array of channels - the nth runner's compilation output is sent to the nth channel in this array
-	//we read from these channels in order to ensure we run the suites in order
-	orderedCompilationOutputs := []chan compilationOutput{}
-	for _ = range runners {
-		orderedCompilationOutputs = append(orderedCompilationOutputs, make(chan compilationOutput, 1))
-	}
-
-	//we're going to spin up numCompilers compilers - they're going to run concurrently and will consume this channel
-	//we prefill the channel then close it, this ensures we compile things in the correct order
-	workPool := make(chan compilationInput, len(runners))
-	for i, runner := range runners {
-		workPool <- compilationInput{runner, orderedCompilationOutputs[i]}
-	}
-	close(workPool)
-
-	//pick a reasonable numCompilers
-	if numCompilers == 0 {
-		numCompilers = runtime.NumCPU()
-	}
-
-	//a WaitGroup to help us wait for all compilers to shut down
-	wg := &sync.WaitGroup{}
-	wg.Add(numCompilers)
-
-	//spin up the concurrent compilers
-	for i := 0; i < numCompilers; i++ {
-		go func() {
-			defer wg.Done()
-			for input := range workPool {
-				if r.interruptHandler.WasInterrupted() {
-					return
-				}
-
-				if willCompile != nil {
-					willCompile(input.runner.Suite)
-				}
-
-				//We retry because Go sometimes steps on itself when multiple compiles happen in parallel.  This is ugly, but should help resolve flakiness...
-				var err error
-				retries := 0
-				for retries <= 5 {
-					if r.interruptHandler.WasInterrupted() {
-						return
-					}
-					if err = input.runner.Compile(); err == nil {
-						break
-					}
-					retries++
-				}
-
-				input.result <- compilationOutput{input.runner, err}
-			}
-		}()
-	}
-
-	//read from the compilation output channels *in order* and send them to the caller
-	//close the compilationOutputs channel to tell the caller we're done
-	go func() {
-		defer close(compilationOutputs)
-		for _, orderedCompilationOutput := range orderedCompilationOutputs {
-			select {
-			case compilationOutput := <-orderedCompilationOutput:
-				compilationOutputs <- compilationOutput
-			case <-r.interruptHandler.C:
-				//interrupt detected, wait for the compilers to shut down then bail
-				//this ensure we clean up after ourselves as we don't leave any compilation processes running
-				wg.Wait()
-				return
-			}
-		}
-	}()
-
-	return compilationOutputs
-}
-
-func (r *SuiteRunner) RunSuites(runners []*testrunner.TestRunner, numCompilers int, keepGoing bool, willCompile func(suite testsuite.TestSuite)) (testrunner.RunResult, int) {
-	runResult := testrunner.PassingRunResult()
-
-	compilationOutputs := r.compileInParallel(runners, numCompilers, willCompile)
-
-	numSuitesThatRan := 0
-	suitesThatFailed := []testsuite.TestSuite{}
-	for compilationOutput := range compilationOutputs {
-		if compilationOutput.err != nil {
-			fmt.Print(compilationOutput.err.Error())
-		}
-		numSuitesThatRan++
-		suiteRunResult := testrunner.FailingRunResult()
-		if compilationOutput.err == nil {
-			suiteRunResult = compilationOutput.runner.Run()
-		}
-		r.notifier.SendSuiteCompletionNotification(compilationOutput.runner.Suite, suiteRunResult.Passed)
-		r.notifier.RunCommand(compilationOutput.runner.Suite, suiteRunResult.Passed)
-		runResult = runResult.Merge(suiteRunResult)
-		if !suiteRunResult.Passed {
-			suitesThatFailed = append(suitesThatFailed, compilationOutput.runner.Suite)
-			if !keepGoing {
-				break
-			}
-		}
-		if numSuitesThatRan < len(runners) && !config.DefaultReporterConfig.Succinct {
-			fmt.Println("")
-		}
-	}
-
-	if keepGoing && !runResult.Passed {
-		r.listFailedSuites(suitesThatFailed)
-	}
-
-	return runResult, numSuitesThatRan
-}
-
-func (r *SuiteRunner) listFailedSuites(suitesThatFailed []testsuite.TestSuite) {
-	fmt.Println("")
-	fmt.Println("There were failures detected in the following suites:")
-
-	maxPackageNameLength := 0
-	for _, suite := range suitesThatFailed {
-		if len(suite.PackageName) > maxPackageNameLength {
-			maxPackageNameLength = len(suite.PackageName)
-		}
-	}
-
-	packageNameFormatter := fmt.Sprintf("%%%ds", maxPackageNameLength)
-
-	for _, suite := range suitesThatFailed {
-		if config.DefaultReporterConfig.NoColor {
-			fmt.Printf("\t"+packageNameFormatter+" %s\n", suite.PackageName, suite.Path)
-		} else {
-			fmt.Fprintf(colorable.NewColorableStdout(), "\t%s"+packageNameFormatter+"%s %s%s%s\n", redColor, suite.PackageName, defaultStyle, lightGrayColor, suite.Path, defaultStyle)
-		}
-	}
-}

vendor/github.com/onsi/ginkgo/ginkgo/testrunner/log_writer.go

@@ -1,52 +0,0 @@
-package testrunner
-
-import (
-	"bytes"
-	"fmt"
-	"io"
-	"log"
-	"strings"
-	"sync"
-)
-
-type logWriter struct {
-	buffer *bytes.Buffer
-	lock   *sync.Mutex
-	log    *log.Logger
-}
-
-func newLogWriter(target io.Writer, node int) *logWriter {
-	return &logWriter{
-		buffer: &bytes.Buffer{},
-		lock:   &sync.Mutex{},
-		log:    log.New(target, fmt.Sprintf("[%d] ", node), 0),
-	}
-}
-
-func (w *logWriter) Write(data []byte) (n int, err error) {
-	w.lock.Lock()
-	defer w.lock.Unlock()
-
-	w.buffer.Write(data)
-	contents := w.buffer.String()
-
-	lines := strings.Split(contents, "\n")
-	for _, line := range lines[0 : len(lines)-1] {
-		w.log.Println(line)
-	}
-
-	w.buffer.Reset()
-	w.buffer.Write([]byte(lines[len(lines)-1]))
-	return len(data), nil
-}
-
-func (w *logWriter) Close() error {
-	w.lock.Lock()
-	defer w.lock.Unlock()
-
-	if w.buffer.Len() > 0 {
-		w.log.Println(w.buffer.String())
-	}
-
-	return nil
-}

vendor/github.com/onsi/ginkgo/ginkgo/testrunner/run_result.go

@@ -1,27 +0,0 @@
-package testrunner
-
-type RunResult struct {
-	Passed               bool
-	HasProgrammaticFocus bool
-}
-
-func PassingRunResult() RunResult {
-	return RunResult{
-		Passed:               true,
-		HasProgrammaticFocus: false,
-	}
-}
-
-func FailingRunResult() RunResult {
-	return RunResult{
-		Passed:               false,
-		HasProgrammaticFocus: false,
-	}
-}
-
-func (r RunResult) Merge(o RunResult) RunResult {
-	return RunResult{
-		Passed:               r.Passed && o.Passed,
-		HasProgrammaticFocus: r.HasProgrammaticFocus || o.HasProgrammaticFocus,
-	}
-}

vendor/github.com/onsi/ginkgo/ginkgo/testrunner/test_runner.go

@@ -1,488 +0,0 @@
-package testrunner
-
-import (
-	"bytes"
-	"fmt"
-	"io"
-	"io/ioutil"
-	"os"
-	"os/exec"
-	"path/filepath"
-	"strconv"
-	"strings"
-	"syscall"
-	"time"
-
-	"github.com/onsi/ginkgo/config"
-	"github.com/onsi/ginkgo/ginkgo/testsuite"
-	"github.com/onsi/ginkgo/internal/remote"
-	"github.com/onsi/ginkgo/reporters/stenographer"
-	"github.com/onsi/ginkgo/types"
-)
-
-type TestRunner struct {
-	Suite testsuite.TestSuite
-
-	compiled              bool
-	compilationTargetPath string
-
-	numCPU         int
-	parallelStream bool
-	timeout        time.Duration
-	goOpts         map[string]interface{}
-	additionalArgs []string
-	stderr         *bytes.Buffer
-}
-
-func New(suite testsuite.TestSuite, numCPU int, parallelStream bool, timeout time.Duration, goOpts map[string]interface{}, additionalArgs []string) *TestRunner {
-	runner := &TestRunner{
-		Suite:          suite,
-		numCPU:         numCPU,
-		parallelStream: parallelStream,
-		goOpts:         goOpts,
-		additionalArgs: additionalArgs,
-		timeout:        timeout,
-		stderr:         new(bytes.Buffer),
-	}
-
-	if !suite.Precompiled {
-		dir, err := ioutil.TempDir("", "ginkgo")
-		if err != nil {
-			panic(fmt.Sprintf("couldn't create temporary directory... might be time to rm -rf:\n%s", err.Error()))
-		}
-		runner.compilationTargetPath = filepath.Join(dir, suite.PackageName+".test")
-	}
-
-	return runner
-}
-
-func (t *TestRunner) Compile() error {
-	return t.CompileTo(t.compilationTargetPath)
-}
-
-func (t *TestRunner) BuildArgs(path string) []string {
-	args := []string{"test", "-c", "-i", "-o", path, t.Suite.Path}
-
-	if *t.goOpts["covermode"].(*string) != "" {
-		args = append(args, "-cover", fmt.Sprintf("-covermode=%s", *t.goOpts["covermode"].(*string)))
-	} else {
-		if *t.goOpts["cover"].(*bool) || *t.goOpts["coverpkg"].(*string) != "" {
-			args = append(args, "-cover", "-covermode=atomic")
-		}
-	}
-
-	boolOpts := []string{
-		"a",
-		"n",
-		"msan",
-		"race",
-		"x",
-		"work",
-		"linkshared",
-	}
-
-	for _, opt := range boolOpts {
-		if s, found := t.goOpts[opt].(*bool); found && *s {
-			args = append(args, fmt.Sprintf("-%s", opt))
-		}
-	}
-
-	intOpts := []string{
-		"memprofilerate",
-		"blockprofilerate",
-	}
-
-	for _, opt := range intOpts {
-		if s, found := t.goOpts[opt].(*int); found {
-			args = append(args, fmt.Sprintf("-%s=%d", opt, *s))
-		}
-	}
-
-	stringOpts := []string{
-		"asmflags",
-		"buildmode",
-		"compiler",
-		"gccgoflags",
-		"installsuffix",
-		"ldflags",
-		"pkgdir",
-		"toolexec",
-		"coverprofile",
-		"cpuprofile",
-		"memprofile",
-		"outputdir",
-		"coverpkg",
-		"tags",
-		"gcflags",
-	}
-
-	for _, opt := range stringOpts {
-		if s, found := t.goOpts[opt].(*string); found && *s != "" {
-			args = append(args, fmt.Sprintf("-%s=%s", opt, *s))
-		}
-	}
-	return args
-}
-
-func (t *TestRunner) CompileTo(path string) error {
-	if t.compiled {
-		return nil
-	}
-
-	if t.Suite.Precompiled {
-		return nil
-	}
-
-	args := t.BuildArgs(path)
-	cmd := exec.Command("go", args...)
-
-	output, err := cmd.CombinedOutput()
-
-	if err != nil {
-		if len(output) > 0 {
-			return fmt.Errorf("Failed to compile %s:\n\n%s", t.Suite.PackageName, output)
-		}
-		return fmt.Errorf("Failed to compile %s", t.Suite.PackageName)
-	}
-
-	if len(output) > 0 {
-		fmt.Println(string(output))
-	}
-
-	if fileExists(path) == false {
-		compiledFile := t.Suite.PackageName + ".test"
-		if fileExists(compiledFile) {
-			// seems like we are on an old go version that does not support the -o flag on go test
-			// move the compiled test file to the desired location by hand
-			err = os.Rename(compiledFile, path)
-			if err != nil {
-				// We cannot move the file, perhaps because the source and destination
-				// are on different partitions. We can copy the file, however.
-				err = copyFile(compiledFile, path)
-				if err != nil {
-					return fmt.Errorf("Failed to copy compiled file: %s", err)
-				}
-			}
-		} else {
-			return fmt.Errorf("Failed to compile %s: output file %q could not be found", t.Suite.PackageName, path)
-		}
-	}
-
-	t.compiled = true
-
-	return nil
-}
-
-func fileExists(path string) bool {
-	_, err := os.Stat(path)
-	return err == nil || os.IsNotExist(err) == false
-}
-
-// copyFile copies the contents of the file named src to the file named
-// by dst. The file will be created if it does not already exist. If the
-// destination file exists, all it's contents will be replaced by the contents
-// of the source file.
-func copyFile(src, dst string) error {
-	srcInfo, err := os.Stat(src)
-	if err != nil {
-		return err
-	}
-	mode := srcInfo.Mode()
-
-	in, err := os.Open(src)
-	if err != nil {
-		return err
-	}
-
-	defer in.Close()
-
-	out, err := os.Create(dst)
-	if err != nil {
-		return err
-	}
-
-	defer func() {
-		closeErr := out.Close()
-		if err == nil {
-			err = closeErr
-		}
-	}()
-
-	_, err = io.Copy(out, in)
-	if err != nil {
-		return err
-	}
-
-	err = out.Sync()
-	if err != nil {
-		return err
-	}
-
-	return out.Chmod(mode)
-}
-
-func (t *TestRunner) Run() RunResult {
-	if t.Suite.IsGinkgo {
-		if t.numCPU > 1 {
-			if t.parallelStream {
-				return t.runAndStreamParallelGinkgoSuite()
-			} else {
-				return t.runParallelGinkgoSuite()
-			}
-		} else {
-			return t.runSerialGinkgoSuite()
-		}
-	} else {
-		return t.runGoTestSuite()
-	}
-}
-
-func (t *TestRunner) CleanUp() {
-	if t.Suite.Precompiled {
-		return
-	}
-	os.RemoveAll(filepath.Dir(t.compilationTargetPath))
-}
-
-func (t *TestRunner) runSerialGinkgoSuite() RunResult {
-	ginkgoArgs := config.BuildFlagArgs("ginkgo", config.GinkgoConfig, config.DefaultReporterConfig)
-	return t.run(t.cmd(ginkgoArgs, os.Stdout, 1), nil)
-}
-
-func (t *TestRunner) runGoTestSuite() RunResult {
-	return t.run(t.cmd([]string{"-test.v"}, os.Stdout, 1), nil)
-}
-
-func (t *TestRunner) runAndStreamParallelGinkgoSuite() RunResult {
-	completions := make(chan RunResult)
-	writers := make([]*logWriter, t.numCPU)
-
-	server, err := remote.NewServer(t.numCPU)
-	if err != nil {
-		panic("Failed to start parallel spec server")
-	}
-
-	server.Start()
-	defer server.Close()
-
-	for cpu := 0; cpu < t.numCPU; cpu++ {
-		config.GinkgoConfig.ParallelNode = cpu + 1
-		config.GinkgoConfig.ParallelTotal = t.numCPU
-		config.GinkgoConfig.SyncHost = server.Address()
-
-		ginkgoArgs := config.BuildFlagArgs("ginkgo", config.GinkgoConfig, config.DefaultReporterConfig)
-
-		writers[cpu] = newLogWriter(os.Stdout, cpu+1)
-
-		cmd := t.cmd(ginkgoArgs, writers[cpu], cpu+1)
-
-		server.RegisterAlive(cpu+1, func() bool {
-			if cmd.ProcessState == nil {
-				return true
-			}
-			return !cmd.ProcessState.Exited()
-		})
-
-		go t.run(cmd, completions)
-	}
-
-	res := PassingRunResult()
-
-	for cpu := 0; cpu < t.numCPU; cpu++ {
-		res = res.Merge(<-completions)
-	}
-
-	for _, writer := range writers {
-		writer.Close()
-	}
-
-	os.Stdout.Sync()
-
-	if *t.goOpts["cover"].(*bool) || *t.goOpts["coverpkg"].(*string) != "" || *t.goOpts["covermode"].(*string) != "" {
-		t.combineCoverprofiles()
-	}
-
-	return res
-}
-
-func (t *TestRunner) runParallelGinkgoSuite() RunResult {
-	result := make(chan bool)
-	completions := make(chan RunResult)
-	writers := make([]*logWriter, t.numCPU)
-	reports := make([]*bytes.Buffer, t.numCPU)
-
-	stenographer := stenographer.New(!config.DefaultReporterConfig.NoColor, config.GinkgoConfig.FlakeAttempts > 1)
-	aggregator := remote.NewAggregator(t.numCPU, result, config.DefaultReporterConfig, stenographer)
-
-	server, err := remote.NewServer(t.numCPU)
-	if err != nil {
-		panic("Failed to start parallel spec server")
-	}
-	server.RegisterReporters(aggregator)
-	server.Start()
-	defer server.Close()
-
-	for cpu := 0; cpu < t.numCPU; cpu++ {
-		config.GinkgoConfig.ParallelNode = cpu + 1
-		config.GinkgoConfig.ParallelTotal = t.numCPU
-		config.GinkgoConfig.SyncHost = server.Address()
-		config.GinkgoConfig.StreamHost = server.Address()
-
-		ginkgoArgs := config.BuildFlagArgs("ginkgo", config.GinkgoConfig, config.DefaultReporterConfig)
-
-		reports[cpu] = &bytes.Buffer{}
-		writers[cpu] = newLogWriter(reports[cpu], cpu+1)
-
-		cmd := t.cmd(ginkgoArgs, writers[cpu], cpu+1)
-
-		server.RegisterAlive(cpu+1, func() bool {
-			if cmd.ProcessState == nil {
-				return true
-			}
-			return !cmd.ProcessState.Exited()
-		})
-
-		go t.run(cmd, completions)
-	}
-
-	res := PassingRunResult()
-
-	for cpu := 0; cpu < t.numCPU; cpu++ {
-		res = res.Merge(<-completions)
-	}
-
-	//all test processes are done, at this point
-	//we should be able to wait for the aggregator to tell us that it's done
-
-	select {
-	case <-result:
-		fmt.Println("")
-	case <-time.After(time.Second):
-		//the aggregator never got back to us!  something must have gone wrong
-		fmt.Println(`
-	 -------------------------------------------------------------------
-	|                                                                   |
-	|  Ginkgo timed out waiting for all parallel nodes to report back!  |
-	|                                                                   |
-	 -------------------------------------------------------------------
-`)
-		fmt.Println(t.Suite.PackageName, "timed out. path:", t.Suite.Path)
-		os.Stdout.Sync()
-
-		for _, writer := range writers {
-			writer.Close()
-		}
-
-		for _, report := range reports {
-			fmt.Print(report.String())
-		}
-
-		os.Stdout.Sync()
-	}
-
-	if *t.goOpts["cover"].(*bool) || *t.goOpts["coverpkg"].(*string) != "" || *t.goOpts["covermode"].(*string) != "" {
-		t.combineCoverprofiles()
-	}
-
-	return res
-}
-
-func (t *TestRunner) cmd(ginkgoArgs []string, stream io.Writer, node int) *exec.Cmd {
-	args := []string{"--test.timeout=" + t.timeout.String()}
-	if *t.goOpts["cover"].(*bool) || *t.goOpts["coverpkg"].(*string) != "" || *t.goOpts["covermode"].(*string) != "" {
-		coverprofile := "--test.coverprofile=" + t.Suite.PackageName + ".coverprofile"
-		if t.numCPU > 1 {
-			coverprofile = fmt.Sprintf("%s.%d", coverprofile, node)
-		}
-		args = append(args, coverprofile)
-	}
-
-	args = append(args, ginkgoArgs...)
-	args = append(args, t.additionalArgs...)
-
-	path := t.compilationTargetPath
-	if t.Suite.Precompiled {
-		path, _ = filepath.Abs(filepath.Join(t.Suite.Path, fmt.Sprintf("%s.test", t.Suite.PackageName)))
-	}
-
-	cmd := exec.Command(path, args...)
-
-	cmd.Dir = t.Suite.Path
-	cmd.Stderr = io.MultiWriter(stream, t.stderr)
-	cmd.Stdout = stream
-
-	return cmd
-}
-
-func (t *TestRunner) run(cmd *exec.Cmd, completions chan RunResult) RunResult {
-	var res RunResult
-
-	defer func() {
-		if completions != nil {
-			completions <- res
-		}
-	}()
-
-	err := cmd.Start()
-	if err != nil {
-		fmt.Printf("Failed to run test suite!\n\t%s", err.Error())
-		return res
-	}
-
-	cmd.Wait()
-
-	exitStatus := cmd.ProcessState.Sys().(syscall.WaitStatus).ExitStatus()
-	res.Passed = (exitStatus == 0) || (exitStatus == types.GINKGO_FOCUS_EXIT_CODE)
-	res.HasProgrammaticFocus = (exitStatus == types.GINKGO_FOCUS_EXIT_CODE)
-
-	if strings.Contains(t.stderr.String(), "warning: no tests to run") {
-		if *t.goOpts["requireSuite"].(*bool) {
-			res.Passed = false
-		}
-		fmt.Fprintf(os.Stderr, `Found no test suites, did you forget to run "ginkgo bootstrap"?`)
-	}
-
-	return res
-}
-
-func (t *TestRunner) combineCoverprofiles() {
-	profiles := []string{}
-	for cpu := 1; cpu <= t.numCPU; cpu++ {
-		coverFile := fmt.Sprintf("%s.coverprofile.%d", t.Suite.PackageName, cpu)
-		coverFile = filepath.Join(t.Suite.Path, coverFile)
-		coverProfile, err := ioutil.ReadFile(coverFile)
-		os.Remove(coverFile)
-
-		if err == nil {
-			profiles = append(profiles, string(coverProfile))
-		}
-	}
-
-	if len(profiles) != t.numCPU {
-		return
-	}
-
-	lines := map[string]int{}
-	lineOrder := []string{}
-	for i, coverProfile := range profiles {
-		for _, line := range strings.Split(string(coverProfile), "\n")[1:] {
-			if len(line) == 0 {
-				continue
-			}
-			components := strings.Split(line, " ")
-			count, _ := strconv.Atoi(components[len(components)-1])
-			prefix := strings.Join(components[0:len(components)-1], " ")
-			lines[prefix] += count
-			if i == 0 {
-				lineOrder = append(lineOrder, prefix)
-			}
-		}
-	}
-
-	output := []string{"mode: atomic"}
-	for _, line := range lineOrder {
-		output = append(output, fmt.Sprintf("%s %d", line, lines[line]))
-	}
-	finalOutput := strings.Join(output, "\n")
-	ioutil.WriteFile(filepath.Join(t.Suite.Path, fmt.Sprintf("%s.coverprofile", t.Suite.PackageName)), []byte(finalOutput), 0666)
-}

vendor/github.com/onsi/ginkgo/ginkgo/testrunner/test_runner_test.go

@@ -1,57 +0,0 @@
-package testrunner_test
-
-import (
-	"testing"
-
-	. "github.com/onsi/ginkgo"
-	"github.com/onsi/ginkgo/ginkgo/testrunner"
-	"github.com/onsi/ginkgo/ginkgo/testsuite"
-	. "github.com/onsi/gomega"
-)
-
-func strAddr(s string) interface{} {
-	return &s
-}
-
-func boolAddr(s bool) interface{} {
-	return &s
-}
-
-func intAddr(s int) interface{} {
-	return &s
-}
-
-var _ = Describe("TestRunner", func() {
-	It("should pass through go opts", func() {
-		//var opts map[string]interface{}
-		opts := map[string]interface{}{
-			"asmflags":         strAddr("a"),
-			"pkgdir":           strAddr("b"),
-			"gcflags":          strAddr("c"),
-			"covermode":        strAddr(""),
-			"coverpkg":         strAddr(""),
-			"cover":            boolAddr(false),
-			"blockprofilerate": intAddr(100),
-		}
-		tr := testrunner.New(testsuite.TestSuite{}, 1, false, 0, opts, []string{})
-
-		args := tr.BuildArgs(".")
-		Ω(args).Should(Equal([]string{
-			"test",
-			"-c",
-			"-i",
-			"-o",
-			".",
-			"",
-			"-blockprofilerate=100",
-			"-asmflags=a",
-			"-pkgdir=b",
-			"-gcflags=c",
-		}))
-	})
-})
-
-func TestTestRunner(t *testing.T) {
-	RegisterFailHandler(Fail)
-	RunSpecs(t, "Test Runner Suite")
-}

vendor/github.com/onsi/ginkgo/ginkgo/testsuite/test_suite.go

@@ -1,115 +0,0 @@
-package testsuite
-
-import (
-	"errors"
-	"io/ioutil"
-	"os"
-	"path/filepath"
-	"regexp"
-	"strings"
-)
-
-type TestSuite struct {
-	Path        string
-	PackageName string
-	IsGinkgo    bool
-	Precompiled bool
-}
-
-func PrecompiledTestSuite(path string) (TestSuite, error) {
-	info, err := os.Stat(path)
-	if err != nil {
-		return TestSuite{}, err
-	}
-
-	if info.IsDir() {
-		return TestSuite{}, errors.New("this is a directory, not a file")
-	}
-
-	if filepath.Ext(path) != ".test" {
-		return TestSuite{}, errors.New("this is not a .test binary")
-	}
-
-	if info.Mode()&0111 == 0 {
-		return TestSuite{}, errors.New("this is not executable")
-	}
-
-	dir := relPath(filepath.Dir(path))
-	packageName := strings.TrimSuffix(filepath.Base(path), filepath.Ext(path))
-
-	return TestSuite{
-		Path:        dir,
-		PackageName: packageName,
-		IsGinkgo:    true,
-		Precompiled: true,
-	}, nil
-}
-
-func SuitesInDir(dir string, recurse bool) []TestSuite {
-	suites := []TestSuite{}
-
-	if vendorExperimentCheck(dir) {
-		return suites
-	}
-
-	files, _ := ioutil.ReadDir(dir)
-	re := regexp.MustCompile(`_test\.go$`)
-	for _, file := range files {
-		if !file.IsDir() && re.Match([]byte(file.Name())) {
-			suites = append(suites, New(dir, files))
-			break
-		}
-	}
-
-	if recurse {
-		re = regexp.MustCompile(`^[._]`)
-		for _, file := range files {
-			if file.IsDir() && !re.Match([]byte(file.Name())) {
-				suites = append(suites, SuitesInDir(dir+"/"+file.Name(), recurse)...)
-			}
-		}
-	}
-
-	return suites
-}
-
-func relPath(dir string) string {
-	dir, _ = filepath.Abs(dir)
-	cwd, _ := os.Getwd()
-	dir, _ = filepath.Rel(cwd, filepath.Clean(dir))
-
-	if string(dir[0]) != "." {
-		dir = "." + string(filepath.Separator) + dir
-	}
-
-	return dir
-}
-
-func New(dir string, files []os.FileInfo) TestSuite {
-	return TestSuite{
-		Path:        relPath(dir),
-		PackageName: packageNameForSuite(dir),
-		IsGinkgo:    filesHaveGinkgoSuite(dir, files),
-	}
-}
-
-func packageNameForSuite(dir string) string {
-	path, _ := filepath.Abs(dir)
-	return filepath.Base(path)
-}
-
-func filesHaveGinkgoSuite(dir string, files []os.FileInfo) bool {
-	reTestFile := regexp.MustCompile(`_test\.go$`)
-	reGinkgo := regexp.MustCompile(`package ginkgo|\/ginkgo"`)
-
-	for _, file := range files {
-		if !file.IsDir() && reTestFile.Match([]byte(file.Name())) {
-			contents, _ := ioutil.ReadFile(dir + "/" + file.Name())
-			if reGinkgo.Match(contents) {
-				return true
-			}
-		}
-	}
-
-	return false
-}

vendor/github.com/onsi/ginkgo/ginkgo/testsuite/testsuite_suite_test.go

@@ -1,13 +0,0 @@
-package testsuite_test
-
-import (
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-
-	"testing"
-)
-
-func TestTestsuite(t *testing.T) {
-	RegisterFailHandler(Fail)
-	RunSpecs(t, "Testsuite Suite")
-}

vendor/github.com/onsi/ginkgo/ginkgo/testsuite/testsuite_test.go

@@ -1,201 +0,0 @@
-// +build go1.6
-
-package testsuite_test
-
-import (
-	"io/ioutil"
-	"os"
-	"path/filepath"
-
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/ginkgo/ginkgo/testsuite"
-	. "github.com/onsi/gomega"
-)
-
-var _ = Describe("TestSuite", func() {
-	var tmpDir string
-	var relTmpDir string
-
-	writeFile := func(folder string, filename string, content string, mode os.FileMode) {
-		path := filepath.Join(tmpDir, folder)
-		err := os.MkdirAll(path, 0700)
-		Ω(err).ShouldNot(HaveOccurred())
-
-		path = filepath.Join(path, filename)
-		ioutil.WriteFile(path, []byte(content), mode)
-	}
-
-	var origVendor string
-
-	BeforeSuite(func() {
-		origVendor = os.Getenv("GO15VENDOREXPERIMENT")
-	})
-
-	AfterSuite(func() {
-		os.Setenv("GO15VENDOREXPERIMENT", origVendor)
-	})
-
-	BeforeEach(func() {
-		var err error
-		tmpDir, err = ioutil.TempDir("/tmp", "ginkgo")
-		Ω(err).ShouldNot(HaveOccurred())
-
-		cwd, err := os.Getwd()
-		Ω(err).ShouldNot(HaveOccurred())
-		relTmpDir, err = filepath.Rel(cwd, tmpDir)
-		Ω(err).ShouldNot(HaveOccurred())
-
-		//go files in the root directory (no tests)
-		writeFile("/", "main.go", "package main", 0666)
-
-		//non-go files in a nested directory
-		writeFile("/redherring", "big_test.jpg", "package ginkgo", 0666)
-
-		//non-ginkgo tests in a nested directory
-		writeFile("/professorplum", "professorplum_test.go", `import "testing"`, 0666)
-
-		//ginkgo tests in a nested directory
-		writeFile("/colonelmustard", "colonelmustard_test.go", `import "github.com/onsi/ginkgo"`, 0666)
-
-		//ginkgo tests in a deeply nested directory
-		writeFile("/colonelmustard/library", "library_test.go", `import "github.com/onsi/ginkgo"`, 0666)
-
-		//ginkgo tests deeply nested in a vendored dependency
-		writeFile("/vendor/mrspeacock/lounge", "lounge_test.go", `import "github.com/onsi/ginkgo"`, 0666)
-
-		//a precompiled ginkgo test
-		writeFile("/precompiled-dir", "precompiled.test", `fake-binary-file`, 0777)
-		writeFile("/precompiled-dir", "some-other-binary", `fake-binary-file`, 0777)
-		writeFile("/precompiled-dir", "nonexecutable.test", `fake-binary-file`, 0666)
-	})
-
-	AfterEach(func() {
-		os.RemoveAll(tmpDir)
-	})
-
-	Describe("Finding precompiled test suites", func() {
-		Context("if pointed at an executable file that ends with .test", func() {
-			It("should return a precompiled test suite", func() {
-				suite, err := PrecompiledTestSuite(filepath.Join(tmpDir, "precompiled-dir", "precompiled.test"))
-				Ω(err).ShouldNot(HaveOccurred())
-				Ω(suite).Should(Equal(TestSuite{
-					Path:        relTmpDir + "/precompiled-dir",
-					PackageName: "precompiled",
-					IsGinkgo:    true,
-					Precompiled: true,
-				}))
-			})
-		})
-
-		Context("if pointed at a directory", func() {
-			It("should error", func() {
-				suite, err := PrecompiledTestSuite(filepath.Join(tmpDir, "precompiled-dir"))
-				Ω(suite).Should(BeZero())
-				Ω(err).Should(HaveOccurred())
-			})
-		})
-
-		Context("if pointed at an executable that doesn't have .test", func() {
-			It("should error", func() {
-				suite, err := PrecompiledTestSuite(filepath.Join(tmpDir, "precompiled-dir", "some-other-binary"))
-				Ω(suite).Should(BeZero())
-				Ω(err).Should(HaveOccurred())
-			})
-		})
-
-		Context("if pointed at a .test that isn't executable", func() {
-			It("should error", func() {
-				suite, err := PrecompiledTestSuite(filepath.Join(tmpDir, "precompiled-dir", "nonexecutable.test"))
-				Ω(suite).Should(BeZero())
-				Ω(err).Should(HaveOccurred())
-			})
-		})
-
-		Context("if pointed at a nonexisting file", func() {
-			It("should error", func() {
-				suite, err := PrecompiledTestSuite(filepath.Join(tmpDir, "precompiled-dir", "nope-nothing-to-see-here"))
-				Ω(suite).Should(BeZero())
-				Ω(err).Should(HaveOccurred())
-			})
-		})
-	})
-
-	Describe("scanning for suites in a directory", func() {
-		Context("when there are no tests in the specified directory", func() {
-			It("should come up empty", func() {
-				suites := SuitesInDir(tmpDir, false)
-				Ω(suites).Should(BeEmpty())
-			})
-		})
-
-		Context("when there are ginkgo tests in the specified directory", func() {
-			It("should return an appropriately configured suite", func() {
-				suites := SuitesInDir(filepath.Join(tmpDir, "colonelmustard"), false)
-				Ω(suites).Should(HaveLen(1))
-
-				Ω(suites[0].Path).Should(Equal(relTmpDir + "/colonelmustard"))
-				Ω(suites[0].PackageName).Should(Equal("colonelmustard"))
-				Ω(suites[0].IsGinkgo).Should(BeTrue())
-				Ω(suites[0].Precompiled).Should(BeFalse())
-			})
-		})
-
-		Context("when there are non-ginkgo tests in the specified directory", func() {
-			It("should return an appropriately configured suite", func() {
-				suites := SuitesInDir(filepath.Join(tmpDir, "professorplum"), false)
-				Ω(suites).Should(HaveLen(1))
-
-				Ω(suites[0].Path).Should(Equal(relTmpDir + "/professorplum"))
-				Ω(suites[0].PackageName).Should(Equal("professorplum"))
-				Ω(suites[0].IsGinkgo).Should(BeFalse())
-				Ω(suites[0].Precompiled).Should(BeFalse())
-			})
-		})
-
-		Context("given GO15VENDOREXPERIMENT disabled", func() {
-			BeforeEach(func() {
-				os.Setenv("GO15VENDOREXPERIMENT", "0")
-			})
-
-			AfterEach(func() {
-				os.Setenv("GO15VENDOREXPERIMENT", "")
-			})
-
-			It("should not skip vendor dirs", func() {
-				suites := SuitesInDir(filepath.Join(tmpDir+"/vendor"), true)
-				Ω(suites).Should(HaveLen(1))
-			})
-
-			It("should recurse into vendor dirs", func() {
-				suites := SuitesInDir(filepath.Join(tmpDir), true)
-				Ω(suites).Should(HaveLen(4))
-			})
-		})
-
-		Context("when recursively scanning", func() {
-			It("should return suites for corresponding test suites, only", func() {
-				suites := SuitesInDir(tmpDir, true)
-				Ω(suites).Should(HaveLen(3))
-
-				Ω(suites).Should(ContainElement(TestSuite{
-					Path:        relTmpDir + "/colonelmustard",
-					PackageName: "colonelmustard",
-					IsGinkgo:    true,
-					Precompiled: false,
-				}))
-				Ω(suites).Should(ContainElement(TestSuite{
-					Path:        relTmpDir + "/professorplum",
-					PackageName: "professorplum",
-					IsGinkgo:    false,
-					Precompiled: false,
-				}))
-				Ω(suites).Should(ContainElement(TestSuite{
-					Path:        relTmpDir + "/colonelmustard/library",
-					PackageName: "library",
-					IsGinkgo:    true,
-					Precompiled: false,
-				}))
-			})
-		})
-	})
-})

vendor/github.com/onsi/ginkgo/ginkgo/testsuite/vendor_check_go15.go

@@ -1,16 +0,0 @@
-// +build !go1.6
-
-package testsuite
-
-import (
-	"os"
-	"path"
-)
-
-// "This change will only be enabled if the go command is run with
-// GO15VENDOREXPERIMENT=1 in its environment."
-// c.f. the vendor-experiment proposal https://goo.gl/2ucMeC
-func vendorExperimentCheck(dir string) bool {
-	vendorExperiment := os.Getenv("GO15VENDOREXPERIMENT")
-	return vendorExperiment == "1" && path.Base(dir) == "vendor"
-}

vendor/github.com/onsi/ginkgo/ginkgo/testsuite/vendor_check_go15_test.go

@@ -1,201 +0,0 @@
-// +build !go1.6
-
-package testsuite_test
-
-import (
-	"io/ioutil"
-	"os"
-	"path/filepath"
-
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/ginkgo/ginkgo/testsuite"
-	. "github.com/onsi/gomega"
-)
-
-var _ = Describe("TestSuite", func() {
-	var tmpDir string
-	var relTmpDir string
-
-	writeFile := func(folder string, filename string, content string, mode os.FileMode) {
-		path := filepath.Join(tmpDir, folder)
-		err := os.MkdirAll(path, 0700)
-		Ω(err).ShouldNot(HaveOccurred())
-
-		path = filepath.Join(path, filename)
-		ioutil.WriteFile(path, []byte(content), mode)
-	}
-
-	var origVendor string
-
-	BeforeSuite(func() {
-		origVendor = os.Getenv("GO15VENDOREXPERIMENT")
-	})
-
-	AfterSuite(func() {
-		os.Setenv("GO15VENDOREXPERIMENT", origVendor)
-	})
-
-	BeforeEach(func() {
-		var err error
-		tmpDir, err = ioutil.TempDir("/tmp", "ginkgo")
-		Ω(err).ShouldNot(HaveOccurred())
-
-		cwd, err := os.Getwd()
-		Ω(err).ShouldNot(HaveOccurred())
-		relTmpDir, err = filepath.Rel(cwd, tmpDir)
-		Ω(err).ShouldNot(HaveOccurred())
-
-		//go files in the root directory (no tests)
-		writeFile("/", "main.go", "package main", 0666)
-
-		//non-go files in a nested directory
-		writeFile("/redherring", "big_test.jpg", "package ginkgo", 0666)
-
-		//non-ginkgo tests in a nested directory
-		writeFile("/professorplum", "professorplum_test.go", `import "testing"`, 0666)
-
-		//ginkgo tests in a nested directory
-		writeFile("/colonelmustard", "colonelmustard_test.go", `import "github.com/onsi/ginkgo"`, 0666)
-
-		//ginkgo tests in a deeply nested directory
-		writeFile("/colonelmustard/library", "library_test.go", `import "github.com/onsi/ginkgo"`, 0666)
-
-		//ginkgo tests deeply nested in a vendored dependency
-		writeFile("/vendor/mrspeacock/lounge", "lounge_test.go", `import "github.com/onsi/ginkgo"`, 0666)
-
-		//a precompiled ginkgo test
-		writeFile("/precompiled-dir", "precompiled.test", `fake-binary-file`, 0777)
-		writeFile("/precompiled-dir", "some-other-binary", `fake-binary-file`, 0777)
-		writeFile("/precompiled-dir", "nonexecutable.test", `fake-binary-file`, 0666)
-	})
-
-	AfterEach(func() {
-		os.RemoveAll(tmpDir)
-	})
-
-	Describe("Finding precompiled test suites", func() {
-		Context("if pointed at an executable file that ends with .test", func() {
-			It("should return a precompiled test suite", func() {
-				suite, err := PrecompiledTestSuite(filepath.Join(tmpDir, "precompiled-dir", "precompiled.test"))
-				Ω(err).ShouldNot(HaveOccurred())
-				Ω(suite).Should(Equal(TestSuite{
-					Path:        relTmpDir + "/precompiled-dir",
-					PackageName: "precompiled",
-					IsGinkgo:    true,
-					Precompiled: true,
-				}))
-			})
-		})
-
-		Context("if pointed at a directory", func() {
-			It("should error", func() {
-				suite, err := PrecompiledTestSuite(filepath.Join(tmpDir, "precompiled-dir"))
-				Ω(suite).Should(BeZero())
-				Ω(err).Should(HaveOccurred())
-			})
-		})
-
-		Context("if pointed at an executable that doesn't have .test", func() {
-			It("should error", func() {
-				suite, err := PrecompiledTestSuite(filepath.Join(tmpDir, "precompiled-dir", "some-other-binary"))
-				Ω(suite).Should(BeZero())
-				Ω(err).Should(HaveOccurred())
-			})
-		})
-
-		Context("if pointed at a .test that isn't executable", func() {
-			It("should error", func() {
-				suite, err := PrecompiledTestSuite(filepath.Join(tmpDir, "precompiled-dir", "nonexecutable.test"))
-				Ω(suite).Should(BeZero())
-				Ω(err).Should(HaveOccurred())
-			})
-		})
-
-		Context("if pointed at a nonexisting file", func() {
-			It("should error", func() {
-				suite, err := PrecompiledTestSuite(filepath.Join(tmpDir, "precompiled-dir", "nope-nothing-to-see-here"))
-				Ω(suite).Should(BeZero())
-				Ω(err).Should(HaveOccurred())
-			})
-		})
-	})
-
-	Describe("scanning for suites in a directory", func() {
-		Context("when there are no tests in the specified directory", func() {
-			It("should come up empty", func() {
-				suites := SuitesInDir(tmpDir, false)
-				Ω(suites).Should(BeEmpty())
-			})
-		})
-
-		Context("when there are ginkgo tests in the specified directory", func() {
-			It("should return an appropriately configured suite", func() {
-				suites := SuitesInDir(filepath.Join(tmpDir, "colonelmustard"), false)
-				Ω(suites).Should(HaveLen(1))
-
-				Ω(suites[0].Path).Should(Equal(relTmpDir + "/colonelmustard"))
-				Ω(suites[0].PackageName).Should(Equal("colonelmustard"))
-				Ω(suites[0].IsGinkgo).Should(BeTrue())
-				Ω(suites[0].Precompiled).Should(BeFalse())
-			})
-		})
-
-		Context("when there are non-ginkgo tests in the specified directory", func() {
-			It("should return an appropriately configured suite", func() {
-				suites := SuitesInDir(filepath.Join(tmpDir, "professorplum"), false)
-				Ω(suites).Should(HaveLen(1))
-
-				Ω(suites[0].Path).Should(Equal(relTmpDir + "/professorplum"))
-				Ω(suites[0].PackageName).Should(Equal("professorplum"))
-				Ω(suites[0].IsGinkgo).Should(BeFalse())
-				Ω(suites[0].Precompiled).Should(BeFalse())
-			})
-		})
-
-		Context("given GO15VENDOREXPERIMENT", func() {
-			BeforeEach(func() {
-				os.Setenv("GO15VENDOREXPERIMENT", "1")
-			})
-
-			AfterEach(func() {
-				os.Setenv("GO15VENDOREXPERIMENT", "")
-			})
-
-			It("should skip vendor dirs", func() {
-				suites := SuitesInDir(filepath.Join(tmpDir+"/vendor"), false)
-				Ω(suites).Should(HaveLen(0))
-			})
-
-			It("should not recurse into vendor dirs", func() {
-				suites := SuitesInDir(filepath.Join(tmpDir), true)
-				Ω(suites).Should(HaveLen(3))
-			})
-		})
-
-		Context("when recursively scanning", func() {
-			It("should return suites for corresponding test suites, only", func() {
-				suites := SuitesInDir(tmpDir, true)
-				Ω(suites).Should(HaveLen(4))
-
-				Ω(suites).Should(ContainElement(TestSuite{
-					Path:        relTmpDir + "/colonelmustard",
-					PackageName: "colonelmustard",
-					IsGinkgo:    true,
-					Precompiled: false,
-				}))
-				Ω(suites).Should(ContainElement(TestSuite{
-					Path:        relTmpDir + "/professorplum",
-					PackageName: "professorplum",
-					IsGinkgo:    false,
-					Precompiled: false,
-				}))
-				Ω(suites).Should(ContainElement(TestSuite{
-					Path:        relTmpDir + "/colonelmustard/library",
-					PackageName: "library",
-					IsGinkgo:    true,
-					Precompiled: false,
-				}))
-			})
-		})
-	})
-})

vendor/github.com/onsi/ginkgo/ginkgo/testsuite/vendor_check_go16.go

@@ -1,15 +0,0 @@
-// +build go1.6
-
-package testsuite
-
-import (
-	"os"
-	"path"
-)
-
-// in 1.6 the vendor directory became the default go behaviour, so now
-// check if its disabled.
-func vendorExperimentCheck(dir string) bool {
-	vendorExperiment := os.Getenv("GO15VENDOREXPERIMENT")
-	return vendorExperiment != "0" && path.Base(dir) == "vendor"
-}

vendor/github.com/onsi/ginkgo/ginkgo/unfocus_command.go

@@ -1,38 +0,0 @@
-package main
-
-import (
-	"flag"
-	"fmt"
-	"os/exec"
-)
-
-func BuildUnfocusCommand() *Command {
-	return &Command{
-		Name:         "unfocus",
-		AltName:      "blur",
-		FlagSet:      flag.NewFlagSet("unfocus", flag.ExitOnError),
-		UsageCommand: "ginkgo unfocus (or ginkgo blur)",
-		Usage: []string{
-			"Recursively unfocuses any focused tests under the current directory",
-		},
-		Command: unfocusSpecs,
-	}
-}
-
-func unfocusSpecs([]string, []string) {
-	unfocus("Describe")
-	unfocus("Context")
-	unfocus("It")
-	unfocus("Measure")
-	unfocus("DescribeTable")
-	unfocus("Entry")
-}
-
-func unfocus(component string) {
-	fmt.Printf("Removing F%s...\n", component)
-	cmd := exec.Command("gofmt", fmt.Sprintf("-r=F%s -> %s", component, component), "-w", ".")
-	out, _ := cmd.CombinedOutput()
-	if string(out) != "" {
-		println(string(out))
-	}
-}

vendor/github.com/onsi/ginkgo/ginkgo/version_command.go

@@ -1,23 +0,0 @@
-package main
-
-import (
-	"flag"
-	"fmt"
-	"github.com/onsi/ginkgo/config"
-)
-
-func BuildVersionCommand() *Command {
-	return &Command{
-		Name:         "version",
-		FlagSet:      flag.NewFlagSet("version", flag.ExitOnError),
-		UsageCommand: "ginkgo version",
-		Usage: []string{
-			"Print Ginkgo's version",
-		},
-		Command: printVersion,
-	}
-}
-
-func printVersion([]string, []string) {
-	fmt.Printf("Ginkgo Version %s\n", config.VERSION)
-}

vendor/github.com/onsi/ginkgo/ginkgo/watch/delta.go

@@ -1,22 +0,0 @@
-package watch
-
-import "sort"
-
-type Delta struct {
-	ModifiedPackages []string
-
-	NewSuites      []*Suite
-	RemovedSuites  []*Suite
-	modifiedSuites []*Suite
-}
-
-type DescendingByDelta []*Suite
-
-func (a DescendingByDelta) Len() int           { return len(a) }
-func (a DescendingByDelta) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
-func (a DescendingByDelta) Less(i, j int) bool { return a[i].Delta() > a[j].Delta() }
-
-func (d Delta) ModifiedSuites() []*Suite {
-	sort.Sort(DescendingByDelta(d.modifiedSuites))
-	return d.modifiedSuites
-}

vendor/github.com/onsi/ginkgo/ginkgo/watch/delta_tracker.go

@@ -1,75 +0,0 @@
-package watch
-
-import (
-	"fmt"
-
-	"regexp"
-
-	"github.com/onsi/ginkgo/ginkgo/testsuite"
-)
-
-type SuiteErrors map[testsuite.TestSuite]error
-
-type DeltaTracker struct {
-	maxDepth      int
-	watchRegExp   *regexp.Regexp
-	suites        map[string]*Suite
-	packageHashes *PackageHashes
-}
-
-func NewDeltaTracker(maxDepth int, watchRegExp *regexp.Regexp) *DeltaTracker {
-	return &DeltaTracker{
-		maxDepth:      maxDepth,
-		watchRegExp:   watchRegExp,
-		packageHashes: NewPackageHashes(watchRegExp),
-		suites:        map[string]*Suite{},
-	}
-}
-
-func (d *DeltaTracker) Delta(suites []testsuite.TestSuite) (delta Delta, errors SuiteErrors) {
-	errors = SuiteErrors{}
-	delta.ModifiedPackages = d.packageHashes.CheckForChanges()
-
-	providedSuitePaths := map[string]bool{}
-	for _, suite := range suites {
-		providedSuitePaths[suite.Path] = true
-	}
-
-	d.packageHashes.StartTrackingUsage()
-
-	for _, suite := range d.suites {
-		if providedSuitePaths[suite.Suite.Path] {
-			if suite.Delta() > 0 {
-				delta.modifiedSuites = append(delta.modifiedSuites, suite)
-			}
-		} else {
-			delta.RemovedSuites = append(delta.RemovedSuites, suite)
-		}
-	}
-
-	d.packageHashes.StopTrackingUsageAndPrune()
-
-	for _, suite := range suites {
-		_, ok := d.suites[suite.Path]
-		if !ok {
-			s, err := NewSuite(suite, d.maxDepth, d.packageHashes)
-			if err != nil {
-				errors[suite] = err
-				continue
-			}
-			d.suites[suite.Path] = s
-			delta.NewSuites = append(delta.NewSuites, s)
-		}
-	}
-
-	return delta, errors
-}
-
-func (d *DeltaTracker) WillRun(suite testsuite.TestSuite) error {
-	s, ok := d.suites[suite.Path]
-	if !ok {
-		return fmt.Errorf("unknown suite %s", suite.Path)
-	}
-
-	return s.MarkAsRunAndRecomputedDependencies(d.maxDepth)
-}

vendor/github.com/onsi/ginkgo/ginkgo/watch/dependencies.go

@@ -1,91 +0,0 @@
-package watch
-
-import (
-	"go/build"
-	"regexp"
-)
-
-var ginkgoAndGomegaFilter = regexp.MustCompile(`github\.com/onsi/ginkgo|github\.com/onsi/gomega`)
-
-type Dependencies struct {
-	deps map[string]int
-}
-
-func NewDependencies(path string, maxDepth int) (Dependencies, error) {
-	d := Dependencies{
-		deps: map[string]int{},
-	}
-
-	if maxDepth == 0 {
-		return d, nil
-	}
-
-	err := d.seedWithDepsForPackageAtPath(path)
-	if err != nil {
-		return d, err
-	}
-
-	for depth := 1; depth < maxDepth; depth++ {
-		n := len(d.deps)
-		d.addDepsForDepth(depth)
-		if n == len(d.deps) {
-			break
-		}
-	}
-
-	return d, nil
-}
-
-func (d Dependencies) Dependencies() map[string]int {
-	return d.deps
-}
-
-func (d Dependencies) seedWithDepsForPackageAtPath(path string) error {
-	pkg, err := build.ImportDir(path, 0)
-	if err != nil {
-		return err
-	}
-
-	d.resolveAndAdd(pkg.Imports, 1)
-	d.resolveAndAdd(pkg.TestImports, 1)
-	d.resolveAndAdd(pkg.XTestImports, 1)
-
-	delete(d.deps, pkg.Dir)
-	return nil
-}
-
-func (d Dependencies) addDepsForDepth(depth int) {
-	for dep, depDepth := range d.deps {
-		if depDepth == depth {
-			d.addDepsForDep(dep, depth+1)
-		}
-	}
-}
-
-func (d Dependencies) addDepsForDep(dep string, depth int) {
-	pkg, err := build.ImportDir(dep, 0)
-	if err != nil {
-		println(err.Error())
-		return
-	}
-	d.resolveAndAdd(pkg.Imports, depth)
-}
-
-func (d Dependencies) resolveAndAdd(deps []string, depth int) {
-	for _, dep := range deps {
-		pkg, err := build.Import(dep, ".", 0)
-		if err != nil {
-			continue
-		}
-		if pkg.Goroot == false && !ginkgoAndGomegaFilter.Match([]byte(pkg.Dir)) {
-			d.addDepIfNotPresent(pkg.Dir, depth)
-		}
-	}
-}
-
-func (d Dependencies) addDepIfNotPresent(dep string, depth int) {
-	_, ok := d.deps[dep]
-	if !ok {
-		d.deps[dep] = depth
-	}
-}

vendor/github.com/onsi/ginkgo/ginkgo/watch/package_hash.go

@@ -1,104 +0,0 @@
-package watch
-
-import (
-	"fmt"
-	"io/ioutil"
-	"os"
-	"regexp"
-	"time"
-)
-
-var goTestRegExp = regexp.MustCompile(`_test\.go$`)
-
-type PackageHash struct {
-	CodeModifiedTime time.Time
-	TestModifiedTime time.Time
-	Deleted          bool
-
-	path        string
-	codeHash    string
-	testHash    string
-	watchRegExp *regexp.Regexp
-}
-
-func NewPackageHash(path string, watchRegExp *regexp.Regexp) *PackageHash {
-	p := &PackageHash{
-		path:        path,
-		watchRegExp: watchRegExp,
-	}
-
-	p.codeHash, _, p.testHash, _, p.Deleted = p.computeHashes()
-
-	return p
-}
-
-func (p *PackageHash) CheckForChanges() bool {
-	codeHash, codeModifiedTime, testHash, testModifiedTime, deleted := p.computeHashes()
-
-	if deleted {
-		if p.Deleted == false {
-			t := time.Now()
-			p.CodeModifiedTime = t
-			p.TestModifiedTime = t
-		}
-		p.Deleted = true
-		return true
-	}
-
-	modified := false
-	p.Deleted = false
-
-	if p.codeHash != codeHash {
-		p.CodeModifiedTime = codeModifiedTime
-		modified = true
-	}
-	if p.testHash != testHash {
-		p.TestModifiedTime = testModifiedTime
-		modified = true
-	}
-
-	p.codeHash = codeHash
-	p.testHash = testHash
-	return modified
-}
-
-func (p *PackageHash) computeHashes() (codeHash string, codeModifiedTime time.Time, testHash string, testModifiedTime time.Time, deleted bool) {
-	infos, err := ioutil.ReadDir(p.path)
-
-	if err != nil {
-		deleted = true
-		return
-	}
-
-	for _, info := range infos {
-		if info.IsDir() {
-			continue
-		}
-
-		if goTestRegExp.Match([]byte(info.Name())) {
-			testHash += p.hashForFileInfo(info)
-			if info.ModTime().After(testModifiedTime) {
-				testModifiedTime = info.ModTime()
-			}
-			continue
-		}
-
-		if p.watchRegExp.Match([]byte(info.Name())) {
-			codeHash += p.hashForFileInfo(info)
-			if info.ModTime().After(codeModifiedTime) {
-				codeModifiedTime = info.ModTime()
-			}
-		}
-	}
-
-	testHash += codeHash
-	if codeModifiedTime.After(testModifiedTime) {
-		testModifiedTime = codeModifiedTime
-	}
-
-	return
-}
-
-func (p *PackageHash) hashForFileInfo(info os.FileInfo) string {
-	return fmt.Sprintf("%s_%d_%d", info.Name(), info.Size(), info.ModTime().UnixNano())
-}

vendor/github.com/onsi/ginkgo/ginkgo/watch/package_hashes.go

@@ -1,85 +0,0 @@
-package watch
-
-import (
-	"path/filepath"
-	"regexp"
-	"sync"
-)
-
-type PackageHashes struct {
-	PackageHashes map[string]*PackageHash
-	usedPaths     map[string]bool
-	watchRegExp   *regexp.Regexp
-	lock          *sync.Mutex
-}
-
-func NewPackageHashes(watchRegExp *regexp.Regexp) *PackageHashes {
-	return &PackageHashes{
-		PackageHashes: map[string]*PackageHash{},
-		usedPaths:     nil,
-		watchRegExp:   watchRegExp,
-		lock:          &sync.Mutex{},
-	}
-}
-
-func (p *PackageHashes) CheckForChanges() []string {
-	p.lock.Lock()
-	defer p.lock.Unlock()
-
-	modified := []string{}
-
-	for _, packageHash := range p.PackageHashes {
-		if packageHash.CheckForChanges() {
-			modified = append(modified, packageHash.path)
-		}
-	}
-
-	return modified
-}
-
-func (p *PackageHashes) Add(path string) *PackageHash {
-	p.lock.Lock()
-	defer p.lock.Unlock()
-
-	path, _ = filepath.Abs(path)
-	_, ok := p.PackageHashes[path]
-	if !ok {
-		p.PackageHashes[path] = NewPackageHash(path, p.watchRegExp)
-	}
-
-	if p.usedPaths != nil {
-		p.usedPaths[path] = true
-	}
-	return p.PackageHashes[path]
-}
-
-func (p *PackageHashes) Get(path string) *PackageHash {
-	p.lock.Lock()
-	defer p.lock.Unlock()
-
-	path, _ = filepath.Abs(path)
-	if p.usedPaths != nil {
-		p.usedPaths[path] = true
-	}
-	return p.PackageHashes[path]
-}
-
-func (p *PackageHashes) StartTrackingUsage() {
-	p.lock.Lock()
-	defer p.lock.Unlock()
-
-	p.usedPaths = map[string]bool{}
-}
-
-func (p *PackageHashes) StopTrackingUsageAndPrune() {
-	p.lock.Lock()
-	defer p.lock.Unlock()
-
-	for path := range p.PackageHashes {
-		if !p.usedPaths[path] {
-			delete(p.PackageHashes, path)
-		}
-	}
-
-	p.usedPaths = nil
-}

vendor/github.com/onsi/ginkgo/ginkgo/watch/suite.go

@@ -1,87 +0,0 @@
-package watch
-
-import (
-	"fmt"
-	"math"
-	"time"
-
-	"github.com/onsi/ginkgo/ginkgo/testsuite"
-)
-
-type Suite struct {
-	Suite        testsuite.TestSuite
-	RunTime      time.Time
-	Dependencies Dependencies
-
-	sharedPackageHashes *PackageHashes
-}
-
-func NewSuite(suite testsuite.TestSuite, maxDepth int, sharedPackageHashes *PackageHashes) (*Suite, error) {
-	deps, err := NewDependencies(suite.Path, maxDepth)
-	if err != nil {
-		return nil, err
-	}
-
-	sharedPackageHashes.Add(suite.Path)
-	for dep := range deps.Dependencies() {
-		sharedPackageHashes.Add(dep)
-	}
-
-	return &Suite{
-		Suite:        suite,
-		Dependencies: deps,
-
-		sharedPackageHashes: sharedPackageHashes,
-	}, nil
-}
-
-func (s *Suite) Delta() float64 {
-	delta := s.delta(s.Suite.Path, true, 0) * 1000
-	for dep, depth := range s.Dependencies.Dependencies() {
-		delta += s.delta(dep, false, depth)
-	}
-	return delta
-}
-
-func (s *Suite) MarkAsRunAndRecomputedDependencies(maxDepth int) error {
-	s.RunTime = time.Now()
-
-	deps, err := NewDependencies(s.Suite.Path, maxDepth)
-	if err != nil {
-		return err
-	}
-
-	s.sharedPackageHashes.Add(s.Suite.Path)
-	for dep := range deps.Dependencies() {
-		s.sharedPackageHashes.Add(dep)
-	}
-
-	s.Dependencies = deps
-
-	return nil
-}
-
-func (s *Suite) Description() string {
-	numDeps := len(s.Dependencies.Dependencies())
-	pluralizer := "ies"
-	if numDeps == 1 {
-		pluralizer = "y"
-	}
-	return fmt.Sprintf("%s [%d dependenc%s]", s.Suite.Path, numDeps, pluralizer)
-}
-
-func (s *Suite) delta(packagePath string, includeTests bool, depth int) float64 {
-	return math.Max(float64(s.dt(packagePath, includeTests)), 0) / float64(depth+1)
-}
-
-func (s *Suite) dt(packagePath string, includeTests bool) time.Duration {
-	packageHash := s.sharedPackageHashes.Get(packagePath)
-	var modifiedTime time.Time
-	if includeTests {
-		modifiedTime = packageHash.TestModifiedTime
-	} else {
-		modifiedTime = packageHash.CodeModifiedTime
-	}
-
-	return modifiedTime.Sub(s.RunTime)
-}

vendor/github.com/onsi/ginkgo/ginkgo/watch_command.go

@@ -1,175 +0,0 @@
-package main
-
-import (
-	"flag"
-	"fmt"
-	"regexp"
-	"time"
-
-	"github.com/onsi/ginkgo/config"
-	"github.com/onsi/ginkgo/ginkgo/interrupthandler"
-	"github.com/onsi/ginkgo/ginkgo/testrunner"
-	"github.com/onsi/ginkgo/ginkgo/testsuite"
-	"github.com/onsi/ginkgo/ginkgo/watch"
-	colorable "github.com/onsi/ginkgo/reporters/stenographer/support/go-colorable"
-)
-
-func BuildWatchCommand() *Command {
-	commandFlags := NewWatchCommandFlags(flag.NewFlagSet("watch", flag.ExitOnError))
-	interruptHandler := interrupthandler.NewInterruptHandler()
-	notifier := NewNotifier(commandFlags)
-	watcher := &SpecWatcher{
-		commandFlags:     commandFlags,
-		notifier:         notifier,
-		interruptHandler: interruptHandler,
-		suiteRunner:      NewSuiteRunner(notifier, interruptHandler),
-	}
-
-	return &Command{
-		Name:         "watch",
-		FlagSet:      commandFlags.FlagSet,
-		UsageCommand: "ginkgo watch <FLAGS> <PACKAGES> -- <PASS-THROUGHS>",
-		Usage: []string{
-			"Watches the tests in the passed in <PACKAGES> and runs them when changes occur.",
-			"Any arguments after -- will be passed to the test.",
-		},
-		Command:                   watcher.WatchSpecs,
-		SuppressFlagDocumentation: true,
-		FlagDocSubstitute: []string{
-			"Accepts all the flags that the ginkgo command accepts except for --keepGoing and --untilItFails",
-		},
-	}
-}
-
-type SpecWatcher struct {
-	commandFlags     *RunWatchAndBuildCommandFlags
-	notifier         *Notifier
-	interruptHandler *interrupthandler.InterruptHandler
-	suiteRunner      *SuiteRunner
-}
-
-func (w *SpecWatcher) WatchSpecs(args []string, additionalArgs []string) {
-	w.commandFlags.computeNodes()
-	w.notifier.VerifyNotificationsAreAvailable()
-
-	w.WatchSuites(args, additionalArgs)
-}
-
-func (w *SpecWatcher) runnersForSuites(suites []testsuite.TestSuite, additionalArgs []string) []*testrunner.TestRunner {
-	runners := []*testrunner.TestRunner{}
-
-	for _, suite := range suites {
-		runners = append(runners, testrunner.New(suite, w.commandFlags.NumCPU, w.commandFlags.ParallelStream, w.commandFlags.Timeout, w.commandFlags.GoOpts, additionalArgs))
-	}
-
-	return runners
-}
-
-func (w *SpecWatcher) WatchSuites(args []string, additionalArgs []string) {
-	suites, _ := findSuites(args, w.commandFlags.Recurse, w.commandFlags.SkipPackage, false)
-
-	if len(suites) == 0 {
-		complainAndQuit("Found no test suites")
-	}
-
-	fmt.Printf("Identified %d test %s.  Locating dependencies to a depth of %d (this may take a while)...\n", len(suites), pluralizedWord("suite", "suites", len(suites)), w.commandFlags.Depth)
-	deltaTracker := watch.NewDeltaTracker(w.commandFlags.Depth, regexp.MustCompile(w.commandFlags.WatchRegExp))
-	delta, errors := deltaTracker.Delta(suites)
-
-	fmt.Printf("Watching %d %s:\n", len(delta.NewSuites), pluralizedWord("suite", "suites", len(delta.NewSuites)))
-	for _, suite := range delta.NewSuites {
-		fmt.Println("  " + suite.Description())
-	}
-
-	for suite, err := range errors {
-		fmt.Printf("Failed to watch %s: %s\n", suite.PackageName, err)
-	}
-
-	if len(suites) == 1 {
-		runners := w.runnersForSuites(suites, additionalArgs)
-		w.suiteRunner.RunSuites(runners, w.commandFlags.NumCompilers, true, nil)
-		runners[0].CleanUp()
-	}
-
-	ticker := time.NewTicker(time.Second)
-
-	for {
-		select {
-		case <-ticker.C:
-			suites, _ := findSuites(args, w.commandFlags.Recurse, w.commandFlags.SkipPackage, false)
-			delta, _ := deltaTracker.Delta(suites)
-			coloredStream := colorable.NewColorableStdout()
-
-			suitesToRun := []testsuite.TestSuite{}
-
-			if len(delta.NewSuites) > 0 {
-				fmt.Fprintf(coloredStream, greenColor+"Detected %d new %s:\n"+defaultStyle, len(delta.NewSuites), pluralizedWord("suite", "suites", len(delta.NewSuites)))
-				for _, suite := range delta.NewSuites {
-					suitesToRun = append(suitesToRun, suite.Suite)
-					fmt.Fprintln(coloredStream, "  "+suite.Description())
-				}
-			}
-
-			modifiedSuites := delta.ModifiedSuites()
-			if len(modifiedSuites) > 0 {
-				fmt.Fprintln(coloredStream, greenColor+"\nDetected changes in:"+defaultStyle)
-				for _, pkg := range delta.ModifiedPackages {
-					fmt.Fprintln(coloredStream, "  "+pkg)
-				}
-				fmt.Fprintf(coloredStream, greenColor+"Will run %d %s:\n"+defaultStyle, len(modifiedSuites), pluralizedWord("suite", "suites", len(modifiedSuites)))
-				for _, suite := range modifiedSuites {
-					suitesToRun = append(suitesToRun, suite.Suite)
-					fmt.Fprintln(coloredStream, "  "+suite.Description())
-				}
-				fmt.Fprintln(coloredStream, "")
-			}
-
-			if len(suitesToRun) > 0 {
-				w.UpdateSeed()
-				w.ComputeSuccinctMode(len(suitesToRun))
-				runners := w.runnersForSuites(suitesToRun, additionalArgs)
-				result, _ := w.suiteRunner.RunSuites(runners, w.commandFlags.NumCompilers, true, func(suite testsuite.TestSuite) {
-					deltaTracker.WillRun(suite)
-				})
-				for _, runner := range runners {
-					runner.CleanUp()
-				}
-				if !w.interruptHandler.WasInterrupted() {
-					color := redColor
-					if result.Passed {
-						color = greenColor
-					}
-					fmt.Fprintln(coloredStream, color+"\nDone.  Resuming watch..."+defaultStyle)
-				}
-			}
-
-		case <-w.interruptHandler.C:
-			return
-		}
-	}
-}
-
-func (w *SpecWatcher) ComputeSuccinctMode(numSuites int) {
-	if config.DefaultReporterConfig.Verbose {
-		config.DefaultReporterConfig.Succinct = false
-		return
-	}
-
-	if w.commandFlags.wasSet("succinct") {
-		return
-	}
-
-	if numSuites == 1 {
-		config.DefaultReporterConfig.Succinct = false
-	}
-
-	if numSuites > 1 {
-		config.DefaultReporterConfig.Succinct = true
-	}
-}
-
-func (w *SpecWatcher) UpdateSeed() {
-	if !w.commandFlags.wasSet("seed") {
-		config.GinkgoConfig.RandomSeed = time.Now().Unix()
-	}
-}

vendor/github.com/onsi/ginkgo/ginkgo_dsl.go

@@ -1,569 +0,0 @@
-/*
-Ginkgo is a BDD-style testing framework for Golang
-
-The godoc documentation describes Ginkgo's API.  More comprehensive documentation (with examples!) is available at http://onsi.github.io/ginkgo/
-
-Ginkgo's preferred matcher library is [Gomega](http://github.com/onsi/gomega)
-
-Ginkgo on Github: http://github.com/onsi/ginkgo
-
-Ginkgo is MIT-Licensed
-*/
-package ginkgo
-
-import (
-	"flag"
-	"fmt"
-	"io"
-	"net/http"
-	"os"
-	"strings"
-	"time"
-
-	"github.com/onsi/ginkgo/config"
-	"github.com/onsi/ginkgo/internal/codelocation"
-	"github.com/onsi/ginkgo/internal/failer"
-	"github.com/onsi/ginkgo/internal/remote"
-	"github.com/onsi/ginkgo/internal/suite"
-	"github.com/onsi/ginkgo/internal/testingtproxy"
-	"github.com/onsi/ginkgo/internal/writer"
-	"github.com/onsi/ginkgo/reporters"
-	"github.com/onsi/ginkgo/reporters/stenographer"
-	"github.com/onsi/ginkgo/types"
-)
-
-const GINKGO_VERSION = config.VERSION
-const GINKGO_PANIC = `
-Your test failed.
-Ginkgo panics to prevent subsequent assertions from running.
-Normally Ginkgo rescues this panic so you shouldn't see it.
-
-But, if you make an assertion in a goroutine, Ginkgo can't capture the panic.
-To circumvent this, you should call
-
-	defer GinkgoRecover()
-
-at the top of the goroutine that caused this panic.
-`
-const defaultTimeout = 1
-
-var globalSuite *suite.Suite
-var globalFailer *failer.Failer
-
-func init() {
-	config.Flags(flag.CommandLine, "ginkgo", true)
-	GinkgoWriter = writer.New(os.Stdout)
-	globalFailer = failer.New()
-	globalSuite = suite.New(globalFailer)
-}
-
-//GinkgoWriter implements an io.Writer
-//When running in verbose mode any writes to GinkgoWriter will be immediately printed
-//to stdout.  Otherwise, GinkgoWriter will buffer any writes produced during the current test and flush them to screen
-//only if the current test fails.
-var GinkgoWriter io.Writer
-
-//The interface by which Ginkgo receives *testing.T
-type GinkgoTestingT interface {
-	Fail()
-}
-
-//GinkgoRandomSeed returns the seed used to randomize spec execution order.  It is
-//useful for seeding your own pseudorandom number generators (PRNGs) to ensure
-//consistent executions from run to run, where your tests contain variability (for
-//example, when selecting random test data).
-func GinkgoRandomSeed() int64 {
-	return config.GinkgoConfig.RandomSeed
-}
-
-//GinkgoParallelNode returns the parallel node number for the current ginkgo process
-//The node number is 1-indexed
-func GinkgoParallelNode() int {
-	return config.GinkgoConfig.ParallelNode
-}
-
-//Some matcher libraries or legacy codebases require a *testing.T
-//GinkgoT implements an interface analogous to *testing.T and can be used if
-//the library in question accepts *testing.T through an interface
-//
-// For example, with testify:
-// assert.Equal(GinkgoT(), 123, 123, "they should be equal")
-//
-// Or with gomock:
-// gomock.NewController(GinkgoT())
-//
-// GinkgoT() takes an optional offset argument that can be used to get the
-// correct line number associated with the failure.
-func GinkgoT(optionalOffset ...int) GinkgoTInterface {
-	offset := 3
-	if len(optionalOffset) > 0 {
-		offset = optionalOffset[0]
-	}
-	return testingtproxy.New(GinkgoWriter, Fail, offset)
-}
-
-//The interface returned by GinkgoT().  This covers most of the methods
-//in the testing package's T.
-type GinkgoTInterface interface {
-	Fail()
-	Error(args ...interface{})
-	Errorf(format string, args ...interface{})
-	FailNow()
-	Fatal(args ...interface{})
-	Fatalf(format string, args ...interface{})
-	Log(args ...interface{})
-	Logf(format string, args ...interface{})
-	Failed() bool
-	Parallel()
-	Skip(args ...interface{})
-	Skipf(format string, args ...interface{})
-	SkipNow()
-	Skipped() bool
-}
-
-//Custom Ginkgo test reporters must implement the Reporter interface.
-//
-//The custom reporter is passed in a SuiteSummary when the suite begins and ends,
-//and a SpecSummary just before a spec begins and just after a spec ends
-type Reporter reporters.Reporter
-
-//Asynchronous specs are given a channel of the Done type.  You must close or write to the channel
-//to tell Ginkgo that your async test is done.
-type Done chan<- interface{}
-
-//GinkgoTestDescription represents the information about the current running test returned by CurrentGinkgoTestDescription
-//	FullTestText: a concatenation of ComponentTexts and the TestText
-//	ComponentTexts: a list of all texts for the Describes & Contexts leading up to the current test
-//	TestText: the text in the actual It or Measure node
-//	IsMeasurement: true if the current test is a measurement
-//	FileName: the name of the file containing the current test
-//	LineNumber: the line number for the current test
-//	Failed: if the current test has failed, this will be true (useful in an AfterEach)
-type GinkgoTestDescription struct {
-	FullTestText   string
-	ComponentTexts []string
-	TestText       string
-
-	IsMeasurement bool
-
-	FileName   string
-	LineNumber int
-
-	Failed bool
-}
-
-//CurrentGinkgoTestDescripton returns information about the current running test.
-func CurrentGinkgoTestDescription() GinkgoTestDescription {
-	summary, ok := globalSuite.CurrentRunningSpecSummary()
-	if !ok {
-		return GinkgoTestDescription{}
-	}
-
-	subjectCodeLocation := summary.ComponentCodeLocations[len(summary.ComponentCodeLocations)-1]
-
-	return GinkgoTestDescription{
-		ComponentTexts: summary.ComponentTexts[1:],
-		FullTestText:   strings.Join(summary.ComponentTexts[1:], " "),
-		TestText:       summary.ComponentTexts[len(summary.ComponentTexts)-1],
-		IsMeasurement:  summary.IsMeasurement,
-		FileName:       subjectCodeLocation.FileName,
-		LineNumber:     subjectCodeLocation.LineNumber,
-		Failed:         summary.HasFailureState(),
-	}
-}
-
-//Measurement tests receive a Benchmarker.
-//
-//You use the Time() function to time how long the passed in body function takes to run
-//You use the RecordValue() function to track arbitrary numerical measurements.
-//The RecordValueWithPrecision() function can be used alternatively to provide the unit
-//and resolution of the numeric measurement.
-//The optional info argument is passed to the test reporter and can be used to
-// provide the measurement data to a custom reporter with context.
-//
-//See http://onsi.github.io/ginkgo/#benchmark_tests for more details
-type Benchmarker interface {
-	Time(name string, body func(), info ...interface{}) (elapsedTime time.Duration)
-	RecordValue(name string, value float64, info ...interface{})
-	RecordValueWithPrecision(name string, value float64, units string, precision int, info ...interface{})
-}
-
-//RunSpecs is the entry point for the Ginkgo test runner.
-//You must call this within a Golang testing TestX(t *testing.T) function.
-//
-//To bootstrap a test suite you can use the Ginkgo CLI:
-//
-//	ginkgo bootstrap
-func RunSpecs(t GinkgoTestingT, description string) bool {
-	specReporters := []Reporter{buildDefaultReporter()}
-	return RunSpecsWithCustomReporters(t, description, specReporters)
-}
-
-//To run your tests with Ginkgo's default reporter and your custom reporter(s), replace
-//RunSpecs() with this method.
-func RunSpecsWithDefaultAndCustomReporters(t GinkgoTestingT, description string, specReporters []Reporter) bool {
-	specReporters = append([]Reporter{buildDefaultReporter()}, specReporters...)
-	return RunSpecsWithCustomReporters(t, description, specReporters)
-}
-
-//To run your tests with your custom reporter(s) (and *not* Ginkgo's default reporter), replace
-//RunSpecs() with this method.  Note that parallel tests will not work correctly without the default reporter
-func RunSpecsWithCustomReporters(t GinkgoTestingT, description string, specReporters []Reporter) bool {
-	writer := GinkgoWriter.(*writer.Writer)
-	writer.SetStream(config.DefaultReporterConfig.Verbose)
-	reporters := make([]reporters.Reporter, len(specReporters))
-	for i, reporter := range specReporters {
-		reporters[i] = reporter
-	}
-	passed, hasFocusedTests := globalSuite.Run(t, description, reporters, writer, config.GinkgoConfig)
-	if passed && hasFocusedTests {
-		fmt.Println("PASS | FOCUSED")
-		os.Exit(types.GINKGO_FOCUS_EXIT_CODE)
-	}
-	return passed
-}
-
-func buildDefaultReporter() Reporter {
-	remoteReportingServer := config.GinkgoConfig.StreamHost
-	if remoteReportingServer == "" {
-		stenographer := stenographer.New(!config.DefaultReporterConfig.NoColor, config.GinkgoConfig.FlakeAttempts > 1)
-		return reporters.NewDefaultReporter(config.DefaultReporterConfig, stenographer)
-	} else {
-		return remote.NewForwardingReporter(remoteReportingServer, &http.Client{}, remote.NewOutputInterceptor())
-	}
-}
-
-//Skip notifies Ginkgo that the current spec should be skipped.
-func Skip(message string, callerSkip ...int) {
-	skip := 0
-	if len(callerSkip) > 0 {
-		skip = callerSkip[0]
-	}
-
-	globalFailer.Skip(message, codelocation.New(skip+1))
-	panic(GINKGO_PANIC)
-}
-
-//Fail notifies Ginkgo that the current spec has failed. (Gomega will call Fail for you automatically when an assertion fails.)
-func Fail(message string, callerSkip ...int) {
-	skip := 0
-	if len(callerSkip) > 0 {
-		skip = callerSkip[0]
-	}
-
-	globalFailer.Fail(message, codelocation.New(skip+1))
-	panic(GINKGO_PANIC)
-}
-
-//GinkgoRecover should be deferred at the top of any spawned goroutine that (may) call `Fail`
-//Since Gomega assertions call fail, you should throw a `defer GinkgoRecover()` at the top of any goroutine that
-//calls out to Gomega
-//
-//Here's why: Ginkgo's `Fail` method records the failure and then panics to prevent
-//further assertions from running.  This panic must be recovered.  Ginkgo does this for you
-//if the panic originates in a Ginkgo node (an It, BeforeEach, etc...)
-//
-//Unfortunately, if a panic originates on a goroutine *launched* from one of these nodes there's no
-//way for Ginkgo to rescue the panic.  To do this, you must remember to `defer GinkgoRecover()` at the top of such a goroutine.
-func GinkgoRecover() {
-	e := recover()
-	if e != nil {
-		globalFailer.Panic(codelocation.New(1), e)
-	}
-}
-
-//Describe blocks allow you to organize your specs.  A Describe block can contain any number of
-//BeforeEach, AfterEach, JustBeforeEach, It, and Measurement blocks.
-//
-//In addition you can nest Describe and Context blocks.  Describe and Context blocks are functionally
-//equivalent.  The difference is purely semantic -- you typical Describe the behavior of an object
-//or method and, within that Describe, outline a number of Contexts.
-func Describe(text string, body func()) bool {
-	globalSuite.PushContainerNode(text, body, types.FlagTypeNone, codelocation.New(1))
-	return true
-}
-
-//You can focus the tests within a describe block using FDescribe
-func FDescribe(text string, body func()) bool {
-	globalSuite.PushContainerNode(text, body, types.FlagTypeFocused, codelocation.New(1))
-	return true
-}
-
-//You can mark the tests within a describe block as pending using PDescribe
-func PDescribe(text string, body func()) bool {
-	globalSuite.PushContainerNode(text, body, types.FlagTypePending, codelocation.New(1))
-	return true
-}
-
-//You can mark the tests within a describe block as pending using XDescribe
-func XDescribe(text string, body func()) bool {
-	globalSuite.PushContainerNode(text, body, types.FlagTypePending, codelocation.New(1))
-	return true
-}
-
-//Context blocks allow you to organize your specs.  A Context block can contain any number of
-//BeforeEach, AfterEach, JustBeforeEach, It, and Measurement blocks.
-//
-//In addition you can nest Describe and Context blocks.  Describe and Context blocks are functionally
-//equivalent.  The difference is purely semantic -- you typical Describe the behavior of an object
-//or method and, within that Describe, outline a number of Contexts.
-func Context(text string, body func()) bool {
-	globalSuite.PushContainerNode(text, body, types.FlagTypeNone, codelocation.New(1))
-	return true
-}
-
-//You can focus the tests within a describe block using FContext
-func FContext(text string, body func()) bool {
-	globalSuite.PushContainerNode(text, body, types.FlagTypeFocused, codelocation.New(1))
-	return true
-}
-
-//You can mark the tests within a describe block as pending using PContext
-func PContext(text string, body func()) bool {
-	globalSuite.PushContainerNode(text, body, types.FlagTypePending, codelocation.New(1))
-	return true
-}
-
-//You can mark the tests within a describe block as pending using XContext
-func XContext(text string, body func()) bool {
-	globalSuite.PushContainerNode(text, body, types.FlagTypePending, codelocation.New(1))
-	return true
-}
-
-//It blocks contain your test code and assertions.  You cannot nest any other Ginkgo blocks
-//within an It block.
-//
-//Ginkgo will normally run It blocks synchronously.  To perform asynchronous tests, pass a
-//function that accepts a Done channel.  When you do this, you can also provide an optional timeout.
-func It(text string, body interface{}, timeout ...float64) bool {
-	globalSuite.PushItNode(text, body, types.FlagTypeNone, codelocation.New(1), parseTimeout(timeout...))
-	return true
-}
-
-//You can focus individual Its using FIt
-func FIt(text string, body interface{}, timeout ...float64) bool {
-	globalSuite.PushItNode(text, body, types.FlagTypeFocused, codelocation.New(1), parseTimeout(timeout...))
-	return true
-}
-
-//You can mark Its as pending using PIt
-func PIt(text string, _ ...interface{}) bool {
-	globalSuite.PushItNode(text, func() {}, types.FlagTypePending, codelocation.New(1), 0)
-	return true
-}
-
-//You can mark Its as pending using XIt
-func XIt(text string, _ ...interface{}) bool {
-	globalSuite.PushItNode(text, func() {}, types.FlagTypePending, codelocation.New(1), 0)
-	return true
-}
-
-//Specify blocks are aliases for It blocks and allow for more natural wording in situations
-//which "It" does not fit into a natural sentence flow. All the same protocols apply for Specify blocks
-//which apply to It blocks.
-func Specify(text string, body interface{}, timeout ...float64) bool {
-	return It(text, body, timeout...)
-}
-
-//You can focus individual Specifys using FSpecify
-func FSpecify(text string, body interface{}, timeout ...float64) bool {
-	return FIt(text, body, timeout...)
-}
-
-//You can mark Specifys as pending using PSpecify
-func PSpecify(text string, is ...interface{}) bool {
-	return PIt(text, is...)
-}
-
-//You can mark Specifys as pending using XSpecify
-func XSpecify(text string, is ...interface{}) bool {
-	return XIt(text, is...)
-}
-
-//By allows you to better document large Its.
-//
-//Generally you should try to keep your Its short and to the point.  This is not always possible, however,
-//especially in the context of integration tests that capture a particular workflow.
-//
-//By allows you to document such flows.  By must be called within a runnable node (It, BeforeEach, Measure, etc...)
-//By will simply log the passed in text to the GinkgoWriter.  If By is handed a function it will immediately run the function.
-func By(text string, callbacks ...func()) {
-	preamble := "\x1b[1mSTEP\x1b[0m"
-	if config.DefaultReporterConfig.NoColor {
-		preamble = "STEP"
-	}
-	fmt.Fprintln(GinkgoWriter, preamble+": "+text)
-	if len(callbacks) == 1 {
-		callbacks[0]()
-	}
-	if len(callbacks) > 1 {
-		panic("just one callback per By, please")
-	}
-}
-
-//Measure blocks run the passed in body function repeatedly (determined by the samples argument)
-//and accumulate metrics provided to the Benchmarker by the body function.
-//
-//The body function must have the signature:
-//	func(b Benchmarker)
-func Measure(text string, body interface{}, samples int) bool {
-	globalSuite.PushMeasureNode(text, body, types.FlagTypeNone, codelocation.New(1), samples)
-	return true
-}
-
-//You can focus individual Measures using FMeasure
-func FMeasure(text string, body interface{}, samples int) bool {
-	globalSuite.PushMeasureNode(text, body, types.FlagTypeFocused, codelocation.New(1), samples)
-	return true
-}
-
-//You can mark Maeasurements as pending using PMeasure
-func PMeasure(text string, _ ...interface{}) bool {
-	globalSuite.PushMeasureNode(text, func(b Benchmarker) {}, types.FlagTypePending, codelocation.New(1), 0)
-	return true
-}
-
-//You can mark Maeasurements as pending using XMeasure
-func XMeasure(text string, _ ...interface{}) bool {
-	globalSuite.PushMeasureNode(text, func(b Benchmarker) {}, types.FlagTypePending, codelocation.New(1), 0)
-	return true
-}
-
-//BeforeSuite blocks are run just once before any specs are run.  When running in parallel, each
-//parallel node process will call BeforeSuite.
-//
-//BeforeSuite blocks can be made asynchronous by providing a body function that accepts a Done channel
-//
-//You may only register *one* BeforeSuite handler per test suite.  You typically do so in your bootstrap file at the top level.
-func BeforeSuite(body interface{}, timeout ...float64) bool {
-	globalSuite.SetBeforeSuiteNode(body, codelocation.New(1), parseTimeout(timeout...))
-	return true
-}
-
-//AfterSuite blocks are *always* run after all the specs regardless of whether specs have passed or failed.
-//Moreover, if Ginkgo receives an interrupt signal (^C) it will attempt to run the AfterSuite before exiting.
-//
-//When running in parallel, each parallel node process will call AfterSuite.
-//
-//AfterSuite blocks can be made asynchronous by providing a body function that accepts a Done channel
-//
-//You may only register *one* AfterSuite handler per test suite.  You typically do so in your bootstrap file at the top level.
-func AfterSuite(body interface{}, timeout ...float64) bool {
-	globalSuite.SetAfterSuiteNode(body, codelocation.New(1), parseTimeout(timeout...))
-	return true
-}
-
-//SynchronizedBeforeSuite blocks are primarily meant to solve the problem of setting up singleton external resources shared across
-//nodes when running tests in parallel.  For example, say you have a shared database that you can only start one instance of that
-//must be used in your tests.  When running in parallel, only one node should set up the database and all other nodes should wait
-//until that node is done before running.
-//
-//SynchronizedBeforeSuite accomplishes this by taking *two* function arguments.  The first is only run on parallel node #1.  The second is
-//run on all nodes, but *only* after the first function completes succesfully.  Ginkgo also makes it possible to send data from the first function (on Node 1)
-//to the second function (on all the other nodes).
-//
-//The functions have the following signatures.  The first function (which only runs on node 1) has the signature:
-//
-//	func() []byte
-//
-//or, to run asynchronously:
-//
-//	func(done Done) []byte
-//
-//The byte array returned by the first function is then passed to the second function, which has the signature:
-//
-//	func(data []byte)
-//
-//or, to run asynchronously:
-//
-//	func(data []byte, done Done)
-//
-//Here's a simple pseudo-code example that starts a shared database on Node 1 and shares the database's address with the other nodes:
-//
-//	var dbClient db.Client
-//	var dbRunner db.Runner
-//
-//	var _ = SynchronizedBeforeSuite(func() []byte {
-//		dbRunner = db.NewRunner()
-//		err := dbRunner.Start()
-//		Ω(err).ShouldNot(HaveOccurred())
-//		return []byte(dbRunner.URL)
-//	}, func(data []byte) {
-//		dbClient = db.NewClient()
-//		err := dbClient.Connect(string(data))
-//		Ω(err).ShouldNot(HaveOccurred())
-//	})
-func SynchronizedBeforeSuite(node1Body interface{}, allNodesBody interface{}, timeout ...float64) bool {
-	globalSuite.SetSynchronizedBeforeSuiteNode(
-		node1Body,
-		allNodesBody,
-		codelocation.New(1),
-		parseTimeout(timeout...),
-	)
-	return true
-}
-
-//SynchronizedAfterSuite blocks complement the SynchronizedBeforeSuite blocks in solving the problem of setting up
-//external singleton resources shared across nodes when running tests in parallel.
-//
-//SynchronizedAfterSuite accomplishes this by taking *two* function arguments.  The first runs on all nodes.  The second runs only on parallel node #1
-//and *only* after all other nodes have finished and exited.  This ensures that node 1, and any resources it is running, remain alive until
-//all other nodes are finished.
-//
-//Both functions have the same signature: either func() or func(done Done) to run asynchronously.
-//
-//Here's a pseudo-code example that complements that given in SynchronizedBeforeSuite.  Here, SynchronizedAfterSuite is used to tear down the shared database
-//only after all nodes have finished:
-//
-//	var _ = SynchronizedAfterSuite(func() {
-//		dbClient.Cleanup()
-//	}, func() {
-//		dbRunner.Stop()
-//	})
-func SynchronizedAfterSuite(allNodesBody interface{}, node1Body interface{}, timeout ...float64) bool {
-	globalSuite.SetSynchronizedAfterSuiteNode(
-		allNodesBody,
-		node1Body,
-		codelocation.New(1),
-		parseTimeout(timeout...),
-	)
-	return true
-}
-
-//BeforeEach blocks are run before It blocks.  When multiple BeforeEach blocks are defined in nested
-//Describe and Context blocks the outermost BeforeEach blocks are run first.
-//
-//Like It blocks, BeforeEach blocks can be made asynchronous by providing a body function that accepts
-//a Done channel
-func BeforeEach(body interface{}, timeout ...float64) bool {
-	globalSuite.PushBeforeEachNode(body, codelocation.New(1), parseTimeout(timeout...))
-	return true
-}
-
-//JustBeforeEach blocks are run before It blocks but *after* all BeforeEach blocks.  For more details,
-//read the [documentation](http://onsi.github.io/ginkgo/#separating_creation_and_configuration_)
-//
-//Like It blocks, BeforeEach blocks can be made asynchronous by providing a body function that accepts
-//a Done channel
-func JustBeforeEach(body interface{}, timeout ...float64) bool {
-	globalSuite.PushJustBeforeEachNode(body, codelocation.New(1), parseTimeout(timeout...))
-	return true
-}
-
-//AfterEach blocks are run after It blocks.   When multiple AfterEach blocks are defined in nested
-//Describe and Context blocks the innermost AfterEach blocks are run first.
-//
-//Like It blocks, AfterEach blocks can be made asynchronous by providing a body function that accepts
-//a Done channel
-func AfterEach(body interface{}, timeout ...float64) bool {
-	globalSuite.PushAfterEachNode(body, codelocation.New(1), parseTimeout(timeout...))
-	return true
-}
-
-func parseTimeout(timeout ...float64) time.Duration {
-	if len(timeout) == 0 {
-		return time.Duration(defaultTimeout * int64(time.Second))
-	} else {
-		return time.Duration(timeout[0] * float64(time.Second))
-	}
-}

vendor/github.com/onsi/ginkgo/integration/_fixtures/convert_fixtures/extra_functions_test.go

@@ -1,14 +0,0 @@
-package tmp
-
-import (
-	"testing"
-)
-
-func TestSomethingLessImportant(t *testing.T) {
-	strp := "hello!"
-	somethingImportant(t, &strp)
-}
-
-func somethingImportant(t *testing.T, message *string) {
-	t.Log("Something important happened in a test: " + *message)
-}

vendor/github.com/onsi/ginkgo/integration/_fixtures/convert_fixtures/nested/nested_test.go

@@ -1,10 +0,0 @@
-package nested
-
-import (
-	"testing"
-)
-
-func TestSomethingLessImportant(t *testing.T) {
-	whatever := &UselessStruct{}
-	t.Fail(whatever.ImportantField != "SECRET_PASSWORD")
-}

vendor/github.com/onsi/ginkgo/integration/_fixtures/convert_fixtures/nested_without_gofiles/subpackage/nested_subpackage_test.go

@@ -1,9 +0,0 @@
-package subpackage
-
-import (
-	"testing"
-)
-
-func TestNestedSubPackages(t *testing.T) {
-	t.Fail(true)
-}

vendor/github.com/onsi/ginkgo/integration/_fixtures/convert_fixtures/outside_package_test.go

@@ -1,16 +0,0 @@
-package tmp_test
-
-import (
-	"testing"
-)
-
-type UselessStruct struct {
-	ImportantField string
-}
-
-func TestSomethingImportant(t *testing.T) {
-	whatever := &UselessStruct{}
-	if whatever.ImportantField != "SECRET_PASSWORD" {
-		t.Fail()
-	}
-}

vendor/github.com/onsi/ginkgo/integration/_fixtures/convert_fixtures/xunit_test.go

@@ -1,41 +0,0 @@
-package tmp
-
-import (
-	"testing"
-)
-
-type UselessStruct struct {
-	ImportantField string
-	T              *testing.T
-}
-
-var testFunc = func(t *testing.T, arg *string) {}
-
-func assertEqual(t *testing.T, arg1, arg2 interface{}) {
-	if arg1 != arg2 {
-		t.Fail()
-	}
-}
-
-func TestSomethingImportant(t *testing.T) {
-	whatever := &UselessStruct{
-		T:              t,
-		ImportantField: "SECRET_PASSWORD",
-	}
-	something := &UselessStruct{ImportantField: "string value"}
-	assertEqual(t, whatever.ImportantField, "SECRET_PASSWORD")
-	assertEqual(t, something.ImportantField, "string value")
-
-	var foo = func(t *testing.T) {}
-	foo(t)
-
-	strp := "something"
-	testFunc(t, &strp)
-	t.Fail()
-}
-
-func Test3Things(t *testing.T) {
-	if 3 != 3 {
-		t.Fail()
-	}
-}

vendor/github.com/onsi/ginkgo/integration/_fixtures/convert_goldmasters/extra_functions_test.go

@@ -1,17 +0,0 @@
-package tmp
-
-import (
-	. "github.com/onsi/ginkgo"
-)
-
-var _ = Describe("Testing with Ginkgo", func() {
-	It("something less important", func() {
-
-		strp := "hello!"
-		somethingImportant(GinkgoT(), &strp)
-	})
-})
-
-func somethingImportant(t GinkgoTInterface, message *string) {
-	t.Log("Something important happened in a test: " + *message)
-}

vendor/github.com/onsi/ginkgo/integration/_fixtures/convert_goldmasters/fixtures_suite_test.go

@@ -1,13 +0,0 @@
-package tmp
-
-import (
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-
-	"testing"
-)
-
-func TestTmp(t *testing.T) {
-	RegisterFailHandler(Fail)
-	RunSpecs(t, "Tmp Suite")
-}

vendor/github.com/onsi/ginkgo/integration/_fixtures/convert_goldmasters/nested_subpackage_test.go

@@ -1,11 +0,0 @@
-package subpackage
-
-import (
-	. "github.com/onsi/ginkgo"
-)
-
-var _ = Describe("Testing with Ginkgo", func() {
-	It("nested sub packages", func() {
-		GinkgoT().Fail(true)
-	})
-})

vendor/github.com/onsi/ginkgo/integration/_fixtures/convert_goldmasters/nested_suite_test.go

@@ -1,13 +0,0 @@
-package nested_test
-
-import (
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-
-	"testing"
-)
-
-func TestNested(t *testing.T) {
-	RegisterFailHandler(Fail)
-	RunSpecs(t, "Nested Suite")
-}

vendor/github.com/onsi/ginkgo/integration/_fixtures/convert_goldmasters/nested_test.go

@@ -1,13 +0,0 @@
-package nested
-
-import (
-	. "github.com/onsi/ginkgo"
-)
-
-var _ = Describe("Testing with Ginkgo", func() {
-	It("something less important", func() {
-
-		whatever := &UselessStruct{}
-		GinkgoT().Fail(whatever.ImportantField != "SECRET_PASSWORD")
-	})
-})

vendor/github.com/onsi/ginkgo/integration/_fixtures/convert_goldmasters/outside_package_test.go

@@ -1,19 +0,0 @@
-package tmp_test
-
-import (
-	. "github.com/onsi/ginkgo"
-)
-
-var _ = Describe("Testing with Ginkgo", func() {
-	It("something important", func() {
-
-		whatever := &UselessStruct{}
-		if whatever.ImportantField != "SECRET_PASSWORD" {
-			GinkgoT().Fail()
-		}
-	})
-})
-
-type UselessStruct struct {
-	ImportantField string
-}

vendor/github.com/onsi/ginkgo/integration/_fixtures/convert_goldmasters/suite_test.go

@@ -1,13 +0,0 @@
-package tmp_test
-
-import (
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-
-	"testing"
-)
-
-func TestConvertFixtures(t *testing.T) {
-	RegisterFailHandler(Fail)
-	RunSpecs(t, "ConvertFixtures Suite")
-}

vendor/github.com/onsi/ginkgo/integration/_fixtures/convert_goldmasters/xunit_test.go

@@ -1,44 +0,0 @@
-package tmp
-
-import (
-	. "github.com/onsi/ginkgo"
-)
-
-var _ = Describe("Testing with Ginkgo", func() {
-	It("something important", func() {
-
-		whatever := &UselessStruct{
-			T:              GinkgoT(),
-			ImportantField: "SECRET_PASSWORD",
-		}
-		something := &UselessStruct{ImportantField: "string value"}
-		assertEqual(GinkgoT(), whatever.ImportantField, "SECRET_PASSWORD")
-		assertEqual(GinkgoT(), something.ImportantField, "string value")
-
-		var foo = func(t GinkgoTInterface) {}
-		foo(GinkgoT())
-
-		strp := "something"
-		testFunc(GinkgoT(), &strp)
-		GinkgoT().Fail()
-	})
-	It("3 things", func() {
-
-		if 3 != 3 {
-			GinkgoT().Fail()
-		}
-	})
-})
-
-type UselessStruct struct {
-	ImportantField string
-	T              GinkgoTInterface
-}
-
-var testFunc = func(t GinkgoTInterface, arg *string) {}
-
-func assertEqual(t GinkgoTInterface, arg1, arg2 interface{}) {
-	if arg1 != arg2 {
-		t.Fail()
-	}
-}

vendor/github.com/onsi/ginkgo/integration/_fixtures/coverage_fixture/coverage.go

@@ -1,21 +0,0 @@
-package coverage_fixture
-
-func A() string {
-	return "A"
-}
-
-func B() string {
-	return "B"
-}
-
-func C() string {
-	return "C"
-}
-
-func D() string {
-	return "D"
-}
-
-func E() string {
-	return "untested"
-}

vendor/github.com/onsi/ginkgo/integration/_fixtures/coverage_fixture/coverage_fixture_suite_test.go

@@ -1,13 +0,0 @@
-package coverage_fixture_test
-
-import (
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-
-	"testing"
-)
-
-func TestCoverageFixture(t *testing.T) {
-	RegisterFailHandler(Fail)
-	RunSpecs(t, "CoverageFixture Suite")
-}

vendor/github.com/onsi/ginkgo/integration/_fixtures/coverage_fixture/coverage_fixture_test.go

@@ -1,31 +0,0 @@
-package coverage_fixture_test
-
-import (
-	. "github.com/onsi/ginkgo/integration/_fixtures/coverage_fixture"
-	. "github.com/onsi/ginkgo/integration/_fixtures/coverage_fixture/external_coverage_fixture"
-
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-)
-
-var _ = Describe("CoverageFixture", func() {
-	It("should test A", func() {
-		Ω(A()).Should(Equal("A"))
-	})
-
-	It("should test B", func() {
-		Ω(B()).Should(Equal("B"))
-	})
-
-	It("should test C", func() {
-		Ω(C()).Should(Equal("C"))
-	})
-
-	It("should test D", func() {
-		Ω(D()).Should(Equal("D"))
-	})
-
-	It("should test external package", func() {
-		Ω(Tested()).Should(Equal("tested"))
-	})
-})

vendor/github.com/onsi/ginkgo/integration/_fixtures/coverage_fixture/external_coverage_fixture/external_coverage.go

@@ -1,9 +0,0 @@
-package external_coverage
-
-func Tested() string {
-	return "tested"
-}
-
-func Untested() string {
-	return "untested"
-}

vendor/github.com/onsi/ginkgo/integration/_fixtures/does_not_compile/does_not_compile_suite_test.go

@@ -1,13 +0,0 @@
-package does_not_compile_test
-
-import (
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-
-	"testing"
-)
-
-func TestDoes_not_compile(t *testing.T) {
-	RegisterFailHandler(Fail)
-	RunSpecs(t, "Does_not_compile Suite")
-}

vendor/github.com/onsi/ginkgo/integration/_fixtures/does_not_compile/does_not_compile_test.go

@@ -1,11 +0,0 @@
-package does_not_compile_test
-
-import (
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/ginkgo/integration/_fixtures/does_not_compile"
-	. "github.com/onsi/gomega"
-)
-
-var _ = Describe("DoesNotCompile", func() {
-
-})

vendor/github.com/onsi/ginkgo/integration/_fixtures/eventually_failing/eventually_failing_suite_test.go

@@ -1,13 +0,0 @@
-package eventually_failing_test
-
-import (
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-
-	"testing"
-)
-
-func TestEventuallyFailing(t *testing.T) {
-	RegisterFailHandler(Fail)
-	RunSpecs(t, "EventuallyFailing Suite")
-}

vendor/github.com/onsi/ginkgo/integration/_fixtures/eventually_failing/eventually_failing_test.go

@@ -1,29 +0,0 @@
-package eventually_failing_test
-
-import (
-	"fmt"
-	"io/ioutil"
-	"strings"
-	"time"
-
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-)
-
-var _ = Describe("EventuallyFailing", func() {
-	It("should fail on the third try", func() {
-		time.Sleep(time.Second)
-		files, err := ioutil.ReadDir(".")
-		Ω(err).ShouldNot(HaveOccurred())
-
-		numRuns := 1
-		for _, file := range files {
-			if strings.HasPrefix(file.Name(), "counter") {
-				numRuns++
-			}
-		}
-
-		Ω(numRuns).Should(BeNumerically("<", 3))
-		ioutil.WriteFile(fmt.Sprintf("./counter-%d", numRuns), []byte("foo"), 0777)
-	})
-})

vendor/github.com/onsi/ginkgo/integration/_fixtures/exiting_synchronized_setup_tests/exiting_synchronized_setup_tests_suite_test.go

@@ -1,35 +0,0 @@
-package synchronized_setup_tests_test
-
-import (
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-
-	"fmt"
-	"os"
-	"testing"
-)
-
-func TestSynchronized_setup_tests(t *testing.T) {
-	RegisterFailHandler(Fail)
-	RunSpecs(t, "Synchronized_setup_tests Suite")
-}
-
-var beforeData string
-
-var _ = SynchronizedBeforeSuite(func() []byte {
-	fmt.Printf("BEFORE_A_%d\n", GinkgoParallelNode())
-	os.Exit(1)
-	return []byte("WHAT EVZ")
-}, func(data []byte) {
-	println("NEVER SEE THIS")
-})
-
-var _ = Describe("Synchronized Setup", func() {
-	It("should do nothing", func() {
-		Ω(true).Should(BeTrue())
-	})
-
-	It("should do nothing", func() {
-		Ω(true).Should(BeTrue())
-	})
-})

vendor/github.com/onsi/ginkgo/integration/_fixtures/fail_fixture/fail_fixture_suite_test.go

@@ -1,13 +0,0 @@
-package fail_fixture_test
-
-import (
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-
-	"testing"
-)
-
-func TestFail_fixture(t *testing.T) {
-	RegisterFailHandler(Fail)
-	RunSpecs(t, "Fail_fixture Suite")
-}

vendor/github.com/onsi/ginkgo/integration/_fixtures/fail_fixture/fail_fixture_test.go

@@ -1,99 +0,0 @@
-package fail_fixture_test
-
-import (
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-)
-
-var _ = It("handles top level failures", func() {
-	Ω("a top level failure on line 9").Should(Equal("nope"))
-	println("NEVER SEE THIS")
-})
-
-var _ = It("handles async top level failures", func(done Done) {
-	Fail("an async top level failure on line 14")
-	println("NEVER SEE THIS")
-}, 0.1)
-
-var _ = It("FAIL in a goroutine", func(done Done) {
-	go func() {
-		defer GinkgoRecover()
-		Fail("a top level goroutine failure on line 21")
-		println("NEVER SEE THIS")
-	}()
-}, 0.1)
-
-var _ = Describe("Excercising different failure modes", func() {
-	It("synchronous failures", func() {
-		Ω("a sync failure").Should(Equal("nope"))
-		println("NEVER SEE THIS")
-	})
-
-	It("synchronous panics", func() {
-		panic("a sync panic")
-		println("NEVER SEE THIS")
-	})
-
-	It("synchronous failures with FAIL", func() {
-		Fail("a sync FAIL failure")
-		println("NEVER SEE THIS")
-	})
-
-	It("async timeout", func(done Done) {
-		Ω(true).Should(BeTrue())
-	}, 0.1)
-
-	It("async failure", func(done Done) {
-		Ω("an async failure").Should(Equal("nope"))
-		println("NEVER SEE THIS")
-	}, 0.1)
-
-	It("async panic", func(done Done) {
-		panic("an async panic")
-		println("NEVER SEE THIS")
-	}, 0.1)
-
-	It("async failure with FAIL", func(done Done) {
-		Fail("an async FAIL failure")
-		println("NEVER SEE THIS")
-	}, 0.1)
-
-	It("FAIL in a goroutine", func(done Done) {
-		go func() {
-			defer GinkgoRecover()
-			Fail("a goroutine FAIL failure")
-			println("NEVER SEE THIS")
-		}()
-	}, 0.1)
-
-	It("Gomega in a goroutine", func(done Done) {
-		go func() {
-			defer GinkgoRecover()
-			Ω("a goroutine failure").Should(Equal("nope"))
-			println("NEVER SEE THIS")
-		}()
-	}, 0.1)
-
-	It("Panic in a goroutine", func(done Done) {
-		go func() {
-			defer GinkgoRecover()
-			panic("a goroutine panic")
-			println("NEVER SEE THIS")
-		}()
-	}, 0.1)
-
-	Measure("a FAIL measure", func(Benchmarker) {
-		Fail("a measure FAIL failure")
-		println("NEVER SEE THIS")
-	}, 1)
-
-	Measure("a gomega failed measure", func(Benchmarker) {
-		Ω("a measure failure").Should(Equal("nope"))
-		println("NEVER SEE THIS")
-	}, 1)
-
-	Measure("a panicking measure", func(Benchmarker) {
-		panic("a measure panic")
-		println("NEVER SEE THIS")
-	}, 1)
-})

vendor/github.com/onsi/ginkgo/integration/_fixtures/failing_after_suite/failing_after_suite_suite_test.go

@@ -1,22 +0,0 @@
-package failing_before_suite_test
-
-import (
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-
-	"testing"
-)
-
-func TestFailingAfterSuite(t *testing.T) {
-	RegisterFailHandler(Fail)
-	RunSpecs(t, "FailingAfterSuite Suite")
-}
-
-var _ = BeforeSuite(func() {
-	println("BEFORE SUITE")
-})
-
-var _ = AfterSuite(func() {
-	println("AFTER SUITE")
-	panic("BAM!")
-})

vendor/github.com/onsi/ginkgo/integration/_fixtures/failing_after_suite/failing_after_suite_test.go

@@ -1,15 +0,0 @@
-package failing_before_suite_test
-
-import (
-	. "github.com/onsi/ginkgo"
-)
-
-var _ = Describe("FailingBeforeSuite", func() {
-	It("should run", func() {
-		println("A TEST")
-	})
-
-	It("should run", func() {
-		println("A TEST")
-	})
-})

vendor/github.com/onsi/ginkgo/integration/_fixtures/failing_before_suite/failing_before_suite_suite_test.go

@@ -1,22 +0,0 @@
-package failing_before_suite_test
-
-import (
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-
-	"testing"
-)
-
-func TestFailing_before_suite(t *testing.T) {
-	RegisterFailHandler(Fail)
-	RunSpecs(t, "Failing_before_suite Suite")
-}
-
-var _ = BeforeSuite(func() {
-	println("BEFORE SUITE")
-	panic("BAM!")
-})
-
-var _ = AfterSuite(func() {
-	println("AFTER SUITE")
-})

vendor/github.com/onsi/ginkgo/integration/_fixtures/failing_before_suite/failing_before_suite_test.go

@@ -1,15 +0,0 @@
-package failing_before_suite_test
-
-import (
-	. "github.com/onsi/ginkgo"
-)
-
-var _ = Describe("FailingBeforeSuite", func() {
-	It("should never run", func() {
-		println("NEVER SEE THIS")
-	})
-
-	It("should never run", func() {
-		println("NEVER SEE THIS")
-	})
-})

vendor/github.com/onsi/ginkgo/integration/_fixtures/failing_ginkgo_tests/failing_ginkgo_tests.go

@@ -1,5 +0,0 @@
-package failing_ginkgo_tests
-
-func AlwaysFalse() bool {
-	return false
-}

vendor/github.com/onsi/ginkgo/integration/_fixtures/failing_ginkgo_tests/failing_ginkgo_tests_suite_test.go

@@ -1,13 +0,0 @@
-package failing_ginkgo_tests_test
-
-import (
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-
-	"testing"
-)
-
-func TestFailing_ginkgo_tests(t *testing.T) {
-	RegisterFailHandler(Fail)
-	RunSpecs(t, "Failing_ginkgo_tests Suite")
-}

vendor/github.com/onsi/ginkgo/integration/_fixtures/failing_ginkgo_tests/failing_ginkgo_tests_test.go

@@ -1,17 +0,0 @@
-package failing_ginkgo_tests_test
-
-import (
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/ginkgo/integration/_fixtures/failing_ginkgo_tests"
-	. "github.com/onsi/gomega"
-)
-
-var _ = Describe("FailingGinkgoTests", func() {
-	It("should fail", func() {
-		Ω(AlwaysFalse()).Should(BeTrue())
-	})
-
-	It("should pass", func() {
-		Ω(AlwaysFalse()).Should(BeFalse())
-	})
-})

vendor/github.com/onsi/ginkgo/integration/_fixtures/flags_tests/flags.go

@@ -1,9 +0,0 @@
-package flags
-
-func Tested() string {
-	return "tested"
-}
-
-func Untested() string {
-	return "untested"
-}

vendor/github.com/onsi/ginkgo/integration/_fixtures/flags_tests/flags_suite_test.go

@@ -1,13 +0,0 @@
-package flags_test
-
-import (
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-
-	"testing"
-)
-
-func TestFlags(t *testing.T) {
-	RegisterFailHandler(Fail)
-	RunSpecs(t, "Flags Suite")
-}

vendor/github.com/onsi/ginkgo/integration/_fixtures/flags_tests/flags_test.go

@@ -1,95 +0,0 @@
-package flags_test
-
-import (
-	"flag"
-	"fmt"
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/ginkgo/integration/_fixtures/flags_tests"
-	. "github.com/onsi/gomega"
-	"time"
-	remapped "math"
-)
-
-var customFlag string
-
-func init() {
-	flag.StringVar(&customFlag, "customFlag", "default", "custom flag!")
-}
-
-var _ = Describe("Testing various flags", func() {
-	FDescribe("the focused set", func() {
-		Measure("a measurement", func(b Benchmarker) {
-			b.RecordValue("a value", 3)
-		}, 3)
-
-		It("should honor -cover", func() {
-			Ω(Tested()).Should(Equal("tested"))
-		})
-
-		It("should allow gcflags", func() {
-			fmt.Printf("NaN returns %T\n", remapped.NaN())
-		})
-
-		PIt("should honor -failOnPending and -noisyPendings")
-
-		Describe("smores", func() {
-			It("should honor -skip: marshmallow", func() {
-				println("marshmallow")
-			})
-
-			It("should honor -focus: chocolate", func() {
-				println("chocolate")
-			})
-		})
-
-		It("should detect races", func(done Done) {
-			var a string
-			go func() {
-				a = "now you don't"
-				close(done)
-			}()
-			a = "now you see me"
-			println(a)
-		})
-
-		It("should randomize A", func() {
-			println("RANDOM_A")
-		})
-
-		It("should randomize B", func() {
-			println("RANDOM_B")
-		})
-
-		It("should randomize C", func() {
-			println("RANDOM_C")
-		})
-
-		It("should honor -slowSpecThreshold", func() {
-			time.Sleep(100 * time.Millisecond)
-		})
-
-		It("should pass in additional arguments after '--' directly to the test process", func() {
-			fmt.Printf("CUSTOM_FLAG: %s", customFlag)
-		})
-	})
-
-	Describe("more smores", func() {
-		It("should not run these unless -focus is set", func() {
-			println("smores")
-		})
-	})
-
-	Describe("a failing test", func() {
-		It("should fail", func() {
-			Ω(true).Should(Equal(false))
-		})
-	})
-
-	Describe("a flaky test", func() {
-		runs := 0
-		It("should only pass the second time it's run", func() {
-			runs++
-			Ω(runs).Should(BeNumerically("==", 2))
-		})
-	})
-})

vendor/github.com/onsi/ginkgo/integration/_fixtures/focused_fixture/focused_fixture_suite_test.go

@@ -1,13 +0,0 @@
-package focused_fixture_test
-
-import (
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-
-	"testing"
-)
-
-func TestFocused_fixture(t *testing.T) {
-	RegisterFailHandler(Fail)
-	RunSpecs(t, "Focused_fixture Suite")
-}

vendor/github.com/onsi/ginkgo/integration/_fixtures/focused_fixture/focused_fixture_test.go

@@ -1,63 +0,0 @@
-package focused_fixture_test
-
-import (
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/ginkgo/extensions/table"
-)
-
-var _ = Describe("FocusedFixture", func() {
-	FDescribe("focused", func() {
-		It("focused", func() {
-
-		})
-	})
-
-	FContext("focused", func() {
-		It("focused", func() {
-
-		})
-	})
-
-	FIt("focused", func() {
-
-	})
-
-	FMeasure("focused", func(b Benchmarker) {
-
-	}, 2)
-
-	FDescribeTable("focused",
-		func() {},
-		Entry("focused"),
-	)
-
-	DescribeTable("focused",
-		func() {},
-		FEntry("focused"),
-	)
-
-	Describe("not focused", func() {
-		It("not focused", func() {
-
-		})
-	})
-
-	Context("not focused", func() {
-		It("not focused", func() {
-
-		})
-	})
-
-	It("not focused", func() {
-
-	})
-
-	Measure("not focused", func(b Benchmarker) {
-
-	}, 2)
-
-	DescribeTable("not focused",
-		func() {},
-		Entry("not focused"),
-	)
-})

vendor/github.com/onsi/ginkgo/integration/_fixtures/hanging_suite/hanging_suite_suite_test.go

@@ -1,13 +0,0 @@
-package hanging_suite_test
-
-import (
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-
-	"testing"
-)
-
-func TestHangingSuite(t *testing.T) {
-	RegisterFailHandler(Fail)
-	RunSpecs(t, "HangingSuite Suite")
-}

vendor/github.com/onsi/ginkgo/integration/_fixtures/hanging_suite/hanging_suite_test.go

@@ -1,29 +0,0 @@
-package hanging_suite_test
-
-import (
-	"fmt"
-	"time"
-	. "github.com/onsi/ginkgo"
-)
-
-var _ = AfterSuite(func() {
-	fmt.Println("Heading Out After Suite")
-})
-
-var _ = Describe("HangingSuite", func() {
-	BeforeEach(func() {
-		fmt.Fprintln(GinkgoWriter, "Just beginning")
-	})
-
-	Context("inner context", func() {
-		BeforeEach(func() {
-			fmt.Fprintln(GinkgoWriter, "Almost there...")
-		})
-
-		It("should hang out for a while", func() {
-			fmt.Fprintln(GinkgoWriter, "Hanging Out")
-			fmt.Println("Sleeping...")
-			time.Sleep(time.Hour)
-		})
-	})
-})

vendor/github.com/onsi/ginkgo/integration/_fixtures/more_ginkgo_tests/more_ginkgo_tests.go

@@ -1,5 +0,0 @@
-package more_ginkgo_tests
-
-func AlwaysTrue() bool {
-	return true
-}

vendor/github.com/onsi/ginkgo/integration/_fixtures/more_ginkgo_tests/more_ginkgo_tests_suite_test.go

@@ -1,13 +0,0 @@
-package more_ginkgo_tests_test
-
-import (
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-
-	"testing"
-)
-
-func TestMore_ginkgo_tests(t *testing.T) {
-	RegisterFailHandler(Fail)
-	RunSpecs(t, "More_ginkgo_tests Suite")
-}

vendor/github.com/onsi/ginkgo/integration/_fixtures/more_ginkgo_tests/more_ginkgo_tests_test.go

@@ -1,17 +0,0 @@
-package more_ginkgo_tests_test
-
-import (
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/ginkgo/integration/_fixtures/more_ginkgo_tests"
-	. "github.com/onsi/gomega"
-)
-
-var _ = Describe("MoreGinkgoTests", func() {
-	It("should pass", func() {
-		Ω(AlwaysTrue()).Should(BeTrue())
-	})
-
-	It("should always pass", func() {
-		Ω(AlwaysTrue()).Should(BeTrue())
-	})
-})

vendor/github.com/onsi/ginkgo/integration/_fixtures/no_test_fn/no_test_fn.go

@@ -1,5 +0,0 @@
-package no_test_fn
-
-func StringIdentity(a string) string {
-	return a
-}

vendor/github.com/onsi/ginkgo/integration/_fixtures/no_test_fn/no_test_fn_test.go

@@ -1,13 +0,0 @@
-package no_test_fn_test
-
-import (
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/ginkgo/integration/_fixtures/no_test_fn"
-	. "github.com/onsi/gomega"
-)
-
-var _ = Describe("NoTestFn", func() {
-	It("should proxy strings", func() {
-		Ω(StringIdentity("foo")).Should(Equal("foo"))
-	})
-})