godouble

type CombinationMatcher interface {
	Matcher
	ForMethod(t T, m reflect.Method)
	ForType(t T, ft reflect.Type)
}

type Completion interface {
	Expectation
	Complete(count int) bool
}

type Expectation interface {
	// Is the expectation met, complete with count?
	Met(count int) bool
}

type FakeMethodCall interface {
	// The full set of all recorded calls to this method available to be verified
	RecordedCalls
	MethodCall
}

type Matcher interface {

	//Matches returns true if the arg (or args) matches this matcher
	Matches(args ...interface{}) bool
}

type MatcherForMethod func(t T, m reflect.Method, chained MethodArgsMatcher, matchers ...interface{}) MethodArgsMatcher

type Method interface {
	Stub() StubbedMethodCall
	Mock() MockedMethodCall
	Spy() SpyMethodCall
	Fake(impl interface{}) FakeMethodCall
	Reflect() reflect.Method
}

type MethodArgsMatcher interface {
	Matcher
	//ForMethod uses t to assert suitability of this matcher to match the method signature of m
	ForMethod(t T, m reflect.Method)
}

type MethodCall interface {
	// contains filtered or unexported methods
}

type MockedMethodCall interface {
	/*
			Matching is used to setup whether this call will match a given set of arguments.

		    Empty matcherList list will fatally fail the test

		    If the first matcher is a Matcher then it is used (test will fatally fail is more matcherList are sent)
		    If the first matcher is a func then is equivalent to Matching(Matcher(matcherList[0],matcherList[1:))
		    Otherwise each matcher is converted to a Matcher via either Func() or Eql()
		    and this list is sent to Args()
	*/
	Matching(matchers ...interface{}) MockedMethodCall

	//Setup that this call will only match if the supplied calls are already complete
	After(calls ...MockedMethodCall) MockedMethodCall

	/*
		Returning is used to setup return values for this call

		The returnValues are converted to a ReturnValues via Values()
	*/
	Returning(values ...interface{}) MockedMethodCall

	//Setup an expectation on the number of times this call will be invoked
	Expect(expect Expectation) MockedMethodCall

	MethodCall
	// contains filtered or unexported methods
}

type RecordedCalls interface {
	/*
		Matching returns the subset of calls that match

		Empty matcherList list will fatally fail the test

		If the first matcher is a Matcher then it is used (test will fatally fail is more matcherList are sent)
		If the first matcher is a func then is equivalent to Matching(Matcher(matcherList[0],matcherList[1:))
		Otherwise each matcher is converted to a Matcher via either Func() or Eql()
		and this list is sent to Args()
	*/
	Matching(matchers ...interface{}) RecordedCalls

	/*
		Slice returns a subset of these calls, including call at index from, excluding call at index to (like go slice))

		If necessary use NumCalls() to reference calls from the end of the slice.
		eg to get the last 3 calls - r.Slice(r.NumCalls() -3, r.NumCalls())
	*/
	Slice(from int, to int) RecordedCalls

	// After returns the subset of these calls that were invoked after all of otherCalls
	After(otherCalls RecordedCalls) RecordedCalls

	// Expect asserts the number of calls in this set
	Expect(expect Expectation)

	// NumCalls returns the number of calls in this set.
	// Prefer to use Expect() rather than asserting the result of NumCalls()
	NumCalls() int
	// contains filtered or unexported methods
}

type ReturnChannel interface {

	//Send a list of return values
	Send(...interface{})

	//Close the channel, subsequent invocations that need values will cause the test to fail fatally
	Close()

	//Set a timeout. If the timeout expires before a Value is available on the channel
	//  ( via Send() ) the test will fail fatally.
	SetTimeout(timeout time.Duration, sleeper ...Timewarp)

	ReturnValues
}

type ReturnValues interface {

	//Receive is called when a method is exercised
	//
	// non nil error response will fatally terminate the test
	Receive() ([]interface{}, error)
}

type ReturnsForMethod func(t T, m reflect.Method, chained ReturnValues, returnValues ...interface{}) ReturnValues

type SingleArgMatcher interface {
	Matcher

	//ForType uses t to assert suitability of this matcher to match a single argument of type ft
	ForType(t T, ft reflect.Type)
}

type SpyMethodCall interface {
	/*
		Returning is used to setup return values for this call

		The returnValues are converted to a ReturnValues via Values()
	*/
	Returning(values ...interface{}) SpyMethodCall

	// The full set of all recorded calls to this method available to be verified
	RecordedCalls

	MethodCall
}

type StubbedMethodCall interface {
	/*
			Matching is used to setup whether this call will match a given set of arguments.

		    Empty matcherList list will fatally fail the test

		    If the first matcher is a Matcher then it is used (test will fatally fail is more matcherList are sent)
		    If the first matcher is a func then is equivalent to Matching(Matcher(matcherList[0],matcherList[1:))
		    Otherwise each matcher is converted to a Matcher via either Func() or Eql()
		    and this list is sent to Args()
	*/
	Matching(matchers ...interface{}) StubbedMethodCall

	/*
		Returning is used to setup return values for this call

		The returnValues are converted to a ReturnValues via Values()
	*/
	Returning(returnValues ...interface{}) StubbedMethodCall

	MethodCall
}

type T interface {
	Errorf(format string, args ...interface{})
	Fatalf(format string, args ...interface{})
	Logf(format string, args ...interface{})
	Helper()
}

type TestDouble struct {
	// contains filtered or unexported fields
}

type Timewarp func(d time.Duration) <-chan time.Time

type ValidatingReturnValues interface {
	ReturnValues
	ForMethod(t T, method reflect.Method)
}

type Verifiable interface {
	Verify()
}