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.go20
-rw-r--r--vendor/github.com/golang/mock/gomock/call_test.go51
-rw-r--r--vendor/github.com/golang/mock/gomock/callset_test.go76
-rw-r--r--vendor/github.com/golang/mock/gomock/controller.go119
-rw-r--r--vendor/github.com/golang/mock/gomock/controller_test.go712
-rw-r--r--vendor/github.com/golang/mock/gomock/matchers.go50
-rw-r--r--vendor/github.com/golang/mock/gomock/matchers_test.go70
-rw-r--r--vendor/github.com/golang/mock/gomock/mock_matcher/mock_matcher.go57
8 files changed, 135 insertions, 1020 deletions
diff --git a/vendor/github.com/golang/mock/gomock/call.go b/vendor/github.com/golang/mock/gomock/call.go
index a3fa1ae..3d54d9f 100644
--- a/vendor/github.com/golang/mock/gomock/call.go
+++ b/vendor/github.com/golang/mock/gomock/call.go
@@ -23,7 +23,7 @@ import (
// Call represents an expected call to a mock.
type Call struct {
- t TestReporter // for triggering test failures on invalid call setup
+ 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
@@ -46,10 +46,8 @@ type Call struct {
// newCall creates a *Call. It requires the method type in order to support
// unexported methods.
-func newCall(t TestReporter, receiver interface{}, method string, methodType reflect.Type, args ...interface{}) *Call {
- if h, ok := t.(testHelper); ok {
- h.Helper()
- }
+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))
@@ -159,9 +157,7 @@ func (c *Call) Do(f interface{}) *Call {
// Return declares the values to be returned by the mocked function call.
func (c *Call) Return(rets ...interface{}) *Call {
- if h, ok := c.t.(testHelper); ok {
- h.Helper()
- }
+ c.t.Helper()
mt := c.methodType
if len(rets) != mt.NumOut() {
@@ -209,9 +205,7 @@ func (c *Call) Times(n int) *Call {
// 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 {
- if h, ok := c.t.(testHelper); ok {
- h.Helper()
- }
+ c.t.Helper()
mt := c.methodType
// TODO: This will break on variadic methods.
@@ -264,9 +258,7 @@ func (c *Call) isPreReq(other *Call) bool {
// After declares that the call may only match after preReq has been exhausted.
func (c *Call) After(preReq *Call) *Call {
- if h, ok := c.t.(testHelper); ok {
- h.Helper()
- }
+ c.t.Helper()
if c == preReq {
c.t.Fatalf("A call isn't allowed to be its own prerequisite")
diff --git a/vendor/github.com/golang/mock/gomock/call_test.go b/vendor/github.com/golang/mock/gomock/call_test.go
deleted file mode 100644
index 3a8315b..0000000
--- a/vendor/github.com/golang/mock/gomock/call_test.go
+++ /dev/null
@@ -1,51 +0,0 @@
-package gomock
-
-import (
- "testing"
-)
-
-type mockTestReporter struct {
- errorCalls int
- fatalCalls int
-}
-
-func (o *mockTestReporter) Errorf(format string, args ...interface{}) {
- o.errorCalls++
-}
-
-func (o *mockTestReporter) Fatalf(format string, args ...interface{}) {
- o.fatalCalls++
-}
-
-func (o *mockTestReporter) Helper() {}
-
-func TestCall_After(t *testing.T) {
- t.Run("SelfPrereqCallsFatalf", func(t *testing.T) {
- tr1 := &mockTestReporter{}
-
- c := &Call{t: tr1}
- c.After(c)
-
- if tr1.fatalCalls != 1 {
- t.Errorf("number of fatal calls == %v, want 1", tr1.fatalCalls)
- }
- })
-
- t.Run("LoopInCallOrderCallsFatalf", func(t *testing.T) {
- tr1 := &mockTestReporter{}
- tr2 := &mockTestReporter{}
-
- c1 := &Call{t: tr1}
- c2 := &Call{t: tr2}
- c1.After(c2)
- c2.After(c1)
-
- if tr1.errorCalls != 0 || tr1.fatalCalls != 0 {
- t.Error("unexpected errors")
- }
-
- if tr2.fatalCalls != 1 {
- t.Errorf("number of fatal calls == %v, want 1", tr2.fatalCalls)
- }
- })
-}
diff --git a/vendor/github.com/golang/mock/gomock/callset_test.go b/vendor/github.com/golang/mock/gomock/callset_test.go
deleted file mode 100644
index 7fc711a..0000000
--- a/vendor/github.com/golang/mock/gomock/callset_test.go
+++ /dev/null
@@ -1,76 +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 (
- "reflect"
- "testing"
-)
-
-type receiverType struct{}
-
-func (receiverType) Func() {}
-
-func TestCallSetAdd(t *testing.T) {
- method := "TestMethod"
- var receiver interface{} = "TestReceiver"
- cs := newCallSet()
-
- numCalls := 10
- for i := 0; i < numCalls; i++ {
- cs.Add(newCall(t, receiver, method, reflect.TypeOf(receiverType{}.Func)))
- }
-
- call, err := cs.FindMatch(receiver, method, []interface{}{})
- if err != nil {
- t.Fatalf("FindMatch: %v", err)
- }
- if call == nil {
- t.Fatalf("FindMatch: Got nil, want non-nil *Call")
- }
-}
-
-func TestCallSetRemove(t *testing.T) {
- method := "TestMethod"
- var receiver interface{} = "TestReceiver"
-
- cs := newCallSet()
- ourCalls := []*Call{}
-
- numCalls := 10
- for i := 0; i < numCalls; i++ {
- // NOTE: abuse the `numCalls` value to convey initial ordering of mocked calls
- generatedCall := &Call{receiver: receiver, method: method, numCalls: i}
- cs.Add(generatedCall)
- ourCalls = append(ourCalls, generatedCall)
- }
-
- // validateOrder validates that the calls in the array are ordered as they were added
- validateOrder := func(calls []*Call) {
- // lastNum tracks the last `numCalls` (call order) value seen
- lastNum := -1
- for _, c := range calls {
- if lastNum >= c.numCalls {
- t.Errorf("found call %d after call %d", c.numCalls, lastNum)
- }
- lastNum = c.numCalls
- }
- }
-
- for _, c := range ourCalls {
- validateOrder(cs.expected[callSetKey{receiver, method}])
- cs.Remove(c)
- }
-}
diff --git a/vendor/github.com/golang/mock/gomock/controller.go b/vendor/github.com/golang/mock/gomock/controller.go
index a7b7918..0651c91 100644
--- a/vendor/github.com/golang/mock/gomock/controller.go
+++ b/vendor/github.com/golang/mock/gomock/controller.go
@@ -12,7 +12,7 @@
// See the License for the specific language governing permissions and
// limitations under the License.
-// GoMock - a mock framework for Go.
+// Package gomock is a mock framework for Go.
//
// Standard usage:
// (1) Define an interface that you wish to mock.
@@ -56,59 +56,111 @@
package gomock
import (
+ "context"
"fmt"
- "golang.org/x/net/context"
"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.
+// 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{})
}
-// 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.
+// 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
- t TestReporter
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: t,
+ T: h,
expectedCalls: newCallSet(),
}
}
type cancelReporter struct {
- t TestReporter
+ TestHelper
cancel func()
}
-func (r *cancelReporter) Errorf(format string, args ...interface{}) { r.t.Errorf(format, args...) }
+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.t.Fatalf(format, args...)
+ 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{t, cancel}), 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 {
- if h, ok := ctrl.t.(testHelper); ok {
- h.Helper()
- }
+ ctrl.T.Helper()
recv := reflect.ValueOf(receiver)
for i := 0; i < recv.Type().NumMethod(); i++ {
@@ -116,16 +168,15 @@ func (ctrl *Controller) RecordCall(receiver interface{}, method string, args ...
return ctrl.RecordCallWithMethodType(receiver, method, recv.Method(i).Type(), args...)
}
}
- ctrl.t.Fatalf("gomock: failed finding method %s on %T", method, receiver)
+ 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 {
- if h, ok := ctrl.t.(testHelper); ok {
- h.Helper()
- }
+ ctrl.T.Helper()
- call := newCall(ctrl.t, receiver, method, methodType, args...)
+ call := newCall(ctrl.T, receiver, method, methodType, args...)
ctrl.mu.Lock()
defer ctrl.mu.Unlock()
@@ -134,20 +185,20 @@ func (ctrl *Controller) RecordCallWithMethodType(receiver interface{}, method st
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{} {
- if h, ok := ctrl.t.(testHelper); ok {
- h.Helper()
- }
+ 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)
+ ctrl.T.Fatalf("Unexpected call to %T.%v(%v) at %s because: %s", receiver, method, args, origin, err)
}
// Two things happen here:
@@ -175,16 +226,17 @@ func (ctrl *Controller) Call(receiver interface{}, method string, args ...interf
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() {
- if h, ok := ctrl.t.(testHelper); ok {
- h.Helper()
- }
+ 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.T.Fatalf("Controller.Finish was called more than once. It has to be called exactly once.")
}
ctrl.finished = true
@@ -197,10 +249,10 @@ func (ctrl *Controller) Finish() {
// 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)
+ ctrl.T.Errorf("missing call(s) to %v", call)
}
if len(failures) != 0 {
- ctrl.t.Fatalf("aborting test due to missing call(s)")
+ ctrl.T.Fatalf("aborting test due to missing call(s)")
}
}
@@ -210,8 +262,3 @@ func callerInfo(skip int) string {
}
return "unknown file"
}
-
-type testHelper interface {
- TestReporter
- Helper()
-}
diff --git a/vendor/github.com/golang/mock/gomock/controller_test.go b/vendor/github.com/golang/mock/gomock/controller_test.go
deleted file mode 100644
index b3bb4de..0000000
--- a/vendor/github.com/golang/mock/gomock/controller_test.go
+++ /dev/null
@@ -1,712 +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_test
-
-import (
- "fmt"
- "reflect"
- "testing"
-
- "strings"
-
- "github.com/golang/mock/gomock"
-)
-
-type ErrorReporter struct {
- t *testing.T
- log []string
- failed bool
- fatalToken struct{}
-}
-
-func NewErrorReporter(t *testing.T) *ErrorReporter {
- return &ErrorReporter{t: t}
-}
-
-func (e *ErrorReporter) reportLog() {
- for _, entry := range e.log {
- e.t.Log(entry)
- }
-}
-
-func (e *ErrorReporter) assertPass(msg string) {
- if e.failed {
- e.t.Errorf("Expected pass, but got failure(s): %s", msg)
- e.reportLog()
- }
-}
-
-func (e *ErrorReporter) assertFail(msg string) {
- if !e.failed {
- e.t.Errorf("Expected failure, but got pass: %s", msg)
- }
-}
-
-// Use to check that code triggers a fatal test failure.
-func (e *ErrorReporter) assertFatal(fn func(), expectedErrMsgs ...string) {
- defer func() {
- err := recover()
- if err == nil {
- var actual string
- if e.failed {
- actual = "non-fatal failure"
- } else {
- actual = "pass"
- }
- e.t.Error("Expected fatal failure, but got a", actual)
- } else if token, ok := err.(*struct{}); ok && token == &e.fatalToken {
- // This is okay - the panic is from Fatalf().
- if expectedErrMsgs != nil {
- // assert that the actual error message
- // contains expectedErrMsgs
-
- // check the last actualErrMsg, because the previous messages come from previous errors
- actualErrMsg := e.log[len(e.log)-1]
- for _, expectedErrMsg := range expectedErrMsgs {
- if !strings.Contains(actualErrMsg, expectedErrMsg) {
- e.t.Errorf("Error message:\ngot: %q\nwant to contain: %q\n", actualErrMsg, expectedErrMsg)
- }
- }
- }
- return
- } else {
- // Some other panic.
- panic(err)
- }
- }()
-
- fn()
-}
-
-// recoverUnexpectedFatal can be used as a deferred call in test cases to
-// recover from and display a call to ErrorReporter.Fatalf().
-func (e *ErrorReporter) recoverUnexpectedFatal() {
- err := recover()
- if err == nil {
- // No panic.
- } else if token, ok := err.(*struct{}); ok && token == &e.fatalToken {
- // Unexpected fatal error happened.
- e.t.Error("Got unexpected fatal error(s). All errors up to this point:")
- e.reportLog()
- return
- } else {
- // Some other panic.
- panic(err)
- }
-}
-
-func (e *ErrorReporter) Logf(format string, args ...interface{}) {
- e.log = append(e.log, fmt.Sprintf(format, args...))
-}
-
-func (e *ErrorReporter) Errorf(format string, args ...interface{}) {
- e.Logf(format, args...)
- e.failed = true
-}
-
-func (e *ErrorReporter) Fatalf(format string, args ...interface{}) {
- e.Logf(format, args...)
- e.failed = true
- panic(&e.fatalToken)
-}
-
-// A type purely for use as a receiver in testing the Controller.
-type Subject struct{}
-
-func (s *Subject) FooMethod(arg string) int {
- return 0
-}
-
-func (s *Subject) BarMethod(arg string) int {
- return 0
-}
-
-func (s *Subject) VariadicMethod(arg int, vararg ...string) {}
-
-// A type purely for ActOnTestStructMethod
-type TestStruct struct {
- Number int
- Message string
-}
-
-func (s *Subject) ActOnTestStructMethod(arg TestStruct, arg1 int) int {
- return 0
-}
-
-func (s *Subject) SetArgMethod(sliceArg []byte, ptrArg *int) {}
-
-func assertEqual(t *testing.T, expected interface{}, actual interface{}) {
- if !reflect.DeepEqual(expected, actual) {
- t.Errorf("Expected %+v, but got %+v", expected, actual)
- }
-}
-
-func createFixtures(t *testing.T) (reporter *ErrorReporter, ctrl *gomock.Controller) {
- // reporter acts as a testing.T-like object that we pass to the
- // Controller. We use it to test that the mock considered tests
- // successful or failed.
- reporter = NewErrorReporter(t)
- ctrl = gomock.NewController(reporter)
- return
-}
-
-func TestNoCalls(t *testing.T) {
- reporter, ctrl := createFixtures(t)
- ctrl.Finish()
- reporter.assertPass("No calls expected or made.")
-}
-
-func TestNoRecordedCallsForAReceiver(t *testing.T) {
- reporter, ctrl := createFixtures(t)
- subject := new(Subject)
-
- reporter.assertFatal(func() {
- ctrl.Call(subject, "NotRecordedMethod", "argument")
- }, "Unexpected call to", "there are no expected calls of the method \"NotRecordedMethod\" for that receiver")
- ctrl.Finish()
-}
-
-func TestNoRecordedMatchingMethodNameForAReceiver(t *testing.T) {
- reporter, ctrl := createFixtures(t)
- subject := new(Subject)
-
- ctrl.RecordCall(subject, "FooMethod", "argument")
- reporter.assertFatal(func() {
- ctrl.Call(subject, "NotRecordedMethod", "argument")
- }, "Unexpected call to", "there are no expected calls of the method \"NotRecordedMethod\" for that receiver")
- reporter.assertFatal(func() {
- // The expected call wasn't made.
- ctrl.Finish()
- })
-}
-
-// This tests that a call with an arguments of some primitive type matches a recorded call.
-func TestExpectedMethodCall(t *testing.T) {
- reporter, ctrl := createFixtures(t)
- subject := new(Subject)
-
- ctrl.RecordCall(subject, "FooMethod", "argument")
- ctrl.Call(subject, "FooMethod", "argument")
- ctrl.Finish()
-
- reporter.assertPass("Expected method call made.")
-}
-
-func TestUnexpectedMethodCall(t *testing.T) {
- reporter, ctrl := createFixtures(t)
- subject := new(Subject)
-
- reporter.assertFatal(func() {
- ctrl.Call(subject, "FooMethod", "argument")
- })
-
- ctrl.Finish()
-}
-
-func TestRepeatedCall(t *testing.T) {
- reporter, ctrl := createFixtures(t)
- subject := new(Subject)
-
- ctrl.RecordCall(subject, "FooMethod", "argument").Times(3)
- ctrl.Call(subject, "FooMethod", "argument")
- ctrl.Call(subject, "FooMethod", "argument")
- ctrl.Call(subject, "FooMethod", "argument")
- reporter.assertPass("After expected repeated method calls.")
- reporter.assertFatal(func() {
- ctrl.Call(subject, "FooMethod", "argument")
- })
- ctrl.Finish()
- reporter.assertFail("After calling one too many times.")
-}
-
-func TestUnexpectedArgCount(t *testing.T) {
- reporter, ctrl := createFixtures(t)
- defer reporter.recoverUnexpectedFatal()
- subject := new(Subject)
-
- ctrl.RecordCall(subject, "FooMethod", "argument")
- reporter.assertFatal(func() {
- // This call is made with the wrong number of arguments...
- ctrl.Call(subject, "FooMethod", "argument", "extra_argument")
- }, "Unexpected call to", "wrong number of arguments", "Got: 2, want: 1")
- reporter.assertFatal(func() {
- // ... so is this.
- ctrl.Call(subject, "FooMethod")
- }, "Unexpected call to", "wrong number of arguments", "Got: 0, want: 1")
- reporter.assertFatal(func() {
- // The expected call wasn't made.
- ctrl.Finish()
- })
-}
-
-// This tests that a call with complex arguments (a struct and some primitive type) matches a recorded call.
-func TestExpectedMethodCall_CustomStruct(t *testing.T) {
- reporter, ctrl := createFixtures(t)
- subject := new(Subject)
-
- expectedArg0 := TestStruct{Number: 123, Message: "hello"}
- ctrl.RecordCall(subject, "ActOnTestStructMethod", expectedArg0, 15)
- ctrl.Call(subject, "ActOnTestStructMethod", expectedArg0, 15)
-
- reporter.assertPass("Expected method call made.")
-}
-
-func TestUnexpectedArgValue_FirstArg(t *testing.T) {
- reporter, ctrl := createFixtures(t)
- defer reporter.recoverUnexpectedFatal()
- subject := new(Subject)
-
- expectedArg0 := TestStruct{Number: 123, Message: "hello"}
- ctrl.RecordCall(subject, "ActOnTestStructMethod", expectedArg0, 15)
-
- reporter.assertFatal(func() {
- // the method argument (of TestStruct type) has 1 unexpected value (for the Message field)
- ctrl.Call(subject, "ActOnTestStructMethod", TestStruct{Number: 123, Message: "no message"}, 15)
- }, "Unexpected call to", "doesn't match the argument at index 0",
- "Got: {123 no message}\nWant: is equal to {123 hello}")
-
- reporter.assertFatal(func() {
- // the method argument (of TestStruct type) has 2 unexpected values (for both fields)
- ctrl.Call(subject, "ActOnTestStructMethod", TestStruct{Number: 11, Message: "no message"}, 15)
- }, "Unexpected call to", "doesn't match the argument at index 0",
- "Got: {11 no message}\nWant: is equal to {123 hello}")
-
- reporter.assertFatal(func() {
- // The expected call wasn't made.
- ctrl.Finish()
- })
-}
-
-func TestUnexpectedArgValue_SecondtArg(t *testing.T) {
- reporter, ctrl := createFixtures(t)
- defer reporter.recoverUnexpectedFatal()
- subject := new(Subject)
-
- expectedArg0 := TestStruct{Number: 123, Message: "hello"}
- ctrl.RecordCall(subject, "ActOnTestStructMethod", expectedArg0, 15)
-
- reporter.assertFatal(func() {
- ctrl.Call(subject, "ActOnTestStructMethod", TestStruct{Number: 123, Message: "hello"}, 3)
- }, "Unexpected call to", "doesn't match the argument at index 1",
- "Got: 3\nWant: is equal to 15")
-
- reporter.assertFatal(func() {
- // The expected call wasn't made.
- ctrl.Finish()
- })
-}
-
-func TestAnyTimes(t *testing.T) {
- reporter, ctrl := createFixtures(t)
- subject := new(Subject)
-
- ctrl.RecordCall(subject, "FooMethod", "argument").AnyTimes()
- for i := 0; i < 100; i++ {
- ctrl.Call(subject, "FooMethod", "argument")
- }
- reporter.assertPass("After 100 method calls.")
- ctrl.Finish()
-}
-
-func TestMinTimes1(t *testing.T) {
- // It fails if there are no calls
- reporter, ctrl := createFixtures(t)
- subject := new(Subject)
- ctrl.RecordCall(subject, "FooMethod", "argument").MinTimes(1)
- reporter.assertFatal(func() {
- ctrl.Finish()
- })
-
- // It succeeds if there is one call
- reporter, ctrl = createFixtures(t)
- subject = new(Subject)
- ctrl.RecordCall(subject, "FooMethod", "argument").MinTimes(1)
- ctrl.Call(subject, "FooMethod", "argument")
- ctrl.Finish()
-
- // It succeeds if there are many calls
- reporter, ctrl = createFixtures(t)
- subject = new(Subject)
- ctrl.RecordCall(subject, "FooMethod", "argument").MinTimes(1)
- for i := 0; i < 100; i++ {
- ctrl.Call(subject, "FooMethod", "argument")
- }
- ctrl.Finish()
-}
-
-func TestMaxTimes1(t *testing.T) {
- // It succeeds if there are no calls
- _, ctrl := createFixtures(t)
- subject := new(Subject)
- ctrl.RecordCall(subject, "FooMethod", "argument").MaxTimes(1)
- ctrl.Finish()
-
- // It succeeds if there is one call
- _, ctrl = createFixtures(t)
- subject = new(Subject)
- ctrl.RecordCall(subject, "FooMethod", "argument").MaxTimes(1)
- ctrl.Call(subject, "FooMethod", "argument")
- ctrl.Finish()
-
- //It fails if there are more
- reporter, ctrl := createFixtures(t)
- subject = new(Subject)
- ctrl.RecordCall(subject, "FooMethod", "argument").MaxTimes(1)
- ctrl.Call(subject, "FooMethod", "argument")
- reporter.assertFatal(func() {
- ctrl.Call(subject, "FooMethod", "argument")
- })
- ctrl.Finish()
-}
-
-func TestMinMaxTimes(t *testing.T) {
- // It fails if there are less calls than specified
- reporter, ctrl := createFixtures(t)
- subject := new(Subject)
- ctrl.RecordCall(subject, "FooMethod", "argument").MinTimes(2).MaxTimes(2)
- ctrl.Call(subject, "FooMethod", "argument")
- reporter.assertFatal(func() {
- ctrl.Finish()
- })
-
- // It fails if there are more calls than specified
- reporter, ctrl = createFixtures(t)
- subject = new(Subject)
- ctrl.RecordCall(subject, "FooMethod", "argument").MinTimes(2).MaxTimes(2)
- ctrl.Call(subject, "FooMethod", "argument")
- ctrl.Call(subject, "FooMethod", "argument")
- reporter.assertFatal(func() {
- ctrl.Call(subject, "FooMethod", "argument")
- })
-
- // It succeeds if there is just the right number of calls
- reporter, ctrl = createFixtures(t)
- subject = new(Subject)
- ctrl.RecordCall(subject, "FooMethod", "argument").MaxTimes(2).MinTimes(2)
- ctrl.Call(subject, "FooMethod", "argument")
- ctrl.Call(subject, "FooMethod", "argument")
- ctrl.Finish()
-}
-
-func TestDo(t *testing.T) {
- _, ctrl := createFixtures(t)
- subject := new(Subject)
-
- doCalled := false
- var argument string
- ctrl.RecordCall(subject, "FooMethod", "argument").Do(
- func(arg string) {
- doCalled = true
- argument = arg
- })
- if doCalled {
- t.Error("Do() callback called too early.")
- }
-
- ctrl.Call(subject, "FooMethod", "argument")
-
- if !doCalled {
- t.Error("Do() callback not called.")
- }
- if "argument" != argument {
- t.Error("Do callback received wrong argument.")
- }
-
- ctrl.Finish()
-}
-
-func TestDoAndReturn(t *testing.T) {
- _, ctrl := createFixtures(t)
- subject := new(Subject)
-
- doCalled := false
- var argument string
- ctrl.RecordCall(subject, "FooMethod", "argument").DoAndReturn(
- func(arg string) int {
- doCalled = true
- argument = arg
- return 5
- })
- if doCalled {
- t.Error("Do() callback called too early.")
- }
-
- rets := ctrl.Call(subject, "FooMethod", "argument")
-
- if !doCalled {
- t.Error("Do() callback not called.")
- }
- if "argument" != argument {
- t.Error("Do callback received wrong argument.")
- }
- if len(rets) != 1 {
- t.Fatalf("Return values from Call: got %d, want 1", len(rets))
- }
- if ret, ok := rets[0].(int); !ok {
- t.Fatalf("Return value is not an int")
- } else if ret != 5 {
- t.Errorf("DoAndReturn return value: got %d, want 5", ret)
- }
-
- ctrl.Finish()
-}
-
-func TestSetArgSlice(t *testing.T) {
- _, ctrl := createFixtures(t)
- subject := new(Subject)
-
- var in = []byte{4, 5, 6}
- var set = []byte{1, 2, 3}
- ctrl.RecordCall(subject, "SetArgMethod", in, nil).SetArg(0, set)
- ctrl.Call(subject, "SetArgMethod", in, nil)
-
- if !reflect.DeepEqual(in, set) {
- t.Error("Expected SetArg() to modify input slice argument")
- }
-
- ctrl.Finish()
-}
-
-func TestSetArgPtr(t *testing.T) {
- _, ctrl := createFixtures(t)
- subject := new(Subject)
-
- var in int = 43
- const set = 42
- ctrl.RecordCall(subject, "SetArgMethod", nil, &in).SetArg(1, set)
- ctrl.Call(subject, "SetArgMethod", nil, &in)
-
- if in != set {
- t.Error("Expected SetArg() to modify value pointed to by argument")
- }
-
- ctrl.Finish()
-}
-
-func TestReturn(t *testing.T) {
- _, ctrl := createFixtures(t)
- subject := new(Subject)
-
- // Unspecified return should produce "zero" result.
- ctrl.RecordCall(subject, "FooMethod", "zero")
- ctrl.RecordCall(subject, "FooMethod", "five").Return(5)
-
- assertEqual(
- t,
- []interface{}{0},
- ctrl.Call(subject, "FooMethod", "zero"))
-
- assertEqual(
- t,
- []interface{}{5},
- ctrl.Call(subject, "FooMethod", "five"))
- ctrl.Finish()
-}
-
-func TestUnorderedCalls(t *testing.T) {
- reporter, ctrl := createFixtures(t)
- defer reporter.recoverUnexpectedFatal()
- subjectTwo := new(Subject)
- subjectOne := new(Subject)
-
- ctrl.RecordCall(subjectOne, "FooMethod", "1")
- ctrl.RecordCall(subjectOne, "BarMethod", "2")
- ctrl.RecordCall(subjectTwo, "FooMethod", "3")
- ctrl.RecordCall(subjectTwo, "BarMethod", "4")
-
- // Make the calls in a different order, which should be fine.
- ctrl.Call(subjectOne, "BarMethod", "2")
- ctrl.Call(subjectTwo, "FooMethod", "3")
- ctrl.Call(subjectTwo, "BarMethod", "4")
- ctrl.Call(subjectOne, "FooMethod", "1")
-
- reporter.assertPass("After making all calls in different order")
-
- ctrl.Finish()
-
- reporter.assertPass("After finish")
-}
-
-func commonTestOrderedCalls(t *testing.T) (reporter *ErrorReporter, ctrl *gomock.Controller, subjectOne, subjectTwo *Subject) {
- reporter, ctrl = createFixtures(t)
-
- subjectOne = new(Subject)
- subjectTwo = new(Subject)
-
- gomock.InOrder(
- ctrl.RecordCall(subjectOne, "FooMethod", "1").AnyTimes(),
- ctrl.RecordCall(subjectTwo, "FooMethod", "2"),
- ctrl.RecordCall(subjectTwo, "BarMethod", "3"),
- )
-
- return
-}
-
-func TestOrderedCallsCorrect(t *testing.T) {
- reporter, ctrl, subjectOne, subjectTwo := commonTestOrderedCalls(t)
-
- ctrl.Call(subjectOne, "FooMethod", "1")
- ctrl.Call(subjectTwo, "FooMethod", "2")
- ctrl.Call(subjectTwo, "BarMethod", "3")
-
- ctrl.Finish()
-
- reporter.assertPass("After finish")
-}
-
-func TestOrderedCallsInCorrect(t *testing.T) {
- reporter, ctrl, subjectOne, subjectTwo := commonTestOrderedCalls(t)
-
- ctrl.Call(subjectOne, "FooMethod", "1")
- reporter.assertFatal(func() {
- // FooMethod(2) should be called before BarMethod(3)
- ctrl.Call(subjectTwo, "BarMethod", "3")
- }, "Unexpected call to", "Subject.BarMethod([3])", "doesn't have a prerequisite call satisfied")
-}
-
-// Test that calls that are prerequisites to other calls but have maxCalls >
-// minCalls are removed from the expected call set.
-func TestOrderedCallsWithPreReqMaxUnbounded(t *testing.T) {
- reporter, ctrl, subjectOne, subjectTwo := commonTestOrderedCalls(t)
-
- // Initially we should be able to call FooMethod("1") as many times as we
- // want.
- ctrl.Call(subjectOne, "FooMethod", "1")
- ctrl.Call(subjectOne, "FooMethod", "1")
-
- // But calling something that has it as a prerequite should remove it from
- // the expected call set. This allows tests to ensure that FooMethod("1") is
- // *not* called after FooMethod("2").
- ctrl.Call(subjectTwo, "FooMethod", "2")
-
- // Therefore this call should fail:
- reporter.assertFatal(func() {
- ctrl.Call(subjectOne, "FooMethod", "1")
- })
-}
-
-func TestCallAfterLoopPanic(t *testing.T) {
- _, ctrl := createFixtures(t)
-
- subject := new(Subject)
-
- firstCall := ctrl.RecordCall(subject, "FooMethod", "1")
- secondCall := ctrl.RecordCall(subject, "FooMethod", "2")
- thirdCall := ctrl.RecordCall(subject, "FooMethod", "3")
-
- gomock.InOrder(firstCall, secondCall, thirdCall)
-
- defer func() {
- err := recover()
- if err == nil {
- t.Error("Call.After creation of dependency loop did not panic.")
- }
- }()
-
- // This should panic due to dependency loop.
- firstCall.After(thirdCall)
-}
-
-func TestPanicOverridesExpectationChecks(t *testing.T) {
- ctrl := gomock.NewController(t)
- reporter := NewErrorReporter(t)
-
- reporter.assertFatal(func() {
- ctrl.RecordCall(new(Subject), "FooMethod", "1")
- defer ctrl.Finish()
- reporter.Fatalf("Intentional panic")
- })
-}
-
-func TestSetArgWithBadType(t *testing.T) {
- rep, ctrl := createFixtures(t)
- defer ctrl.Finish()
-
- s := new(Subject)
- // This should catch a type error:
- rep.assertFatal(func() {
- ctrl.RecordCall(s, "FooMethod", "1").SetArg(0, "blah")
- })
- ctrl.Call(s, "FooMethod", "1")
-}
-
-func TestTimes0(t *testing.T) {
- rep, ctrl := createFixtures(t)
- defer ctrl.Finish()
-
- s := new(Subject)
- ctrl.RecordCall(s, "FooMethod", "arg").Times(0)
- rep.assertFatal(func() {
- ctrl.Call(s, "FooMethod", "arg")
- })
-}
-
-func TestVariadicMatching(t *testing.T) {
- rep, ctrl := createFixtures(t)
- defer rep.recoverUnexpectedFatal()
-
- s := new(Subject)
- ctrl.RecordCall(s, "VariadicMethod", 0, "1", "2")
- ctrl.Call(s, "VariadicMethod", 0, "1", "2")
- ctrl.Finish()
- rep.assertPass("variadic matching works")
-}
-
-func TestVariadicNoMatch(t *testing.T) {
- rep, ctrl := createFixtures(t)
- defer rep.recoverUnexpectedFatal()
-
- s := new(Subject)
- ctrl.RecordCall(s, "VariadicMethod", 0)
- rep.assertFatal(func() {
- ctrl.Call(s, "VariadicMethod", 1)
- }, "Expected call at", "doesn't match the argument at index 0",
- "Got: 1\nWant: is equal to 0")
- ctrl.Call(s, "VariadicMethod", 0)
- ctrl.Finish()
-}
-
-func TestVariadicMatchingWithSlice(t *testing.T) {
- testCases := [][]string{
- {"1"},
- {"1", "2"},
- }
- for _, tc := range testCases {
- t.Run(fmt.Sprintf("%d arguments", len(tc)), func(t *testing.T) {
- rep, ctrl := createFixtures(t)
- defer rep.recoverUnexpectedFatal()
-
- s := new(Subject)
- ctrl.RecordCall(s, "VariadicMethod", 1, tc)
- args := make([]interface{}, len(tc)+1)
- args[0] = 1
- for i, arg := range tc {
- args[i+1] = arg
- }
- ctrl.Call(s, "VariadicMethod", args...)
- ctrl.Finish()
- rep.assertPass("slices can be used as matchers for variadic arguments")
- })
- }
-}
-
-func TestDuplicateFinishCallFails(t *testing.T) {
- rep, ctrl := createFixtures(t)
-
- ctrl.Finish()
- rep.assertPass("the first Finish call should succeed")
-
- rep.assertFatal(ctrl.Finish, "Controller.Finish was called more than once. It has to be called exactly once.")
-}
diff --git a/vendor/github.com/golang/mock/gomock/matchers.go b/vendor/github.com/golang/mock/gomock/matchers.go
index e8b1ddc..fbff060 100644
--- a/vendor/github.com/golang/mock/gomock/matchers.go
+++ b/vendor/github.com/golang/mock/gomock/matchers.go
@@ -1,5 +1,3 @@
-//go:generate mockgen -destination mock_matcher/mock_matcher.go github.com/golang/mock/gomock Matcher
-
// Copyright 2010 Google Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
@@ -87,13 +85,57 @@ func (n notMatcher) String() string {
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
-func Any() Matcher { return anyMatcher{} }
+// 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} }
-func Nil() Matcher { return nilMatcher{} }
+
+// 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)}
+}
diff --git a/vendor/github.com/golang/mock/gomock/matchers_test.go b/vendor/github.com/golang/mock/gomock/matchers_test.go
deleted file mode 100644
index 29b97fb..0000000
--- a/vendor/github.com/golang/mock/gomock/matchers_test.go
+++ /dev/null
@@ -1,70 +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_test
-
-import (
- "errors"
- "testing"
-
- "github.com/golang/mock/gomock"
- mock_matcher "github.com/golang/mock/gomock/mock_matcher"
-)
-
-func TestMatchers(t *testing.T) {
- type e interface{}
- type testCase struct {
- matcher gomock.Matcher
- yes, no []e
- }
- tests := []testCase{
- testCase{gomock.Any(), []e{3, nil, "foo"}, nil},
- testCase{gomock.Eq(4), []e{4}, []e{3, "blah", nil, int64(4)}},
- testCase{gomock.Nil(),
- []e{nil, (error)(nil), (chan bool)(nil), (*int)(nil)},
- []e{"", 0, make(chan bool), errors.New("err"), new(int)}},
- testCase{gomock.Not(gomock.Eq(4)), []e{3, "blah", nil, int64(4)}, []e{4}},
- }
- for i, test := range tests {
- for _, x := range test.yes {
- if !test.matcher.Matches(x) {
- t.Errorf(`test %d: "%v %s" should be true.`, i, x, test.matcher)
- }
- }
- for _, x := range test.no {
- if test.matcher.Matches(x) {
- t.Errorf(`test %d: "%v %s" should be false.`, i, x, test.matcher)
- }
- }
- }
-}
-
-// A more thorough test of notMatcher
-func TestNotMatcher(t *testing.T) {
- ctrl := gomock.NewController(t)
- defer ctrl.Finish()
-
- mockMatcher := mock_matcher.NewMockMatcher(ctrl)
- notMatcher := gomock.Not(mockMatcher)
-
- mockMatcher.EXPECT().Matches(4).Return(true)
- if match := notMatcher.Matches(4); match {
- t.Errorf("notMatcher should not match 4")
- }
-
- mockMatcher.EXPECT().Matches(5).Return(false)
- if match := notMatcher.Matches(5); !match {
- t.Errorf("notMatcher should match 5")
- }
-}
diff --git a/vendor/github.com/golang/mock/gomock/mock_matcher/mock_matcher.go b/vendor/github.com/golang/mock/gomock/mock_matcher/mock_matcher.go
deleted file mode 100644
index 7e4b4c8..0000000
--- a/vendor/github.com/golang/mock/gomock/mock_matcher/mock_matcher.go
+++ /dev/null
@@ -1,57 +0,0 @@
-// Code generated by MockGen. DO NOT EDIT.
-// Source: github.com/golang/mock/gomock (interfaces: Matcher)
-
-// Package mock_gomock is a generated GoMock package.
-package mock_gomock
-
-import (
- gomock "github.com/golang/mock/gomock"
- reflect "reflect"
-)
-
-// MockMatcher is a mock of Matcher interface
-type MockMatcher struct {
- ctrl *gomock.Controller
- recorder *MockMatcherMockRecorder
-}
-
-// MockMatcherMockRecorder is the mock recorder for MockMatcher
-type MockMatcherMockRecorder struct {
- mock *MockMatcher
-}
-
-// NewMockMatcher creates a new mock instance
-func NewMockMatcher(ctrl *gomock.Controller) *MockMatcher {
- mock := &MockMatcher{ctrl: ctrl}
- mock.recorder = &MockMatcherMockRecorder{mock}
- return mock
-}
-
-// EXPECT returns an object that allows the caller to indicate expected use
-func (m *MockMatcher) EXPECT() *MockMatcherMockRecorder {
- return m.recorder
-}
-
-// Matches mocks base method
-func (m *MockMatcher) Matches(arg0 interface{}) bool {
- ret := m.ctrl.Call(m, "Matches", arg0)
- ret0, _ := ret[0].(bool)
- return ret0
-}
-
-// Matches indicates an expected call of Matches
-func (mr *MockMatcherMockRecorder) Matches(arg0 interface{}) *gomock.Call {
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Matches", reflect.TypeOf((*MockMatcher)(nil).Matches), arg0)
-}
-
-// String mocks base method
-func (m *MockMatcher) String() string {
- ret := m.ctrl.Call(m, "String")
- ret0, _ := ret[0].(string)
- return ret0
-}
-
-// String indicates an expected call of String
-func (mr *MockMatcherMockRecorder) String() *gomock.Call {
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "String", reflect.TypeOf((*MockMatcher)(nil).String))
-}