summaryrefslogtreecommitdiff
path: root/vendor/github.com/golang/mock/gomock
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/github.com/golang/mock/gomock')
-rw-r--r--vendor/github.com/golang/mock/gomock/call.go420
-rw-r--r--vendor/github.com/golang/mock/gomock/callset.go108
-rw-r--r--vendor/github.com/golang/mock/gomock/controller.go264
-rw-r--r--vendor/github.com/golang/mock/gomock/matchers.go141
4 files changed, 0 insertions, 933 deletions
diff --git a/vendor/github.com/golang/mock/gomock/call.go b/vendor/github.com/golang/mock/gomock/call.go
deleted file mode 100644
index 3d54d9f..0000000
--- a/vendor/github.com/golang/mock/gomock/call.go
+++ /dev/null
@@ -1,420 +0,0 @@
-// Copyright 2010 Google Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package gomock
-
-import (
- "fmt"
- "reflect"
- "strconv"
- "strings"
-)
-
-// Call represents an expected call to a mock.
-type Call struct {
- t TestHelper // for triggering test failures on invalid call setup
-
- receiver interface{} // the receiver of the method call
- method string // the name of the method
- methodType reflect.Type // the type of the method
- args []Matcher // the args
- origin string // file and line number of call setup
-
- preReqs []*Call // prerequisite calls
-
- // Expectations
- minCalls, maxCalls int
-
- numCalls int // actual number made
-
- // actions are called when this Call is called. Each action gets the args and
- // can set the return values by returning a non-nil slice. Actions run in the
- // order they are created.
- actions []func([]interface{}) []interface{}
-}
-
-// newCall creates a *Call. It requires the method type in order to support
-// unexported methods.
-func newCall(t TestHelper, receiver interface{}, method string, methodType reflect.Type, args ...interface{}) *Call {
- t.Helper()
-
- // TODO: check arity, types.
- margs := make([]Matcher, len(args))
- for i, arg := range args {
- if m, ok := arg.(Matcher); ok {
- margs[i] = m
- } else if arg == nil {
- // Handle nil specially so that passing a nil interface value
- // will match the typed nils of concrete args.
- margs[i] = Nil()
- } else {
- margs[i] = Eq(arg)
- }
- }
-
- origin := callerInfo(3)
- actions := []func([]interface{}) []interface{}{func([]interface{}) []interface{} {
- // Synthesize the zero value for each of the return args' types.
- rets := make([]interface{}, methodType.NumOut())
- for i := 0; i < methodType.NumOut(); i++ {
- rets[i] = reflect.Zero(methodType.Out(i)).Interface()
- }
- return rets
- }}
- return &Call{t: t, receiver: receiver, method: method, methodType: methodType,
- args: margs, origin: origin, minCalls: 1, maxCalls: 1, actions: actions}
-}
-
-// AnyTimes allows the expectation to be called 0 or more times
-func (c *Call) AnyTimes() *Call {
- c.minCalls, c.maxCalls = 0, 1e8 // close enough to infinity
- return c
-}
-
-// MinTimes requires the call to occur at least n times. If AnyTimes or MaxTimes have not been called, MinTimes also
-// sets the maximum number of calls to infinity.
-func (c *Call) MinTimes(n int) *Call {
- c.minCalls = n
- if c.maxCalls == 1 {
- c.maxCalls = 1e8
- }
- return c
-}
-
-// MaxTimes limits the number of calls to n times. If AnyTimes or MinTimes have not been called, MaxTimes also
-// sets the minimum number of calls to 0.
-func (c *Call) MaxTimes(n int) *Call {
- c.maxCalls = n
- if c.minCalls == 1 {
- c.minCalls = 0
- }
- return c
-}
-
-// 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.
-func (c *Call) DoAndReturn(f interface{}) *Call {
- // TODO: Check arity and types here, rather than dying badly elsewhere.
- v := reflect.ValueOf(f)
-
- c.addAction(func(args []interface{}) []interface{} {
- vargs := make([]reflect.Value, len(args))
- ft := v.Type()
- for i := 0; i < len(args); i++ {
- if args[i] != nil {
- vargs[i] = reflect.ValueOf(args[i])
- } else {
- // Use the zero value for the arg.
- vargs[i] = reflect.Zero(ft.In(i))
- }
- }
- vrets := v.Call(vargs)
- rets := make([]interface{}, len(vrets))
- for i, ret := range vrets {
- rets[i] = ret.Interface()
- }
- return rets
- })
- return c
-}
-
-// 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.
-func (c *Call) Do(f interface{}) *Call {
- // TODO: Check arity and types here, rather than dying badly elsewhere.
- v := reflect.ValueOf(f)
-
- c.addAction(func(args []interface{}) []interface{} {
- vargs := make([]reflect.Value, len(args))
- ft := v.Type()
- for i := 0; i < len(args); i++ {
- if args[i] != nil {
- vargs[i] = reflect.ValueOf(args[i])
- } else {
- // Use the zero value for the arg.
- vargs[i] = reflect.Zero(ft.In(i))
- }
- }
- v.Call(vargs)
- return nil
- })
- return c
-}
-
-// Return declares the values to be returned by the mocked function call.
-func (c *Call) Return(rets ...interface{}) *Call {
- c.t.Helper()
-
- mt := c.methodType
- if len(rets) != mt.NumOut() {
- c.t.Fatalf("wrong number of arguments to Return for %T.%v: got %d, want %d [%s]",
- c.receiver, c.method, len(rets), mt.NumOut(), c.origin)
- }
- for i, ret := range rets {
- if got, want := reflect.TypeOf(ret), mt.Out(i); got == want {
- // Identical types; nothing to do.
- } else if got == nil {
- // Nil needs special handling.
- switch want.Kind() {
- case reflect.Chan, reflect.Func, reflect.Interface, reflect.Map, reflect.Ptr, reflect.Slice:
- // ok
- default:
- c.t.Fatalf("argument %d to Return for %T.%v is nil, but %v is not nillable [%s]",
- i, c.receiver, c.method, want, c.origin)
- }
- } else if got.AssignableTo(want) {
- // Assignable type relation. Make the assignment now so that the generated code
- // can return the values with a type assertion.
- v := reflect.New(want).Elem()
- v.Set(reflect.ValueOf(ret))
- rets[i] = v.Interface()
- } else {
- c.t.Fatalf("wrong type of argument %d to Return for %T.%v: %v is not assignable to %v [%s]",
- i, c.receiver, c.method, got, want, c.origin)
- }
- }
-
- c.addAction(func([]interface{}) []interface{} {
- return rets
- })
-
- return c
-}
-
-// Times declares the exact number of times a function call is expected to be executed.
-func (c *Call) Times(n int) *Call {
- c.minCalls, c.maxCalls = n, n
- return c
-}
-
-// SetArg declares an action that will set the nth argument's value,
-// indirected through a pointer. Or, in the case of a slice, SetArg
-// will copy value's elements into the nth argument.
-func (c *Call) SetArg(n int, value interface{}) *Call {
- c.t.Helper()
-
- mt := c.methodType
- // TODO: This will break on variadic methods.
- // We will need to check those at invocation time.
- if n < 0 || n >= mt.NumIn() {
- c.t.Fatalf("SetArg(%d, ...) called for a method with %d args [%s]",
- n, mt.NumIn(), c.origin)
- }
- // Permit setting argument through an interface.
- // In the interface case, we don't (nay, can't) check the type here.
- at := mt.In(n)
- switch at.Kind() {
- case reflect.Ptr:
- dt := at.Elem()
- if vt := reflect.TypeOf(value); !vt.AssignableTo(dt) {
- c.t.Fatalf("SetArg(%d, ...) argument is a %v, not assignable to %v [%s]",
- n, vt, dt, c.origin)
- }
- case reflect.Interface:
- // nothing to do
- case reflect.Slice:
- // nothing to do
- default:
- c.t.Fatalf("SetArg(%d, ...) referring to argument of non-pointer non-interface non-slice type %v [%s]",
- n, at, c.origin)
- }
-
- c.addAction(func(args []interface{}) []interface{} {
- v := reflect.ValueOf(value)
- switch reflect.TypeOf(args[n]).Kind() {
- case reflect.Slice:
- setSlice(args[n], v)
- default:
- reflect.ValueOf(args[n]).Elem().Set(v)
- }
- return nil
- })
- return c
-}
-
-// isPreReq returns true if other is a direct or indirect prerequisite to c.
-func (c *Call) isPreReq(other *Call) bool {
- for _, preReq := range c.preReqs {
- if other == preReq || preReq.isPreReq(other) {
- return true
- }
- }
- return false
-}
-
-// After declares that the call may only match after preReq has been exhausted.
-func (c *Call) After(preReq *Call) *Call {
- c.t.Helper()
-
- if c == preReq {
- c.t.Fatalf("A call isn't allowed to be its own prerequisite")
- }
- if preReq.isPreReq(c) {
- c.t.Fatalf("Loop in call order: %v is a prerequisite to %v (possibly indirectly).", c, preReq)
- }
-
- c.preReqs = append(c.preReqs, preReq)
- return c
-}
-
-// Returns true if the minimum number of calls have been made.
-func (c *Call) satisfied() bool {
- return c.numCalls >= c.minCalls
-}
-
-// Returns true iff the maximum number of calls have been made.
-func (c *Call) exhausted() bool {
- return c.numCalls >= c.maxCalls
-}
-
-func (c *Call) String() string {
- args := make([]string, len(c.args))
- for i, arg := range c.args {
- args[i] = arg.String()
- }
- arguments := strings.Join(args, ", ")
- return fmt.Sprintf("%T.%v(%s) %s", c.receiver, c.method, arguments, c.origin)
-}
-
-// Tests if the given call matches the expected call.
-// If yes, returns nil. If no, returns error with message explaining why it does not match.
-func (c *Call) matches(args []interface{}) error {
- if !c.methodType.IsVariadic() {
- if len(args) != len(c.args) {
- return fmt.Errorf("Expected call at %s has the wrong number of arguments. Got: %d, want: %d",
- c.origin, len(args), len(c.args))
- }
-
- for i, m := range c.args {
- if !m.Matches(args[i]) {
- return fmt.Errorf("Expected call at %s doesn't match the argument at index %s.\nGot: %v\nWant: %v",
- c.origin, strconv.Itoa(i), args[i], m)
- }
- }
- } else {
- if len(c.args) < c.methodType.NumIn()-1 {
- return fmt.Errorf("Expected call at %s has the wrong number of matchers. Got: %d, want: %d",
- c.origin, len(c.args), c.methodType.NumIn()-1)
- }
- if len(c.args) != c.methodType.NumIn() && len(args) != len(c.args) {
- return fmt.Errorf("Expected call at %s has the wrong number of arguments. Got: %d, want: %d",
- c.origin, len(args), len(c.args))
- }
- if len(args) < len(c.args)-1 {
- return fmt.Errorf("Expected call at %s has the wrong number of arguments. Got: %d, want: greater than or equal to %d",
- c.origin, len(args), len(c.args)-1)
- }
-
- for i, m := range c.args {
- if i < c.methodType.NumIn()-1 {
- // Non-variadic args
- if !m.Matches(args[i]) {
- return fmt.Errorf("Expected call at %s doesn't match the argument at index %s.\nGot: %v\nWant: %v",
- c.origin, strconv.Itoa(i), args[i], m)
- }
- continue
- }
- // The last arg has a possibility of a variadic argument, so let it branch
-
- // sample: Foo(a int, b int, c ...int)
- if i < len(c.args) && i < len(args) {
- if m.Matches(args[i]) {
- // Got Foo(a, b, c) want Foo(matcherA, matcherB, gomock.Any())
- // Got Foo(a, b, c) want Foo(matcherA, matcherB, someSliceMatcher)
- // Got Foo(a, b, c) want Foo(matcherA, matcherB, matcherC)
- // Got Foo(a, b) want Foo(matcherA, matcherB)
- // Got Foo(a, b, c, d) want Foo(matcherA, matcherB, matcherC, matcherD)
- continue
- }
- }
-
- // The number of actual args don't match the number of matchers,
- // or the last matcher is a slice and the last arg is not.
- // If this function still matches it is because the last matcher
- // matches all the remaining arguments or the lack of any.
- // Convert the remaining arguments, if any, into a slice of the
- // expected type.
- vargsType := c.methodType.In(c.methodType.NumIn() - 1)
- vargs := reflect.MakeSlice(vargsType, 0, len(args)-i)
- for _, arg := range args[i:] {
- vargs = reflect.Append(vargs, reflect.ValueOf(arg))
- }
- if m.Matches(vargs.Interface()) {
- // Got Foo(a, b, c, d, e) want Foo(matcherA, matcherB, gomock.Any())
- // Got Foo(a, b, c, d, e) want Foo(matcherA, matcherB, someSliceMatcher)
- // Got Foo(a, b) want Foo(matcherA, matcherB, gomock.Any())
- // Got Foo(a, b) want Foo(matcherA, matcherB, someEmptySliceMatcher)
- break
- }
- // Wrong number of matchers or not match. Fail.
- // Got Foo(a, b) want Foo(matcherA, matcherB, matcherC, matcherD)
- // Got Foo(a, b, c) want Foo(matcherA, matcherB, matcherC, matcherD)
- // Got Foo(a, b, c, d) want Foo(matcherA, matcherB, matcherC, matcherD, matcherE)
- // Got Foo(a, b, c, d, e) want Foo(matcherA, matcherB, matcherC, matcherD)
- // Got Foo(a, b, c) want Foo(matcherA, matcherB)
- return fmt.Errorf("Expected call at %s doesn't match the argument at index %s.\nGot: %v\nWant: %v",
- c.origin, strconv.Itoa(i), args[i:], c.args[i])
-
- }
- }
-
- // Check that all prerequisite calls have been satisfied.
- for _, preReqCall := range c.preReqs {
- if !preReqCall.satisfied() {
- return fmt.Errorf("Expected call at %s doesn't have a prerequisite call satisfied:\n%v\nshould be called before:\n%v",
- c.origin, preReqCall, c)
- }
- }
-
- // Check that the call is not exhausted.
- if c.exhausted() {
- return fmt.Errorf("Expected call at %s has already been called the max number of times.", c.origin)
- }
-
- return nil
-}
-
-// dropPrereqs tells the expected Call to not re-check prerequisite calls any
-// longer, and to return its current set.
-func (c *Call) dropPrereqs() (preReqs []*Call) {
- preReqs = c.preReqs
- c.preReqs = nil
- return
-}
-
-func (c *Call) call(args []interface{}) []func([]interface{}) []interface{} {
- c.numCalls++
- return c.actions
-}
-
-// InOrder declares that the given calls should occur in order.
-func InOrder(calls ...*Call) {
- for i := 1; i < len(calls); i++ {
- calls[i].After(calls[i-1])
- }
-}
-
-func setSlice(arg interface{}, v reflect.Value) {
- va := reflect.ValueOf(arg)
- for i := 0; i < v.Len(); i++ {
- va.Index(i).Set(v.Index(i))
- }
-}
-
-func (c *Call) addAction(action func([]interface{}) []interface{}) {
- c.actions = append(c.actions, action)
-}
diff --git a/vendor/github.com/golang/mock/gomock/callset.go b/vendor/github.com/golang/mock/gomock/callset.go
deleted file mode 100644
index c44a8a5..0000000
--- a/vendor/github.com/golang/mock/gomock/callset.go
+++ /dev/null
@@ -1,108 +0,0 @@
-// Copyright 2011 Google Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package gomock
-
-import (
- "bytes"
- "fmt"
-)
-
-// callSet represents a set of expected calls, indexed by receiver and method
-// name.
-type callSet struct {
- // Calls that are still expected.
- expected map[callSetKey][]*Call
- // Calls that have been exhausted.
- exhausted map[callSetKey][]*Call
-}
-
-// callSetKey is the key in the maps in callSet
-type callSetKey struct {
- receiver interface{}
- fname string
-}
-
-func newCallSet() *callSet {
- return &callSet{make(map[callSetKey][]*Call), make(map[callSetKey][]*Call)}
-}
-
-// Add adds a new expected call.
-func (cs callSet) Add(call *Call) {
- key := callSetKey{call.receiver, call.method}
- m := cs.expected
- if call.exhausted() {
- m = cs.exhausted
- }
- m[key] = append(m[key], call)
-}
-
-// Remove removes an expected call.
-func (cs callSet) Remove(call *Call) {
- key := callSetKey{call.receiver, call.method}
- calls := cs.expected[key]
- for i, c := range calls {
- if c == call {
- // maintain order for remaining calls
- cs.expected[key] = append(calls[:i], calls[i+1:]...)
- cs.exhausted[key] = append(cs.exhausted[key], call)
- break
- }
- }
-}
-
-// FindMatch searches for a matching call. Returns error with explanation message if no call matched.
-func (cs callSet) FindMatch(receiver interface{}, method string, args []interface{}) (*Call, error) {
- key := callSetKey{receiver, method}
-
- // Search through the expected calls.
- expected := cs.expected[key]
- var callsErrors bytes.Buffer
- for _, call := range expected {
- err := call.matches(args)
- if err != nil {
- fmt.Fprintf(&callsErrors, "\n%v", err)
- } else {
- return call, nil
- }
- }
-
- // If we haven't found a match then search through the exhausted calls so we
- // get useful error messages.
- exhausted := cs.exhausted[key]
- for _, call := range exhausted {
- if err := call.matches(args); err != nil {
- fmt.Fprintf(&callsErrors, "\n%v", err)
- }
- }
-
- if len(expected)+len(exhausted) == 0 {
- fmt.Fprintf(&callsErrors, "there are no expected calls of the method %q for that receiver", method)
- }
-
- return nil, fmt.Errorf(callsErrors.String())
-}
-
-// Failures returns the calls that are not satisfied.
-func (cs callSet) Failures() []*Call {
- failures := make([]*Call, 0, len(cs.expected))
- for _, calls := range cs.expected {
- for _, call := range calls {
- if !call.satisfied() {
- failures = append(failures, call)
- }
- }
- }
- return failures
-}
diff --git a/vendor/github.com/golang/mock/gomock/controller.go b/vendor/github.com/golang/mock/gomock/controller.go
deleted file mode 100644
index 0651c91..0000000
--- a/vendor/github.com/golang/mock/gomock/controller.go
+++ /dev/null
@@ -1,264 +0,0 @@
-// Copyright 2010 Google Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-// Package gomock is a mock framework for Go.
-//
-// Standard usage:
-// (1) Define an interface that you wish to mock.
-// type MyInterface interface {
-// SomeMethod(x int64, y string)
-// }
-// (2) Use mockgen to generate a mock from the interface.
-// (3) Use the mock in a test:
-// func TestMyThing(t *testing.T) {
-// mockCtrl := gomock.NewController(t)
-// defer mockCtrl.Finish()
-//
-// mockObj := something.NewMockMyInterface(mockCtrl)
-// mockObj.EXPECT().SomeMethod(4, "blah")
-// // pass mockObj to a real object and play with it.
-// }
-//
-// By default, expected calls are not enforced to run in any particular order.
-// Call order dependency can be enforced by use of InOrder and/or Call.After.
-// Call.After can create more varied call order dependencies, but InOrder is
-// often more convenient.
-//
-// The following examples create equivalent call order dependencies.
-//
-// Example of using Call.After to chain expected call order:
-//
-// firstCall := mockObj.EXPECT().SomeMethod(1, "first")
-// secondCall := mockObj.EXPECT().SomeMethod(2, "second").After(firstCall)
-// mockObj.EXPECT().SomeMethod(3, "third").After(secondCall)
-//
-// Example of using InOrder to declare expected call order:
-//
-// gomock.InOrder(
-// mockObj.EXPECT().SomeMethod(1, "first"),
-// mockObj.EXPECT().SomeMethod(2, "second"),
-// mockObj.EXPECT().SomeMethod(3, "third"),
-// )
-//
-// TODO:
-// - Handle different argument/return types (e.g. ..., chan, map, interface).
-package gomock
-
-import (
- "context"
- "fmt"
- "reflect"
- "runtime"
- "sync"
-)
-
-// 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{})
-}
-
-// 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 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(st)
-// 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
- mu sync.Mutex
- expectedCalls *callSet
- finished bool
-}
-
-// NewController returns a new Controller. It is the preferred way to create a
-// Controller.
-func NewController(t TestReporter) *Controller {
- h, ok := t.(TestHelper)
- if !ok {
- h = nopTestHelper{t}
- }
-
- return &Controller{
- T: h,
- expectedCalls: newCallSet(),
- }
-}
-
-type cancelReporter struct {
- TestHelper
- cancel func()
-}
-
-func (r *cancelReporter) Errorf(format string, args ...interface{}) {
- r.TestHelper.Errorf(format, args...)
-}
-func (r *cancelReporter) Fatalf(format string, args ...interface{}) {
- defer r.cancel()
- r.TestHelper.Fatalf(format, args...)
-}
-
-// WithContext returns a new Controller and a Context, which is cancelled on any
-// fatal failure.
-func WithContext(ctx context.Context, t TestReporter) (*Controller, context.Context) {
- h, ok := t.(TestHelper)
- if !ok {
- h = nopTestHelper{t}
- }
-
- ctx, cancel := context.WithCancel(ctx)
- return NewController(&cancelReporter{h, cancel}), ctx
-}
-
-type nopTestHelper struct {
- TestReporter
-}
-
-func (h nopTestHelper) Helper() {}
-
-// RecordCall is called by a mock. It should not be called by user code.
-func (ctrl *Controller) RecordCall(receiver interface{}, method string, args ...interface{}) *Call {
- ctrl.T.Helper()
-
- recv := reflect.ValueOf(receiver)
- for i := 0; i < recv.Type().NumMethod(); i++ {
- if recv.Type().Method(i).Name == method {
- return ctrl.RecordCallWithMethodType(receiver, method, recv.Method(i).Type(), args...)
- }
- }
- ctrl.T.Fatalf("gomock: failed finding method %s on %T", method, receiver)
- panic("unreachable")
-}
-
-// RecordCallWithMethodType 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 {
- ctrl.T.Helper()
-
- call := newCall(ctrl.T, receiver, method, methodType, args...)
-
- ctrl.mu.Lock()
- defer ctrl.mu.Unlock()
- ctrl.expectedCalls.Add(call)
-
- return call
-}
-
-// Call is called by a mock. It should not be called by user code.
-func (ctrl *Controller) Call(receiver interface{}, method string, args ...interface{}) []interface{} {
- ctrl.T.Helper()
-
- // Nest this code so we can use defer to make sure the lock is released.
- actions := func() []func([]interface{}) []interface{} {
- ctrl.T.Helper()
- ctrl.mu.Lock()
- defer ctrl.mu.Unlock()
-
- expected, err := ctrl.expectedCalls.FindMatch(receiver, method, args)
- if err != nil {
- origin := callerInfo(2)
- ctrl.T.Fatalf("Unexpected call to %T.%v(%v) at %s because: %s", receiver, method, args, origin, err)
- }
-
- // Two things happen here:
- // * the matching call no longer needs to check prerequite calls,
- // * and the prerequite calls are no longer expected, so remove them.
- preReqCalls := expected.dropPrereqs()
- for _, preReqCall := range preReqCalls {
- ctrl.expectedCalls.Remove(preReqCall)
- }
-
- actions := expected.call(args)
- if expected.exhausted() {
- ctrl.expectedCalls.Remove(expected)
- }
- return actions
- }()
-
- var rets []interface{}
- for _, action := range actions {
- if r := action(args); r != nil {
- rets = r
- }
- }
-
- return rets
-}
-
-// 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.
-func (ctrl *Controller) Finish() {
- ctrl.T.Helper()
-
- ctrl.mu.Lock()
- defer ctrl.mu.Unlock()
-
- if ctrl.finished {
- ctrl.T.Fatalf("Controller.Finish was called more than once. It has to be called exactly once.")
- }
- ctrl.finished = true
-
- // If we're currently panicking, probably because this is a deferred call,
- // pass through the panic.
- if err := recover(); err != nil {
- panic(err)
- }
-
- // Check that all remaining expected calls are satisfied.
- failures := ctrl.expectedCalls.Failures()
- for _, call := range failures {
- ctrl.T.Errorf("missing call(s) to %v", call)
- }
- if len(failures) != 0 {
- ctrl.T.Fatalf("aborting test due to missing call(s)")
- }
-}
-
-func callerInfo(skip int) string {
- if _, file, line, ok := runtime.Caller(skip + 1); ok {
- return fmt.Sprintf("%s:%d", file, line)
- }
- return "unknown file"
-}
diff --git a/vendor/github.com/golang/mock/gomock/matchers.go b/vendor/github.com/golang/mock/gomock/matchers.go
deleted file mode 100644
index fbff060..0000000
--- a/vendor/github.com/golang/mock/gomock/matchers.go
+++ /dev/null
@@ -1,141 +0,0 @@
-// Copyright 2010 Google Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package gomock
-
-import (
- "fmt"
- "reflect"
-)
-
-// 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
-}
-
-type anyMatcher struct{}
-
-func (anyMatcher) Matches(x interface{}) bool {
- return true
-}
-
-func (anyMatcher) String() string {
- return "is anything"
-}
-
-type eqMatcher struct {
- x interface{}
-}
-
-func (e eqMatcher) Matches(x interface{}) bool {
- return reflect.DeepEqual(e.x, x)
-}
-
-func (e eqMatcher) String() string {
- return fmt.Sprintf("is equal to %v", e.x)
-}
-
-type nilMatcher struct{}
-
-func (nilMatcher) Matches(x interface{}) bool {
- if x == nil {
- return true
- }
-
- v := reflect.ValueOf(x)
- switch v.Kind() {
- case reflect.Chan, reflect.Func, reflect.Interface, reflect.Map,
- reflect.Ptr, reflect.Slice:
- return v.IsNil()
- }
-
- return false
-}
-
-func (nilMatcher) String() string {
- return "is nil"
-}
-
-type notMatcher struct {
- m Matcher
-}
-
-func (n notMatcher) Matches(x interface{}) bool {
- return !n.m.Matches(x)
-}
-
-func (n notMatcher) String() string {
- // TODO: Improve this if we add a NotString method to the Matcher interface.
- return "not(" + n.m.String() + ")"
-}
-
-type assignableToTypeOfMatcher struct {
- targetType reflect.Type
-}
-
-func (m assignableToTypeOfMatcher) Matches(x interface{}) bool {
- return reflect.TypeOf(x).AssignableTo(m.targetType)
-}
-
-func (m assignableToTypeOfMatcher) String() string {
- return "is assignable to " + m.targetType.Name()
-}
-
-// Constructors
-// Any returns a matcher that always matches.
-func Any() Matcher { return anyMatcher{} }
-
-// Eq returns a matcher that matches on equality.
-//
-// Example usage:
-// Eq(5).Matches(5) // returns true
-// Eq(5).Matches(4) // returns false
-func Eq(x interface{}) Matcher { return eqMatcher{x} }
-
-// 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 Nil() Matcher { return nilMatcher{} }
-
-// 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 Not(x interface{}) Matcher {
- if m, ok := x.(Matcher); ok {
- return notMatcher{m}
- }
- return notMatcher{Eq(x)}
-}
-
-// 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
-func AssignableToTypeOf(x interface{}) Matcher {
- return assignableToTypeOfMatcher{reflect.TypeOf(x)}
-}