update testing related dependencies

Signed-off-by: Davanum Srinivas <davanum@gmail.com>
2021-05-18 19:31:47 -04:00
parent 22ec3b0edd
commit 0803ea49b9
155 changed files with 2892 additions and 3215 deletions
--- a/vendor/github.com/onsi/ginkgo/.travis.yml
+++ b/vendor/github.com/onsi/ginkgo/.travis.yml
@@ -1,17 +1,25 @@
 language: go
 go:
-  - 1.12.x
  - 1.13.x
+  - 1.14.x
  - tip

+cache:
+  directories:
+    - $GOPATH/pkg/mod
+
 # allow internal package imports, necessary for forked repositories
 go_import_path: github.com/onsi/ginkgo

 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
+  - GO111MODULE="off" go get -v -t ./...
+  - GO111MODULE="off" go get golang.org/x/tools/cmd/cover
+  - GO111MODULE="off" go get github.com/onsi/gomega
+  - GO111MODULE="off" go install github.com/onsi/ginkgo/ginkgo
  - export PATH=$PATH:$HOME/gopath/bin

-script: $HOME/gopath/bin/ginkgo -r --randomizeAllSpecs --randomizeSuites --race --trace && go vet
+script:
+  - GO111MODULE="on" go mod tidy
+  - diff -u <(echo -n) <(git diff go.mod)
+  - diff -u <(echo -n) <(git diff go.sum)
+  - $HOME/gopath/bin/ginkgo -r --randomizeAllSpecs --randomizeSuites --race --trace && go vet
--- a/vendor/github.com/onsi/ginkgo/CHANGELOG.md
+++ b/vendor/github.com/onsi/ginkgo/CHANGELOG.md
@@ -1,3 +1,58 @@
+## 1.14.0
+
+### Features
+- Defer running top-level container nodes until RunSpecs is called [d44dedf]
+- [Document Ginkgo lifecycle](http://onsi.github.io/ginkgo/#understanding-ginkgos-lifecycle)
+- Add `extensions/globals` package (#692) [3295c8f] - this can be helpful in contexts where you are test-driving your test-generation code (see [#692](https://github.com/onsi/ginkgo/pull/692))
+- Print Skip reason in JUnit reporter if one was provided [820dfab]
+
+## 1.13.0
+
+### Features
+- Add a version of table.Entry that allows dumping the entry parameters. (#689) [21eaef2]
+
+### Fixes
+- Ensure integration tests pass in an environment sans GOPATH [606fba2]
+- Add books package (#568) [fc0e44e]
+- doc(readme): installation via "tools package" (#677) [83bb20e]
+- Solve the undefined: unix.Dup2 compile error on mips64le (#680) [0624f75]
+- Import package without dot (#687) [6321024]
+- Fix integration tests to stop require GOPATH (#686) [a912ec5]
+
+## 1.12.3
+
+### Fixes
+- Print correct code location of failing table test (#666) [c6d7afb]
+
+## 1.12.2
+
+### Fixes
+- Update dependencies [ea4a036]
+
+## 1.12.1
+
+### Fixes
+- Make unfocus ("blur") much faster (#674) [8b18061]
+- Fix typo (#673) [7fdcbe8]
+- Test against 1.14 and remove 1.12 [d5c2ad6]
+- Test if a coverprofile content is empty before checking its latest character (#670) [14d9fa2]
+- replace tail package with maintained one. this fixes go get errors (#667) [4ba33d4]
+- improve ginkgo performance - makes progress on #644 [a14f98e]
+- fix convert integration tests [1f8ba69]
+- fix typo succesful -> successful (#663) [1ea49cf]
+- Fix invalid link (#658) [b886136]
+- convert utility : Include comments from source (#657) [1077c6d]
+- Explain what BDD means [d79e7fb]
+- skip race detector test on unsupported platform (#642) [f8ab89d]
+- Use Dup2 from golang.org/x/sys/unix instead of syscallDup (#638) [5d53c55]
+- Fix missing newline in combined coverage file (#641) [6a07ea2]
+- check if a spec is run before returning SpecSummary (#645) [8850000]
+
+## 1.12.0
+
+### Features
+- Add module definition (#630) [78916ab]
+
 ## 1.11.0

 ### Features
@@ -203,7 +258,7 @@ New Features:
 - `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 now summarizes any spec failures that occurred at the end of the test run. 
 - `ginkgo --randomizeSuites` will run tests *suites* in random order using the generated/passed-in seed.

 Improvements:
--- a/vendor/github.com/onsi/ginkgo/README.md
+++ b/vendor/github.com/onsi/ginkgo/README.md
@@ -1,29 +1,45 @@
-![Ginkgo: A Go BDD Testing Framework](http://onsi.github.io/ginkgo/images/ginkgo.png)
+![Ginkgo: A Go BDD Testing Framework](https://onsi.github.io/ginkgo/images/ginkgo.png)

 [![Build Status](https://travis-ci.org/onsi/ginkgo.svg?branch=master)](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)!
+Jump to the [docs](https://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.
+If you have a question, comment, bug report, feature request, etc. please open a GitHub issue, or visit the [Ginkgo Slack channel](https://app.slack.com/client/T029RQSE6/CQQ50BBNW).
+
+## TLDR
+Ginkgo builds on Go's `testing` package, allowing expressive [Behavior-Driven Development](https://en.wikipedia.org/wiki/Behavior-driven_development) ("BDD") style tests.
+It is typically (and optionally) paired with the [Gomega](https://github.com/onsi/gomega) matcher library.
+
+```go
+Describe("the strings package", func() {
+  Context("strings.Contains()", func() {
+    When("the string contains the substring in the middle", func() {
+      It("returns `true`", func() {
+        Expect(strings.Contains("Ginkgo is awesome", "is")).To(BeTrue())
+      })
+    })
+  })
+})
+```

 ## 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)
+- Ginkgo uses Go's `testing` package and can live alongside your existing `testing` tests.  It's easy to [bootstrap](https://onsi.github.io/ginkgo/#bootstrapping-a-suite) and start writing your [first tests](https://onsi.github.io/ginkgo/#adding-specs-to-a-suite)

- Structure your BDD-style tests expressively:
-    - Nestable [`Describe`, `Context` and `When` 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` and `Specify` 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.
+- Ginkgo allows you to write tests in Go using expressive [Behavior-Driven Development](https://en.wikipedia.org/wiki/Behavior-driven_development) ("BDD") style:
+    - Nestable [`Describe`, `Context` and `When` container blocks](https://onsi.github.io/ginkgo/#organizing-specs-with-containers-describe-and-context)
+    - [`BeforeEach` and `AfterEach` blocks](https://onsi.github.io/ginkgo/#extracting-common-setup-beforeeach) for setup and teardown
+    - [`It` and `Specify` blocks](https://onsi.github.io/ginkgo/#individual-specs-it) that hold your assertions
+    - [`JustBeforeEach` blocks](https://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](https://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)
+    - Mark specs as [pending](https://onsi.github.io/ginkgo/#pending-specs)
+    - [Focus](https://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](https://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](https://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`: a command line interface with plenty of handy command line arguments for [running your tests](https://onsi.github.io/ginkgo/#running-tests) and [generating](https://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 Go's code coverage tool
    - `ginkgo convert` converts an XUnit-style `testing` package to a Ginkgo-style package
@@ -37,37 +53,58 @@ If you have a question, comment, bug report, feature request, etc. please open a

 - `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 testing [asynchronicity](https://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. 
+- Built-in support for [benchmarking](https://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.
+- 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](https://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
+    - Write [custom reporters](https://onsi.github.io/ginkgo/#writing-custom-reporters) (for example, Ginkgo comes with a [JUnit XML reporter](https://onsi.github.io/ginkgo/#generating-junit-xml-output) and a TeamCity reporter).
+    - [Adapt an existing matcher library (or write your own!)](https://onsi.github.io/ginkgo/#using-other-matcher-libraries) to work with Ginkgo

-## [Gomega](http://github.com/onsi/gomega): Ginkgo's Preferred Matcher Library
+## [Gomega](https://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/)
+Ginkgo is best paired with Gomega.  Learn more about Gomega [here](https://onsi.github.io/gomega/)

-## [Agouti](http://github.com/sclevine/agouti): A Go Acceptance Testing Framework
+## [Agouti](https://github.com/sclevine/agouti): A Go Acceptance Testing Framework

-Agouti allows you run WebDriver integration tests.  Learn more about Agouti [here](http://agouti.org)
+Agouti allows you run WebDriver integration tests.  Learn more about Agouti [here](https://agouti.org)

-## Set Me Up!
+## Getting Started

-You'll need the Go command-line tools. Ginkgo is tested with Go 1.6+, but preferably you should get the latest. Follow the [installation instructions](https://golang.org/doc/install) if you don't have it installed.
+You'll need the Go command-line tools. Follow the [installation instructions](https://golang.org/doc/install) if you don't have it installed.

+### Global installation
+To install the Ginkgo command line interface into the `$PATH` (actually to `$GOBIN`):
 ```bash
+go get -u github.com/onsi/ginkgo/ginkgo
+```

-go get -u github.com/onsi/ginkgo/ginkgo  # installs the ginkgo CLI
-go get -u github.com/onsi/gomega/...     # fetches the matcher library
+### Go module ["tools package"](https://github.com/golang/go/issues/25922):
+Create (or update) a file called `tools/tools.go` with the following contents:
+```go
+// +build tools

+package tools
+
+import (
+	_ "github.com/onsi/ginkgo"
+)
+
+// This file imports packages that are used when running go generate, or used
+// during the development process but not otherwise depended on by built code.
+```
+The Ginkgo command can then be run via `go run github.com/onsi/ginkgo/ginkgo`.
+This approach allows the version of Ginkgo to be maintained under source control for reproducible results,
+and is well suited to automated test pipelines.
+
+### Bootstrapping
+```bash
 cd path/to/package/you/want/to/test

 ginkgo bootstrap # set up a new ginkgo suite
@@ -87,16 +124,16 @@ With that said, it's great to know what your options are :)

 ### What Go gives you out of the box

-Testing is a first class citizen in Go, 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.
+Testing is a first class citizen in Go, however Go's built-in testing primitives are somewhat limited: The [testing](https://golang.org/pkg/testing) package provides basic XUnit style tests and no assertion library.

 ### Matcher libraries for Go'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)
+- [gocheck](https://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)
+You can also use Ginkgo's matcher library [Gomega](https://github.com/onsi/gomega) in [XUnit style tests](https://onsi.github.io/gomega/#using-gomega-with-golangs-xunitstyle-tests)

 ### BDD style testing frameworks

--- a/vendor/github.com/onsi/ginkgo/config/config.go
+++ b/vendor/github.com/onsi/ginkgo/config/config.go
@@ -1,7 +1,7 @@
 /*
 Ginkgo accepts a number of configuration options.

-These are documented [here](http://onsi.github.io/ginkgo/#the_ginkgo_cli)
+These are documented [here](http://onsi.github.io/ginkgo/#the-ginkgo-cli)

 You can also learn more via

@@ -20,7 +20,7 @@ import (
 	"fmt"
 )

-const VERSION = "1.11.0"
+const VERSION = "1.14.0"

 type GinkgoConfigType struct {
 	RandomSeed         int64
--- a/vendor/github.com/onsi/ginkgo/ginkgo/build_command.go
+++ b/vendor/github.com/onsi/ginkgo/ginkgo/build_command.go
@@ -57,8 +57,6 @@ func (r *SpecBuilder) BuildSpecs(args []string, additionalArgs []string) {
 		} else {
 			fmt.Printf("    compiled %s.test\n", suite.PackageName)
 		}
-
-		runner.CleanUp()
 	}

 	if passed {
--- a/vendor/github.com/onsi/ginkgo/ginkgo/convert/package_rewriter.go
+++ b/vendor/github.com/onsi/ginkgo/ginkgo/convert/package_rewriter.go
@@ -33,7 +33,8 @@ func RewritePackage(packageName string) {
 */
 func findTestsInPackage(pkg *build.Package) (testfiles []string) {
 	for _, file := range append(pkg.TestGoFiles, pkg.XTestGoFiles...) {
-		testfiles = append(testfiles, filepath.Join(pkg.Dir, file))
+		testfile, _ := filepath.Abs(filepath.Join(pkg.Dir, file))
+		testfiles = append(testfiles, testfile)
 	}

 	dirFiles, err := ioutil.ReadDir(pkg.Dir)
@@ -103,10 +104,11 @@ func addGinkgoSuiteForPackage(pkg *build.Package) {
 * Shells out to `go fmt` to format the package
 */
 func goFmtPackage(pkg *build.Package) {
-	output, err := exec.Command("go", "fmt", pkg.ImportPath).Output()
+	path, _ := filepath.Abs(pkg.ImportPath)
+	output, err := exec.Command("go", "fmt", path).CombinedOutput()

 	if err != nil {
-		fmt.Printf("Warning: Error running 'go fmt %s'.\nstdout: %s\n%s\n", pkg.ImportPath, output, err.Error())
+		fmt.Printf("Warning: Error running 'go fmt %s'.\nstdout: %s\n%s\n", path, output, err.Error())
 	}
 }

--- a/vendor/github.com/onsi/ginkgo/ginkgo/convert/testfile_rewriter.go
+++ b/vendor/github.com/onsi/ginkgo/ginkgo/convert/testfile_rewriter.go
@@ -22,7 +22,7 @@ import (
 */
 func rewriteTestsInFile(pathToFile string) {
 	fileSet := token.NewFileSet()
-	rootNode, err := parser.ParseFile(fileSet, pathToFile, nil, 0)
+	rootNode, err := parser.ParseFile(fileSet, pathToFile, nil, parser.ParseComments)
 	if err != nil {
 		panic(fmt.Sprintf("Error parsing test file '%s':\n%s\n", pathToFile, err.Error()))
 	}
@@ -56,11 +56,12 @@ func rewriteTestsInFile(pathToFile string) {
 	}

 	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())
+	err = ioutil.WriteFile(pathToFile, buffer.Bytes(), fileInfo.Mode())
 }

 /*
--- a/vendor/github.com/onsi/ginkgo/ginkgo/generate_command.go
+++ b/vendor/github.com/onsi/ginkgo/ginkgo/generate_command.go
@@ -39,7 +39,7 @@ import (
 	{{if .IncludeImports}}. "github.com/onsi/ginkgo"{{end}}
 	{{if .IncludeImports}}. "github.com/onsi/gomega"{{end}}

-	{{if .DotImportPackage}}. "{{.PackageImportPath}}"{{end}}
+	{{if .ImportPackage}}"{{.PackageImportPath}}"{{end}}
 )

 var _ = Describe("{{.Subject}}", func() {
@@ -55,7 +55,7 @@ import (
 	"github.com/sclevine/agouti"
 	. "github.com/sclevine/agouti/matchers"

-	{{if .DotImportPackage}}. "{{.PackageImportPath}}"{{end}}
+	{{if .ImportPackage}}"{{.PackageImportPath}}"{{end}}
 )

 var _ = Describe("{{.Subject}}", func() {
@@ -78,7 +78,7 @@ type specData struct {
 	Subject           string
 	PackageImportPath string
 	IncludeImports    bool
-	DotImportPackage  bool
+	ImportPackage     bool
 }

 func generateSpec(args []string, agouti, noDot, internal bool) {
@@ -119,7 +119,7 @@ func generateSpecForSubject(subject string, agouti, noDot, internal bool) error
 		Subject:           formattedName,
 		PackageImportPath: getPackageImportPath(),
 		IncludeImports:    !noDot,
-		DotImportPackage:  !internal,
+		ImportPackage:     !internal,
 	}

 	targetFile := fmt.Sprintf("%s_test.go", specFilePrefix)
--- a/vendor/github.com/onsi/ginkgo/ginkgo/main.go
+++ b/vendor/github.com/onsi/ginkgo/ginkgo/main.go
@@ -288,9 +288,9 @@ func findSuites(args []string, recurseForAll bool, skipPackage string, allowPrec
 }

 func goFmt(path string) {
-	err := exec.Command("go", "fmt", path).Run()
+	out, err := exec.Command("go", "fmt", path).CombinedOutput()
 	if err != nil {
-		complainAndQuit("Could not fmt: " + err.Error())
+		complainAndQuit("Could not fmt: " + err.Error() + "\n" + string(out))
 	}
 }

--- a/vendor/github.com/onsi/ginkgo/ginkgo/run_command.go
+++ b/vendor/github.com/onsi/ginkgo/ginkgo/run_command.go
@@ -179,19 +179,24 @@ func (r *SpecRunner) combineCoverprofiles(runners []*testrunner.TestRunner) erro
 	for index, runner := range runners {
 		contents, err := ioutil.ReadFile(runner.CoverageFile)

+		if err != nil {
+			fmt.Printf("Unable to read coverage file %s to combine, %v\n", runner.CoverageFile, err)
+			return nil // non-fatal error
+		}
+
 		// remove the cover mode line from every file
 		// except the first one
 		if index > 0 {
 			contents = modeRegex.ReplaceAll(contents, []byte{})
 		}

-		if err != nil {
-			fmt.Printf("Unable to read coverage file %s to combine, %v\n", runner.CoverageFile, err)
-			return nil // non-fatal error
-		}
-
 		_, err = combined.Write(contents)

+		// Add a newline to the end of every file if missing.
+		if err == nil && len(contents) > 0 && contents[len(contents)-1] != '\n' {
+			_, err = combined.Write([]byte("\n"))
+		}
+
 		if err != nil {
 			fmt.Printf("Unable to append to coverprofile, %v\n", err)
 			return nil // non-fatal error
--- a/vendor/github.com/onsi/ginkgo/ginkgo/testrunner/test_runner.go
+++ b/vendor/github.com/onsi/ginkgo/ginkgo/testrunner/test_runner.go
@@ -49,11 +49,7 @@ func New(suite testsuite.TestSuite, numCPU int, parallelStream bool, timeout tim
 	}

 	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")
+		runner.compilationTargetPath, _ = filepath.Abs(filepath.Join(suite.Path, suite.PackageName+".test"))
 	}

 	return runner
@@ -248,7 +244,7 @@ func (t *TestRunner) CleanUp() {
 	if t.Suite.Precompiled {
 		return
 	}
-	os.RemoveAll(filepath.Dir(t.compilationTargetPath))
+	os.Remove(t.compilationTargetPath)
 }

 func (t *TestRunner) runSerialGinkgoSuite() RunResult {
--- a/vendor/github.com/onsi/ginkgo/ginkgo/unfocus_command.go
+++ b/vendor/github.com/onsi/ginkgo/ginkgo/unfocus_command.go
@@ -1,11 +1,18 @@
 package main

 import (
+	"bytes"
 	"flag"
 	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"io"
 	"io/ioutil"
-	"os/exec"
+	"os"
+	"path/filepath"
 	"strings"
+	"sync"
 )

 func BuildUnfocusCommand() *Command {
@@ -22,40 +29,152 @@ func BuildUnfocusCommand() *Command {
 }

 func unfocusSpecs([]string, []string) {
-	unfocus("Describe")
-	unfocus("Context")
-	unfocus("It")
-	unfocus("Measure")
-	unfocus("DescribeTable")
-	unfocus("Entry")
-	unfocus("Specify")
-	unfocus("When")
+	fmt.Println("Scanning for focus...")
+
+	goFiles := make(chan string)
+	go func() {
+		unfocusDir(goFiles, ".")
+		close(goFiles)
+	}()
+
+	const workers = 10
+	wg := sync.WaitGroup{}
+	wg.Add(workers)
+
+	for i := 0; i < workers; i++ {
+		go func() {
+			for path := range goFiles {
+				unfocusFile(path)
+			}
+			wg.Done()
+		}()
+	}
+
+	wg.Wait()
 }

-func unfocus(component string) {
-	fmt.Printf("Removing F%s...\n", component)
-	files, err := ioutil.ReadDir(".")
+func unfocusDir(goFiles chan string, path string) {
+	files, err := ioutil.ReadDir(path)
 	if err != nil {
 		fmt.Println(err.Error())
 		return
 	}
+
 	for _, f := range files {
-		// Exclude "vendor" directory
-		if f.IsDir() && f.Name() == "vendor" {
-			continue
-		}
-		// Exclude non-go files in the current directory
-		if !f.IsDir() && !strings.HasSuffix(f.Name(), ".go") {
-			continue
-		}
-		// Recursively run `gofmt` otherwise
-		cmd := exec.Command("gofmt", fmt.Sprintf("-r=F%s -> %s", component, component), "-w", f.Name())
-		out, err := cmd.CombinedOutput()
-		if err != nil {
-			fmt.Println(err.Error())
-		}
-		if string(out) != "" {
-			fmt.Println(string(out))
+		switch {
+		case f.IsDir() && shouldProcessDir(f.Name()):
+			unfocusDir(goFiles, filepath.Join(path, f.Name()))
+		case !f.IsDir() && shouldProcessFile(f.Name()):
+			goFiles <- filepath.Join(path, f.Name())
 		}
 	}
 }
+
+func shouldProcessDir(basename string) bool {
+	return basename != "vendor" && !strings.HasPrefix(basename, ".")
+}
+
+func shouldProcessFile(basename string) bool {
+	return strings.HasSuffix(basename, ".go")
+}
+
+func unfocusFile(path string) {
+	data, err := ioutil.ReadFile(path)
+	if err != nil {
+		fmt.Printf("error reading file '%s': %s\n", path, err.Error())
+		return
+	}
+
+	ast, err := parser.ParseFile(token.NewFileSet(), path, bytes.NewReader(data), 0)
+	if err != nil {
+		fmt.Printf("error parsing file '%s': %s\n", path, err.Error())
+		return
+	}
+
+	eliminations := scanForFocus(ast)
+	if len(eliminations) == 0 {
+		return
+	}
+
+	fmt.Printf("...updating %s\n", path)
+	backup, err := writeBackup(path, data)
+	if err != nil {
+		fmt.Printf("error creating backup file: %s\n", err.Error())
+		return
+	}
+
+	if err := updateFile(path, data, eliminations); err != nil {
+		fmt.Printf("error writing file '%s': %s\n", path, err.Error())
+		return
+	}
+
+	os.Remove(backup)
+}
+
+func writeBackup(path string, data []byte) (string, error) {
+	t, err := ioutil.TempFile(filepath.Dir(path), filepath.Base(path))
+
+	if err != nil {
+		return "", fmt.Errorf("error creating temporary file: %w", err)
+	}
+	defer t.Close()
+
+	if _, err := io.Copy(t, bytes.NewReader(data)); err != nil {
+		return "", fmt.Errorf("error writing to temporary file: %w", err)
+	}
+
+	return t.Name(), nil
+}
+
+func updateFile(path string, data []byte, eliminations []int64) error {
+	to, err := os.Create(path)
+	if err != nil {
+		return fmt.Errorf("error opening file for writing '%s': %w\n", path, err)
+	}
+	defer to.Close()
+
+	from := bytes.NewReader(data)
+	var cursor int64
+	for _, byteToEliminate := range eliminations {
+		if _, err := io.CopyN(to, from, byteToEliminate-cursor); err != nil {
+			return fmt.Errorf("error copying data: %w", err)
+		}
+
+		cursor = byteToEliminate + 1
+
+		if _, err := from.Seek(1, io.SeekCurrent); err != nil {
+			return fmt.Errorf("error seeking to position in buffer: %w", err)
+		}
+	}
+
+	if _, err := io.Copy(to, from); err != nil {
+		return fmt.Errorf("error copying end data: %w", err)
+	}
+
+	return nil
+}
+
+func scanForFocus(file *ast.File) (eliminations []int64) {
+	ast.Inspect(file, func(n ast.Node) bool {
+		if c, ok := n.(*ast.CallExpr); ok {
+			if i, ok := c.Fun.(*ast.Ident); ok {
+				if isFocus(i.Name) {
+					eliminations = append(eliminations, int64(i.Pos()-file.Pos()))
+				}
+			}
+		}
+
+		return true
+	})
+
+	return eliminations
+}
+
+func isFocus(name string) bool {
+	switch name {
+	case "FDescribe", "FContext", "FIt", "FMeasure", "FDescribeTable", "FEntry", "FSpecify", "FWhen":
+		return true
+	default:
+		return false
+	}
+}
--- a/vendor/github.com/onsi/ginkgo/ginkgo/watch/dependencies.go
+++ b/vendor/github.com/onsi/ginkgo/ginkgo/watch/dependencies.go
@@ -6,6 +6,7 @@ import (
 )

 var ginkgoAndGomegaFilter = regexp.MustCompile(`github\.com/onsi/ginkgo|github\.com/onsi/gomega`)
+var ginkgoIntegrationTestFilter = regexp.MustCompile(`github\.com/onsi/ginkgo/integration`) //allow us to integration test this thing

 type Dependencies struct {
 	deps map[string]int
@@ -77,7 +78,7 @@ func (d Dependencies) resolveAndAdd(deps []string, depth int) {
 		if err != nil {
 			continue
 		}
-		if !pkg.Goroot && !ginkgoAndGomegaFilter.Match([]byte(pkg.Dir)) {
+		if !pkg.Goroot && (!ginkgoAndGomegaFilter.Match([]byte(pkg.Dir)) || ginkgoIntegrationTestFilter.Match([]byte(pkg.Dir))) {
 			d.addDepIfNotPresent(pkg.Dir, depth)
 		}
 	}
--- a/vendor/github.com/onsi/ginkgo/ginkgo_dsl.go
+++ b/vendor/github.com/onsi/ginkgo/ginkgo_dsl.go
@@ -22,9 +22,8 @@ import (

 	"github.com/onsi/ginkgo/config"
 	"github.com/onsi/ginkgo/internal/codelocation"
-	"github.com/onsi/ginkgo/internal/failer"
+	"github.com/onsi/ginkgo/internal/global"
 	"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"
@@ -46,16 +45,10 @@ To circumvent this, you should call

 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
@@ -156,7 +149,7 @@ type GinkgoTestDescription struct {

 //CurrentGinkgoTestDescripton returns information about the current running test.
 func CurrentGinkgoTestDescription() GinkgoTestDescription {
-	summary, ok := globalSuite.CurrentRunningSpecSummary()
+	summary, ok := global.Suite.CurrentRunningSpecSummary()
 	if !ok {
 		return GinkgoTestDescription{}
 	}
@@ -223,7 +216,7 @@ func RunSpecsWithCustomReporters(t GinkgoTestingT, description string, specRepor
 	for i, reporter := range specReporters {
 		reporters[i] = reporter
 	}
-	passed, hasFocusedTests := globalSuite.Run(t, description, reporters, writer, config.GinkgoConfig)
+	passed, hasFocusedTests := global.Suite.Run(t, description, reporters, writer, config.GinkgoConfig)
 	if passed && hasFocusedTests && strings.TrimSpace(os.Getenv("GINKGO_EDITOR_INTEGRATION")) == "" {
 		fmt.Println("PASS | FOCUSED")
 		os.Exit(types.GINKGO_FOCUS_EXIT_CODE)
@@ -252,7 +245,7 @@ func Skip(message string, callerSkip ...int) {
 		skip = callerSkip[0]
 	}

-	globalFailer.Skip(message, codelocation.New(skip+1))
+	global.Failer.Skip(message, codelocation.New(skip+1))
 	panic(GINKGO_PANIC)
 }

@@ -263,7 +256,7 @@ func Fail(message string, callerSkip ...int) {
 		skip = callerSkip[0]
 	}

-	globalFailer.Fail(message, codelocation.New(skip+1))
+	global.Failer.Fail(message, codelocation.New(skip+1))
 	panic(GINKGO_PANIC)
 }

@@ -280,7 +273,7 @@ func Fail(message string, callerSkip ...int) {
 func GinkgoRecover() {
 	e := recover()
 	if e != nil {
-		globalFailer.Panic(codelocation.New(1), e)
+		global.Failer.Panic(codelocation.New(1), e)
 	}
 }

@@ -291,25 +284,25 @@ func GinkgoRecover() {
 //equivalent.  The difference is purely semantic -- you typically Describe the behavior of an object
 //or method and, within that Describe, outline a number of Contexts and Whens.
 func Describe(text string, body func()) bool {
-	globalSuite.PushContainerNode(text, body, types.FlagTypeNone, codelocation.New(1))
+	global.Suite.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))
+	global.Suite.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))
+	global.Suite.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))
+	global.Suite.PushContainerNode(text, body, types.FlagTypePending, codelocation.New(1))
 	return true
 }

@@ -320,25 +313,25 @@ func XDescribe(text string, body func()) bool {
 //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 and Whens.
 func Context(text string, body func()) bool {
-	globalSuite.PushContainerNode(text, body, types.FlagTypeNone, codelocation.New(1))
+	global.Suite.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))
+	global.Suite.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))
+	global.Suite.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))
+	global.Suite.PushContainerNode(text, body, types.FlagTypePending, codelocation.New(1))
 	return true
 }

@@ -349,25 +342,25 @@ func XContext(text string, body func()) bool {
 //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 and Whens.
 func When(text string, body func()) bool {
-	globalSuite.PushContainerNode("when "+text, body, types.FlagTypeNone, codelocation.New(1))
+	global.Suite.PushContainerNode("when "+text, body, types.FlagTypeNone, codelocation.New(1))
 	return true
 }

 //You can focus the tests within a describe block using FWhen
 func FWhen(text string, body func()) bool {
-	globalSuite.PushContainerNode("when "+text, body, types.FlagTypeFocused, codelocation.New(1))
+	global.Suite.PushContainerNode("when "+text, body, types.FlagTypeFocused, codelocation.New(1))
 	return true
 }

 //You can mark the tests within a describe block as pending using PWhen
 func PWhen(text string, body func()) bool {
-	globalSuite.PushContainerNode("when "+text, body, types.FlagTypePending, codelocation.New(1))
+	global.Suite.PushContainerNode("when "+text, body, types.FlagTypePending, codelocation.New(1))
 	return true
 }

 //You can mark the tests within a describe block as pending using XWhen
 func XWhen(text string, body func()) bool {
-	globalSuite.PushContainerNode("when "+text, body, types.FlagTypePending, codelocation.New(1))
+	global.Suite.PushContainerNode("when "+text, body, types.FlagTypePending, codelocation.New(1))
 	return true
 }

@@ -377,25 +370,25 @@ func XWhen(text string, body func()) bool {
 //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...))
+	global.Suite.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...))
+	global.Suite.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)
+	global.Suite.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)
+	global.Suite.PushItNode(text, func() {}, types.FlagTypePending, codelocation.New(1), 0)
 	return true
 }

@@ -403,25 +396,25 @@ func XIt(text string, _ ...interface{}) bool {
 //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 {
-	globalSuite.PushItNode(text, body, types.FlagTypeNone, codelocation.New(1), parseTimeout(timeout...))
+	global.Suite.PushItNode(text, body, types.FlagTypeNone, codelocation.New(1), parseTimeout(timeout...))
 	return true
 }

 //You can focus individual Specifys using FSpecify
 func FSpecify(text string, body interface{}, timeout ...float64) bool {
-	globalSuite.PushItNode(text, body, types.FlagTypeFocused, codelocation.New(1), parseTimeout(timeout...))
+	global.Suite.PushItNode(text, body, types.FlagTypeFocused, codelocation.New(1), parseTimeout(timeout...))
 	return true
 }

 //You can mark Specifys as pending using PSpecify
 func PSpecify(text string, is ...interface{}) bool {
-	globalSuite.PushItNode(text, func() {}, types.FlagTypePending, codelocation.New(1), 0)
+	global.Suite.PushItNode(text, func() {}, types.FlagTypePending, codelocation.New(1), 0)
 	return true
 }

 //You can mark Specifys as pending using XSpecify
 func XSpecify(text string, is ...interface{}) bool {
-	globalSuite.PushItNode(text, func() {}, types.FlagTypePending, codelocation.New(1), 0)
+	global.Suite.PushItNode(text, func() {}, types.FlagTypePending, codelocation.New(1), 0)
 	return true
 }

@@ -452,25 +445,25 @@ func By(text string, callbacks ...func()) {
 //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)
+	global.Suite.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)
+	global.Suite.PushMeasureNode(text, body, types.FlagTypeFocused, codelocation.New(1), samples)
 	return true
 }

 //You can mark Measurements as pending using PMeasure
 func PMeasure(text string, _ ...interface{}) bool {
-	globalSuite.PushMeasureNode(text, func(b Benchmarker) {}, types.FlagTypePending, codelocation.New(1), 0)
+	global.Suite.PushMeasureNode(text, func(b Benchmarker) {}, types.FlagTypePending, codelocation.New(1), 0)
 	return true
 }

 //You can mark Measurements as pending using XMeasure
 func XMeasure(text string, _ ...interface{}) bool {
-	globalSuite.PushMeasureNode(text, func(b Benchmarker) {}, types.FlagTypePending, codelocation.New(1), 0)
+	global.Suite.PushMeasureNode(text, func(b Benchmarker) {}, types.FlagTypePending, codelocation.New(1), 0)
 	return true
 }

@@ -481,7 +474,7 @@ func XMeasure(text string, _ ...interface{}) bool {
 //
 //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...))
+	global.Suite.SetBeforeSuiteNode(body, codelocation.New(1), parseTimeout(timeout...))
 	return true
 }

@@ -494,7 +487,7 @@ func BeforeSuite(body interface{}, timeout ...float64) bool {
 //
 //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...))
+	global.Suite.SetAfterSuiteNode(body, codelocation.New(1), parseTimeout(timeout...))
 	return true
 }

@@ -539,7 +532,7 @@ func AfterSuite(body interface{}, timeout ...float64) bool {
 //		Ω(err).ShouldNot(HaveOccurred())
 //	})
 func SynchronizedBeforeSuite(node1Body interface{}, allNodesBody interface{}, timeout ...float64) bool {
-	globalSuite.SetSynchronizedBeforeSuiteNode(
+	global.Suite.SetSynchronizedBeforeSuiteNode(
 		node1Body,
 		allNodesBody,
 		codelocation.New(1),
@@ -566,7 +559,7 @@ func SynchronizedBeforeSuite(node1Body interface{}, allNodesBody interface{}, ti
 //		dbRunner.Stop()
 //	})
 func SynchronizedAfterSuite(allNodesBody interface{}, node1Body interface{}, timeout ...float64) bool {
-	globalSuite.SetSynchronizedAfterSuiteNode(
+	global.Suite.SetSynchronizedAfterSuiteNode(
 		allNodesBody,
 		node1Body,
 		codelocation.New(1),
@@ -581,7 +574,7 @@ func SynchronizedAfterSuite(allNodesBody interface{}, node1Body interface{}, tim
 //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...))
+	global.Suite.PushBeforeEachNode(body, codelocation.New(1), parseTimeout(timeout...))
 	return true
 }

@@ -591,7 +584,7 @@ func BeforeEach(body interface{}, timeout ...float64) bool {
 //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...))
+	global.Suite.PushJustBeforeEachNode(body, codelocation.New(1), parseTimeout(timeout...))
 	return true
 }

@@ -601,7 +594,7 @@ func JustBeforeEach(body interface{}, timeout ...float64) bool {
 //Like It blocks, JustAfterEach blocks can be made asynchronous by providing a body function that accepts
 //a Done channel
 func JustAfterEach(body interface{}, timeout ...float64) bool {
-	globalSuite.PushJustAfterEachNode(body, codelocation.New(1), parseTimeout(timeout...))
+	global.Suite.PushJustAfterEachNode(body, codelocation.New(1), parseTimeout(timeout...))
 	return true
 }

@@ -611,13 +604,13 @@ func JustAfterEach(body interface{}, timeout ...float64) bool {
 //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...))
+	global.Suite.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))
+		return global.DefaultTimeout
 	} else {
 		return time.Duration(timeout[0] * float64(time.Second))
 	}
--- a/vendor/github.com/onsi/ginkgo/go.mod
+++ b/vendor/github.com/onsi/ginkgo/go.mod
@@ -0,0 +1,11 @@
+module github.com/onsi/ginkgo
+
+require (
+	github.com/fsnotify/fsnotify v1.4.9 // indirect
+	github.com/nxadm/tail v1.4.4
+	github.com/onsi/gomega v1.10.1
+	golang.org/x/sys v0.0.0-20200519105757-fe76b779f299
+	golang.org/x/text v0.3.2 // indirect
+)
+
+go 1.13
--- a/vendor/github.com/onsi/ginkgo/go.sum
+++ b/vendor/github.com/onsi/ginkgo/go.sum
@@ -0,0 +1,67 @@
+github.com/fsnotify/fsnotify v1.4.7 h1:IXs+QLmnXW2CcXuY+8Mzv/fWEsPGWxqefPtCP5CnV9I=
+github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
+github.com/fsnotify/fsnotify v1.4.9 h1:hsms1Qyu0jgnwNXIxa+/V/PDsU6CfLf6CNO8H7IWoS4=
+github.com/fsnotify/fsnotify v1.4.9/go.mod h1:znqG4EE+3YCdAaPaxE2ZRY/06pZUdp0tY4IgpuI1SZQ=
+github.com/golang/protobuf v1.2.0 h1:P3YflyNX/ehuJFLhxviNdFxQPkGK5cDcApsge1SqnvM=
+github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/golang/protobuf v1.4.0-rc.1/go.mod h1:ceaxUfeHdC40wWswd/P6IGgMaK3YpKi5j83Wpe3EHw8=
+github.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:xKAWHe0F5eneWXFV3EuXVDTCmh+JuBKY0li0aMyXATA=
+github.com/golang/protobuf v1.4.0-rc.2/go.mod h1:LlEzMj4AhA7rCAGe4KMBDvJI+AwstrUpVNzEA03Pprs=
+github.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:WU3c8KckQ9AFe+yFwt9sWVRKCVIyN9cPHBJSNnbL67w=
+github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0=
+github.com/golang/protobuf v1.4.2 h1:+Z5KGCizgyZCbGh1KZqA0fcLLkwbsjIzS4aV2v7wJX0=
+github.com/golang/protobuf v1.4.2/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
+github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
+github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
+github.com/google/go-cmp v0.4.0 h1:xsAVV57WRhGj6kEIi8ReJzQlHHqcBYCElAvkovg3B/4=
+github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/hpcloud/tail v1.0.0 h1:nfCOvKYfkgYP8hkirhJocXT2+zOD8yUNjXaWfTlyFKI=
+github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU=
+github.com/nxadm/tail v1.4.4 h1:DQuhQpB1tVlglWS2hLQ5OV6B5r8aGxSrPc5Qo6uTN78=
+github.com/nxadm/tail v1.4.4/go.mod h1:kenIhsEOeOJmVchQTgglprH7qJGnHDVpk1VPCcaMI8A=
+github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
+github.com/onsi/ginkgo v1.12.1/go.mod h1:zj2OWP4+oCPe1qIXoGWkgMRwljMUYCdkwsT2108oapk=
+github.com/onsi/gomega v1.7.1 h1:K0jcRCwNQM3vFGh1ppMtDh/+7ApJrjldlX8fA0jDTLQ=
+github.com/onsi/gomega v1.7.1/go.mod h1:XdKZgCCFLUoM/7CFJVPcG8C1xQ1AJ0vpAezJrB7JYyY=
+github.com/onsi/gomega v1.10.1 h1:o0+MgICZLuZ7xjH7Vx6zS/zcu93/BEp1VwkIW1mEXCE=
+github.com/onsi/gomega v1.10.1/go.mod h1:iN09h71vgCQne3DLsj+A5owkum+a2tYe+TOCB1ybHNo=
+golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
+golang.org/x/net v0.0.0-20180906233101-161cd47e91fd h1:nTDtHvHSdCn1m6ITfMRqtOd/9+7a3s8RBNOZ3eYZzJA=
+golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20200520004742-59133d7f0dd7 h1:AeiKBIuRw3UomYXSbLy0Mc2dDLfdtbT/IVn4keq83P0=
+golang.org/x/net v0.0.0-20200520004742-59133d7f0dd7/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
+golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f h1:wMNYb4v58l5UBM7MYRLPG6ZhfOqbKu7X5eyFl8ZhKvA=
+golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190904154756-749cb33beabd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191005200804-aed5e4c7ecf9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191120155948-bd437916bb0e h1:N7DeIrjYszNmSW409R3frPPwglRwMkXSBzwVbkOjLLA=
+golang.org/x/sys v0.0.0-20191120155948-bd437916bb0e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200519105757-fe76b779f299 h1:DYfZAGf2WMFjMxbgTjaC+2HC7NkNAQs+6Q8b9WEB/F4=
+golang.org/x/sys v0.0.0-20200519105757-fe76b779f299/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/text v0.3.0 h1:g61tztE5qeGQ89tm6NTjjM9VPIm088od1l6aSorWRWg=
+golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/text v0.3.2 h1:tW2bmiBqwgJj/UpqtC8EpXEZVYOwU0yG4iWbprSVAcs=
+golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
+golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8=
+google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0=
+google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM=
+google.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miEFZTKqfCUM6K7xSMQL9OKL/b6hQv+e19PK+JZNE=
+google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo=
+google.golang.org/protobuf v1.23.0 h1:4MY060fB1DLGMB/7MBTLnwQUY6+F09GEiz6SsrNqyzM=
+google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/fsnotify.v1 v1.4.7 h1:xOHLXZwVvI9hhs+cLKq5+I5onOuwQLhQwiu63xxlHs4=
+gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys=
+gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 h1:uRGJdciOHaEIrze2W8Q3AKkepLTh2hOroT7a+7czfdQ=
+gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw=
+gopkg.in/yaml.v2 v2.2.4 h1:/eiJrUcujPVeJ3xlSWaiNi3uSVmDGBK1pDHUHAnao1I=
+gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.3.0 h1:clyUAQHOM3G0M3f5vQj7LuJrETvjVot3Z5el9nffUtU=
+gopkg.in/yaml.v2 v2.3.0/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
--- a/vendor/github.com/onsi/ginkgo/internal/global/init.go
+++ b/vendor/github.com/onsi/ginkgo/internal/global/init.go
@@ -0,0 +1,22 @@
+package global
+
+import (
+	"time"
+
+	"github.com/onsi/ginkgo/internal/failer"
+	"github.com/onsi/ginkgo/internal/suite"
+)
+
+const DefaultTimeout = time.Duration(1 * time.Second)
+
+var Suite *suite.Suite
+var Failer *failer.Failer
+
+func init() {
+	InitializeGlobals()
+}
+
+func InitializeGlobals() {
+	Failer = failer.New()
+	Suite = suite.New(Failer)
+}
--- a/vendor/github.com/onsi/ginkgo/internal/remote/aggregator.go
+++ b/vendor/github.com/onsi/ginkgo/internal/remote/aggregator.go
@@ -197,11 +197,11 @@ func (aggregator *Aggregator) announceSpec(specSummary *types.SpecSummary) {
 	switch specSummary.State {
 	case types.SpecStatePassed:
 		if specSummary.IsMeasurement {
-			aggregator.stenographer.AnnounceSuccesfulMeasurement(specSummary, aggregator.config.Succinct)
+			aggregator.stenographer.AnnounceSuccessfulMeasurement(specSummary, aggregator.config.Succinct)
 		} else if specSummary.RunTime.Seconds() >= aggregator.config.SlowSpecThreshold {
-			aggregator.stenographer.AnnounceSuccesfulSlowSpec(specSummary, aggregator.config.Succinct)
+			aggregator.stenographer.AnnounceSuccessfulSlowSpec(specSummary, aggregator.config.Succinct)
 		} else {
-			aggregator.stenographer.AnnounceSuccesfulSpec(specSummary)
+			aggregator.stenographer.AnnounceSuccessfulSpec(specSummary)
 		}

 	case types.SpecStatePending:
--- a/vendor/github.com/onsi/ginkgo/internal/remote/output_interceptor_darwin.go
+++ b/vendor/github.com/onsi/ginkgo/internal/remote/output_interceptor_darwin.go
@@ -0,0 +1,11 @@
+// +build darwin
+
+package remote
+
+import (
+        "golang.org/x/sys/unix"
+)
+
+func interceptorDupx(oldfd int, newfd int) {
+	unix.Dup2(oldfd, newfd)
+}
--- a/vendor/github.com/onsi/ginkgo/internal/remote/output_interceptor_dragonfly.go
+++ b/vendor/github.com/onsi/ginkgo/internal/remote/output_interceptor_dragonfly.go
@@ -0,0 +1,11 @@
+// +build dragonfly
+
+package remote
+
+import (
+        "golang.org/x/sys/unix"
+)
+
+func interceptorDupx(oldfd int, newfd int) {
+	unix.Dup2(oldfd, newfd)
+}
--- a/vendor/github.com/onsi/ginkgo/internal/remote/output_interceptor_freebsd.go
+++ b/vendor/github.com/onsi/ginkgo/internal/remote/output_interceptor_freebsd.go
@@ -0,0 +1,11 @@
+// +build freebsd
+
+package remote
+
+import (
+        "golang.org/x/sys/unix"
+)
+
+func interceptorDupx(oldfd int, newfd int) {
+	unix.Dup2(oldfd, newfd)
+}
--- a/vendor/github.com/onsi/ginkgo/internal/remote/output_interceptor_linux.go
+++ b/vendor/github.com/onsi/ginkgo/internal/remote/output_interceptor_linux.go
@@ -0,0 +1,12 @@
+// +build linux
+// +build !mips64le
+
+package remote
+
+import (
+        "golang.org/x/sys/unix"
+)
+
+func interceptorDupx(oldfd int, newfd int) {
+	unix.Dup2(oldfd, newfd)
+}
--- a/vendor/github.com/onsi/ginkgo/internal/remote/output_interceptor_linux_mips64le.go
+++ b/vendor/github.com/onsi/ginkgo/internal/remote/output_interceptor_linux_mips64le.go
@@ -0,0 +1,12 @@
+// +build linux
+// +build mips64le
+
+package remote
+
+import (
+        "golang.org/x/sys/unix"
+)
+
+func interceptorDupx(oldfd int, newfd int) {
+	unix.Dup3(oldfd, newfd, 0)
+}
--- a/vendor/github.com/onsi/ginkgo/internal/remote/output_interceptor_netbsd.go
+++ b/vendor/github.com/onsi/ginkgo/internal/remote/output_interceptor_netbsd.go
@@ -0,0 +1,11 @@
+// +build netbsd
+
+package remote
+
+import (
+        "golang.org/x/sys/unix"
+)
+
+func interceptorDupx(oldfd int, newfd int) {
+	unix.Dup2(oldfd, newfd)
+}
--- a/vendor/github.com/onsi/ginkgo/internal/remote/output_interceptor_openbsd.go
+++ b/vendor/github.com/onsi/ginkgo/internal/remote/output_interceptor_openbsd.go
@@ -0,0 +1,11 @@
+// +build openbsd
+
+package remote
+
+import (
+        "golang.org/x/sys/unix"
+)
+
+func interceptorDupx(oldfd int, newfd int) {
+	unix.Dup2(oldfd, newfd)
+}
--- a/vendor/github.com/onsi/ginkgo/internal/remote/output_interceptor_solaris.go
+++ b/vendor/github.com/onsi/ginkgo/internal/remote/output_interceptor_solaris.go
@@ -0,0 +1,11 @@
+// +build solaris
+
+package remote
+
+import (
+        "golang.org/x/sys/unix"
+)
+
+func interceptorDupx(oldfd int, newfd int) {
+	unix.Dup2(oldfd, newfd)
+}
--- a/vendor/github.com/onsi/ginkgo/internal/remote/output_interceptor_unix.go
+++ b/vendor/github.com/onsi/ginkgo/internal/remote/output_interceptor_unix.go
@@ -7,7 +7,7 @@ import (
 	"io/ioutil"
 	"os"

-	"github.com/hpcloud/tail"
+	"github.com/nxadm/tail"
 )

 func NewOutputInterceptor() OutputInterceptor {
@@ -35,12 +35,8 @@ func (interceptor *outputInterceptor) StartInterceptingOutput() error {
 		return err
 	}

-	// Call a function in ./syscall_dup_*.go
-	// If building for everything other than linux_arm64,
-	// use a "normal" syscall.Dup2(oldfd, newfd) call. If building for linux_arm64 (which doesn't have syscall.Dup2)
-	// call syscall.Dup3(oldfd, newfd, 0). They are nearly identical, see: http://linux.die.net/man/2/dup3
-	syscallDup(int(interceptor.redirectFile.Fd()), 1)
-	syscallDup(int(interceptor.redirectFile.Fd()), 2)
+	interceptorDupx(int(interceptor.redirectFile.Fd()), 1)
+	interceptorDupx(int(interceptor.redirectFile.Fd()), 2)

 	if interceptor.streamTarget != nil {
 		interceptor.tailer, _ = tail.TailFile(interceptor.redirectFile.Name(), tail.Config{Follow: true})
--- a/vendor/github.com/onsi/ginkgo/internal/remote/syscall_dup_linux_arm64.go
+++ b/vendor/github.com/onsi/ginkgo/internal/remote/syscall_dup_linux_arm64.go
@@ -1,11 +0,0 @@
-// +build linux,arm64
-
-package remote
-
-import "syscall"
-
-// linux_arm64 doesn't have syscall.Dup2 which ginkgo uses, so
-// use the nearly identical syscall.Dup3 instead
-func syscallDup(oldfd int, newfd int) (err error) {
-	return syscall.Dup3(oldfd, newfd, 0)
-}
--- a/vendor/github.com/onsi/ginkgo/internal/remote/syscall_dup_linux_riscv64.go
+++ b/vendor/github.com/onsi/ginkgo/internal/remote/syscall_dup_linux_riscv64.go
@@ -1,11 +0,0 @@
-// +build linux,riscv64
-
-package remote
-
-import "syscall"
-
-// linux_riscv64 doesn't have syscall.Dup2 which ginkgo uses, so
-// use the nearly identical syscall.Dup3 instead
-func syscallDup(oldfd int, newfd int) (err error) {
-	return syscall.Dup3(oldfd, newfd, 0)
-}
--- a/vendor/github.com/onsi/ginkgo/internal/remote/syscall_dup_solaris.go
+++ b/vendor/github.com/onsi/ginkgo/internal/remote/syscall_dup_solaris.go
@@ -1,9 +0,0 @@
-// +build solaris
-
-package remote
-
-import "golang.org/x/sys/unix"
-
-func syscallDup(oldfd int, newfd int) (err error) {
-	return unix.Dup2(oldfd, newfd)
-}
--- a/vendor/github.com/onsi/ginkgo/internal/remote/syscall_dup_unix.go
+++ b/vendor/github.com/onsi/ginkgo/internal/remote/syscall_dup_unix.go
@@ -1,12 +0,0 @@
-// +build !linux !arm64
-// +build !linux !riscv64
-// +build !windows
-// +build !solaris
-
-package remote
-
-import "syscall"
-
-func syscallDup(oldfd int, newfd int) (err error) {
-	return syscall.Dup2(oldfd, newfd)
-}
--- a/vendor/github.com/onsi/ginkgo/internal/suite/suite.go
+++ b/vendor/github.com/onsi/ginkgo/internal/suite/suite.go
@@ -22,25 +22,37 @@ type ginkgoTestingT interface {
 	Fail()
 }

+type deferredContainerNode struct {
+	text         string
+	body         func()
+	flag         types.FlagType
+	codeLocation types.CodeLocation
+}
+
 type Suite struct {
 	topLevelContainer *containernode.ContainerNode
 	currentContainer  *containernode.ContainerNode
-	containerIndex    int
-	beforeSuiteNode   leafnodes.SuiteNode
-	afterSuiteNode    leafnodes.SuiteNode
-	runner            *specrunner.SpecRunner
-	failer            *failer.Failer
-	running           bool
+
+	deferredContainerNodes []deferredContainerNode
+
+	containerIndex      int
+	beforeSuiteNode     leafnodes.SuiteNode
+	afterSuiteNode      leafnodes.SuiteNode
+	runner              *specrunner.SpecRunner
+	failer              *failer.Failer
+	running             bool
+	expandTopLevelNodes bool
 }

 func New(failer *failer.Failer) *Suite {
 	topLevelContainer := containernode.New("[Top Level]", types.FlagTypeNone, types.CodeLocation{})

 	return &Suite{
-		topLevelContainer: topLevelContainer,
-		currentContainer:  topLevelContainer,
-		failer:            failer,
-		containerIndex:    1,
+		topLevelContainer:      topLevelContainer,
+		currentContainer:       topLevelContainer,
+		failer:                 failer,
+		containerIndex:         1,
+		deferredContainerNodes: []deferredContainerNode{},
 	}
 }

@@ -53,6 +65,11 @@ func (suite *Suite) Run(t ginkgoTestingT, description string, reporters []report
 		panic("ginkgo.parallel.node is one-indexed and must be <= ginkgo.parallel.total")
 	}

+	suite.expandTopLevelNodes = true
+	for _, deferredNode := range suite.deferredContainerNodes {
+		suite.PushContainerNode(deferredNode.text, deferredNode.body, deferredNode.flag, deferredNode.codeLocation)
+	}
+
 	r := rand.New(rand.NewSource(config.RandomSeed))
 	suite.topLevelContainer.Shuffle(r)
 	iterator, hasProgrammaticFocus := suite.generateSpecsIterator(description, config)
@@ -102,6 +119,9 @@ func (suite *Suite) generateSpecsIterator(description string, config config.Gink
 }

 func (suite *Suite) CurrentRunningSpecSummary() (*types.SpecSummary, bool) {
+	if !suite.running {
+		return nil, false
+	}
 	return suite.runner.CurrentSpecSummary()
 }

@@ -134,6 +154,23 @@ func (suite *Suite) SetSynchronizedAfterSuiteNode(bodyA interface{}, bodyB inter
 }

 func (suite *Suite) PushContainerNode(text string, body func(), flag types.FlagType, codeLocation types.CodeLocation) {
+	/*
+		We defer walking the container nodes (which immediately evaluates the `body` function)
+		until `RunSpecs` is called.  We do this by storing off the deferred container nodes.  Then, when
+		`RunSpecs` is called we actually go through and add the container nodes to the test structure.
+
+		This allows us to defer calling all the `body` functions until _after_ the top level functions
+		have been walked, _after_ func init()s have been called, and _after_ `go test` has called `flag.Parse()`.
+
+		This allows users to load up configuration information in the `TestX` go test hook just before `RunSpecs`
+		is invoked and solves issues like #693 and makes the lifecycle easier to reason about.
+
+	*/
+	if !suite.expandTopLevelNodes {
+		suite.deferredContainerNodes = append(suite.deferredContainerNodes, deferredContainerNode{text, body, flag, codeLocation})
+		return
+	}
+
 	container := containernode.New(text, flag, codeLocation)
 	suite.currentContainer.PushContainerNode(container)

--- a/vendor/github.com/onsi/ginkgo/reporters/default_reporter.go
+++ b/vendor/github.com/onsi/ginkgo/reporters/default_reporter.go
@@ -57,11 +57,11 @@ func (reporter *DefaultReporter) SpecDidComplete(specSummary *types.SpecSummary)
 	switch specSummary.State {
 	case types.SpecStatePassed:
 		if specSummary.IsMeasurement {
-			reporter.stenographer.AnnounceSuccesfulMeasurement(specSummary, reporter.config.Succinct)
+			reporter.stenographer.AnnounceSuccessfulMeasurement(specSummary, reporter.config.Succinct)
 		} else if specSummary.RunTime.Seconds() >= reporter.config.SlowSpecThreshold {
-			reporter.stenographer.AnnounceSuccesfulSlowSpec(specSummary, reporter.config.Succinct)
+			reporter.stenographer.AnnounceSuccessfulSlowSpec(specSummary, reporter.config.Succinct)
 		} else {
-			reporter.stenographer.AnnounceSuccesfulSpec(specSummary)
+			reporter.stenographer.AnnounceSuccessfulSpec(specSummary)
 			if reporter.config.ReportPassed {
 				reporter.stenographer.AnnounceCapturedOutput(specSummary.CapturedOutput)
 			}
--- a/vendor/github.com/onsi/ginkgo/reporters/junit_reporter.go
+++ b/vendor/github.com/onsi/ginkgo/reporters/junit_reporter.go
@@ -50,7 +50,7 @@ type JUnitFailureMessage struct {
 }

 type JUnitSkipped struct {
-	XMLName xml.Name `xml:"skipped"`
+	Message string `xml:",chardata"`
 }

 type JUnitReporter struct {
@@ -132,6 +132,9 @@ func (reporter *JUnitReporter) SpecDidComplete(specSummary *types.SpecSummary) {
 	}
 	if specSummary.State == types.SpecStateSkipped || specSummary.State == types.SpecStatePending {
 		testCase.Skipped = &JUnitSkipped{}
+		if specSummary.Failure.Message != "" {
+			testCase.Skipped.Message = failureMessage(specSummary.Failure)
+		}
 	}
 	testCase.Time = specSummary.RunTime.Seconds()
 	reporter.suite.TestCases = append(reporter.suite.TestCases, testCase)
--- a/vendor/github.com/onsi/ginkgo/reporters/stenographer/fake_stenographer.go
+++ b/vendor/github.com/onsi/ginkgo/reporters/stenographer/fake_stenographer.go
@@ -105,16 +105,16 @@ func (stenographer *FakeStenographer) AnnounceCapturedOutput(output string) {
 	stenographer.registerCall("AnnounceCapturedOutput", output)
 }

-func (stenographer *FakeStenographer) AnnounceSuccesfulSpec(spec *types.SpecSummary) {
-	stenographer.registerCall("AnnounceSuccesfulSpec", spec)
+func (stenographer *FakeStenographer) AnnounceSuccessfulSpec(spec *types.SpecSummary) {
+	stenographer.registerCall("AnnounceSuccessfulSpec", spec)
 }

-func (stenographer *FakeStenographer) AnnounceSuccesfulSlowSpec(spec *types.SpecSummary, succinct bool) {
-	stenographer.registerCall("AnnounceSuccesfulSlowSpec", spec, succinct)
+func (stenographer *FakeStenographer) AnnounceSuccessfulSlowSpec(spec *types.SpecSummary, succinct bool) {
+	stenographer.registerCall("AnnounceSuccessfulSlowSpec", spec, succinct)
 }

-func (stenographer *FakeStenographer) AnnounceSuccesfulMeasurement(spec *types.SpecSummary, succinct bool) {
-	stenographer.registerCall("AnnounceSuccesfulMeasurement", spec, succinct)
+func (stenographer *FakeStenographer) AnnounceSuccessfulMeasurement(spec *types.SpecSummary, succinct bool) {
+	stenographer.registerCall("AnnounceSuccessfulMeasurement", spec, succinct)
 }

 func (stenographer *FakeStenographer) AnnouncePendingSpec(spec *types.SpecSummary, noisy bool) {
--- a/vendor/github.com/onsi/ginkgo/reporters/stenographer/stenographer.go
+++ b/vendor/github.com/onsi/ginkgo/reporters/stenographer/stenographer.go
@@ -47,9 +47,9 @@ type Stenographer interface {

 	AnnounceCapturedOutput(output string)

-	AnnounceSuccesfulSpec(spec *types.SpecSummary)
-	AnnounceSuccesfulSlowSpec(spec *types.SpecSummary, succinct bool)
-	AnnounceSuccesfulMeasurement(spec *types.SpecSummary, succinct bool)
+	AnnounceSuccessfulSpec(spec *types.SpecSummary)
+	AnnounceSuccessfulSlowSpec(spec *types.SpecSummary, succinct bool)
+	AnnounceSuccessfulMeasurement(spec *types.SpecSummary, succinct bool)

 	AnnouncePendingSpec(spec *types.SpecSummary, noisy bool)
 	AnnounceSkippedSpec(spec *types.SpecSummary, succinct bool, fullTrace bool)
@@ -245,12 +245,12 @@ func (s *consoleStenographer) AnnounceCapturedOutput(output string) {
 	s.midBlock()
 }

-func (s *consoleStenographer) AnnounceSuccesfulSpec(spec *types.SpecSummary) {
+func (s *consoleStenographer) AnnounceSuccessfulSpec(spec *types.SpecSummary) {
 	s.print(0, s.colorize(greenColor, s.denoter))
 	s.stream()
 }

-func (s *consoleStenographer) AnnounceSuccesfulSlowSpec(spec *types.SpecSummary, succinct bool) {
+func (s *consoleStenographer) AnnounceSuccessfulSlowSpec(spec *types.SpecSummary, succinct bool) {
 	s.printBlockWithMessage(
 		s.colorize(greenColor, "%s [SLOW TEST:%.3f seconds]", s.denoter, spec.RunTime.Seconds()),
 		"",
@@ -259,7 +259,7 @@ func (s *consoleStenographer) AnnounceSuccesfulSlowSpec(spec *types.SpecSummary,
 	)
 }

-func (s *consoleStenographer) AnnounceSuccesfulMeasurement(spec *types.SpecSummary, succinct bool) {
+func (s *consoleStenographer) AnnounceSuccessfulMeasurement(spec *types.SpecSummary, succinct bool) {
 	s.printBlockWithMessage(
 		s.colorize(greenColor, "%s [MEASUREMENT]", s.denoter),
 		s.measurementReport(spec, succinct),