update dependencies

Ran a `go get -u` and bumped K8s deps to 1.15.0.

Signed-off-by: Valentin Rothberg <rothberg@redhat.com>

6 files changed, 167 insertions, 148 deletions

diff --git a/vendor/github.com/onsi/gomega/.travis.yml b/vendor/github.com/onsi/gomega/.travis.yml
index 4d71367f6..2420a5d07 100644
--- a/vendor/github.com/onsi/gomega/.travis.yml
+++ b/vendor/github.com/onsi/gomega/.travis.yml
@@ -1,12 +1,9 @@
 language: go
 
 go:
-  - 1.6.x
-  - 1.7.x
-  - 1.8.x
-  - 1.9.x
   - 1.10.x
   - 1.11.x
+  - 1.12.x
 
 env:
   - GO111MODULE=on
@@ -17,7 +14,4 @@ install:
   - go get github.com/onsi/ginkgo
   - go install github.com/onsi/ginkgo/ginkgo
 
-script: |
-  $HOME/gopath/bin/ginkgo -p -r --randomizeAllSpecs --failOnPending --randomizeSuites --race &&
-  go vet &&
-  [ -z "`gofmt -l -e -s -w .`" ]
+script: make test
diff --git a/vendor/github.com/onsi/gomega/CHANGELOG.md b/vendor/github.com/onsi/gomega/CHANGELOG.md
index 9153294f7..5d1eda837 100644
--- a/vendor/github.com/onsi/gomega/CHANGELOG.md
+++ b/vendor/github.com/onsi/gomega/CHANGELOG.md
@@ -1,3 +1,14 @@
+## 1.5.0
+
+### Features
+
+- Added MatchKeys matchers [8b909fc]
+
+### Fixes and Minor Improvements
+
+- Add type aliases to remove stuttering [03b0461]
+- Don't run session_test.go on windows (#324) [5533ce8]
+
 ## 1.4.3
 
 ### Fixes:
diff --git a/vendor/github.com/onsi/gomega/Makefile b/vendor/github.com/onsi/gomega/Makefile
new file mode 100644
index 000000000..c92cd56e3
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/Makefile
@@ -0,0 +1,6 @@
+test:
+	[ -z "`gofmt -s -w -l -e .`" ]
+	go vet
+	ginkgo -p -r --randomizeAllSpecs --failOnPending --randomizeSuites --race
+
+.PHONY: test
diff --git a/vendor/github.com/onsi/gomega/gomega_dsl.go b/vendor/github.com/onsi/gomega/gomega_dsl.go
index 471f691a6..448d595da 100644
--- a/vendor/github.com/onsi/gomega/gomega_dsl.go
+++ b/vendor/github.com/onsi/gomega/gomega_dsl.go
@@ -24,7 +24,7 @@ import (
 	"github.com/onsi/gomega/types"
 )
 
-const GOMEGA_VERSION = "1.4.3"
+const GOMEGA_VERSION = "1.5.0"
 
 const nilFailHandlerPanic = `You are trying to make an assertion, but Gomega's fail handler is nil.
 If you're using Ginkgo then you probably forgot to put your assertion in an It().
@@ -39,20 +39,14 @@ var defaultEventuallyPollingInterval = 10 * time.Millisecond
 var defaultConsistentlyDuration = 100 * time.Millisecond
 var defaultConsistentlyPollingInterval = 10 * time.Millisecond
 
-//RegisterFailHandler connects Ginkgo to Gomega.  When a matcher fails
-//the fail handler passed into RegisterFailHandler is called.
+// RegisterFailHandler connects Ginkgo to Gomega. When a matcher fails
+// the fail handler passed into RegisterFailHandler is called.
 func RegisterFailHandler(handler types.GomegaFailHandler) {
-	if handler == nil {
-		globalFailWrapper = nil
-		return
-	}
-
-	globalFailWrapper = &types.GomegaFailWrapper{
-		Fail:        handler,
-		TWithHelper: testingtsupport.EmptyTWithHelper{},
-	}
+	RegisterFailHandlerWithT(testingtsupport.EmptyTWithHelper{}, handler)
 }
 
+// RegisterFailHandlerWithT ensures that the given types.TWithHelper and fail handler
+// are used globally.
 func RegisterFailHandlerWithT(t types.TWithHelper, handler types.GomegaFailHandler) {
 	if handler == nil {
 		globalFailWrapper = nil
@@ -65,12 +59,12 @@ func RegisterFailHandlerWithT(t types.TWithHelper, handler types.GomegaFailHandl
 	}
 }
 
-//RegisterTestingT connects Gomega to Golang's XUnit style
-//Testing.T tests.  It is now deprecated and you should use NewGomegaWithT() instead.
+// RegisterTestingT connects Gomega to Golang's XUnit style
+// Testing.T tests.  It is now deprecated and you should use NewWithT() instead.
 //
-//Legacy Documentation:
+// Legacy Documentation:
 //
-//You'll need to call this at the top of each XUnit style test:
+// You'll need to call this at the top of each XUnit style test:
 //
 //    func TestFarmHasCow(t *testing.T) {
 //        RegisterTestingT(t)
@@ -83,7 +77,7 @@ func RegisterFailHandlerWithT(t types.TWithHelper, handler types.GomegaFailHandl
 // pass `t` down to the matcher itself).  This means that you cannot run the XUnit style tests
 // in parallel as the global fail handler cannot point to more than one testing.T at a time.
 //
-// NewGomegaWithT() does not have this limitation
+// NewWithT() does not have this limitation
 //
 // (As an aside: Ginkgo gets around this limitation by running parallel tests in different *processes*).
 func RegisterTestingT(t types.GomegaTestingT) {
@@ -95,15 +89,15 @@ func RegisterTestingT(t types.GomegaTestingT) {
 	RegisterFailHandlerWithT(tWithHelper, testingtsupport.BuildTestingTGomegaFailWrapper(t).Fail)
 }
 
-//InterceptGomegaHandlers runs a given callback and returns an array of
-//failure messages generated by any Gomega assertions within the callback.
+// InterceptGomegaFailures runs a given callback and returns an array of
+// failure messages generated by any Gomega assertions within the callback.
 //
-//This is accomplished by temporarily replacing the *global* fail handler
-//with a fail handler that simply annotates failures.  The original fail handler
-//is reset when InterceptGomegaFailures returns.
+// This is accomplished by temporarily replacing the *global* fail handler
+// with a fail handler that simply annotates failures.  The original fail handler
+// is reset when InterceptGomegaFailures returns.
 //
-//This is most useful when testing custom matchers, but can also be used to check
-//on a value using a Gomega assertion without causing a test failure.
+// This is most useful when testing custom matchers, but can also be used to check
+// on a value using a Gomega assertion without causing a test failure.
 func InterceptGomegaFailures(f func()) []string {
 	originalHandler := globalFailWrapper.Fail
 	failures := []string{}
@@ -115,108 +109,108 @@ func InterceptGomegaFailures(f func()) []string {
 	return failures
 }
 
-//Ω wraps an actual value allowing assertions to be made on it:
+// Ω wraps an actual value allowing assertions to be made on it:
 //    Ω("foo").Should(Equal("foo"))
 //
-//If Ω is passed more than one argument it will pass the *first* argument to the matcher.
-//All subsequent arguments will be required to be nil/zero.
+// If Ω is passed more than one argument it will pass the *first* argument to the matcher.
+// All subsequent arguments will be required to be nil/zero.
 //
-//This is convenient if you want to make an assertion on a method/function that returns
-//a value and an error - a common patter in Go.
+// This is convenient if you want to make an assertion on a method/function that returns
+// a value and an error - a common patter in Go.
 //
-//For example, given a function with signature:
-//  func MyAmazingThing() (int, error)
+// For example, given a function with signature:
+//    func MyAmazingThing() (int, error)
 //
-//Then:
+// Then:
 //    Ω(MyAmazingThing()).Should(Equal(3))
-//Will succeed only if `MyAmazingThing()` returns `(3, nil)`
+// Will succeed only if `MyAmazingThing()` returns `(3, nil)`
 //
-//Ω and Expect are identical
-func Ω(actual interface{}, extra ...interface{}) GomegaAssertion {
+// Ω and Expect are identical
+func Ω(actual interface{}, extra ...interface{}) Assertion {
 	return ExpectWithOffset(0, actual, extra...)
 }
 
-//Expect wraps an actual value allowing assertions to be made on it:
+// Expect wraps an actual value allowing assertions to be made on it:
 //    Expect("foo").To(Equal("foo"))
 //
-//If Expect is passed more than one argument it will pass the *first* argument to the matcher.
-//All subsequent arguments will be required to be nil/zero.
+// If Expect is passed more than one argument it will pass the *first* argument to the matcher.
+// All subsequent arguments will be required to be nil/zero.
 //
-//This is convenient if you want to make an assertion on a method/function that returns
-//a value and an error - a common patter in Go.
+// This is convenient if you want to make an assertion on a method/function that returns
+// a value and an error - a common patter in Go.
 //
-//For example, given a function with signature:
-//  func MyAmazingThing() (int, error)
+// For example, given a function with signature:
+//    func MyAmazingThing() (int, error)
 //
-//Then:
+// Then:
 //    Expect(MyAmazingThing()).Should(Equal(3))
-//Will succeed only if `MyAmazingThing()` returns `(3, nil)`
+// Will succeed only if `MyAmazingThing()` returns `(3, nil)`
 //
-//Expect and Ω are identical
-func Expect(actual interface{}, extra ...interface{}) GomegaAssertion {
+// Expect and Ω are identical
+func Expect(actual interface{}, extra ...interface{}) Assertion {
 	return ExpectWithOffset(0, actual, extra...)
 }
 
-//ExpectWithOffset wraps an actual value allowing assertions to be made on it:
+// ExpectWithOffset wraps an actual value allowing assertions to be made on it:
 //    ExpectWithOffset(1, "foo").To(Equal("foo"))
 //
-//Unlike `Expect` and `Ω`, `ExpectWithOffset` takes an additional integer argument
-//this is used to modify the call-stack offset when computing line numbers.
+// Unlike `Expect` and `Ω`, `ExpectWithOffset` takes an additional integer argument
+// this is used to modify the call-stack offset when computing line numbers.
 //
-//This is most useful in helper functions that make assertions.  If you want Gomega's
-//error message to refer to the calling line in the test (as opposed to the line in the helper function)
-//set the first argument of `ExpectWithOffset` appropriately.
-func ExpectWithOffset(offset int, actual interface{}, extra ...interface{}) GomegaAssertion {
+// This is most useful in helper functions that make assertions.  If you want Gomega's
+// error message to refer to the calling line in the test (as opposed to the line in the helper function)
+// set the first argument of `ExpectWithOffset` appropriately.
+func ExpectWithOffset(offset int, actual interface{}, extra ...interface{}) Assertion {
 	if globalFailWrapper == nil {
 		panic(nilFailHandlerPanic)
 	}
 	return assertion.New(actual, globalFailWrapper, offset, extra...)
 }
 
-//Eventually wraps an actual value allowing assertions to be made on it.
-//The assertion is tried periodically until it passes or a timeout occurs.
+// Eventually wraps an actual value allowing assertions to be made on it.
+// The assertion is tried periodically until it passes or a timeout occurs.
 //
-//Both the timeout and polling interval are configurable as optional arguments:
-//The first optional argument is the timeout
-//The second optional argument is the polling interval
+// Both the timeout and polling interval are configurable as optional arguments:
+// The first optional argument is the timeout
+// The second optional argument is the polling interval
 //
-//Both intervals can either be specified as time.Duration, parsable duration strings or as floats/integers.  In the
-//last case they are interpreted as seconds.
+// Both intervals can either be specified as time.Duration, parsable duration strings or as floats/integers.  In the
+// last case they are interpreted as seconds.
 //
-//If Eventually is passed an actual that is a function taking no arguments and returning at least one value,
-//then Eventually will call the function periodically and try the matcher against the function's first return value.
+// If Eventually is passed an actual that is a function taking no arguments and returning at least one value,
+// then Eventually will call the function periodically and try the matcher against the function's first return value.
 //
-//Example:
+// Example:
 //
 //    Eventually(func() int {
 //        return thingImPolling.Count()
 //    }).Should(BeNumerically(">=", 17))
 //
-//Note that this example could be rewritten:
+// Note that this example could be rewritten:
 //
 //    Eventually(thingImPolling.Count).Should(BeNumerically(">=", 17))
 //
-//If the function returns more than one value, then Eventually will pass the first value to the matcher and
-//assert that all other values are nil/zero.
-//This allows you to pass Eventually a function that returns a value and an error - a common pattern in Go.
+// If the function returns more than one value, then Eventually will pass the first value to the matcher and
+// assert that all other values are nil/zero.
+// This allows you to pass Eventually a function that returns a value and an error - a common pattern in Go.
 //
-//For example, consider a method that returns a value and an error:
+// For example, consider a method that returns a value and an error:
 //    func FetchFromDB() (string, error)
 //
-//Then
+// Then
 //    Eventually(FetchFromDB).Should(Equal("hasselhoff"))
 //
-//Will pass only if the the returned error is nil and the returned string passes the matcher.
+// Will pass only if the the returned error is nil and the returned string passes the matcher.
 //
-//Eventually's default timeout is 1 second, and its default polling interval is 10ms
-func Eventually(actual interface{}, intervals ...interface{}) GomegaAsyncAssertion {
+// Eventually's default timeout is 1 second, and its default polling interval is 10ms
+func Eventually(actual interface{}, intervals ...interface{}) AsyncAssertion {
 	return EventuallyWithOffset(0, actual, intervals...)
 }
 
-//EventuallyWithOffset operates like Eventually but takes an additional
-//initial argument to indicate an offset in the call stack.  This is useful when building helper
-//functions that contain matchers.  To learn more, read about `ExpectWithOffset`.
-func EventuallyWithOffset(offset int, actual interface{}, intervals ...interface{}) GomegaAsyncAssertion {
+// EventuallyWithOffset operates like Eventually but takes an additional
+// initial argument to indicate an offset in the call stack.  This is useful when building helper
+// functions that contain matchers.  To learn more, read about `ExpectWithOffset`.
+func EventuallyWithOffset(offset int, actual interface{}, intervals ...interface{}) AsyncAssertion {
 	if globalFailWrapper == nil {
 		panic(nilFailHandlerPanic)
 	}
@@ -231,37 +225,37 @@ func EventuallyWithOffset(offset int, actual interface{}, intervals ...interface
 	return asyncassertion.New(asyncassertion.AsyncAssertionTypeEventually, actual, globalFailWrapper, timeoutInterval, pollingInterval, offset)
 }
 
-//Consistently wraps an actual value allowing assertions to be made on it.
-//The assertion is tried periodically and is required to pass for a period of time.
+// Consistently wraps an actual value allowing assertions to be made on it.
+// The assertion is tried periodically and is required to pass for a period of time.
 //
-//Both the total time and polling interval are configurable as optional arguments:
-//The first optional argument is the duration that Consistently will run for
-//The second optional argument is the polling interval
+// Both the total time and polling interval are configurable as optional arguments:
+// The first optional argument is the duration that Consistently will run for
+// The second optional argument is the polling interval
 //
-//Both intervals can either be specified as time.Duration, parsable duration strings or as floats/integers.  In the
-//last case they are interpreted as seconds.
+// Both intervals can either be specified as time.Duration, parsable duration strings or as floats/integers.  In the
+// last case they are interpreted as seconds.
 //
-//If Consistently is passed an actual that is a function taking no arguments and returning at least one value,
-//then Consistently will call the function periodically and try the matcher against the function's first return value.
+// If Consistently is passed an actual that is a function taking no arguments and returning at least one value,
+// then Consistently will call the function periodically and try the matcher against the function's first return value.
 //
-//If the function returns more than one value, then Consistently will pass the first value to the matcher and
-//assert that all other values are nil/zero.
-//This allows you to pass Consistently a function that returns a value and an error - a common pattern in Go.
+// If the function returns more than one value, then Consistently will pass the first value to the matcher and
+// assert that all other values are nil/zero.
+// This allows you to pass Consistently a function that returns a value and an error - a common pattern in Go.
 //
-//Consistently is useful in cases where you want to assert that something *does not happen* over a period of tiem.
-//For example, you want to assert that a goroutine does *not* send data down a channel.  In this case, you could:
+// Consistently is useful in cases where you want to assert that something *does not happen* over a period of tiem.
+// For example, you want to assert that a goroutine does *not* send data down a channel.  In this case, you could:
 //
-//  Consistently(channel).ShouldNot(Receive())
+//   Consistently(channel).ShouldNot(Receive())
 //
-//Consistently's default duration is 100ms, and its default polling interval is 10ms
-func Consistently(actual interface{}, intervals ...interface{}) GomegaAsyncAssertion {
+// Consistently's default duration is 100ms, and its default polling interval is 10ms
+func Consistently(actual interface{}, intervals ...interface{}) AsyncAssertion {
 	return ConsistentlyWithOffset(0, actual, intervals...)
 }
 
-//ConsistentlyWithOffset operates like Consistnetly but takes an additional
-//initial argument to indicate an offset in the call stack.  This is useful when building helper
-//functions that contain matchers.  To learn more, read about `ExpectWithOffset`.
-func ConsistentlyWithOffset(offset int, actual interface{}, intervals ...interface{}) GomegaAsyncAssertion {
+// ConsistentlyWithOffset operates like Consistnetly but takes an additional
+// initial argument to indicate an offset in the call stack. This is useful when building helper
+// functions that contain matchers. To learn more, read about `ExpectWithOffset`.
+func ConsistentlyWithOffset(offset int, actual interface{}, intervals ...interface{}) AsyncAssertion {
 	if globalFailWrapper == nil {
 		panic(nilFailHandlerPanic)
 	}
@@ -276,59 +270,62 @@ func ConsistentlyWithOffset(offset int, actual interface{}, intervals ...interfa
 	return asyncassertion.New(asyncassertion.AsyncAssertionTypeConsistently, actual, globalFailWrapper, timeoutInterval, pollingInterval, offset)
 }
 
-//Set the default timeout duration for Eventually.  Eventually will repeatedly poll your condition until it succeeds, or until this timeout elapses.
+// SetDefaultEventuallyTimeout sets the default timeout duration for Eventually. Eventually will repeatedly poll your condition until it succeeds, or until this timeout elapses.
 func SetDefaultEventuallyTimeout(t time.Duration) {
 	defaultEventuallyTimeout = t
 }
 
-//Set the default polling interval for Eventually.
+// SetDefaultEventuallyPollingInterval sets the default polling interval for Eventually.
 func SetDefaultEventuallyPollingInterval(t time.Duration) {
 	defaultEventuallyPollingInterval = t
 }
 
-//Set the default duration for Consistently.  Consistently will verify that your condition is satsified for this long.
+// SetDefaultConsistentlyDuration sets  the default duration for Consistently. Consistently will verify that your condition is satsified for this long.
 func SetDefaultConsistentlyDuration(t time.Duration) {
 	defaultConsistentlyDuration = t
 }
 
-//Set the default polling interval for Consistently.
+// SetDefaultConsistentlyPollingInterval sets the default polling interval for Consistently.
 func SetDefaultConsistentlyPollingInterval(t time.Duration) {
 	defaultConsistentlyPollingInterval = t
 }
 
-//GomegaAsyncAssertion is returned by Eventually and Consistently and polls the actual value passed into Eventually against
-//the matcher passed to the Should and ShouldNot methods.
+// AsyncAssertion is returned by Eventually and Consistently and polls the actual value passed into Eventually against
+// the matcher passed to the Should and ShouldNot methods.
 //
-//Both Should and ShouldNot take a variadic optionalDescription argument.  This is passed on to
-//fmt.Sprintf() and is used to annotate failure messages.  This allows you to make your failure messages more
-//descriptive
+// Both Should and ShouldNot take a variadic optionalDescription argument.  This is passed on to
+// fmt.Sprintf() and is used to annotate failure messages.  This allows you to make your failure messages more
+// descriptive.
 //
-//Both Should and ShouldNot return a boolean that is true if the assertion passed and false if it failed.
+// Both Should and ShouldNot return a boolean that is true if the assertion passed and false if it failed.
 //
-//Example:
+// Example:
 //
-//  Eventually(myChannel).Should(Receive(), "Something should have come down the pipe.")
-//  Consistently(myChannel).ShouldNot(Receive(), "Nothing should have come down the pipe.")
-type GomegaAsyncAssertion interface {
+//   Eventually(myChannel).Should(Receive(), "Something should have come down the pipe.")
+//   Consistently(myChannel).ShouldNot(Receive(), "Nothing should have come down the pipe.")
+type AsyncAssertion interface {
 	Should(matcher types.GomegaMatcher, optionalDescription ...interface{}) bool
 	ShouldNot(matcher types.GomegaMatcher, optionalDescription ...interface{}) bool
 }
 
-//GomegaAssertion is returned by Ω and Expect and compares the actual value to the matcher
-//passed to the Should/ShouldNot and To/ToNot/NotTo methods.
+// GomegaAsyncAssertion is deprecated in favor of AsyncAssertion, which does not stutter.
+type GomegaAsyncAssertion = AsyncAssertion
+
+// Assertion is returned by Ω and Expect and compares the actual value to the matcher
+// passed to the Should/ShouldNot and To/ToNot/NotTo methods.
 //
-//Typically Should/ShouldNot are used with Ω and To/ToNot/NotTo are used with Expect
-//though this is not enforced.
+// Typically Should/ShouldNot are used with Ω and To/ToNot/NotTo are used with Expect
+// though this is not enforced.
 //
-//All methods take a variadic optionalDescription argument.  This is passed on to fmt.Sprintf()
-//and is used to annotate failure messages.
+// All methods take a variadic optionalDescription argument.  This is passed on to fmt.Sprintf()
+// and is used to annotate failure messages.
 //
-//All methods return a bool that is true if hte assertion passed and false if it failed.
+// All methods return a bool that is true if hte assertion passed and false if it failed.
 //
-//Example:
+// Example:
 //
-//   Ω(farm.HasCow()).Should(BeTrue(), "Farm %v should have a cow", farm)
-type GomegaAssertion interface {
+//    Ω(farm.HasCow()).Should(BeTrue(), "Farm %v should have a cow", farm)
+type Assertion interface {
 	Should(matcher types.GomegaMatcher, optionalDescription ...interface{}) bool
 	ShouldNot(matcher types.GomegaMatcher, optionalDescription ...interface{}) bool
 
@@ -337,39 +334,50 @@ type GomegaAssertion interface {
 	NotTo(matcher types.GomegaMatcher, optionalDescription ...interface{}) bool
 }
 
-//OmegaMatcher is deprecated in favor of the better-named and better-organized types.GomegaMatcher but sticks around to support existing code that uses it
+// GomegaAssertion is deprecated in favor of Assertion, which does not stutter.
+type GomegaAssertion = Assertion
+
+// OmegaMatcher is deprecated in favor of the better-named and better-organized types.GomegaMatcher but sticks around to support existing code that uses it
 type OmegaMatcher types.GomegaMatcher
 
-//GomegaWithT wraps a *testing.T and provides `Expect`, `Eventually`, and `Consistently` methods.  This allows you to leverage
-//Gomega's rich ecosystem of matchers in standard `testing` test suites.
+// WithT wraps a *testing.T and provides `Expect`, `Eventually`, and `Consistently` methods.  This allows you to leverage
+// Gomega's rich ecosystem of matchers in standard `testing` test suites.
 //
-//Use `NewGomegaWithT` to instantiate a `GomegaWithT`
-type GomegaWithT struct {
+// Use `NewWithT` to instantiate a `WithT`
+type WithT struct {
 	t types.GomegaTestingT
 }
 
-//NewGomegaWithT takes a *testing.T and returngs a `GomegaWithT` allowing you to use `Expect`, `Eventually`, and `Consistently` along with
-//Gomega's rich ecosystem of matchers in standard `testing` test suits.
+// GomegaWithT is deprecated in favor of gomega.WithT, which does not stutter.
+type GomegaWithT = WithT
+
+// NewWithT takes a *testing.T and returngs a `gomega.WithT` allowing you to use `Expect`, `Eventually`, and `Consistently` along with
+// Gomega's rich ecosystem of matchers in standard `testing` test suits.
 //
 //    func TestFarmHasCow(t *testing.T) {
-//        g := GomegaWithT(t)
+//        g := gomega.NewWithT(t)
 //
 //        f := farm.New([]string{"Cow", "Horse"})
 //        g.Expect(f.HasCow()).To(BeTrue(), "Farm should have cow")
 //     }
-func NewGomegaWithT(t types.GomegaTestingT) *GomegaWithT {
-	return &GomegaWithT{
+func NewWithT(t types.GomegaTestingT) *WithT {
+	return &WithT{
 		t: t,
 	}
 }
 
-//See documentation for Expect
-func (g *GomegaWithT) Expect(actual interface{}, extra ...interface{}) GomegaAssertion {
+// NewGomegaWithT is deprecated in favor of gomega.NewWithT, which does not stutter.
+func NewGomegaWithT(t types.GomegaTestingT) *GomegaWithT {
+	return NewWithT(t)
+}
+
+// Expect is used to make assertions. See documentation for Expect.
+func (g *WithT) Expect(actual interface{}, extra ...interface{}) Assertion {
 	return assertion.New(actual, testingtsupport.BuildTestingTGomegaFailWrapper(g.t), 0, extra...)
 }
 
-//See documentation for Eventually
-func (g *GomegaWithT) Eventually(actual interface{}, intervals ...interface{}) GomegaAsyncAssertion {
+// Eventually is used to make asynchronous assertions. See documentation for Eventually.
+func (g *WithT) Eventually(actual interface{}, intervals ...interface{}) AsyncAssertion {
 	timeoutInterval := defaultEventuallyTimeout
 	pollingInterval := defaultEventuallyPollingInterval
 	if len(intervals) > 0 {
@@ -381,8 +389,8 @@ func (g *GomegaWithT) Eventually(actual interface{}, intervals ...interface{}) G
 	return asyncassertion.New(asyncassertion.AsyncAssertionTypeEventually, actual, testingtsupport.BuildTestingTGomegaFailWrapper(g.t), timeoutInterval, pollingInterval, 0)
 }
 
-//See documentation for Consistently
-func (g *GomegaWithT) Consistently(actual interface{}, intervals ...interface{}) GomegaAsyncAssertion {
+// Consistently is used to make asynchronous assertions. See documentation for Consistently.
+func (g *WithT) Consistently(actual interface{}, intervals ...interface{}) AsyncAssertion {
 	timeoutInterval := defaultConsistentlyDuration
 	pollingInterval := defaultConsistentlyPollingInterval
 	if len(intervals) > 0 {
diff --git a/vendor/github.com/onsi/gomega/matchers/have_occurred_matcher.go b/vendor/github.com/onsi/gomega/matchers/have_occurred_matcher.go
index ebdd71786..bef00ae21 100644
--- a/vendor/github.com/onsi/gomega/matchers/have_occurred_matcher.go
+++ b/vendor/github.com/onsi/gomega/matchers/have_occurred_matcher.go
@@ -29,5 +29,5 @@ func (matcher *HaveOccurredMatcher) FailureMessage(actual interface{}) (message
 }
 
 func (matcher *HaveOccurredMatcher) NegatedFailureMessage(actual interface{}) (message string) {
-	return fmt.Sprintf("Expected error:\n%s\n%s\n%s", format.Object(actual, 1), format.IndentString(actual.(error).Error(), 1), "not to have occurred")
+	return fmt.Sprintf("Unexpected error:\n%s\n%s\n%s", format.Object(actual, 1), format.IndentString(actual.(error).Error(), 1), "occurred")
 }
diff --git a/vendor/github.com/onsi/gomega/matchers/match_xml_matcher.go b/vendor/github.com/onsi/gomega/matchers/match_xml_matcher.go
index 3b412ce81..5c815f5af 100644
--- a/vendor/github.com/onsi/gomega/matchers/match_xml_matcher.go
+++ b/vendor/github.com/onsi/gomega/matchers/match_xml_matcher.go
@@ -70,7 +70,7 @@ func parseXmlContent(content string) (*xmlNode, error) {
 			if err == io.EOF {
 				break
 			}
-			return nil, fmt.Errorf("failed to decode next token: %v", err)
+			return nil, fmt.Errorf("failed to decode next token: %v", err) // untested section
 		}
 
 		lastNodeIndex := len(allNodes) - 1
@@ -94,7 +94,7 @@ func parseXmlContent(content string) (*xmlNode, error) {
 		case xml.CharData:
 			lastNode.Content = append(lastNode.Content, tok.Copy()...)
 		case xml.Comment:
-			lastNode.Comments = append(lastNode.Comments, tok.Copy())
+			lastNode.Comments = append(lastNode.Comments, tok.Copy()) // untested section
 		case xml.ProcInst:
 			lastNode.ProcInsts = append(lastNode.ProcInsts, tok.Copy())
 		}