func InOrder(calls ...*Call)
InOrder declares that the given calls should occur in order.
Call represents an expected call to a mock.
type Call struct {
// contains filtered or unexported fields
}
func (c *Call) After(preReq *Call) *Call
After declares that the call may only match after preReq has been exhausted.
func (c *Call) AnyTimes() *Call
AnyTimes allows the expectation to be called 0 or more times
func (c *Call) Do(f interface{}) *Call
Do declares the action to run when the call is matched. The function's return values are ignored to retain backward compatibility. To use the return values call DoAndReturn. It takes an interface{} argument to support n-arity functions. The anonymous function must match the function signature mocked method.
func (c *Call) DoAndReturn(f interface{}) *Call
DoAndReturn declares the action to run when the call is matched. The return values from this function are returned by the mocked function. It takes an interface{} argument to support n-arity functions. The anonymous function must match the function signature mocked method.
▹ Example (CaptureArguments)
▹ Example (Latency)
func (c *Call) MaxTimes(n int) *Call
MaxTimes limits the number of calls to n times. If AnyTimes or MinTimes have not been called or if MinTimes was previously called with 1, MaxTimes also sets the minimum number of calls to 0.
func (c *Call) MinTimes(n int) *Call
MinTimes requires the call to occur at least n times. If AnyTimes or MaxTimes have not been called or if MaxTimes was previously called with 1, MinTimes also sets the maximum number of calls to infinity.
func (c *Call) Return(rets ...interface{}) *Call
Return declares the values to be returned by the mocked function call.
func (c *Call) SetArg(n int, value interface{}) *Call
SetArg declares an action that will set the nth argument's value, indirected through a pointer. Or, in the case of a slice and map, SetArg will copy value's elements/key-value pairs into the nth argument.
func (c *Call) String() string
func (c *Call) Times(n int) *Call
Times declares the exact number of times a function call is expected to be executed.
A Controller represents the top-level control of a mock ecosystem. It defines the scope and lifetime of mock objects, as well as their expectations. It is safe to call Controller's methods from multiple goroutines. Each test should create a new Controller and invoke Finish via defer.
func TestFoo(t *testing.T) {
ctrl := gomock.NewController(t)
defer ctrl.Finish()
// ..
}
func TestBar(t *testing.T) {
t.Run("Sub-Test-1", st) {
ctrl := gomock.NewController(st)
defer ctrl.Finish()
// ..
})
t.Run("Sub-Test-2", st) {
ctrl := gomock.NewController(st)
defer ctrl.Finish()
// ..
})
})
type Controller struct {
// T should only be called within a generated mock. It is not intended to
// be used in user code and may be changed in future versions. T is the
// TestReporter passed in when creating the Controller via NewController.
// If the TestReporter does not implement a TestHelper it will be wrapped
// with a nopTestHelper.
T TestHelper
// contains filtered or unexported fields
}
func NewController(t TestReporter) *Controller
NewController returns a new Controller. It is the preferred way to create a Controller.
New in go1.14+, if you are passing a *testing.T into this function you no longer need to call ctrl.Finish() in your test methods.
func WithContext(ctx context.Context, t TestReporter) (*Controller, context.Context)
WithContext returns a new Controller and a Context, which is cancelled on any fatal failure.
func (ctrl *Controller) Call(receiver interface{}, method string, args ...interface{}) []interface{}
Call is called by a mock. It should not be called by user code.
func (ctrl *Controller) Finish()
Finish checks to see if all the methods that were expected to be called were called. It should be invoked for each Controller. It is not idempotent and therefore can only be invoked once.
New in go1.14+, if you are passing a *testing.T into NewController function you no longer need to call ctrl.Finish() in your test methods.
func (ctrl *Controller) RecordCall(receiver interface{}, method string, args ...interface{}) *Call
RecordCall is called by a mock. It should not be called by user code.
func (ctrl *Controller) RecordCallWithMethodType(receiver interface{}, method string, methodType reflect.Type, args ...interface{}) *Call
RecordCallWithMethodType is called by a mock. It should not be called by user code.
GotFormatter is used to better print failure messages. If a matcher implements GotFormatter, it will use the result from Got when printing the failure message.
type GotFormatter interface {
// Got is invoked with the received value. The result is used when
// printing the failure message.
Got(got interface{}) string
}
GotFormatterFunc type is an adapter to allow the use of ordinary functions as a GotFormatter. If f is a function with the appropriate signature, GotFormatterFunc(f) is a GotFormatter that calls f.
type GotFormatterFunc func(got interface{}) string
func (f GotFormatterFunc) Got(got interface{}) string
Got implements GotFormatter.
A Matcher is a representation of a class of values. It is used to represent the valid or expected arguments to a mocked method.
type Matcher interface {
// Matches returns whether x is a match.
Matches(x interface{}) bool
// String describes what the matcher matches.
String() string
}
func All(ms ...Matcher) Matcher
All returns a composite Matcher that returns true if and only all of the matchers return true.
func Any() Matcher
Any returns a matcher that always matches.
func AssignableToTypeOf(x interface{}) Matcher
AssignableToTypeOf is a Matcher that matches if the parameter to the mock function is assignable to the type of the parameter to this function.
Example usage:
var s fmt.Stringer = &bytes.Buffer{}
AssignableToTypeOf(s).Matches(time.Second) // returns true
AssignableToTypeOf(s).Matches(99) // returns false
var ctx = reflect.TypeOf((*context.Context)(nil)).Elem()
AssignableToTypeOf(ctx).Matches(context.Background()) // returns true
func Eq(x interface{}) Matcher
Eq returns a matcher that matches on equality.
Example usage:
Eq(5).Matches(5) // returns true Eq(5).Matches(4) // returns false
func GotFormatterAdapter(s GotFormatter, m Matcher) Matcher
GotFormatterAdapter attaches a GotFormatter to a Matcher.
func InAnyOrder(x interface{}) Matcher
InAnyOrder is a Matcher that returns true for collections of the same elements ignoring the order.
Example usage:
InAnyOrder([]int{1, 2, 3}).Matches([]int{1, 3, 2}) // returns true
InAnyOrder([]int{1, 2, 3}).Matches([]int{1, 2}) // returns false
func Len(i int) Matcher
Len returns a matcher that matches on length. This matcher returns false if is compared to a type that is not an array, chan, map, slice, or string.
func Nil() Matcher
Nil returns a matcher that matches if the received value is nil.
Example usage:
var x *bytes.Buffer
Nil().Matches(x) // returns true
x = &bytes.Buffer{}
Nil().Matches(x) // returns false
func Not(x interface{}) Matcher
Not reverses the results of its given child matcher.
Example usage:
Not(Eq(5)).Matches(4) // returns true Not(Eq(5)).Matches(5) // returns false
func WantFormatter(s fmt.Stringer, m Matcher) Matcher
WantFormatter modifies the given Matcher's String() method to the given Stringer. This allows for control on how the "Want" is formatted when printing .
StringerFunc type is an adapter to allow the use of ordinary functions as a Stringer. If f is a function with the appropriate signature, StringerFunc(f) is a Stringer that calls f.
type StringerFunc func() string
func (f StringerFunc) String() string
String implements fmt.Stringer.
TestHelper is a TestReporter that has the Helper method. It is satisfied by the standard library's *testing.T.
type TestHelper interface {
TestReporter
Helper()
}
A TestReporter is something that can be used to report test failures. It is satisfied by the standard library's *testing.T.
type TestReporter interface {
Errorf(format string, args ...interface{})
Fatalf(format string, args ...interface{})
}
| Name | Synopsis |
|---|---|
| .. | |