vendor: Update vendor logic

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

@@ -1,16 +1,18 @@
 language: go
+
 go:
-  - 1.6.x
-  - 1.7.x
-  - 1.8.x
-  - 1.9.x
   - 1.10.x
   - 1.11.x
+  - 1.12.x
+  - gotip
+
+env:
+  - GO111MODULE=on
 
 install:
-  - env GO111MODULE=on go get -v ./...
-  - env GO111MODULE=on go build ./...
+  - go get -v ./...
+  - go build ./...
   - go get github.com/onsi/ginkgo
   - go install github.com/onsi/ginkgo/ginkgo
 
-script: env GO111MODULE=on $HOME/gopath/bin/ginkgo -p -r --randomizeAllSpecs --failOnPending --randomizeSuites --race && env GO111MODULE=on go vet
+script: make test

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

@@ -1,3 +1,53 @@
+## 1.7.0
+
+### Features
+- export format property variables (#347) [642e5ba]
+
+### Fixes
+- minor fix in the documentation of ExpectWithOffset (#358) [beea727]
+
+## 1.6.0
+
+### Features
+
+- Display special chars on error [41e1b26]
+- Add BeElementOf matcher [6a48b48]
+
+### Fixes
+
+- Remove duplication in XML matcher tests [cc1a6cb]
+- Remove unnecessary conversions (#357) [7bf756a]
+- Fixed import order (#353) [2e3b965]
+- Added missing error handling in test (#355) [c98d3eb]
+- Simplify code (#356) [0001ed9]
+- Simplify code (#354) [0d9100e]
+- Fixed typos (#352) [3f647c4]
+- Add failure message tests to BeElementOf matcher [efe19c3]
+- Update go-testcov untested sections [37ee382]
+- Mark all uncovered files so go-testcov ./... works [53b150e]
+- Reenable gotip in travis [5c249dc]
+- Fix the typo of comment (#345) [f0e010e]
+- Optimize contain_element_matcher [abeb93d]
+
+
+## 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:
+
+- ensure file name and line numbers are correctly reported for XUnit [6fff58f]
+- Fixed matcher for content-type (#305) [69d9b43]
+
 ## 1.4.2
 
 ### Fixes:

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

vendor/github.com/onsi/gomega/format/format.go

@@ -1,6 +1,9 @@
 /*
 Gomega's format package pretty-prints objects.  It explores input objects recursively and generates formatted, indented output with type information.
 */
+
+// untested sections: 4
+
 package format
 
 import (
@@ -33,7 +36,15 @@ var PrintContextObjects = false
 // TruncatedDiff choose if we should display a truncated pretty diff or not
 var TruncatedDiff = true
 
-// Ctx interface defined here to keep backwards compatability with go < 1.7
+// TruncateThreshold (default 50) specifies the maximum length string to print in string comparison assertion error
+// messages.
+var TruncateThreshold uint = 50
+
+// CharactersAroundMismatchToInclude (default 5) specifies how many contextual characters should be printed before and
+// after the first diff location in a truncated string assertion error message.
+var CharactersAroundMismatchToInclude uint = 5
+
+// Ctx interface defined here to keep backwards compatibility with go < 1.7
 // It matches the context.Context interface
 type Ctx interface {
 	Deadline() (deadline time.Time, ok bool)
@@ -58,7 +69,7 @@ Generates a formatted matcher success/failure message of the form:
 	<message>
 		<pretty printed expected>
 
-If expected is omited, then the message looks like:
+If expected is omitted, then the message looks like:
 
 	Expected
 		<pretty printed actual>
@@ -85,7 +96,7 @@ to equal               |
 */
 
 func MessageWithDiff(actual, message, expected string) string {
-	if TruncatedDiff && len(actual) >= truncateThreshold && len(expected) >= truncateThreshold {
+	if TruncatedDiff && len(actual) >= int(TruncateThreshold) && len(expected) >= int(TruncateThreshold) {
 		diffPoint := findFirstMismatch(actual, expected)
 		formattedActual := truncateAndFormat(actual, diffPoint)
 		formattedExpected := truncateAndFormat(expected, diffPoint)
@@ -97,14 +108,23 @@ func MessageWithDiff(actual, message, expected string) string {
 		padding := strings.Repeat(" ", spaceFromMessageToActual+spacesBeforeFormattedMismatch) + "|"
 		return Message(formattedActual, message+padding, formattedExpected)
 	}
+
+	actual = escapedWithGoSyntax(actual)
+	expected = escapedWithGoSyntax(expected)
+
 	return Message(actual, message, expected)
 }
 
+func escapedWithGoSyntax(str string) string {
+	withQuotes := fmt.Sprintf("%q", str)
+	return withQuotes[1 : len(withQuotes)-1]
+}
+
 func truncateAndFormat(str string, index int) string {
 	leftPadding := `...`
 	rightPadding := `...`
 
-	start := index - charactersAroundMismatchToInclude
+	start := index - int(CharactersAroundMismatchToInclude)
 	if start < 0 {
 		start = 0
 		leftPadding = ""
@@ -112,7 +132,7 @@ func truncateAndFormat(str string, index int) string {
 
 	// slice index must include the mis-matched character
 	lengthOfMismatchedCharacter := 1
-	end := index + charactersAroundMismatchToInclude + lengthOfMismatchedCharacter
+	end := index + int(CharactersAroundMismatchToInclude) + lengthOfMismatchedCharacter
 	if end > len(str) {
 		end = len(str)
 		rightPadding = ""
@@ -141,11 +161,6 @@ func findFirstMismatch(a, b string) int {
 	return 0
 }
 
-const (
-	truncateThreshold                 = 50
-	charactersAroundMismatchToInclude = 5
-)
-
 /*
 Pretty prints the passed in object at the passed in indentation level.
 
@@ -288,7 +303,7 @@ func formatString(object interface{}, indentation uint) string {
 			}
 		}
 
-		return fmt.Sprintf("%s", result)
+		return result
 	} else {
 		return fmt.Sprintf("%q", object)
 	}

vendor/github.com/onsi/gomega/gomega_dsl.go

@@ -24,7 +24,7 @@ import (
 	"github.com/onsi/gomega/types"
 )
 
-const GOMEGA_VERSION = "1.4.2"
+const GOMEGA_VERSION = "1.7.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,25 +39,32 @@ 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) {
+	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
 		return
 	}
+
 	globalFailWrapper = &types.GomegaFailWrapper{
 		Fail:        handler,
-		TWithHelper: testingtsupport.EmptyTWithHelper{},
+		TWithHelper: t,
 	}
 }
 
-//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)
@@ -70,22 +77,27 @@ func RegisterFailHandler(handler types.GomegaFailHandler) {
 // 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) {
-	RegisterFailHandler(testingtsupport.BuildTestingTGomegaFailWrapper(t).Fail)
+	tWithHelper, hasHelper := t.(types.TWithHelper)
+	if !hasHelper {
+		RegisterFailHandler(testingtsupport.BuildTestingTGomegaFailWrapper(t).Fail)
+		return
+	}
+	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{}
@@ -97,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
+// that 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)
 	}
@@ -213,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 time.
+// 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)
 	}
@@ -258,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 satisfied 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 the 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
 
@@ -319,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 {
@@ -363,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 {

vendor/github.com/onsi/gomega/internal/asyncassertion/async_assertion.go

@@ -1,3 +1,5 @@
+// untested sections: 2
+
 package asyncassertion
 
 import (

vendor/github.com/onsi/gomega/matchers.go

@@ -269,6 +269,22 @@ func ContainElement(element interface{}) types.GomegaMatcher {
 	}
 }
 
+//BeElementOf succeeds if actual is contained in the passed in elements.
+//BeElementOf() always uses Equal() to perform the match.
+//When the passed in elements are comprised of a single element that is either an Array or Slice, BeElementOf() behaves
+//as the reverse of ContainElement() that operates with Equal() to perform the match.
+//    Expect(2).Should(BeElementOf([]int{1, 2}))
+//    Expect(2).Should(BeElementOf([2]int{1, 2}))
+//Otherwise, BeElementOf() provides a syntactic sugar for Or(Equal(_), Equal(_), ...):
+//    Expect(2).Should(BeElementOf(1, 2))
+//
+//Actual must be typed.
+func BeElementOf(elements ...interface{}) types.GomegaMatcher {
+	return &matchers.BeElementOfMatcher{
+		Elements: elements,
+	}
+}
+
 //ConsistOf succeeds if actual contains precisely the elements passed into the matcher.  The ordering of the elements does not matter.
 //By default ConsistOf() uses Equal() to match the elements, however custom matchers can be passed in instead.  Here are some examples:
 //

vendor/github.com/onsi/gomega/matchers/assignable_to_type_of_matcher.go

@@ -1,3 +1,5 @@
+// untested sections: 2
+
 package matchers
 
 import (

vendor/github.com/onsi/gomega/matchers/be_a_directory.go

@@ -1,3 +1,5 @@
+// untested sections: 5
+
 package matchers
 
 import (

vendor/github.com/onsi/gomega/matchers/be_a_regular_file.go

@@ -1,3 +1,5 @@
+// untested sections: 5
+
 package matchers
 
 import (

vendor/github.com/onsi/gomega/matchers/be_an_existing_file.go

@@ -1,3 +1,5 @@
+// untested sections: 3
+
 package matchers
 
 import (

vendor/github.com/onsi/gomega/matchers/be_closed_matcher.go

@@ -1,3 +1,5 @@
+// untested sections: 2
+
 package matchers
 
 import (
@@ -23,8 +25,8 @@ func (matcher *BeClosedMatcher) Match(actual interface{}) (success bool, err err
 	}
 
 	winnerIndex, _, open := reflect.Select([]reflect.SelectCase{
-		reflect.SelectCase{Dir: reflect.SelectRecv, Chan: channelValue},
-		reflect.SelectCase{Dir: reflect.SelectDefault},
+		{Dir: reflect.SelectRecv, Chan: channelValue},
+		{Dir: reflect.SelectDefault},
 	})
 
 	var closed bool

vendor/github.com/onsi/gomega/matchers/be_element_of_matcher.go

@@ -0,0 +1,57 @@
+// untested sections: 1
+
+package matchers
+
+import (
+	"fmt"
+	"reflect"
+
+	"github.com/onsi/gomega/format"
+)
+
+type BeElementOfMatcher struct {
+	Elements []interface{}
+}
+
+func (matcher *BeElementOfMatcher) Match(actual interface{}) (success bool, err error) {
+	if reflect.TypeOf(actual) == nil {
+		return false, fmt.Errorf("BeElement matcher expects actual to be typed")
+	}
+
+	length := len(matcher.Elements)
+	valueAt := func(i int) interface{} {
+		return matcher.Elements[i]
+	}
+	// Special handling of a single element of type Array or Slice
+	if length == 1 && isArrayOrSlice(valueAt(0)) {
+		element := valueAt(0)
+		value := reflect.ValueOf(element)
+		length = value.Len()
+		valueAt = func(i int) interface{} {
+			return value.Index(i).Interface()
+		}
+	}
+
+	var lastError error
+	for i := 0; i < length; i++ {
+		matcher := &EqualMatcher{Expected: valueAt(i)}
+		success, err := matcher.Match(actual)
+		if err != nil {
+			lastError = err
+			continue
+		}
+		if success {
+			return true, nil
+		}
+	}
+
+	return false, lastError
+}
+
+func (matcher *BeElementOfMatcher) FailureMessage(actual interface{}) (message string) {
+	return format.Message(actual, "to be an element of", matcher.Elements)
+}
+
+func (matcher *BeElementOfMatcher) NegatedFailureMessage(actual interface{}) (message string) {
+	return format.Message(actual, "not to be an element of", matcher.Elements)
+}

vendor/github.com/onsi/gomega/matchers/be_empty_matcher.go

@@ -1,3 +1,5 @@
+// untested sections: 2
+
 package matchers
 
 import (

vendor/github.com/onsi/gomega/matchers/be_equivalent_to_matcher.go

@@ -1,3 +1,5 @@
+// untested sections: 2
+
 package matchers
 
 import (

vendor/github.com/onsi/gomega/matchers/be_false_matcher.go

@@ -1,3 +1,5 @@
+// untested sections: 2
+
 package matchers
 
 import (

vendor/github.com/onsi/gomega/matchers/be_identical_to.go

@@ -1,3 +1,5 @@
+// untested sections: 2
+
 package matchers
 
 import (

vendor/github.com/onsi/gomega/matchers/be_nil_matcher.go

@@ -1,3 +1,5 @@
+// untested sections: 2
+
 package matchers
 
 import "github.com/onsi/gomega/format"

vendor/github.com/onsi/gomega/matchers/be_numerically_matcher.go

@@ -1,3 +1,5 @@
+// untested sections: 4
+
 package matchers
 
 import (

vendor/github.com/onsi/gomega/matchers/be_sent_matcher.go

@@ -1,3 +1,5 @@
+// untested sections: 3
+
 package matchers
 
 import (
@@ -42,8 +44,8 @@ func (matcher *BeSentMatcher) Match(actual interface{}) (success bool, err error
 	}()
 
 	winnerIndex, _, _ := reflect.Select([]reflect.SelectCase{
-		reflect.SelectCase{Dir: reflect.SelectSend, Chan: channelValue, Send: argValue},
-		reflect.SelectCase{Dir: reflect.SelectDefault},
+		{Dir: reflect.SelectSend, Chan: channelValue, Send: argValue},
+		{Dir: reflect.SelectDefault},
 	})
 
 	var didSend bool

vendor/github.com/onsi/gomega/matchers/be_temporally_matcher.go

@@ -1,3 +1,5 @@
+// untested sections: 3
+
 package matchers
 
 import (

vendor/github.com/onsi/gomega/matchers/be_true_matcher.go

@@ -1,3 +1,5 @@
+// untested sections: 2
+
 package matchers
 
 import (

vendor/github.com/onsi/gomega/matchers/consist_of.go

@@ -1,3 +1,5 @@
+// untested sections: 3
+
 package matchers
 
 import (

vendor/github.com/onsi/gomega/matchers/contain_element_matcher.go

@@ -1,3 +1,5 @@
+// untested sections: 2
+
 package matchers
 
 import (
@@ -22,19 +24,21 @@ func (matcher *ContainElementMatcher) Match(actual interface{}) (success bool, e
 	}
 
 	value := reflect.ValueOf(actual)
-	var keys []reflect.Value
+	var valueAt func(int) interface{}
 	if isMap(actual) {
-		keys = value.MapKeys()
+		keys := value.MapKeys()
+		valueAt = func(i int) interface{} {
+			return value.MapIndex(keys[i]).Interface()
+		}
+	} else {
+		valueAt = func(i int) interface{} {
+			return value.Index(i).Interface()
+		}
 	}
+
 	var lastError error
 	for i := 0; i < value.Len(); i++ {
-		var success bool
-		var err error
-		if isMap(actual) {
-			success, err = elemMatcher.Match(value.MapIndex(keys[i]).Interface())
-		} else {
-			success, err = elemMatcher.Match(value.Index(i).Interface())
-		}
+		success, err := elemMatcher.Match(valueAt(i))
 		if err != nil {
 			lastError = err
 			continue

vendor/github.com/onsi/gomega/matchers/contain_substring_matcher.go

@@ -1,3 +1,5 @@
+// untested sections: 2
+
 package matchers
 
 import (

vendor/github.com/onsi/gomega/matchers/have_cap_matcher.go

@@ -1,3 +1,5 @@
+// untested sections: 2
+
 package matchers
 
 import (

vendor/github.com/onsi/gomega/matchers/have_key_matcher.go

@@ -1,3 +1,5 @@
+// untested sections: 6
+
 package matchers
 
 import (

vendor/github.com/onsi/gomega/matchers/have_key_with_value_matcher.go

@@ -1,3 +1,5 @@
+// untested sections:10
+
 package matchers
 
 import (

vendor/github.com/onsi/gomega/matchers/have_occurred_matcher.go

@@ -1,3 +1,5 @@
+// untested sections: 2
+
 package matchers
 
 import (
@@ -29,5 +31,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")
 }

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())
 		}

vendor/github.com/onsi/gomega/matchers/match_yaml_matcher.go

@@ -53,11 +53,11 @@ func normalise(input string) string {
 	var val interface{}
 	err := yaml.Unmarshal([]byte(input), &val)
 	if err != nil {
-		panic(err) // guarded by Match
+		panic(err) // unreachable since Match already calls Unmarshal
 	}
 	output, err := yaml.Marshal(val)
 	if err != nil {
-		panic(err) // guarded by Unmarshal
+		panic(err) // untested section, unreachable since we Unmarshal above
 	}
 	return strings.TrimSpace(string(output))
 }

vendor/github.com/onsi/gomega/matchers/receive_matcher.go

@@ -1,3 +1,5 @@
+// untested sections: 3
+
 package matchers
 
 import (
@@ -39,8 +41,8 @@ func (matcher *ReceiveMatcher) Match(actual interface{}) (success bool, err erro
 	}
 
 	winnerIndex, value, open := reflect.Select([]reflect.SelectCase{
-		reflect.SelectCase{Dir: reflect.SelectRecv, Chan: channelValue},
-		reflect.SelectCase{Dir: reflect.SelectDefault},
+		{Dir: reflect.SelectRecv, Chan: channelValue},
+		{Dir: reflect.SelectDefault},
 	})
 
 	var closed bool

vendor/github.com/onsi/gomega/matchers/semi_structured_data_support.go

@@ -1,3 +1,5 @@
+// untested sections: 5
+
 package matchers
 
 import (

vendor/github.com/onsi/gomega/matchers/support/goraph/bipartitegraph/bipartitegraph.go

@@ -1,6 +1,5 @@
 package bipartitegraph
 
-import "errors"
 import "fmt"
 
 import . "github.com/onsi/gomega/matchers/support/goraph/node"
@@ -14,12 +13,12 @@ type BipartiteGraph struct {
 
 func NewBipartiteGraph(leftValues, rightValues []interface{}, neighbours func(interface{}, interface{}) (bool, error)) (*BipartiteGraph, error) {
 	left := NodeOrderedSet{}
-	for i, _ := range leftValues {
+	for i := range leftValues {
 		left = append(left, Node{Id: i})
 	}
 
 	right := NodeOrderedSet{}
-	for j, _ := range rightValues {
+	for j := range rightValues {
 		right = append(right, Node{Id: j + len(left)})
 	}
 
@@ -28,7 +27,7 @@ func NewBipartiteGraph(leftValues, rightValues []interface{}, neighbours func(in
 		for j, rightValue := range rightValues {
 			neighbours, err := neighbours(leftValue, rightValue)
 			if err != nil {
-				return nil, errors.New(fmt.Sprintf("error determining adjacency for %v and %v: %s", leftValue, rightValue, err.Error()))
+				return nil, fmt.Errorf("error determining adjacency for %v and %v: %s", leftValue, rightValue, err.Error())
 			}
 
 			if neighbours {

vendor/github.com/onsi/gomega/matchers/type_support.go

@@ -6,6 +6,9 @@ See the docs for Gomega for documentation on the matchers
 
 http://onsi.github.io/gomega/
 */
+
+// untested sections: 11
+
 package matchers
 
 import (