How to use isCleanuper method of gomock Package

...125	ctrl := &Controller{126		T:             h,127		expectedCalls: newCallSet(),128	}129	if c, ok := isCleanuper(ctrl.T); ok {130		c.Cleanup(func() {131			ctrl.T.Helper()132			ctrl.finish(true, nil)133		})134	}135	return ctrl136}137type cancelReporter struct {138	t      TestHelper139	cancel func()140}141func (r *cancelReporter) Errorf(format string, args ...interface{}) {142	r.t.Errorf(format, args...)143}144func (r *cancelReporter) Fatalf(format string, args ...interface{}) {145	defer r.cancel()146	r.t.Fatalf(format, args...)147}148func (r *cancelReporter) Helper() {149	r.t.Helper()150}151// WithContext returns a new Controller and a Context, which is cancelled on any152// fatal failure.153func WithContext(ctx context.Context, t TestReporter) (*Controller, context.Context) {154	h, ok := t.(TestHelper)155	if !ok {156		h = &nopTestHelper{t: t}157	}158	ctx, cancel := context.WithCancel(ctx)159	return NewController(&cancelReporter{t: h, cancel: cancel}), ctx160}161type nopTestHelper struct {162	t TestReporter163}164func (h *nopTestHelper) Errorf(format string, args ...interface{}) {165	h.t.Errorf(format, args...)166}167func (h *nopTestHelper) Fatalf(format string, args ...interface{}) {168	h.t.Fatalf(format, args...)169}170func (h nopTestHelper) Helper() {}171// RecordCall is called by a mock. It should not be called by user code.172func (ctrl *Controller) RecordCall(receiver interface{}, method string, args ...interface{}) *Call {173	ctrl.T.Helper()174	recv := reflect.ValueOf(receiver)175	for i := 0; i < recv.Type().NumMethod(); i++ {176		if recv.Type().Method(i).Name == method {177			return ctrl.RecordCallWithMethodType(receiver, method, recv.Method(i).Type(), args...)178		}179	}180	ctrl.T.Fatalf("gomock: failed finding method %s on %T", method, receiver)181	panic("unreachable")182}183// RecordCallWithMethodType is called by a mock. It should not be called by user code.184func (ctrl *Controller) RecordCallWithMethodType(receiver interface{}, method string, methodType reflect.Type, args ...interface{}) *Call {185	ctrl.T.Helper()186	call := newCall(ctrl.T, receiver, method, methodType, args...)187	ctrl.mu.Lock()188	defer ctrl.mu.Unlock()189	ctrl.expectedCalls.Add(call)190	return call191}192// Call is called by a mock. It should not be called by user code.193func (ctrl *Controller) Call(receiver interface{}, method string, args ...interface{}) []interface{} {194	ctrl.T.Helper()195	// Nest this code so we can use defer to make sure the lock is released.196	actions := func() []func([]interface{}) []interface{} {197		ctrl.T.Helper()198		ctrl.mu.Lock()199		defer ctrl.mu.Unlock()200		expected, err := ctrl.expectedCalls.FindMatch(receiver, method, args)201		if err != nil {202			// callerInfo's skip should be updated if the number of calls between the user's test203			// and this line changes, i.e. this code is wrapped in another anonymous function.204			// 0 is us, 1 is controller.Call(), 2 is the generated mock, and 3 is the user's test.205			origin := callerInfo(3)206			ctrl.T.Fatalf("Unexpected call to %T.%v(%v) at %s because: %s", receiver, method, args, origin, err)207		}208		// Two things happen here:209		// * the matching call no longer needs to check prerequite calls,210		// * and the prerequite calls are no longer expected, so remove them.211		preReqCalls := expected.dropPrereqs()212		for _, preReqCall := range preReqCalls {213			ctrl.expectedCalls.Remove(preReqCall)214		}215		actions := expected.call()216		if expected.exhausted() {217			ctrl.expectedCalls.Remove(expected)218		}219		return actions220	}()221	var rets []interface{}222	for _, action := range actions {223		if r := action(args); r != nil {224			rets = r225		}226	}227	return rets228}229// Finish checks to see if all the methods that were expected to be called230// were called. It should be invoked for each Controller. It is not idempotent231// and therefore can only be invoked once.232//233// New in go1.14+, if you are passing a *testing.T into NewController function you no234// longer need to call ctrl.Finish() in your test methods.235func (ctrl *Controller) Finish() {236	// If we're currently panicking, probably because this is a deferred call.237	// This must be recovered in the deferred function.238	err := recover()239	ctrl.finish(false, err)240}241func (ctrl *Controller) finish(cleanup bool, panicErr interface{}) {242	ctrl.T.Helper()243	ctrl.mu.Lock()244	defer ctrl.mu.Unlock()245	if ctrl.finished {246		if _, ok := isCleanuper(ctrl.T); !ok {247			ctrl.T.Fatalf("Controller.Finish was called more than once. It has to be called exactly once.")248		}249		return250	}251	ctrl.finished = true252	// Short-circuit, pass through the panic.253	if panicErr != nil {254		panic(panicErr)255	}256	// Check that all remaining expected calls are satisfied.257	failures := ctrl.expectedCalls.Failures()258	for _, call := range failures {259		ctrl.T.Errorf("missing call(s) to %v", call)260	}261	if len(failures) != 0 {262		if !cleanup {263			ctrl.T.Fatalf("aborting test due to missing call(s)")264			return265		}266		ctrl.T.Errorf("aborting test due to missing call(s)")267	}268}269// callerInfo returns the file:line of the call site. skip is the number270// of stack frames to skip when reporting. 0 is callerInfo's call site.271func callerInfo(skip int) string {272	if _, file, line, ok := runtime.Caller(skip + 1); ok {273		return fmt.Sprintf("%s:%d", file, line)274	}275	return "unknown file"276}277// isCleanuper checks it if t's base TestReporter has a Cleanup method.278func isCleanuper(t TestReporter) (cleanuper, bool) {279	tr := unwrapTestReporter(t)280	c, ok := tr.(cleanuper)281	return c, ok282}283// unwrapTestReporter unwraps TestReporter to the base implementation.284func unwrapTestReporter(t TestReporter) TestReporter {285	tr := t286	switch nt := t.(type) {287	case *cancelReporter:288		tr = nt.t289		if h, check := tr.(*nopTestHelper); check {290			tr = h.t291		}292	case *nopTestHelper:...

1import (2func TestIsCleanuper(t *testing.T) {3	ctrl := gomock.NewController(t)4	defer ctrl.Finish()5	mockCleaner := mock.NewMockCleaner(ctrl)6	mockCleaner.EXPECT().CleanUp().Return(nil)7	err := DoSomething(mockCleaner)8	if err != nil {9		t.Errorf("DoSomething() returned error %v, want nil", err)10	}11}12func DoSomething(c Cleaner) error {13	return c.CleanUp()14}15import (16func TestIsCleanuper(t *testing.T) {17	ctrl := gomock.NewController(t)18	defer ctrl.Finish()19	mockCleaner := mock.NewMockCleaner(ctrl)20	mockCleaner.EXPECT().CleanUp().Return(fmt.Errorf("error"))21	err := DoSomething(mockCleaner)22	if err == nil {23		t.Errorf("DoSomething() returned error nil, want error")24	}25}26func DoSomething(c Cleaner) error {27	return c.CleanUp()28}29import (30func TestIsCleanuper(t *testing.T) {31	ctrl := gomock.NewController(t)32	defer ctrl.Finish()33	mockCleaner := mock.NewMockCleaner(ctrl)34	mockCleaner.EXPECT().CleanUp().Return(nil).Times(2)35	err := DoSomething(mockCleaner)36	if err != nil {37		t.Errorf("DoSomething() returned error %v, want nil", err)38	}39	err = DoSomething(mockCleaner)40	if err != nil {

1import (2func TestMock(t *testing.T) {3    ctrl := gomock.NewController(t)4    defer ctrl.Finish()5    mock := NewMockCleanuper(ctrl)6    mock.EXPECT().Cleanup()7    fmt.Println("I am in test")8    mock.Cleanup()9    assert.True(t, true)10}11import (12type Cleanuper interface {13    Cleanup()14}15func NewMockCleanuper(ctrl *gomock.Controller) *MockCleanuper {16    mock := &MockCleanuper{ctrl: ctrl}17    mock.recorder = &_MockCleanuperRecorder{mock}18}19type MockCleanuper struct {20}21func (_m *MockCleanuper) EXPECT() *_MockCleanuperRecorder {22}23func (_m *MockCleanuper) Cleanup() {24    _m.ctrl.T.Helper()25    _m.ctrl.Call(_m, "Cleanup")26}27type _MockCleanuperRecorder struct {28}29func (_m *_MockCleanuperRecorder) Cleanup() *gomock.Call {30    return _m.mock.ctrl.RecordCall(_m.mock, "Cleanup")31}32import (33func TestMock(t *testing.T) {34    fmt.Println("I am in test")35}36import (37func TestMock(t *testing.T) {38    fmt.Println("I am in test")39}40import (41func TestMock(t *testing.T) {42    fmt.Println("I am in test")43}44import (

1import (2func TestCleanuper(t *testing.T) {3	ctrl := gomock.NewController(t)4	defer ctrl.Finish()5	m := mocks.NewMockCleanuper(ctrl)6	m.EXPECT().Cleanup("foo").Return(nil)7	fmt.Println(m.Cleanup("foo"))8}9import (10func TestCleanuper(t *testing.T) {11	ctrl := gomock.NewController(t)12	defer ctrl.Finish()13	m := mocks.NewMockCleanuper(ctrl)14	m.EXPECT().Cleanup("foo").Return(nil)15	fmt.Println(m.Cleanup("foo"))16}17import (18func TestCleanuper(t *testing.T) {19	ctrl := gomock.NewController(t)20	defer ctrl.Finish()21	m := mocks.NewMockCleanuper(ctrl)22	m.EXPECT().Cleanup("foo").Return(nil)23	fmt.Println(m.Cleanup("foo"))24}25import (26func TestCleanuper(t *testing.T) {27	ctrl := gomock.NewController(t)28	defer ctrl.Finish()29	m := mocks.NewMockCleanuper(ctrl)30	m.EXPECT().Cleanup("foo").Return(nil)31	fmt.Println(m.Cleanup("foo"))32}33import (34func TestCleanuper(t *testing.T) {35	ctrl := gomock.NewController(t)36	defer ctrl.Finish()37	m := mocks.NewMockCleanuper(ctrl)38	m.EXPECT().Cleanup("foo").Return(nil)39	fmt.Println(m.Cleanup("foo"))40}

1import (2func main() {3	ctrl := gomock.NewController(nil)4	defer ctrl.Finish()5	mockCleaner := _1.NewMockCleaner(ctrl)6	mockCleaner.EXPECT().Clean().Return(nil)7	cleaner := _1.NewCleaner(mockCleaner)8	if err := cleaner.Clean(); err != nil {9		fmt.Printf("Error cleaning: %v", err)10	}11}12import (13func TestCleaner_Clean(t *testing.T) {14	ctrl := gomock.NewController(t)15	defer ctrl.Finish()16	mockCleaner := _1.NewMockCleaner(ctrl)17	mockCleaner.EXPECT().Clean().Return(errors.New("Could not clean"))18	cleaner := _1.NewCleaner(mockCleaner)19	if err := cleaner.Clean(); err != nil {20		t.Errorf("Expected error, got %v", err)21	}22}23import (24type Cleaner struct {25}26func NewCleaner(c isCleanuper) *Cleaner {27	return &Cleaner{28	}29}30func (c *Cleaner) Clean() error {31	if err := c.Cleaner.Clean(); err != nil {32		return errors.New("Could not clean")33	}34}35type isCleanuper interface {36	Clean() error37}38type Cleaner struct {39}40func NewCleaner() *Cleaner {41	return &Cleaner{}42}

1func main() {2    ctrl := gomock.NewController(t)3    defer ctrl.Finish()4    mock := NewMockCleanuper(ctrl)5    mock.EXPECT().Cleanup().Do(func() {6        fmt.Println("Cleanup")7    })8    mock.Cleanup()9}10func main() {11    ctrl := gomock.NewController(t)12    defer ctrl.Finish()13    mock := NewMockCleanuper(ctrl)14    mock.EXPECT().Cleanup().Do(func() {15        fmt.Println("Cleanup")16    })17    mock.Cleanup()18}19func main() {20    ctrl := gomock.NewController(t)21    defer ctrl.Finish()22    mock := NewMockCleanuper(ctrl)23    mock.EXPECT().Cleanup().Do(func() {24        fmt.Println("Cleanup")25    })26    mock.Cleanup()27}28func main() {29    ctrl := gomock.NewController(t)30    defer ctrl.Finish()31    mock := NewMockCleanuper(ctrl)32    mock.EXPECT().Cleanup().Do(func() {33        fmt.Println("Cleanup")34    })35    mock.Cleanup()36}37func main() {38    ctrl := gomock.NewController(t)39    defer ctrl.Finish()40    mock := NewMockCleanuper(ctrl)41    mock.EXPECT().Cleanup().Do(func() {42        fmt.Println("Cleanup")43    })44    mock.Cleanup()45}46func main() {47    ctrl := gomock.NewController(t)48    defer ctrl.Finish()49    mock := NewMockCleanuper(ctrl)50    mock.EXPECT().Cleanup().Do(func() {51        fmt.Println("Cleanup")52    })53    mock.Cleanup()54}55func main() {56    ctrl := gomock.NewController(t)57    defer ctrl.Finish()58    mock := NewMockCleanuper(ctrl)59    mock.EXPECT().Cleanup().Do(func() {60        fmt.Println("Cleanup")61    })

1import (2func TestIsCleanuper(t *testing.T) {3	c := cleaner.NewCleaner()4	ctrl := gomock.NewController(t)5	defer ctrl.Finish()6	mock := mock_cleaner.NewMockCleaner(ctrl)7	mock.EXPECT().IsCleaner().Return(true)8	fmt.Println("IsCleaner:", c.IsCleaner())9}10import "fmt"11type Cleaner interface {12	IsCleaner() bool13}14type CleanerImpl struct{}15func (c *CleanerImpl) IsCleaner() bool {16	fmt.Println("IsCleaner")17}18func NewCleaner() Cleaner {19	return &CleanerImpl{}20}21import (22type MockCleaner struct {23}24type MockCleanerMockRecorder struct {25}26func NewMockCleaner(ctrl *gomock.Controller) *MockCleaner {27	mock := &MockCleaner{ctrl: ctrl}28	mock.recorder = &MockCleanerMockRecorder{mock}29}30func (_m *MockCleaner) EXPECT() *MockCleanerMockRecorder {31}32func (_m *MockCleaner) IsCleaner() bool {33	ret := _m.ctrl.Call(_m, "IsCleaner")34	ret0, _ := ret[0].(bool)35}36func (_mr *MockCleanerMockRecorder) IsCleaner() *gomock.Call {37	return _mr.mock.ctrl.RecordCall(_mr.mock, "IsCleaner")38}39import (

1import (2func main() {3    ctrl := gomock.NewController(nil)4    defer ctrl.Finish()5    mock := mock.NewMockCleanuper(ctrl)6    mock.EXPECT().Cleanup().Return(nil)7    fmt.Println(mock.Cleanup())8}9import (10func main() {11    fmt.Println(m.Cleanup())12}13type Cleanuper interface {14    Cleanup() error15}16import (17var _ Cleanuper = (*MockCleanuper)(nil)18type MockCleanuper struct {19}20type MockCleanuperMockRecorder struct {21}22func NewMockCleanuper(ctrl *gomock.Controller) *MockCleanuper {23    mock := &MockCleanuper{ctrl: ctrl}24    mock.callInfo = &gomock.CallInfo{Method: "MockCleanuper"}25    mock.recorder = &MockCleanuperMockRecorder{mock}26}27func (m *MockCleanuper) EXPECT() *MockCleanuperMockRecorder {28}29func (m *MockCleanuper) Cleanup() error {30    m.ctrl.TestingT().Helper()31    ret := m.ctrl.Call(m, "Cleanup")32    ret0, _ := ret[0].(error)33}34func (mr *MockCleanuperMockRecorder) Cleanup() *gomock.Call {35    mr.mock.ctrl.TestingT().Helper()36    return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Cleanup", reflect.TypeOf((*MockCleanuper)(nil).Cleanup))37}38require (

1func TestMockObjectIsClean(t *testing.T) {2	mockCtrl := gomock.NewController(t)3	defer mockCtrl.Finish()4	mockObject := NewMockInterface(mockCtrl)5	mockObject.EXPECT().Method1(gomock.Any()).Return(nil).Times(1)6	mockObject.Method1("test")7	if !mockObject.IsClean() {8		t.Error("Mock object is not clean")9	}10}11func TestMockObjectIsNotClean(t *testing.T) {12	mockCtrl := gomock.NewController(t)13	defer mockCtrl.Finish()14	mockObject := NewMockInterface(mockCtrl)15	mockObject.EXPECT().Method1(gomock.Any()).Return(nil).Times(1)16	mockObject.Method1("test")17	if mockObject.IsClean() {18		t.Error("Mock object is clean")19	}20}21func TestMockObjectIsCleanInOrder(t *testing.T) {22	mockCtrl := gomock.NewController(t)23	defer mockCtrl.Finish()24	mockObject := NewMockInterface(mockCtrl)25	mockObject.EXPECT().Method1(gomock.Any()).Return(nil).Times(1)26	mockObject.Method1("test")27	gomock.InOrder(28}29func TestMockObjectIsCleanAny(t *testing.T) {30	mockCtrl := gomock.NewController(t)