How to use assertFatal method of gomock_test Package

...44		e.t.Errorf("Expected failure, but got pass: %s", msg)45	}46}47// Use to check that code triggers a fatal test failure.48func (e *ErrorReporter) assertFatal(fn func(), expectedErrMsgs ...string) {49	defer func() {50		err := recover()51		if err == nil {52			var actual string53			if e.failed {54				actual = "non-fatal failure"55			} else {56				actual = "pass"57			}58			e.t.Error("Expected fatal failure, but got a", actual)59		} else if token, ok := err.(*struct{}); ok && token == &e.fatalToken {60			// This is okay - the panic is from Fatalf().61			if expectedErrMsgs != nil {62				// assert that the actual error message63				// contains expectedErrMsgs64				// check the last actualErrMsg, because the previous messages come from previous errors65				actualErrMsg := e.log[len(e.log)-1]66				for _, expectedErrMsg := range expectedErrMsgs {67					if !strings.Contains(actualErrMsg, expectedErrMsg) {68						e.t.Errorf("Error message:\ngot: %q\nwant to contain: %q\n", actualErrMsg, expectedErrMsg)69					}70				}71			}72			return73		} else {74			// Some other panic.75			panic(err)76		}77	}()78	fn()79}80// recoverUnexpectedFatal can be used as a deferred call in test cases to81// recover from and display a call to ErrorReporter.Fatalf().82func (e *ErrorReporter) recoverUnexpectedFatal() {83	err := recover()84	if err == nil {85		// No panic.86	} else if token, ok := err.(*struct{}); ok && token == &e.fatalToken {87		// Unexpected fatal error happened.88		e.t.Error("Got unexpected fatal error(s). All errors up to this point:")89		e.reportLog()90		return91	} else {92		// Some other panic.93		panic(err)94	}95}96func (e *ErrorReporter) Log(args ...interface{}) {97	e.log = append(e.log, fmt.Sprint(args...))98}99func (e *ErrorReporter) Logf(format string, args ...interface{}) {100	e.log = append(e.log, fmt.Sprintf(format, args...))101}102func (e *ErrorReporter) Errorf(format string, args ...interface{}) {103	e.Logf(format, args...)104	e.failed = true105}106func (e *ErrorReporter) Fatalf(format string, args ...interface{}) {107	e.Logf(format, args...)108	e.failed = true109	panic(&e.fatalToken)110}111type HelperReporter struct {112	gomock.TestReporter113	helper int114}115func (h *HelperReporter) Helper() {116	h.helper++117}118// A type purely for use as a receiver in testing the Controller.119type Subject struct{}120func (s *Subject) FooMethod(arg string) int {121	return 0122}123func (s *Subject) BarMethod(arg string) int {124	return 0125}126func (s *Subject) VariadicMethod(arg int, vararg ...string) {}127// A type purely for ActOnTestStructMethod128type TestStruct struct {129	Number  int130	Message string131}132func (s *Subject) ActOnTestStructMethod(arg TestStruct, arg1 int) int {133	return 0134}135func (s *Subject) SetArgMethod(sliceArg []byte, ptrArg *int) {}136func assertEqual(t *testing.T, expected interface{}, actual interface{}) {137	if !reflect.DeepEqual(expected, actual) {138		t.Errorf("Expected %+v, but got %+v", expected, actual)139	}140}141func createFixtures(t *testing.T) (reporter *ErrorReporter, ctrl *gomock.Controller) {142	// reporter acts as a testing.T-like object that we pass to the143	// Controller. We use it to test that the mock considered tests144	// successful or failed.145	reporter = NewErrorReporter(t)146	ctrl = gomock.NewController(reporter)147	return148}149func TestNoCalls(t *testing.T) {150	reporter, ctrl := createFixtures(t)151	ctrl.Finish()152	reporter.assertPass("No calls expected or made.")153}154func TestNoRecordedCallsForAReceiver(t *testing.T) {155	reporter, ctrl := createFixtures(t)156	subject := new(Subject)157	reporter.assertFatal(func() {158		ctrl.Call(subject, "NotRecordedMethod", "argument")159	}, "Unexpected call to", "there are no expected calls of the method \"NotRecordedMethod\" for that receiver")160	ctrl.Finish()161}162func TestNoRecordedMatchingMethodNameForAReceiver(t *testing.T) {163	reporter, ctrl := createFixtures(t)164	subject := new(Subject)165	ctrl.RecordCall(subject, "FooMethod", "argument")166	reporter.assertFatal(func() {167		ctrl.Call(subject, "NotRecordedMethod", "argument")168	}, "Unexpected call to", "there are no expected calls of the method \"NotRecordedMethod\" for that receiver")169	reporter.assertFatal(func() {170		// The expected call wasn't made.171		ctrl.Finish()172	})173}174// This tests that a call with an arguments of some primitive type matches a recorded call.175func TestExpectedMethodCall(t *testing.T) {176	reporter, ctrl := createFixtures(t)177	subject := new(Subject)178	ctrl.RecordCall(subject, "FooMethod", "argument")179	ctrl.Call(subject, "FooMethod", "argument")180	ctrl.Finish()181	reporter.assertPass("Expected method call made.")182}183func TestUnexpectedMethodCall(t *testing.T) {184	reporter, ctrl := createFixtures(t)185	subject := new(Subject)186	reporter.assertFatal(func() {187		ctrl.Call(subject, "FooMethod", "argument")188	})189	ctrl.Finish()190}191func TestRepeatedCall(t *testing.T) {192	reporter, ctrl := createFixtures(t)193	subject := new(Subject)194	ctrl.RecordCall(subject, "FooMethod", "argument").Times(3)195	ctrl.Call(subject, "FooMethod", "argument")196	ctrl.Call(subject, "FooMethod", "argument")197	ctrl.Call(subject, "FooMethod", "argument")198	reporter.assertPass("After expected repeated method calls.")199	reporter.assertFatal(func() {200		ctrl.Call(subject, "FooMethod", "argument")201	})202	ctrl.Finish()203	reporter.assertFail("After calling one too many times.")204}205func TestUnexpectedArgCount(t *testing.T) {206	reporter, ctrl := createFixtures(t)207	defer reporter.recoverUnexpectedFatal()208	subject := new(Subject)209	ctrl.RecordCall(subject, "FooMethod", "argument")210	reporter.assertFatal(func() {211		// This call is made with the wrong number of arguments...212		ctrl.Call(subject, "FooMethod", "argument", "extra_argument")213	}, "Unexpected call to", "wrong number of arguments", "Got: 2, want: 1")214	reporter.assertFatal(func() {215		// ... so is this.216		ctrl.Call(subject, "FooMethod")217	}, "Unexpected call to", "wrong number of arguments", "Got: 0, want: 1")218	reporter.assertFatal(func() {219		// The expected call wasn't made.220		ctrl.Finish()221	})222}223// This tests that a call with complex arguments (a struct and some primitive type) matches a recorded call.224func TestExpectedMethodCall_CustomStruct(t *testing.T) {225	reporter, ctrl := createFixtures(t)226	subject := new(Subject)227	expectedArg0 := TestStruct{Number: 123, Message: "hello"}228	ctrl.RecordCall(subject, "ActOnTestStructMethod", expectedArg0, 15)229	ctrl.Call(subject, "ActOnTestStructMethod", expectedArg0, 15)230	reporter.assertPass("Expected method call made.")231}232func TestUnexpectedArgValue_FirstArg(t *testing.T) {233	reporter, ctrl := createFixtures(t)234	defer reporter.recoverUnexpectedFatal()235	subject := new(Subject)236	expectedArg0 := TestStruct{Number: 123, Message: "hello %s"}237	ctrl.RecordCall(subject, "ActOnTestStructMethod", expectedArg0, 15)238	reporter.assertFatal(func() {239		// the method argument (of TestStruct type) has 1 unexpected value (for the Message field)240		ctrl.Call(subject, "ActOnTestStructMethod", TestStruct{Number: 123, Message: "no message"}, 15)241	}, "Unexpected call to", "doesn't match the argument at index 0",242		"Got: {123 no message} (gomock_test.TestStruct)\nWant: is equal to {123 hello %s} (gomock_test.TestStruct)")243	reporter.assertFatal(func() {244		// the method argument (of TestStruct type) has 2 unexpected values (for both fields)245		ctrl.Call(subject, "ActOnTestStructMethod", TestStruct{Number: 11, Message: "no message"}, 15)246	}, "Unexpected call to", "doesn't match the argument at index 0",247		"Got: {11 no message} (gomock_test.TestStruct)\nWant: is equal to {123 hello %s} (gomock_test.TestStruct)")248	reporter.assertFatal(func() {249		// The expected call wasn't made.250		ctrl.Finish()251	})252}253func TestUnexpectedArgValue_SecondArg(t *testing.T) {254	reporter, ctrl := createFixtures(t)255	defer reporter.recoverUnexpectedFatal()256	subject := new(Subject)257	expectedArg0 := TestStruct{Number: 123, Message: "hello"}258	ctrl.RecordCall(subject, "ActOnTestStructMethod", expectedArg0, 15)259	reporter.assertFatal(func() {260		ctrl.Call(subject, "ActOnTestStructMethod", TestStruct{Number: 123, Message: "hello"}, 3)261	}, "Unexpected call to", "doesn't match the argument at index 1",262		"Got: 3 (int)\nWant: is equal to 15 (int)")263	reporter.assertFatal(func() {264		// The expected call wasn't made.265		ctrl.Finish()266	})267}268func TestUnexpectedArgValue_WantFormatter(t *testing.T) {269	reporter, ctrl := createFixtures(t)270	defer reporter.recoverUnexpectedFatal()271	subject := new(Subject)272	expectedArg0 := TestStruct{Number: 123, Message: "hello"}273	ctrl.RecordCall(274		subject,275		"ActOnTestStructMethod",276		expectedArg0,277		gomock.WantFormatter(278			gomock.StringerFunc(func() string { return "is equal to fifteen" }),279			gomock.Eq(15),280		),281	)282	reporter.assertFatal(func() {283		ctrl.Call(subject, "ActOnTestStructMethod", TestStruct{Number: 123, Message: "hello"}, 3)284	}, "Unexpected call to", "doesn't match the argument at index 1",285		"Got: 3 (int)\nWant: is equal to fifteen")286	reporter.assertFatal(func() {287		// The expected call wasn't made.288		ctrl.Finish()289	})290}291func TestUnexpectedArgValue_GotFormatter(t *testing.T) {292	reporter, ctrl := createFixtures(t)293	defer reporter.recoverUnexpectedFatal()294	subject := new(Subject)295	expectedArg0 := TestStruct{Number: 123, Message: "hello"}296	ctrl.RecordCall(297		subject,298		"ActOnTestStructMethod",299		expectedArg0,300		gomock.GotFormatterAdapter(301			gomock.GotFormatterFunc(func(i interface{}) string {302				// Leading 0s303				return fmt.Sprintf("%02d", i)304			}),305			gomock.Eq(15),306		),307	)308	reporter.assertFatal(func() {309		ctrl.Call(subject, "ActOnTestStructMethod", TestStruct{Number: 123, Message: "hello"}, 3)310	}, "Unexpected call to", "doesn't match the argument at index 1",311		"Got: 03\nWant: is equal to 15")312	reporter.assertFatal(func() {313		// The expected call wasn't made.314		ctrl.Finish()315	})316}317func TestAnyTimes(t *testing.T) {318	reporter, ctrl := createFixtures(t)319	subject := new(Subject)320	ctrl.RecordCall(subject, "FooMethod", "argument").AnyTimes()321	for i := 0; i < 100; i++ {322		ctrl.Call(subject, "FooMethod", "argument")323	}324	reporter.assertPass("After 100 method calls.")325	ctrl.Finish()326}327func TestMinTimes1(t *testing.T) {328	// It fails if there are no calls329	reporter, ctrl := createFixtures(t)330	subject := new(Subject)331	ctrl.RecordCall(subject, "FooMethod", "argument").MinTimes(1)332	reporter.assertFatal(func() {333		ctrl.Finish()334	})335	// It succeeds if there is one call336	_, ctrl = createFixtures(t)337	subject = new(Subject)338	ctrl.RecordCall(subject, "FooMethod", "argument").MinTimes(1)339	ctrl.Call(subject, "FooMethod", "argument")340	ctrl.Finish()341	// It succeeds if there are many calls342	_, ctrl = createFixtures(t)343	subject = new(Subject)344	ctrl.RecordCall(subject, "FooMethod", "argument").MinTimes(1)345	for i := 0; i < 100; i++ {346		ctrl.Call(subject, "FooMethod", "argument")347	}348	ctrl.Finish()349}350func TestMaxTimes1(t *testing.T) {351	// It succeeds if there are no calls352	_, ctrl := createFixtures(t)353	subject := new(Subject)354	ctrl.RecordCall(subject, "FooMethod", "argument").MaxTimes(1)355	ctrl.Finish()356	// It succeeds if there is one call357	_, ctrl = createFixtures(t)358	subject = new(Subject)359	ctrl.RecordCall(subject, "FooMethod", "argument").MaxTimes(1)360	ctrl.Call(subject, "FooMethod", "argument")361	ctrl.Finish()362	// It fails if there are more363	reporter, ctrl := createFixtures(t)364	subject = new(Subject)365	ctrl.RecordCall(subject, "FooMethod", "argument").MaxTimes(1)366	ctrl.Call(subject, "FooMethod", "argument")367	reporter.assertFatal(func() {368		ctrl.Call(subject, "FooMethod", "argument")369	})370	ctrl.Finish()371}372func TestMinMaxTimes(t *testing.T) {373	// It fails if there are less calls than specified374	reporter, ctrl := createFixtures(t)375	subject := new(Subject)376	ctrl.RecordCall(subject, "FooMethod", "argument").MinTimes(2).MaxTimes(2)377	ctrl.Call(subject, "FooMethod", "argument")378	reporter.assertFatal(func() {379		ctrl.Finish()380	})381	// It fails if there are more calls than specified382	reporter, ctrl = createFixtures(t)383	subject = new(Subject)384	ctrl.RecordCall(subject, "FooMethod", "argument").MinTimes(2).MaxTimes(2)385	ctrl.Call(subject, "FooMethod", "argument")386	ctrl.Call(subject, "FooMethod", "argument")387	reporter.assertFatal(func() {388		ctrl.Call(subject, "FooMethod", "argument")389	})390	// It succeeds if there is just the right number of calls391	_, ctrl = createFixtures(t)392	subject = new(Subject)393	ctrl.RecordCall(subject, "FooMethod", "argument").MaxTimes(2).MinTimes(2)394	ctrl.Call(subject, "FooMethod", "argument")395	ctrl.Call(subject, "FooMethod", "argument")396	ctrl.Finish()397	// If MaxTimes is called after MinTimes is called with 1, MaxTimes takes precedence.398	reporter, ctrl = createFixtures(t)399	subject = new(Subject)400	ctrl.RecordCall(subject, "FooMethod", "argument").MinTimes(1).MaxTimes(2)401	ctrl.Call(subject, "FooMethod", "argument")402	ctrl.Call(subject, "FooMethod", "argument")403	reporter.assertFatal(func() {404		ctrl.Call(subject, "FooMethod", "argument")405	})406	// If MinTimes is called after MaxTimes is called with 1, MinTimes takes precedence.407	_, ctrl = createFixtures(t)408	subject = new(Subject)409	ctrl.RecordCall(subject, "FooMethod", "argument").MaxTimes(1).MinTimes(2)410	for i := 0; i < 100; i++ {411		ctrl.Call(subject, "FooMethod", "argument")412	}413	ctrl.Finish()414}415func TestDo(t *testing.T) {416	_, ctrl := createFixtures(t)417	subject := new(Subject)418	doCalled := false419	var argument string420	wantArg := "argument"421	ctrl.RecordCall(subject, "FooMethod", wantArg).Do(422		func(arg string) {423			doCalled = true424			argument = arg425		})426	if doCalled {427		t.Error("Do() callback called too early.")428	}429	ctrl.Call(subject, "FooMethod", wantArg)430	if !doCalled {431		t.Error("Do() callback not called.")432	}433	if wantArg != argument {434		t.Error("Do callback received wrong argument.")435	}436	ctrl.Finish()437}438func TestDoAndReturn(t *testing.T) {439	_, ctrl := createFixtures(t)440	subject := new(Subject)441	doCalled := false442	var argument string443	wantArg := "argument"444	ctrl.RecordCall(subject, "FooMethod", wantArg).DoAndReturn(445		func(arg string) int {446			doCalled = true447			argument = arg448			return 5449		})450	if doCalled {451		t.Error("Do() callback called too early.")452	}453	rets := ctrl.Call(subject, "FooMethod", wantArg)454	if !doCalled {455		t.Error("Do() callback not called.")456	}457	if wantArg != argument {458		t.Error("Do callback received wrong argument.")459	}460	if len(rets) != 1 {461		t.Fatalf("Return values from Call: got %d, want 1", len(rets))462	}463	if ret, ok := rets[0].(int); !ok {464		t.Fatalf("Return value is not an int")465	} else if ret != 5 {466		t.Errorf("DoAndReturn return value: got %d, want 5", ret)467	}468	ctrl.Finish()469}470func TestSetArgSlice(t *testing.T) {471	_, ctrl := createFixtures(t)472	subject := new(Subject)473	var in = []byte{4, 5, 6}474	var set = []byte{1, 2, 3}475	ctrl.RecordCall(subject, "SetArgMethod", in, nil).SetArg(0, set)476	ctrl.Call(subject, "SetArgMethod", in, nil)477	if !reflect.DeepEqual(in, set) {478		t.Error("Expected SetArg() to modify input slice argument")479	}480	ctrl.Finish()481}482func TestSetArgPtr(t *testing.T) {483	_, ctrl := createFixtures(t)484	subject := new(Subject)485	var in int = 43486	const set = 42487	ctrl.RecordCall(subject, "SetArgMethod", nil, &in).SetArg(1, set)488	ctrl.Call(subject, "SetArgMethod", nil, &in)489	if in != set {490		t.Error("Expected SetArg() to modify value pointed to by argument")491	}492	ctrl.Finish()493}494func TestReturn(t *testing.T) {495	_, ctrl := createFixtures(t)496	subject := new(Subject)497	// Unspecified return should produce "zero" result.498	ctrl.RecordCall(subject, "FooMethod", "zero")499	ctrl.RecordCall(subject, "FooMethod", "five").Return(5)500	assertEqual(501		t,502		[]interface{}{0},503		ctrl.Call(subject, "FooMethod", "zero"))504	assertEqual(505		t,506		[]interface{}{5},507		ctrl.Call(subject, "FooMethod", "five"))508	ctrl.Finish()509}510func TestUnorderedCalls(t *testing.T) {511	reporter, ctrl := createFixtures(t)512	defer reporter.recoverUnexpectedFatal()513	subjectTwo := new(Subject)514	subjectOne := new(Subject)515	ctrl.RecordCall(subjectOne, "FooMethod", "1")516	ctrl.RecordCall(subjectOne, "BarMethod", "2")517	ctrl.RecordCall(subjectTwo, "FooMethod", "3")518	ctrl.RecordCall(subjectTwo, "BarMethod", "4")519	// Make the calls in a different order, which should be fine.520	ctrl.Call(subjectOne, "BarMethod", "2")521	ctrl.Call(subjectTwo, "FooMethod", "3")522	ctrl.Call(subjectTwo, "BarMethod", "4")523	ctrl.Call(subjectOne, "FooMethod", "1")524	reporter.assertPass("After making all calls in different order")525	ctrl.Finish()526	reporter.assertPass("After finish")527}528func commonTestOrderedCalls(t *testing.T) (reporter *ErrorReporter, ctrl *gomock.Controller, subjectOne, subjectTwo *Subject) {529	reporter, ctrl = createFixtures(t)530	subjectOne = new(Subject)531	subjectTwo = new(Subject)532	gomock.InOrder(533		ctrl.RecordCall(subjectOne, "FooMethod", "1").AnyTimes(),534		ctrl.RecordCall(subjectTwo, "FooMethod", "2"),535		ctrl.RecordCall(subjectTwo, "BarMethod", "3"),536	)537	return538}539func TestOrderedCallsCorrect(t *testing.T) {540	reporter, ctrl, subjectOne, subjectTwo := commonTestOrderedCalls(t)541	ctrl.Call(subjectOne, "FooMethod", "1")542	ctrl.Call(subjectTwo, "FooMethod", "2")543	ctrl.Call(subjectTwo, "BarMethod", "3")544	ctrl.Finish()545	reporter.assertPass("After finish")546}547func TestPanicOverridesExpectationChecks(t *testing.T) {548	ctrl := gomock.NewController(t)549	reporter := NewErrorReporter(t)550	reporter.assertFatal(func() {551		ctrl.RecordCall(new(Subject), "FooMethod", "1")552		defer ctrl.Finish()553		reporter.Fatalf("Intentional panic")554	})555}556func TestSetArgWithBadType(t *testing.T) {557	rep, ctrl := createFixtures(t)558	defer ctrl.Finish()559	s := new(Subject)560	// This should catch a type error:561	rep.assertFatal(func() {562		ctrl.RecordCall(s, "FooMethod", "1").SetArg(0, "blah")563	})564	ctrl.Call(s, "FooMethod", "1")565}566func TestTimes0(t *testing.T) {567	rep, ctrl := createFixtures(t)568	defer ctrl.Finish()569	s := new(Subject)570	ctrl.RecordCall(s, "FooMethod", "arg").Times(0)571	rep.assertFatal(func() {572		ctrl.Call(s, "FooMethod", "arg")573	})574}575func TestVariadicMatching(t *testing.T) {576	rep, ctrl := createFixtures(t)577	defer rep.recoverUnexpectedFatal()578	s := new(Subject)579	ctrl.RecordCall(s, "VariadicMethod", 0, "1", "2")580	ctrl.Call(s, "VariadicMethod", 0, "1", "2")581	ctrl.Finish()582	rep.assertPass("variadic matching works")583}584func TestVariadicNoMatch(t *testing.T) {585	rep, ctrl := createFixtures(t)586	defer rep.recoverUnexpectedFatal()587	s := new(Subject)588	ctrl.RecordCall(s, "VariadicMethod", 0)589	rep.assertFatal(func() {590		ctrl.Call(s, "VariadicMethod", 1)591	}, "expected call at", "doesn't match the argument at index 0",592		"Got: 1 (int)\nWant: is equal to 0 (int)")593	ctrl.Call(s, "VariadicMethod", 0)594	ctrl.Finish()595}596func TestVariadicMatchingWithSlice(t *testing.T) {597	testCases := [][]string{598		{"1"},599		{"1", "2"},600	}601	for _, tc := range testCases {602		t.Run(fmt.Sprintf("%d arguments", len(tc)), func(t *testing.T) {603			rep, ctrl := createFixtures(t)604			defer rep.recoverUnexpectedFatal()605			s := new(Subject)606			ctrl.RecordCall(s, "VariadicMethod", 1, tc)607			args := make([]interface{}, len(tc)+1)608			args[0] = 1609			for i, arg := range tc {610				args[i+1] = arg611			}612			ctrl.Call(s, "VariadicMethod", args...)613			ctrl.Finish()614			rep.assertPass("slices can be used as matchers for variadic arguments")615		})616	}617}618func TestVariadicArgumentsGotFormatter(t *testing.T) {619	rep, ctrl := createFixtures(t)620	defer rep.recoverUnexpectedFatal()621	s := new(Subject)622	ctrl.RecordCall(623		s,624		"VariadicMethod",625		gomock.GotFormatterAdapter(626			gomock.GotFormatterFunc(func(i interface{}) string {627				return fmt.Sprintf("test{%v}", i)628			}),629			gomock.Eq(0),630		),631	)632	rep.assertFatal(func() {633		ctrl.Call(s, "VariadicMethod", 1)634	}, "expected call to", "doesn't match the argument at index 0",635		"Got: test{1}\nWant: is equal to 0")636	ctrl.Call(s, "VariadicMethod", 0)637	ctrl.Finish()638}639func TestVariadicArgumentsGotFormatterTooManyArgsFailure(t *testing.T) {640	rep, ctrl := createFixtures(t)641	defer rep.recoverUnexpectedFatal()642	s := new(Subject)643	ctrl.RecordCall(644		s,645		"VariadicMethod",646		0,647		gomock.GotFormatterAdapter(648			gomock.GotFormatterFunc(func(i interface{}) string {649				return fmt.Sprintf("test{%v}", i)650			}),651			gomock.Eq("1"),652		),653	)654	rep.assertFatal(func() {655		ctrl.Call(s, "VariadicMethod", 0, "2", "3")656	}, "expected call to", "doesn't match the argument at index 1",657		"Got: test{[2 3]}\nWant: is equal to 1")658	ctrl.Call(s, "VariadicMethod", 0, "1")659	ctrl.Finish()660}661func TestNoHelper(t *testing.T) {662	ctrlNoHelper := gomock.NewController(NewErrorReporter(t))663	// doesn't panic664	ctrlNoHelper.T.Helper()665}666func TestWithHelper(t *testing.T) {667	withHelper := &HelperReporter{TestReporter: NewErrorReporter(t)}668	ctrlWithHelper := gomock.NewController(withHelper)...

1func Test(t *testing.T) {2    gomock_test.AssertFatal(t, func() {3    })4}5func Test(t *testing.T) {6    gomock_test.AssertFatal(t, func() {7    })8}9func Test(t *testing.T) {10    gomock_test.AssertFatal(t, func() {11    })12}13func Test(t *testing.T) {14    gomock_test.AssertFatal(t, func() {15    })16}17func Test(t *testing.T) {18    gomock_test.AssertFatal(t, func() {19    })20}21func Test(t *testing.T) {22    gomock_test.AssertFatal(t, func() {23    })24}25func Test(t *testing.T) {26    gomock_test.AssertFatal(t, func() {27    })28}29func Test(t *testing.T) {30    gomock_test.AssertFatal(t, func() {31    })32}33func Test(t *testing.T) {34    gomock_test.AssertFatal(t, func() {35    })36}37func Test(t *testing.T) {38    gomock_test.AssertFatal(t, func() {39    })40}

1func Test1(t *testing.T) {2    g := gomock_test.New(t)3    defer g.Finish()4}5func Test2(t *testing.T) {6    g := gomock_test.New(t)7    defer g.Finish()8}9func Test3(t *testing.T) {10    g := gomock_test.New(t)11    defer g.Finish()12}13func Test4(t *testing.T) {14    g := gomock_test.New(t)15    defer g.Finish()16}17func Test5(t *testing.T) {18    g := gomock_test.New(t)19    defer g.Finish()20}21func Test6(t *testing.T) {22    g := gomock_test.New(t)23    defer g.Finish()24}25func Test7(t *testing.T) {26    g := gomock_test.New(t)27    defer g.Finish()28}29func Test8(t *testing.T) {30    g := gomock_test.New(t)31    defer g.Finish()32}

1import (2func TestSomething(t *testing.T) {3    ctrl := gomock.NewController(t)4    mock := NewMockMyInterface(ctrl)5    mock.EXPECT().DoSomething(1).Return("Hello")6    result := mock.DoSomething(1)7    if result != "Hello" {8        t.Fatalf("Unexpected result: %s", result)9    }10}11import (12func TestSomething(t *testing.T) {13    ctrl := gomock.NewController(t)14    mock := NewMockMyInterface(ctrl)15    mock.EXPECT().DoSomething(1).Return("Hello")16    result := mock.DoSomething(1)17    if result != "Hello" {18        t.Fatalf("Unexpected result: %s", result)19    }20}21import (22func TestSomething(t *testing.T) {23    ctrl := gomock.NewController(t)24    mock := NewMockMyInterface(ctrl)25    mock.EXPECT().DoSomething(1).Return("Hello")26    result := mock.DoSomething(1)27    if result != "Hello" {28        t.Fatalf("Unexpected result: %s", result)29    }30}31import (32func TestSomething(t *testing.T) {

1import (2func TestGomock(t *testing.T) {3	fmt.Println("Hello, playground")4}5import (6func TestGomock(t *testing.T) {7	fmt.Println("Hello, playground")8}

1import (2func TestAdd(t *testing.T) {3	gomock_test := new(gomock_test)4	gomock_test.assertFatal(t, Add(1, 2) == 3, "Add(1, 2) should be 3")5}6func Add(x, y int) int {7}8import (9func TestAdd(t *testing.T) {10	gomock_test := new(gomock_test)11	gomock_test.assertFatal(t, Add(1, 2) == 3, "Add(1, 2) should be 3")12}13func Add(x, y int) int {14}15import (16func TestAdd(t *testing.T) {17	gomock_test := new(gomock_test)18	gomock_test.assertFatal(t, Add(1, 2) == 3, "Add(1, 2) should be 3")19}20func Add(x, y int) int {21}22import (23func TestAdd(t *testing.T) {24	gomock_test := new(gomock_test)25	gomock_test.assertFatal(t, Add(1, 2) == 3, "Add(1, 2) should be 3")26}27func Add(x, y int) int {28}29import (30func TestAdd(t *testing.T) {31	gomock_test := new(gomock_test)32	gomock_test.assertFatal(t, Add(1, 2) == 3, "Add(1, 2)

1import (2type gomock_test struct {3}4func (g *gomock_test) assertFatal(t *testing.T, message string, err error) {5	if err != nil {6		t.Fatalf("%s: %v", message, err)7	}8}9func (g *gomock_test) actual() (string, error) {10	return "", errors.New("error")11}12func main() {13	fmt.Println("vim-go")14}