migrate to go-modules

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

6 files changed, 0 insertions, 750 deletions

diff --git a/vendor/github.com/onsi/gomega/internal/assertion/assertion_suite_test.go b/vendor/github.com/onsi/gomega/internal/assertion/assertion_suite_test.go
deleted file mode 100644
index dae47a48b..000000000
--- a/vendor/github.com/onsi/gomega/internal/assertion/assertion_suite_test.go
+++ /dev/null
@@ -1,13 +0,0 @@
-package assertion_test
-
-import (
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-
-	"testing"
-)
-
-func TestAssertion(t *testing.T) {
-	RegisterFailHandler(Fail)
-	RunSpecs(t, "Assertion Suite")
-}
diff --git a/vendor/github.com/onsi/gomega/internal/assertion/assertion_test.go b/vendor/github.com/onsi/gomega/internal/assertion/assertion_test.go
deleted file mode 100644
index cac0d24c5..000000000
--- a/vendor/github.com/onsi/gomega/internal/assertion/assertion_test.go
+++ /dev/null
@@ -1,258 +0,0 @@
-package assertion_test
-
-import (
-	"errors"
-
-	"github.com/onsi/gomega/internal/testingtsupport"
-
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-	. "github.com/onsi/gomega/internal/assertion"
-	"github.com/onsi/gomega/internal/fakematcher"
-	"github.com/onsi/gomega/types"
-)
-
-var _ = Describe("Assertion", func() {
-	var (
-		a                 *Assertion
-		failureMessage    string
-		failureCallerSkip int
-		matcher           *fakematcher.FakeMatcher
-	)
-
-	input := "The thing I'm testing"
-
-	var fakeFailWrapper = &types.GomegaFailWrapper{
-		Fail: func(message string, callerSkip ...int) {
-			failureMessage = message
-			if len(callerSkip) == 1 {
-				failureCallerSkip = callerSkip[0]
-			}
-		},
-		TWithHelper: testingtsupport.EmptyTWithHelper{},
-	}
-
-	BeforeEach(func() {
-		matcher = &fakematcher.FakeMatcher{}
-		failureMessage = ""
-		failureCallerSkip = 0
-		a = New(input, fakeFailWrapper, 1)
-	})
-
-	Context("when called", func() {
-		It("should pass the provided input value to the matcher", func() {
-			a.Should(matcher)
-
-			Expect(matcher.ReceivedActual).Should(Equal(input))
-			matcher.ReceivedActual = ""
-
-			a.ShouldNot(matcher)
-
-			Expect(matcher.ReceivedActual).Should(Equal(input))
-			matcher.ReceivedActual = ""
-
-			a.To(matcher)
-
-			Expect(matcher.ReceivedActual).Should(Equal(input))
-			matcher.ReceivedActual = ""
-
-			a.ToNot(matcher)
-
-			Expect(matcher.ReceivedActual).Should(Equal(input))
-			matcher.ReceivedActual = ""
-
-			a.NotTo(matcher)
-
-			Expect(matcher.ReceivedActual).Should(Equal(input))
-		})
-	})
-
-	Context("when the matcher succeeds", func() {
-		BeforeEach(func() {
-			matcher.MatchesToReturn = true
-			matcher.ErrToReturn = nil
-		})
-
-		Context("and a positive assertion is being made", func() {
-			It("should not call the failure callback", func() {
-				a.Should(matcher)
-				Expect(failureMessage).Should(Equal(""))
-			})
-
-			It("should be true", func() {
-				Expect(a.Should(matcher)).Should(BeTrue())
-			})
-		})
-
-		Context("and a negative assertion is being made", func() {
-			It("should call the failure callback", func() {
-				a.ShouldNot(matcher)
-				Expect(failureMessage).Should(Equal("negative: The thing I'm testing"))
-				Expect(failureCallerSkip).Should(Equal(3))
-			})
-
-			It("should be false", func() {
-				Expect(a.ShouldNot(matcher)).Should(BeFalse())
-			})
-		})
-	})
-
-	Context("when the matcher fails", func() {
-		BeforeEach(func() {
-			matcher.MatchesToReturn = false
-			matcher.ErrToReturn = nil
-		})
-
-		Context("and a positive assertion is being made", func() {
-			It("should call the failure callback", func() {
-				a.Should(matcher)
-				Expect(failureMessage).Should(Equal("positive: The thing I'm testing"))
-				Expect(failureCallerSkip).Should(Equal(3))
-			})
-
-			It("should be false", func() {
-				Expect(a.Should(matcher)).Should(BeFalse())
-			})
-		})
-
-		Context("and a negative assertion is being made", func() {
-			It("should not call the failure callback", func() {
-				a.ShouldNot(matcher)
-				Expect(failureMessage).Should(Equal(""))
-			})
-
-			It("should be true", func() {
-				Expect(a.ShouldNot(matcher)).Should(BeTrue())
-			})
-		})
-	})
-
-	Context("When reporting a failure", func() {
-		BeforeEach(func() {
-			matcher.MatchesToReturn = false
-			matcher.ErrToReturn = nil
-		})
-
-		Context("and there is an optional description", func() {
-			It("should append the description to the failure message", func() {
-				a.Should(matcher, "A description")
-				Expect(failureMessage).Should(Equal("A description\npositive: The thing I'm testing"))
-				Expect(failureCallerSkip).Should(Equal(3))
-			})
-		})
-
-		Context("and there are multiple arguments to the optional description", func() {
-			It("should append the formatted description to the failure message", func() {
-				a.Should(matcher, "A description of [%d]", 3)
-				Expect(failureMessage).Should(Equal("A description of [3]\npositive: The thing I'm testing"))
-				Expect(failureCallerSkip).Should(Equal(3))
-			})
-		})
-	})
-
-	Context("When the matcher returns an error", func() {
-		BeforeEach(func() {
-			matcher.ErrToReturn = errors.New("Kaboom!")
-		})
-
-		Context("and a positive assertion is being made", func() {
-			It("should call the failure callback", func() {
-				matcher.MatchesToReturn = true
-				a.Should(matcher)
-				Expect(failureMessage).Should(Equal("Kaboom!"))
-				Expect(failureCallerSkip).Should(Equal(3))
-			})
-		})
-
-		Context("and a negative assertion is being made", func() {
-			It("should call the failure callback", func() {
-				matcher.MatchesToReturn = false
-				a.ShouldNot(matcher)
-				Expect(failureMessage).Should(Equal("Kaboom!"))
-				Expect(failureCallerSkip).Should(Equal(3))
-			})
-		})
-
-		It("should always be false", func() {
-			Expect(a.Should(matcher)).Should(BeFalse())
-			Expect(a.ShouldNot(matcher)).Should(BeFalse())
-		})
-	})
-
-	Context("when there are extra parameters", func() {
-		It("(a simple example)", func() {
-			Expect(func() (string, int, error) {
-				return "foo", 0, nil
-			}()).Should(Equal("foo"))
-		})
-
-		Context("when the parameters are all nil or zero", func() {
-			It("should invoke the matcher", func() {
-				matcher.MatchesToReturn = true
-				matcher.ErrToReturn = nil
-
-				var typedNil []string
-				a = New(input, fakeFailWrapper, 1, 0, nil, typedNil)
-
-				result := a.Should(matcher)
-				Expect(result).Should(BeTrue())
-				Expect(matcher.ReceivedActual).Should(Equal(input))
-
-				Expect(failureMessage).Should(BeZero())
-			})
-		})
-
-		Context("when any of the parameters are not nil or zero", func() {
-			It("should call the failure callback", func() {
-				matcher.MatchesToReturn = false
-				matcher.ErrToReturn = nil
-
-				a = New(input, fakeFailWrapper, 1, errors.New("foo"))
-				result := a.Should(matcher)
-				Expect(result).Should(BeFalse())
-				Expect(matcher.ReceivedActual).Should(BeZero(), "The matcher doesn't even get called")
-				Expect(failureMessage).Should(ContainSubstring("foo"))
-				failureMessage = ""
-
-				a = New(input, fakeFailWrapper, 1, nil, 1)
-				result = a.ShouldNot(matcher)
-				Expect(result).Should(BeFalse())
-				Expect(failureMessage).Should(ContainSubstring("1"))
-				failureMessage = ""
-
-				a = New(input, fakeFailWrapper, 1, nil, 0, []string{"foo"})
-				result = a.To(matcher)
-				Expect(result).Should(BeFalse())
-				Expect(failureMessage).Should(ContainSubstring("foo"))
-				failureMessage = ""
-
-				a = New(input, fakeFailWrapper, 1, nil, 0, []string{"foo"})
-				result = a.ToNot(matcher)
-				Expect(result).Should(BeFalse())
-				Expect(failureMessage).Should(ContainSubstring("foo"))
-				failureMessage = ""
-
-				a = New(input, fakeFailWrapper, 1, nil, 0, []string{"foo"})
-				result = a.NotTo(matcher)
-				Expect(result).Should(BeFalse())
-				Expect(failureMessage).Should(ContainSubstring("foo"))
-				Expect(failureCallerSkip).Should(Equal(3))
-			})
-		})
-	})
-
-	Context("Making an assertion without a registered fail handler", func() {
-		It("should panic", func() {
-			defer func() {
-				e := recover()
-				RegisterFailHandler(Fail)
-				if e == nil {
-					Fail("expected a panic to have occurred")
-				}
-			}()
-
-			RegisterFailHandler(nil)
-			Expect(true).Should(BeTrue())
-		})
-	})
-})
diff --git a/vendor/github.com/onsi/gomega/internal/asyncassertion/async_assertion_suite_test.go b/vendor/github.com/onsi/gomega/internal/asyncassertion/async_assertion_suite_test.go
deleted file mode 100644
index bdb0c3d22..000000000
--- a/vendor/github.com/onsi/gomega/internal/asyncassertion/async_assertion_suite_test.go
+++ /dev/null
@@ -1,13 +0,0 @@
-package asyncassertion_test
-
-import (
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-
-	"testing"
-)
-
-func TestAsyncAssertion(t *testing.T) {
-	RegisterFailHandler(Fail)
-	RunSpecs(t, "AsyncAssertion Suite")
-}
diff --git a/vendor/github.com/onsi/gomega/internal/asyncassertion/async_assertion_test.go b/vendor/github.com/onsi/gomega/internal/asyncassertion/async_assertion_test.go
deleted file mode 100644
index afd61a7cd..000000000
--- a/vendor/github.com/onsi/gomega/internal/asyncassertion/async_assertion_test.go
+++ /dev/null
@@ -1,351 +0,0 @@
-package asyncassertion_test
-
-import (
-	"errors"
-	"time"
-
-	"github.com/onsi/gomega/internal/testingtsupport"
-
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-	. "github.com/onsi/gomega/internal/asyncassertion"
-	"github.com/onsi/gomega/types"
-)
-
-var _ = Describe("Async Assertion", func() {
-	var (
-		failureMessage string
-		callerSkip     int
-	)
-
-	var fakeFailWrapper = &types.GomegaFailWrapper{
-		Fail: func(message string, skip ...int) {
-			failureMessage = message
-			callerSkip = skip[0]
-		},
-		TWithHelper: testingtsupport.EmptyTWithHelper{},
-	}
-
-	BeforeEach(func() {
-		failureMessage = ""
-		callerSkip = 0
-	})
-
-	Describe("Eventually", func() {
-		Context("the positive case", func() {
-			It("should poll the function and matcher", func() {
-				counter := 0
-				a := New(AsyncAssertionTypeEventually, func() int {
-					counter++
-					return counter
-				}, fakeFailWrapper, time.Duration(0.2*float64(time.Second)), time.Duration(0.02*float64(time.Second)), 1)
-
-				a.Should(BeNumerically("==", 5))
-				Expect(failureMessage).Should(BeZero())
-			})
-
-			It("should continue when the matcher errors", func() {
-				counter := 0
-				a := New(AsyncAssertionTypeEventually, func() interface{} {
-					counter++
-					if counter == 5 {
-						return "not-a-number" //this should cause the matcher to error
-					}
-					return counter
-				}, fakeFailWrapper, time.Duration(0.2*float64(time.Second)), time.Duration(0.02*float64(time.Second)), 1)
-
-				a.Should(BeNumerically("==", 5), "My description %d", 2)
-
-				Expect(failureMessage).Should(ContainSubstring("Timed out after"))
-				Expect(failureMessage).Should(ContainSubstring("My description 2"))
-				Expect(callerSkip).Should(Equal(4))
-			})
-
-			It("should be able to timeout", func() {
-				counter := 0
-				a := New(AsyncAssertionTypeEventually, func() int {
-					counter++
-					return counter
-				}, fakeFailWrapper, time.Duration(0.2*float64(time.Second)), time.Duration(0.02*float64(time.Second)), 1)
-
-				a.Should(BeNumerically(">", 100), "My description %d", 2)
-
-				Expect(counter).Should(BeNumerically(">", 8))
-				Expect(counter).Should(BeNumerically("<=", 10))
-				Expect(failureMessage).Should(ContainSubstring("Timed out after"))
-				Expect(failureMessage).Should(MatchRegexp(`\<int\>: \d`), "Should pass the correct value to the matcher message formatter.")
-				Expect(failureMessage).Should(ContainSubstring("My description 2"))
-				Expect(callerSkip).Should(Equal(4))
-			})
-		})
-
-		Context("the negative case", func() {
-			It("should poll the function and matcher", func() {
-				counter := 0
-				a := New(AsyncAssertionTypeEventually, func() int {
-					counter += 1
-					return counter
-				}, fakeFailWrapper, time.Duration(0.2*float64(time.Second)), time.Duration(0.02*float64(time.Second)), 1)
-
-				a.ShouldNot(BeNumerically("<", 3))
-
-				Expect(counter).Should(Equal(3))
-				Expect(failureMessage).Should(BeZero())
-			})
-
-			It("should timeout when the matcher errors", func() {
-				a := New(AsyncAssertionTypeEventually, func() interface{} {
-					return 0 //this should cause the matcher to error
-				}, fakeFailWrapper, time.Duration(0.2*float64(time.Second)), time.Duration(0.02*float64(time.Second)), 1)
-
-				a.ShouldNot(HaveLen(0), "My description %d", 2)
-
-				Expect(failureMessage).Should(ContainSubstring("Timed out after"))
-				Expect(failureMessage).Should(ContainSubstring("Error:"))
-				Expect(failureMessage).Should(ContainSubstring("My description 2"))
-				Expect(callerSkip).Should(Equal(4))
-			})
-
-			It("should be able to timeout", func() {
-				a := New(AsyncAssertionTypeEventually, func() int {
-					return 0
-				}, fakeFailWrapper, time.Duration(0.1*float64(time.Second)), time.Duration(0.02*float64(time.Second)), 1)
-
-				a.ShouldNot(Equal(0), "My description %d", 2)
-
-				Expect(failureMessage).Should(ContainSubstring("Timed out after"))
-				Expect(failureMessage).Should(ContainSubstring("<int>: 0"), "Should pass the correct value to the matcher message formatter.")
-				Expect(failureMessage).Should(ContainSubstring("My description 2"))
-				Expect(callerSkip).Should(Equal(4))
-			})
-		})
-
-		Context("with a function that returns multiple values", func() {
-			It("should eventually succeed if the additional arguments are nil", func() {
-				i := 0
-				Eventually(func() (int, error) {
-					i++
-					return i, nil
-				}).Should(Equal(10))
-			})
-
-			It("should eventually timeout if the additional arguments are not nil", func() {
-				i := 0
-				a := New(AsyncAssertionTypeEventually, func() (int, error) {
-					i++
-					return i, errors.New("bam")
-				}, fakeFailWrapper, time.Duration(0.2*float64(time.Second)), time.Duration(0.02*float64(time.Second)), 1)
-				a.Should(Equal(2))
-
-				Expect(failureMessage).Should(ContainSubstring("Timed out after"))
-				Expect(failureMessage).Should(ContainSubstring("Error:"))
-				Expect(failureMessage).Should(ContainSubstring("bam"))
-				Expect(callerSkip).Should(Equal(4))
-			})
-		})
-
-		Context("Making an assertion without a registered fail handler", func() {
-			It("should panic", func() {
-				defer func() {
-					e := recover()
-					RegisterFailHandler(Fail)
-					if e == nil {
-						Fail("expected a panic to have occurred")
-					}
-				}()
-
-				RegisterFailHandler(nil)
-				c := make(chan bool, 1)
-				c <- true
-				Eventually(c).Should(Receive())
-			})
-		})
-	})
-
-	Describe("Consistently", func() {
-		Describe("The positive case", func() {
-			Context("when the matcher consistently passes for the duration", func() {
-				It("should pass", func() {
-					calls := 0
-					a := New(AsyncAssertionTypeConsistently, func() string {
-						calls++
-						return "foo"
-					}, fakeFailWrapper, time.Duration(0.2*float64(time.Second)), time.Duration(0.02*float64(time.Second)), 1)
-
-					a.Should(Equal("foo"))
-					Expect(calls).Should(BeNumerically(">", 8))
-					Expect(calls).Should(BeNumerically("<=", 10))
-					Expect(failureMessage).Should(BeZero())
-				})
-			})
-
-			Context("when the matcher fails at some point", func() {
-				It("should fail", func() {
-					calls := 0
-					a := New(AsyncAssertionTypeConsistently, func() interface{} {
-						calls++
-						if calls > 5 {
-							return "bar"
-						}
-						return "foo"
-					}, fakeFailWrapper, time.Duration(0.2*float64(time.Second)), time.Duration(0.02*float64(time.Second)), 1)
-
-					a.Should(Equal("foo"))
-					Expect(failureMessage).Should(ContainSubstring("to equal"))
-					Expect(callerSkip).Should(Equal(4))
-				})
-			})
-
-			Context("when the matcher errors at some point", func() {
-				It("should fail", func() {
-					calls := 0
-					a := New(AsyncAssertionTypeConsistently, func() interface{} {
-						calls++
-						if calls > 5 {
-							return 3
-						}
-						return []int{1, 2, 3}
-					}, fakeFailWrapper, time.Duration(0.2*float64(time.Second)), time.Duration(0.02*float64(time.Second)), 1)
-
-					a.Should(HaveLen(3))
-					Expect(failureMessage).Should(ContainSubstring("HaveLen matcher expects"))
-					Expect(callerSkip).Should(Equal(4))
-				})
-			})
-		})
-
-		Describe("The negative case", func() {
-			Context("when the matcher consistently passes for the duration", func() {
-				It("should pass", func() {
-					c := make(chan bool)
-					a := New(AsyncAssertionTypeConsistently, c, fakeFailWrapper, time.Duration(0.2*float64(time.Second)), time.Duration(0.02*float64(time.Second)), 1)
-
-					a.ShouldNot(Receive())
-					Expect(failureMessage).Should(BeZero())
-				})
-			})
-
-			Context("when the matcher fails at some point", func() {
-				It("should fail", func() {
-					c := make(chan bool)
-					go func() {
-						time.Sleep(time.Duration(100 * time.Millisecond))
-						c <- true
-					}()
-
-					a := New(AsyncAssertionTypeConsistently, c, fakeFailWrapper, time.Duration(0.2*float64(time.Second)), time.Duration(0.02*float64(time.Second)), 1)
-
-					a.ShouldNot(Receive())
-					Expect(failureMessage).Should(ContainSubstring("not to receive anything"))
-				})
-			})
-
-			Context("when the matcher errors at some point", func() {
-				It("should fail", func() {
-					calls := 0
-					a := New(AsyncAssertionTypeConsistently, func() interface{} {
-						calls++
-						return calls
-					}, fakeFailWrapper, time.Duration(0.2*float64(time.Second)), time.Duration(0.02*float64(time.Second)), 1)
-
-					a.ShouldNot(BeNumerically(">", 5))
-					Expect(failureMessage).Should(ContainSubstring("not to be >"))
-					Expect(callerSkip).Should(Equal(4))
-				})
-			})
-		})
-
-		Context("with a function that returns multiple values", func() {
-			It("should consistently succeed if the additional arguments are nil", func() {
-				i := 2
-				Consistently(func() (int, error) {
-					i++
-					return i, nil
-				}).Should(BeNumerically(">=", 2))
-			})
-
-			It("should eventually timeout if the additional arguments are not nil", func() {
-				i := 2
-				a := New(AsyncAssertionTypeEventually, func() (int, error) {
-					i++
-					return i, errors.New("bam")
-				}, fakeFailWrapper, time.Duration(0.2*float64(time.Second)), time.Duration(0.02*float64(time.Second)), 1)
-				a.Should(BeNumerically(">=", 2))
-
-				Expect(failureMessage).Should(ContainSubstring("Error:"))
-				Expect(failureMessage).Should(ContainSubstring("bam"))
-				Expect(callerSkip).Should(Equal(4))
-			})
-		})
-
-		Context("Making an assertion without a registered fail handler", func() {
-			It("should panic", func() {
-				defer func() {
-					e := recover()
-					RegisterFailHandler(Fail)
-					if e == nil {
-						Fail("expected a panic to have occurred")
-					}
-				}()
-
-				RegisterFailHandler(nil)
-				c := make(chan bool)
-				Consistently(c).ShouldNot(Receive())
-			})
-		})
-	})
-
-	Context("when passed a function with the wrong # or arguments & returns", func() {
-		It("should panic", func() {
-			Expect(func() {
-				New(AsyncAssertionTypeEventually, func() {}, fakeFailWrapper, 0, 0, 1)
-			}).Should(Panic())
-
-			Expect(func() {
-				New(AsyncAssertionTypeEventually, func(a string) int { return 0 }, fakeFailWrapper, 0, 0, 1)
-			}).Should(Panic())
-
-			Expect(func() {
-				New(AsyncAssertionTypeEventually, func() int { return 0 }, fakeFailWrapper, 0, 0, 1)
-			}).ShouldNot(Panic())
-
-			Expect(func() {
-				New(AsyncAssertionTypeEventually, func() (int, error) { return 0, nil }, fakeFailWrapper, 0, 0, 1)
-			}).ShouldNot(Panic())
-		})
-	})
-
-	Describe("bailing early", func() {
-		Context("when actual is a value", func() {
-			It("Eventually should bail out and fail early if the matcher says to", func() {
-				c := make(chan bool)
-				close(c)
-
-				t := time.Now()
-				failures := InterceptGomegaFailures(func() {
-					Eventually(c, 0.1).Should(Receive())
-				})
-				Expect(time.Since(t)).Should(BeNumerically("<", 90*time.Millisecond))
-
-				Expect(failures).Should(HaveLen(1))
-			})
-		})
-
-		Context("when actual is a function", func() {
-			It("should never bail early", func() {
-				c := make(chan bool)
-				close(c)
-
-				t := time.Now()
-				failures := InterceptGomegaFailures(func() {
-					Eventually(func() chan bool {
-						return c
-					}, 0.1).Should(Receive())
-				})
-				Expect(time.Since(t)).Should(BeNumerically(">=", 90*time.Millisecond))
-
-				Expect(failures).Should(HaveLen(1))
-			})
-		})
-	})
-})
diff --git a/vendor/github.com/onsi/gomega/internal/fakematcher/fake_matcher.go b/vendor/github.com/onsi/gomega/internal/fakematcher/fake_matcher.go
deleted file mode 100644
index 6e351a7de..000000000
--- a/vendor/github.com/onsi/gomega/internal/fakematcher/fake_matcher.go
+++ /dev/null
@@ -1,23 +0,0 @@
-package fakematcher
-
-import "fmt"
-
-type FakeMatcher struct {
-	ReceivedActual  interface{}
-	MatchesToReturn bool
-	ErrToReturn     error
-}
-
-func (matcher *FakeMatcher) Match(actual interface{}) (bool, error) {
-	matcher.ReceivedActual = actual
-
-	return matcher.MatchesToReturn, matcher.ErrToReturn
-}
-
-func (matcher *FakeMatcher) FailureMessage(actual interface{}) string {
-	return fmt.Sprintf("positive: %v", actual)
-}
-
-func (matcher *FakeMatcher) NegatedFailureMessage(actual interface{}) string {
-	return fmt.Sprintf("negative: %v", actual)
-}
diff --git a/vendor/github.com/onsi/gomega/internal/testingtsupport/testing_t_support_test.go b/vendor/github.com/onsi/gomega/internal/testingtsupport/testing_t_support_test.go
deleted file mode 100644
index 8fd8f0a6c..000000000
--- a/vendor/github.com/onsi/gomega/internal/testingtsupport/testing_t_support_test.go
+++ /dev/null
@@ -1,92 +0,0 @@
-package testingtsupport_test
-
-import (
-	"regexp"
-	"time"
-
-	"github.com/onsi/gomega/internal/testingtsupport"
-
-	. "github.com/onsi/gomega"
-
-	"fmt"
-	"testing"
-)
-
-func TestTestingT(t *testing.T) {
-	RegisterTestingT(t)
-	Ω(true).Should(BeTrue())
-}
-
-type FakeTWithHelper struct {
-	LastFatal string
-}
-
-func (f *FakeTWithHelper) Fatalf(format string, args ...interface{}) {
-	f.LastFatal = fmt.Sprintf(format, args...)
-}
-
-func TestGomegaWithTWithoutHelper(t *testing.T) {
-	g := NewGomegaWithT(t)
-
-	testingtsupport.StackTracePruneRE = regexp.MustCompile(`\/ginkgo\/`)
-
-	f := &FakeTWithHelper{}
-	testG := NewGomegaWithT(f)
-
-	testG.Expect("foo").To(Equal("foo"))
-	g.Expect(f.LastFatal).To(BeZero())
-
-	testG.Expect("foo").To(Equal("bar"))
-	g.Expect(f.LastFatal).To(ContainSubstring("<string>: foo"))
-	g.Expect(f.LastFatal).To(ContainSubstring("testingtsupport_test"), "It should include a stacktrace")
-
-	testG.Eventually("foo2", time.Millisecond).Should(Equal("bar"))
-	g.Expect(f.LastFatal).To(ContainSubstring("<string>: foo2"))
-
-	testG.Consistently("foo3", time.Millisecond).Should(Equal("bar"))
-	g.Expect(f.LastFatal).To(ContainSubstring("<string>: foo3"))
-}
-
-type FakeTWithoutHelper struct {
-	LastFatal   string
-	HelperCount int
-}
-
-func (f *FakeTWithoutHelper) Fatalf(format string, args ...interface{}) {
-	f.LastFatal = fmt.Sprintf(format, args...)
-}
-
-func (f *FakeTWithoutHelper) Helper() {
-	f.HelperCount += 1
-}
-
-func (f *FakeTWithoutHelper) ResetHelper() {
-	f.HelperCount = 0
-}
-
-func TestGomegaWithTWithHelper(t *testing.T) {
-	g := NewGomegaWithT(t)
-
-	f := &FakeTWithoutHelper{}
-	testG := NewGomegaWithT(f)
-
-	testG.Expect("foo").To(Equal("foo"))
-	g.Expect(f.LastFatal).To(BeZero())
-	g.Expect(f.HelperCount).To(BeNumerically(">", 0))
-	f.ResetHelper()
-
-	testG.Expect("foo").To(Equal("bar"))
-	g.Expect(f.LastFatal).To(ContainSubstring("<string>: foo"))
-	g.Expect(f.LastFatal).NotTo(ContainSubstring("testingtsupport_test"), "It should _not_ include a stacktrace")
-	g.Expect(f.HelperCount).To(BeNumerically(">", 0))
-	f.ResetHelper()
-
-	testG.Eventually("foo2", time.Millisecond).Should(Equal("bar"))
-	g.Expect(f.LastFatal).To(ContainSubstring("<string>: foo2"))
-	g.Expect(f.HelperCount).To(BeNumerically(">", 0))
-	f.ResetHelper()
-
-	testG.Consistently("foo3", time.Millisecond).Should(Equal("bar"))
-	g.Expect(f.LastFatal).To(ContainSubstring("<string>: foo3"))
-	g.Expect(f.HelperCount).To(BeNumerically(">", 0))
-}