KaneAI - World’s First E2E Software Testing Agent.Book a Demo Join TestMu Conference

How to use isCleanuper method of gomock Package

Best Mock code snippet using gomock.isCleanuper

controller.go

Source:controller.go

...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:...

isCleanuper

Using AI Code Generation

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 {

isCleanuper

Using AI Code Generation

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 (

isCleanuper

Using AI Code Generation

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}

isCleanuper

Using AI Code Generation

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}

isCleanuper

Using AI Code Generation

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

isCleanuper

Using AI Code Generation

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 (

isCleanuper

Using AI Code Generation

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 (

isCleanuper

Using AI Code Generation

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)

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.