add prune and remove unused packages

vendor/github.com/golang/mock/gomock/call_test.go

@@ -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)
-		}
-	})
-}

vendor/github.com/golang/mock/gomock/callset_test.go

@@ -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)
-	}
-}

vendor/github.com/golang/mock/gomock/controller_test.go

@@ -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.")
-}

vendor/github.com/golang/mock/gomock/matchers_test.go

@@ -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")
-	}
-}

vendor/github.com/golang/mock/gomock/mock_matcher/mock_matcher.go

@@ -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))
-}