How to use SetArgMethodInterface method of gomock_test Package

...132func (s *Subject) ActOnTestStructMethod(arg TestStruct, arg1 int) int {133	return 0134}135func (s *Subject) SetArgMethod(sliceArg []byte, ptrArg *int, mapArg map[interface{}]interface{}) {}136func (s *Subject) SetArgMethodInterface(sliceArg, ptrArg, mapArg interface{})                    {}137func assertEqual(t *testing.T, expected interface{}, actual interface{}) {138	if !reflect.DeepEqual(expected, actual) {139		t.Errorf("Expected %+v, but got %+v", expected, actual)140	}141}142func createFixtures(t *testing.T) (reporter *ErrorReporter, ctrl *gomock.Controller) {143	// reporter acts as a testing.T-like object that we pass to the144	// Controller. We use it to test that the mock considered tests145	// successful or failed.146	reporter = NewErrorReporter(t)147	ctrl = gomock.NewController(reporter)148	return149}150func TestNoCalls(t *testing.T) {151	reporter, ctrl := createFixtures(t)152	ctrl.Finish()153	reporter.assertPass("No calls expected or made.")154}155func TestNoRecordedCallsForAReceiver(t *testing.T) {156	reporter, ctrl := createFixtures(t)157	subject := new(Subject)158	reporter.assertFatal(func() {159		ctrl.Call(subject, "NotRecordedMethod", "argument")160	}, "Unexpected call to", "there are no expected calls of the method \"NotRecordedMethod\" for that receiver")161	ctrl.Finish()162}163func TestNoRecordedMatchingMethodNameForAReceiver(t *testing.T) {164	reporter, ctrl := createFixtures(t)165	subject := new(Subject)166	ctrl.RecordCall(subject, "FooMethod", "argument")167	reporter.assertFatal(func() {168		ctrl.Call(subject, "NotRecordedMethod", "argument")169	}, "Unexpected call to", "there are no expected calls of the method \"NotRecordedMethod\" for that receiver")170	reporter.assertFatal(func() {171		// The expected call wasn't made.172		ctrl.Finish()173	})174}175// This tests that a call with an arguments of some primitive type matches a recorded call.176func TestExpectedMethodCall(t *testing.T) {177	reporter, ctrl := createFixtures(t)178	subject := new(Subject)179	ctrl.RecordCall(subject, "FooMethod", "argument")180	ctrl.Call(subject, "FooMethod", "argument")181	ctrl.Finish()182	reporter.assertPass("Expected method call made.")183}184func TestUnexpectedMethodCall(t *testing.T) {185	reporter, ctrl := createFixtures(t)186	subject := new(Subject)187	reporter.assertFatal(func() {188		ctrl.Call(subject, "FooMethod", "argument")189	})190	ctrl.Finish()191}192func TestRepeatedCall(t *testing.T) {193	reporter, ctrl := createFixtures(t)194	subject := new(Subject)195	ctrl.RecordCall(subject, "FooMethod", "argument").Times(3)196	ctrl.Call(subject, "FooMethod", "argument")197	ctrl.Call(subject, "FooMethod", "argument")198	ctrl.Call(subject, "FooMethod", "argument")199	reporter.assertPass("After expected repeated method calls.")200	reporter.assertFatal(func() {201		ctrl.Call(subject, "FooMethod", "argument")202	})203	ctrl.Finish()204	reporter.assertFail("After calling one too many times.")205}206func TestUnexpectedArgCount(t *testing.T) {207	reporter, ctrl := createFixtures(t)208	defer reporter.recoverUnexpectedFatal()209	subject := new(Subject)210	ctrl.RecordCall(subject, "FooMethod", "argument")211	reporter.assertFatal(func() {212		// This call is made with the wrong number of arguments...213		ctrl.Call(subject, "FooMethod", "argument", "extra_argument")214	}, "Unexpected call to", "wrong number of arguments", "Got: 2, want: 1")215	reporter.assertFatal(func() {216		// ... so is this.217		ctrl.Call(subject, "FooMethod")218	}, "Unexpected call to", "wrong number of arguments", "Got: 0, want: 1")219	reporter.assertFatal(func() {220		// The expected call wasn't made.221		ctrl.Finish()222	})223}224// This tests that a call with complex arguments (a struct and some primitive type) matches a recorded call.225func TestExpectedMethodCall_CustomStruct(t *testing.T) {226	reporter, ctrl := createFixtures(t)227	subject := new(Subject)228	expectedArg0 := TestStruct{Number: 123, Message: "hello"}229	ctrl.RecordCall(subject, "ActOnTestStructMethod", expectedArg0, 15)230	ctrl.Call(subject, "ActOnTestStructMethod", expectedArg0, 15)231	reporter.assertPass("Expected method call made.")232}233func TestUnexpectedArgValue_FirstArg(t *testing.T) {234	reporter, ctrl := createFixtures(t)235	defer reporter.recoverUnexpectedFatal()236	subject := new(Subject)237	expectedArg0 := TestStruct{Number: 123, Message: "hello %s"}238	ctrl.RecordCall(subject, "ActOnTestStructMethod", expectedArg0, 15)239	reporter.assertFatal(func() {240		// the method argument (of TestStruct type) has 1 unexpected value (for the Message field)241		ctrl.Call(subject, "ActOnTestStructMethod", TestStruct{Number: 123, Message: "no message"}, 15)242	}, "Unexpected call to", "doesn't match the argument at index 0",243		"Got: {123 no message} (gomock_test.TestStruct)\nWant: is equal to {123 hello %s} (gomock_test.TestStruct)")244	reporter.assertFatal(func() {245		// the method argument (of TestStruct type) has 2 unexpected values (for both fields)246		ctrl.Call(subject, "ActOnTestStructMethod", TestStruct{Number: 11, Message: "no message"}, 15)247	}, "Unexpected call to", "doesn't match the argument at index 0",248		"Got: {11 no message} (gomock_test.TestStruct)\nWant: is equal to {123 hello %s} (gomock_test.TestStruct)")249	reporter.assertFatal(func() {250		// The expected call wasn't made.251		ctrl.Finish()252	})253}254func TestUnexpectedArgValue_SecondArg(t *testing.T) {255	reporter, ctrl := createFixtures(t)256	defer reporter.recoverUnexpectedFatal()257	subject := new(Subject)258	expectedArg0 := TestStruct{Number: 123, Message: "hello"}259	ctrl.RecordCall(subject, "ActOnTestStructMethod", expectedArg0, 15)260	reporter.assertFatal(func() {261		ctrl.Call(subject, "ActOnTestStructMethod", TestStruct{Number: 123, Message: "hello"}, 3)262	}, "Unexpected call to", "doesn't match the argument at index 1",263		"Got: 3 (int)\nWant: is equal to 15 (int)")264	reporter.assertFatal(func() {265		// The expected call wasn't made.266		ctrl.Finish()267	})268}269func TestUnexpectedArgValue_WantFormatter(t *testing.T) {270	reporter, ctrl := createFixtures(t)271	defer reporter.recoverUnexpectedFatal()272	subject := new(Subject)273	expectedArg0 := TestStruct{Number: 123, Message: "hello"}274	ctrl.RecordCall(275		subject,276		"ActOnTestStructMethod",277		expectedArg0,278		gomock.WantFormatter(279			gomock.StringerFunc(func() string { return "is equal to fifteen" }),280			gomock.Eq(15),281		),282	)283	reporter.assertFatal(func() {284		ctrl.Call(subject, "ActOnTestStructMethod", TestStruct{Number: 123, Message: "hello"}, 3)285	}, "Unexpected call to", "doesn't match the argument at index 1",286		"Got: 3 (int)\nWant: is equal to fifteen")287	reporter.assertFatal(func() {288		// The expected call wasn't made.289		ctrl.Finish()290	})291}292func TestUnexpectedArgValue_GotFormatter(t *testing.T) {293	reporter, ctrl := createFixtures(t)294	defer reporter.recoverUnexpectedFatal()295	subject := new(Subject)296	expectedArg0 := TestStruct{Number: 123, Message: "hello"}297	ctrl.RecordCall(298		subject,299		"ActOnTestStructMethod",300		expectedArg0,301		gomock.GotFormatterAdapter(302			gomock.GotFormatterFunc(func(i interface{}) string {303				// Leading 0s304				return fmt.Sprintf("%02d", i)305			}),306			gomock.Eq(15),307		),308	)309	reporter.assertFatal(func() {310		ctrl.Call(subject, "ActOnTestStructMethod", TestStruct{Number: 123, Message: "hello"}, 3)311	}, "Unexpected call to", "doesn't match the argument at index 1",312		"Got: 03\nWant: is equal to 15")313	reporter.assertFatal(func() {314		// The expected call wasn't made.315		ctrl.Finish()316	})317}318func TestAnyTimes(t *testing.T) {319	reporter, ctrl := createFixtures(t)320	subject := new(Subject)321	ctrl.RecordCall(subject, "FooMethod", "argument").AnyTimes()322	for i := 0; i < 100; i++ {323		ctrl.Call(subject, "FooMethod", "argument")324	}325	reporter.assertPass("After 100 method calls.")326	ctrl.Finish()327}328func TestMinTimes1(t *testing.T) {329	// It fails if there are no calls330	reporter, ctrl := createFixtures(t)331	subject := new(Subject)332	ctrl.RecordCall(subject, "FooMethod", "argument").MinTimes(1)333	reporter.assertFatal(func() {334		ctrl.Finish()335	})336	// It succeeds if there is one call337	_, ctrl = createFixtures(t)338	subject = new(Subject)339	ctrl.RecordCall(subject, "FooMethod", "argument").MinTimes(1)340	ctrl.Call(subject, "FooMethod", "argument")341	ctrl.Finish()342	// It succeeds if there are many calls343	_, ctrl = createFixtures(t)344	subject = new(Subject)345	ctrl.RecordCall(subject, "FooMethod", "argument").MinTimes(1)346	for i := 0; i < 100; i++ {347		ctrl.Call(subject, "FooMethod", "argument")348	}349	ctrl.Finish()350}351func TestMaxTimes1(t *testing.T) {352	// It succeeds if there are no calls353	_, ctrl := createFixtures(t)354	subject := new(Subject)355	ctrl.RecordCall(subject, "FooMethod", "argument").MaxTimes(1)356	ctrl.Finish()357	// It succeeds if there is one call358	_, ctrl = createFixtures(t)359	subject = new(Subject)360	ctrl.RecordCall(subject, "FooMethod", "argument").MaxTimes(1)361	ctrl.Call(subject, "FooMethod", "argument")362	ctrl.Finish()363	// It fails if there are more364	reporter, ctrl := createFixtures(t)365	subject = new(Subject)366	ctrl.RecordCall(subject, "FooMethod", "argument").MaxTimes(1)367	ctrl.Call(subject, "FooMethod", "argument")368	reporter.assertFatal(func() {369		ctrl.Call(subject, "FooMethod", "argument")370	})371	ctrl.Finish()372}373func TestMinMaxTimes(t *testing.T) {374	// It fails if there are less calls than specified375	reporter, ctrl := createFixtures(t)376	subject := new(Subject)377	ctrl.RecordCall(subject, "FooMethod", "argument").MinTimes(2).MaxTimes(2)378	ctrl.Call(subject, "FooMethod", "argument")379	reporter.assertFatal(func() {380		ctrl.Finish()381	})382	// It fails if there are more calls than specified383	reporter, ctrl = createFixtures(t)384	subject = new(Subject)385	ctrl.RecordCall(subject, "FooMethod", "argument").MinTimes(2).MaxTimes(2)386	ctrl.Call(subject, "FooMethod", "argument")387	ctrl.Call(subject, "FooMethod", "argument")388	reporter.assertFatal(func() {389		ctrl.Call(subject, "FooMethod", "argument")390	})391	// It succeeds if there is just the right number of calls392	_, ctrl = createFixtures(t)393	subject = new(Subject)394	ctrl.RecordCall(subject, "FooMethod", "argument").MaxTimes(2).MinTimes(2)395	ctrl.Call(subject, "FooMethod", "argument")396	ctrl.Call(subject, "FooMethod", "argument")397	ctrl.Finish()398	// If MaxTimes is called after MinTimes is called with 1, MaxTimes takes precedence.399	reporter, ctrl = createFixtures(t)400	subject = new(Subject)401	ctrl.RecordCall(subject, "FooMethod", "argument").MinTimes(1).MaxTimes(2)402	ctrl.Call(subject, "FooMethod", "argument")403	ctrl.Call(subject, "FooMethod", "argument")404	reporter.assertFatal(func() {405		ctrl.Call(subject, "FooMethod", "argument")406	})407	// If MinTimes is called after MaxTimes is called with 1, MinTimes takes precedence.408	_, ctrl = createFixtures(t)409	subject = new(Subject)410	ctrl.RecordCall(subject, "FooMethod", "argument").MaxTimes(1).MinTimes(2)411	for i := 0; i < 100; i++ {412		ctrl.Call(subject, "FooMethod", "argument")413	}414	ctrl.Finish()415}416func TestDo(t *testing.T) {417	_, ctrl := createFixtures(t)418	subject := new(Subject)419	doCalled := false420	var argument string421	wantArg := "argument"422	ctrl.RecordCall(subject, "FooMethod", wantArg).Do(423		func(arg string) {424			doCalled = true425			argument = arg426		})427	if doCalled {428		t.Error("Do() callback called too early.")429	}430	ctrl.Call(subject, "FooMethod", wantArg)431	if !doCalled {432		t.Error("Do() callback not called.")433	}434	if wantArg != argument {435		t.Error("Do callback received wrong argument.")436	}437	ctrl.Finish()438}439func TestDoAndReturn(t *testing.T) {440	_, ctrl := createFixtures(t)441	subject := new(Subject)442	doCalled := false443	var argument string444	wantArg := "argument"445	ctrl.RecordCall(subject, "FooMethod", wantArg).DoAndReturn(446		func(arg string) int {447			doCalled = true448			argument = arg449			return 5450		})451	if doCalled {452		t.Error("Do() callback called too early.")453	}454	rets := ctrl.Call(subject, "FooMethod", wantArg)455	if !doCalled {456		t.Error("Do() callback not called.")457	}458	if wantArg != argument {459		t.Error("Do callback received wrong argument.")460	}461	if len(rets) != 1 {462		t.Fatalf("Return values from Call: got %d, want 1", len(rets))463	}464	if ret, ok := rets[0].(int); !ok {465		t.Fatalf("Return value is not an int")466	} else if ret != 5 {467		t.Errorf("DoAndReturn return value: got %d, want 5", ret)468	}469	ctrl.Finish()470}471func TestSetArgSlice(t *testing.T) {472	_, ctrl := createFixtures(t)473	subject := new(Subject)474	var in = []byte{4, 5, 6}475	var set = []byte{1, 2, 3}476	ctrl.RecordCall(subject, "SetArgMethod", in, nil, nil).SetArg(0, set)477	ctrl.Call(subject, "SetArgMethod", in, nil, nil)478	if !reflect.DeepEqual(in, set) {479		t.Error("Expected SetArg() to modify input slice argument")480	}481	ctrl.RecordCall(subject, "SetArgMethodInterface", in, nil, nil).SetArg(0, set)482	ctrl.Call(subject, "SetArgMethodInterface", in, nil, nil)483	if !reflect.DeepEqual(in, set) {484		t.Error("Expected SetArg() to modify input slice argument as interface{}")485	}486	ctrl.Finish()487}488func TestSetArgMap(t *testing.T) {489	_, ctrl := createFixtures(t)490	subject := new(Subject)491	var in = map[interface{}]interface{}{"int": 1, "string": "random string", 1: "1", 0: 0}492	var set = map[interface{}]interface{}{"int": 2, 1: "2", 2: 100}493	ctrl.RecordCall(subject, "SetArgMethod", nil, nil, in).SetArg(2, set)494	ctrl.Call(subject, "SetArgMethod", nil, nil, in)495	if !reflect.DeepEqual(in, set) {496		t.Error("Expected SetArg() to modify input map argument")497	}498	ctrl.RecordCall(subject, "SetArgMethodInterface", nil, nil, in).SetArg(2, set)499	ctrl.Call(subject, "SetArgMethodInterface", nil, nil, in)500	if !reflect.DeepEqual(in, set) {501		t.Error("Expected SetArg() to modify input map argument as interface{}")502	}503	ctrl.Finish()504}505func TestSetArgPtr(t *testing.T) {506	_, ctrl := createFixtures(t)507	subject := new(Subject)508	var in int = 43509	const set = 42510	ctrl.RecordCall(subject, "SetArgMethod", nil, &in, nil).SetArg(1, set)511	ctrl.Call(subject, "SetArgMethod", nil, &in, nil)512	if in != set {513		t.Error("Expected SetArg() to modify value pointed to by argument")514	}515	ctrl.RecordCall(subject, "SetArgMethodInterface", nil, &in, nil).SetArg(1, set)516	ctrl.Call(subject, "SetArgMethodInterface", nil, &in, nil)517	if in != set {518		t.Error("Expected SetArg() to modify value pointed to by argument as interface{}")519	}520	ctrl.Finish()521}522func TestReturn(t *testing.T) {523	_, ctrl := createFixtures(t)524	subject := new(Subject)525	// Unspecified return should produce "zero" result.526	ctrl.RecordCall(subject, "FooMethod", "zero")527	ctrl.RecordCall(subject, "FooMethod", "five").Return(5)528	assertEqual(529		t,530		[]interface{}{0},...

1import (2func TestSetArgMethodInterface(t *testing.T) {3	ctrl := gomock.NewController(t)4	defer ctrl.Finish()5	mock := gomocktest.NewMockInterface(ctrl)6	mock.EXPECT().SetArgMethodInterface(gomock.Any()).Do(func(s string) {7		fmt.Println(s)8	})9	mock.SetArgMethodInterface("hello")10}11import (12func TestSetArgMethodStruct(t *testing.T) {13	ctrl := gomock.NewController(t)14	defer ctrl.Finish()15	mock := gomocktest.NewMockInterface(ctrl)16	mock.EXPECT().SetArgMethodStruct(gomock.Any()).Do(func(s gomocktest.Struct) {17		fmt.Println(s)18	})19	mock.SetArgMethodStruct(gomocktest.Struct{Name: "hello"})20}21import (22func TestSetArgMethodStructPointer(t *testing.T) {23	ctrl := gomock.NewController(t)24	defer ctrl.Finish()25	mock := gomocktest.NewMockInterface(ctrl)26	mock.EXPECT().SetArgMethodStructPointer(gomock.Any()).Do(func(s *gomocktest.Struct) {27		fmt.Println(s)28	})29	mock.SetArgMethodStructPointer(&gomocktest.Struct{Name: "hello"})30}31import (32func TestSetArgMethodStructPointer(t *testing.T) {33	ctrl := gomock.NewController(t)34	defer ctrl.Finish()35	mock := gomocktest.NewMockInterface(ctrl)36	mock.EXPECT().SetArgMethodStructPointer(gomock.Any()).Do(func(s *gomocktest.Struct) {37		fmt.Println(s)38	})

1import (2func main() {3	ctrl := gomock.NewController(nil)4	defer ctrl.Finish()5	m := gomock_test.NewMockInterface(ctrl)6	m.EXPECT().SetArgMethodInterface(gomock_test.NewMockInterface(ctrl)).Return(nil)7	fmt.Println("Hello")8}9import (10func main() {11	ctrl := gomock.NewController(nil)12	defer ctrl.Finish()13	m := gomock_test.NewMockInterface(ctrl)14	m.EXPECT().SetArgMethodInterface(gomock_test.NewMockInterface(ctrl)).Return(nil)15	fmt.Println("Hello")16}17import (18type MockInterface struct {19}20type MockInterfaceMockRecorder struct {21}22func NewMockInterface(ctrl *gomock.Controller) *MockInterface {23	mock := &MockInterface{ctrl: ctrl}24	mock.recorder = &MockInterfaceMockRecorder{mock}25}26func (m *MockInterface) EXPECT() *MockInterfaceMockRecorder {27}28func (m *MockInterface) SetArgMethodInterface(arg0 Interface) error {29	m.ctrl.T.Helper()30	ret := m.ctrl.Call(m, "SetArgMethodInterface", arg0)31	ret0, _ := ret[0].(error)32}33func (mr *MockInterfaceMockRecorder) SetArgMethodInterface(arg0 interface{}) *gomock

1func main() {2    mockCtrl = gomock.NewController(nil)3    defer mockCtrl.Finish()4    mock = gomock_test.NewMockMyInterface(mockCtrl)5    mock.EXPECT().SetArgMethodInterface(gomock.Any()).Return(nil)6    mock.SetArgMethodInterface(nil)7}8func main() {9    mockCtrl = gomock.NewController(nil)10    defer mockCtrl.Finish()11    mock = gomock_test.NewMockMyInterface(mockCtrl)12    mock.EXPECT().SetArgMethodInterface(gomock.Any()).Return(nil)13    mock.SetArgMethodInterface(nil)14}15func main() {16    mockCtrl = gomock.NewController(nil)17    defer mockCtrl.Finish()18    mock = gomock_test.NewMockMyInterface(mockCtrl)19    mock.EXPECT().SetArgMethodInterface(gomock.Any()).Return(nil)20    mock.SetArgMethodInterface(nil)21}22func main() {23    mockCtrl = gomock.NewController(nil)24    defer mockCtrl.Finish()25    mock = gomock_test.NewMockMyInterface(mockCtrl)26    mock.EXPECT().SetArgMethodInterface(gomock.Any()).Return(nil)27    mock.SetArgMethodInterface(nil)28}29func main() {30    mockCtrl = gomock.NewController(nil)31    defer mockCtrl.Finish()32    mock = gomock_test.NewMockMyInterface(mockCtrl)33    mock.EXPECT().SetArgMethodInterface(gomock.Any()).Return(nil)

1func TestSetArgMethodInterface(t *testing.T) {2	mockCtrl := gomock.NewController(t)3	mockObj := NewMockgomock_test(mockCtrl)4	mockObj.EXPECT().SetArgMethodInterface(gomock.Any()).Do(func(arg string) {5		fmt.Println("argument is ", arg)6	})7	mockObj.SetArgMethodInterface("hello")8}9func TestSetArgMethodInterface(t *testing.T) {10	mockCtrl := gomock.NewController(t)11	mockObj := NewMockgomock_test(mockCtrl)12	mockObj.EXPECT().SetArgMethodInterface(gomock.Any()).Do(func(arg string) {13		fmt.Println("argument is ", arg)14	})15	mockObj.SetArgMethodInterface("hello")16}17func TestSetArgMethodInterface(t *testing.T) {18	mockCtrl := gomock.NewController(t)19	mockObj := NewMockgomock_test(mockCtrl)20	mockObj.EXPECT().SetArgMethodInterface(gomock.Any()).Do(func(arg string) {21		fmt.Println("argument is ", arg)22	})23	mockObj.SetArgMethodInterface("hello")24}25func TestSetArgMethodInterface(t *testing.T) {26	mockCtrl := gomock.NewController(t)27	mockObj := NewMockgomock_test(mockCtrl)28	mockObj.EXPECT().SetArgMethodInterface(gomock.Any()).Do(func(arg string) {29		fmt.Println("argument is ", arg)30	})31	mockObj.SetArgMethodInterface("hello")32}

1import (2func TestSetArgMethodInterface(t *testing.T) {3	ctrl := gomock.NewController(t)4	defer ctrl.Finish()5	mock := gomock_test.NewMockMyInterface(ctrl)6	mock.EXPECT().SetArgMethodInterface(gomock_test.NewMockMyInterface(ctrl)).Return(nil)7	err := mock.SetArgMethodInterface(gomock_test.NewMockMyInterface(ctrl))8	if err != nil {9		fmt.Printf("Error occured: %v", err)10	}11}12import (13func TestSetArgMethodInterface(t *testing.T) {14	ctrl := gomock.NewController(t)15	defer ctrl.Finish()16	mock := gomock_test.NewMockMyInterface(ctrl)17	mock.EXPECT().SetArgMethodInterface(gomock_test.NewMockMyInterface(ctrl)).Return(nil)18	err := mock.SetArgMethodInterface(gomock_test.NewMockMyInterface(ctrl))19	if err != nil {20		fmt.Printf("Error occured: %v", err)21	}22}23import (24func TestSetArgMethodInterface(t *testing.T) {25	ctrl := gomock.NewController(t)26	defer ctrl.Finish()27	mock := gomock_test.NewMockMyInterface(ctrl)28	mock.EXPECT().SetArgMethodInterface(gomock_test.NewMockMyInterface(ctrl)).Return(nil)29	err := mock.SetArgMethodInterface(gomock_test.NewMockMyInterface(ctrl))30	if err != nil {31		fmt.Printf("Error occured: %v", err)32	}33}34import (

1func main() {2    mockObj := gomock.NewMockgomock_test(mockCtrl)3    argMockObj := gomock.NewMockgomock_test(mockCtrl)4    mockObj.EXPECT().SetArgMethodInterface(argMockObj).Return().Times(1)5    mockObj.SetArgMethodInterface(argMockObj)6}7func main() {8    mockObj := gomock.NewMockgomock_test(mockCtrl)9    argMockObj := gomock.NewMockgomock_test(mockCtrl)10    mockObj.EXPECT().SetArgMethodInterface(argMockObj).Return().Times(1)11    mockObj.SetArgMethodInterface(argMockObj)12}13func main() {14    mockObj := gomock.NewMockgomock_test(mockCtrl)15    argMockObj := gomock.NewMockgomock_test(mockCtrl)16    mockObj.EXPECT().SetArgMethodInterface(argMockObj).Return().Times(1)17    mockObj.SetArgMethodInterface(argMockObj)18}19func main() {20    mockObj := gomock.NewMockgomock_test(mockCtrl)21    argMockObj := gomock.NewMockgomock_test(mockCtrl)22    mockObj.EXPECT().SetArgMethodInterface(argMockObj).Return().Times(1)23    mockObj.SetArgMethodInterface(argMockObj)24}25func main() {

1func TestSetArgMethodInterface(t *testing.T) {2	mockCtrl := gomock.NewController(t)3	defer mockCtrl.Finish()4	mockObj := NewMockGomockTest(mockCtrl)5	mockObj.EXPECT().SetArgMethodInterface(gomock.Any()).Do(func(arg interface{}) {6		arg.(interface {7			SetName(name string)8		}).SetName("test")9	})10	mockObj.SetArgMethodInterface(&Person{})11}12func TestSetArgStruct(t *testing.T) {13	mockCtrl := gomock.NewController(t)14	defer mockCtrl.Finish()15	mockObj := NewMockGomockTest(mockCtrl)16	mockObj.EXPECT().SetArgStruct(gomock.Any()).Do(func(arg *Person) {17	})18	mockObj.SetArgStruct(&Person{})19}20func TestSetArgStruct2(t *testing.T) {21	mockCtrl := gomock.NewController(t)22	defer mockCtrl.Finish()23	mockObj := NewMockGomockTest(mockCtrl)24	mockObj.EXPECT().SetArgStruct(gomock.Any()).Do(func(arg *Person) {25	})26	mockObj.SetArgStruct(&Person{Name: "test2"})27}28func TestSetArgStruct3(t *testing.T) {29	mockCtrl := gomock.NewController(t)