From 473acc61c8392dc7ae303d91568e179c4f105a76 Mon Sep 17 00:00:00 2001 From: Dimitri Sokolyuk Date: Tue, 2 Jul 2019 12:12:53 +0200 Subject: add black list --- vendor/github.com/golang/mock/gomock/call.go | 20 +- vendor/github.com/golang/mock/gomock/call_test.go | 51 -- .../github.com/golang/mock/gomock/callset_test.go | 76 --- vendor/github.com/golang/mock/gomock/controller.go | 119 ++-- .../golang/mock/gomock/controller_test.go | 712 --------------------- vendor/github.com/golang/mock/gomock/matchers.go | 50 +- .../github.com/golang/mock/gomock/matchers_test.go | 70 -- .../mock/gomock/mock_matcher/mock_matcher.go | 57 -- 8 files changed, 135 insertions(+), 1020 deletions(-) delete mode 100644 vendor/github.com/golang/mock/gomock/call_test.go delete mode 100644 vendor/github.com/golang/mock/gomock/callset_test.go delete mode 100644 vendor/github.com/golang/mock/gomock/controller_test.go delete mode 100644 vendor/github.com/golang/mock/gomock/matchers_test.go delete mode 100644 vendor/github.com/golang/mock/gomock/mock_matcher/mock_matcher.go (limited to 'vendor/github.com/golang/mock/gomock') 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)) -} -- cgit v1.2.3