How to use Got method of gomock Package

1package api2import (3	"bytes"4	"database/sql"5	"encoding/json"6	"fmt"7	"io/ioutil"8	"net/http"9	"net/http/httptest"10	"testing"11	"github.com/gin-gonic/gin"12	"github.com/golang/mock/gomock"13	"github.com/stretchr/testify/require"14	mockdb "github.com/zakiarsyad/simple-bank/db/mock"15	db "github.com/zakiarsyad/simple-bank/db/sqlc"16	"github.com/zakiarsyad/simple-bank/util"17)18func TestGetAccountAPI(t *testing.T) {19	account := randomAccount()20	testCases := []struct {21		name          string22		accountID     int6423		buildStubs    func(store *mockdb.MockStore)24		checkResponse func(t *testing.T, recoder *httptest.ResponseRecorder)25	}{26		{27			name:      "OK",28			accountID: account.ID,29			buildStubs: func(store *mockdb.MockStore) {30				store.EXPECT().31					GetAccount(gomock.Any(), gomock.Eq(account.ID)).32					Times(1).33					Return(account, nil)34			},35			checkResponse: func(t *testing.T, recorder *httptest.ResponseRecorder) {36				require.Equal(t, http.StatusOK, recorder.Code)37				requireBodyMatchAccount(t, recorder.Body, account)38			},39		},40		{41			name:      "NotFound",42			accountID: account.ID,43			buildStubs: func(store *mockdb.MockStore) {44				store.EXPECT().45					GetAccount(gomock.Any(), gomock.Eq(account.ID)).46					Times(1).47					Return(db.Account{}, sql.ErrNoRows)48			},49			checkResponse: func(t *testing.T, recorder *httptest.ResponseRecorder) {50				require.Equal(t, http.StatusNotFound, recorder.Code)51			},52		},53		{54			name:      "InternalError",55			accountID: account.ID,56			buildStubs: func(store *mockdb.MockStore) {57				store.EXPECT().58					GetAccount(gomock.Any(), gomock.Eq(account.ID)).59					Times(1).60					Return(db.Account{}, sql.ErrConnDone)61			},62			checkResponse: func(t *testing.T, recorder *httptest.ResponseRecorder) {63				require.Equal(t, http.StatusInternalServerError, recorder.Code)64			},65		},66		{67			name:      "InvalidID",68			accountID: 0,69			buildStubs: func(store *mockdb.MockStore) {70				store.EXPECT().71					GetAccount(gomock.Any(), gomock.Any()).72					Times(0)73			},74			checkResponse: func(t *testing.T, recorder *httptest.ResponseRecorder) {75				require.Equal(t, http.StatusBadRequest, recorder.Code)76			},77		},78	}79	for i := range testCases {80		tc := testCases[i]81		t.Run(tc.name, func(t *testing.T) {82			ctrl := gomock.NewController(t)83			defer ctrl.Finish()84			store := mockdb.NewMockStore(ctrl)85			tc.buildStubs(store)86			server := NewServer(store)87			recorder := httptest.NewRecorder()88			url := fmt.Sprintf("/accounts/%d", tc.accountID)89			request, err := http.NewRequest(http.MethodGet, url, nil)90			require.NoError(t, err)91			server.router.ServeHTTP(recorder, request)92			tc.checkResponse(t, recorder)93		})94	}95}96func TestCreateAccountAPI(t *testing.T) {97	account := randomAccount()98	testCases := []struct {99		name          string100		body          gin.H101		buildStubs    func(store *mockdb.MockStore)102		checkResponse func(recoder *httptest.ResponseRecorder)103	}{104		{105			name: "OK",106			body: gin.H{107				"owner":    account.Owner,108				"currency": account.Currency,109			},110			buildStubs: func(store *mockdb.MockStore) {111				arg := db.CreateAccountParams{112					Owner:    account.Owner,113					Currency: account.Currency,114					Balance:  0,115				}116				store.EXPECT().117					CreateAccount(gomock.Any(), gomock.Eq(arg)).118					Times(1).119					Return(account, nil)120			},121			checkResponse: func(recorder *httptest.ResponseRecorder) {122				require.Equal(t, http.StatusOK, recorder.Code)123				requireBodyMatchAccount(t, recorder.Body, account)124			},125		},126		{127			name: "InternalError",128			body: gin.H{129				"owner":    account.Owner,130				"currency": account.Currency,131			},132			buildStubs: func(store *mockdb.MockStore) {133				store.EXPECT().134					CreateAccount(gomock.Any(), gomock.Any()).135					Times(1).136					Return(db.Account{}, sql.ErrConnDone)137			},138			checkResponse: func(recorder *httptest.ResponseRecorder) {139				require.Equal(t, http.StatusInternalServerError, recorder.Code)140			},141		},142		{143			name: "InvalidCurrency",144			body: gin.H{145				"owner":    account.Owner,146				"currency": "invalid",147			},148			buildStubs: func(store *mockdb.MockStore) {149				store.EXPECT().150					CreateAccount(gomock.Any(), gomock.Any()).151					Times(0)152			},153			checkResponse: func(recorder *httptest.ResponseRecorder) {154				require.Equal(t, http.StatusBadRequest, recorder.Code)155			},156		},157		{158			name: "InvalidOwner",159			body: gin.H{160				"owner":    "",161				"currency": account.Currency,162			},163			buildStubs: func(store *mockdb.MockStore) {164				store.EXPECT().165					CreateAccount(gomock.Any(), gomock.Any()).166					Times(0)167			},168			checkResponse: func(recorder *httptest.ResponseRecorder) {169				require.Equal(t, http.StatusBadRequest, recorder.Code)170			},171		},172	}173	for i := range testCases {174		tc := testCases[i]175		t.Run(tc.name, func(t *testing.T) {176			ctrl := gomock.NewController(t)177			defer ctrl.Finish()178			store := mockdb.NewMockStore(ctrl)179			tc.buildStubs(store)180			server := NewServer(store)181			recorder := httptest.NewRecorder()182			// Marshal body data to JSON183			data, err := json.Marshal(tc.body)184			require.NoError(t, err)185			url := "/accounts"186			request, err := http.NewRequest(http.MethodPost, url, bytes.NewReader(data))187			require.NoError(t, err)188			server.router.ServeHTTP(recorder, request)189			tc.checkResponse(recorder)190		})191	}192}193func TestListAccountsAPI(t *testing.T) {194	n := 5195	accounts := make([]db.Account, n)196	for i := 0; i < n; i++ {197		accounts[i] = randomAccount()198	}199	type Query struct {200		pageID   int201		pageSize int202	}203	testCases := []struct {204		name          string205		query         Query206		buildStubs    func(store *mockdb.MockStore)207		checkResponse func(recoder *httptest.ResponseRecorder)208	}{209		{210			name: "OK",211			query: Query{212				pageID:   1,213				pageSize: n,214			},215			buildStubs: func(store *mockdb.MockStore) {216				arg := db.ListAccountsParams{217					Limit:  int32(n),218					Offset: 0,219				}220				store.EXPECT().221					ListAccounts(gomock.Any(), gomock.Eq(arg)).222					Times(1).223					Return(accounts, nil)224			},225			checkResponse: func(recorder *httptest.ResponseRecorder) {226				require.Equal(t, http.StatusOK, recorder.Code)227				requireBodyMatchAccounts(t, recorder.Body, accounts)228			},229		},230		{231			name: "InternalError",232			query: Query{233				pageID:   1,234				pageSize: n,235			},236			buildStubs: func(store *mockdb.MockStore) {237				store.EXPECT().238					ListAccounts(gomock.Any(), gomock.Any()).239					Times(1).240					Return([]db.Account{}, sql.ErrConnDone)241			},242			checkResponse: func(recorder *httptest.ResponseRecorder) {243				require.Equal(t, http.StatusInternalServerError, recorder.Code)244			},245		},246		{247			name: "InvalidPageID",248			query: Query{249				pageID:   -1,250				pageSize: n,251			},252			buildStubs: func(store *mockdb.MockStore) {253				store.EXPECT().254					ListAccounts(gomock.Any(), gomock.Any()).255					Times(0)256			},257			checkResponse: func(recorder *httptest.ResponseRecorder) {258				require.Equal(t, http.StatusBadRequest, recorder.Code)259			},260		},261		{262			name: "InvalidPageID",263			query: Query{264				pageID:   1,265				pageSize: 100000,266			},267			buildStubs: func(store *mockdb.MockStore) {268				store.EXPECT().269					ListAccounts(gomock.Any(), gomock.Any()).270					Times(0)271			},272			checkResponse: func(recorder *httptest.ResponseRecorder) {273				require.Equal(t, http.StatusBadRequest, recorder.Code)274			},275		},276	}277	for i := range testCases {278		tc := testCases[i]279		t.Run(tc.name, func(t *testing.T) {280			ctrl := gomock.NewController(t)281			defer ctrl.Finish()282			store := mockdb.NewMockStore(ctrl)283			tc.buildStubs(store)284			server := NewServer(store)285			recorder := httptest.NewRecorder()286			url := "/accounts"287			request, err := http.NewRequest(http.MethodGet, url, nil)288			require.NoError(t, err)289			// Add query parameters to request URL290			q := request.URL.Query()291			q.Add("page_id", fmt.Sprintf("%d", tc.query.pageID))292			q.Add("page_size", fmt.Sprintf("%d", tc.query.pageSize))293			request.URL.RawQuery = q.Encode()294			server.router.ServeHTTP(recorder, request)295			tc.checkResponse(recorder)296		})297	}298}299func randomAccount() db.Account {300	return db.Account{301		ID:       util.RandomInt(1, 1000),302		Owner:    util.RandomOwner(),303		Balance:  util.RandomMoney(),304		Currency: util.RandomCurrency(),305	}306}307func requireBodyMatchAccount(t *testing.T, body *bytes.Buffer, account db.Account) {308	data, err := ioutil.ReadAll(body)309	require.NoError(t, err)310	var gotAccount db.Account311	err = json.Unmarshal(data, &gotAccount)312	require.NoError(t, err)313	require.Equal(t, account, gotAccount)314}315func requireBodyMatchAccounts(t *testing.T, body *bytes.Buffer, accounts []db.Account) {316	data, err := ioutil.ReadAll(body)317	require.NoError(t, err)318	var gotAccounts []db.Account319	err = json.Unmarshal(data, &gotAccounts)320	require.NoError(t, err)321	require.Equal(t, accounts, gotAccounts)322}...

1package shortener2import (3	"context"4	"errors"5	"fmt"6	"testing"7	"time"8	"github.com/golang/mock/gomock"9	"github.com/stretchr/testify/suite"10	"github.com/thegodmouse/url-shortener/cache"11	mc "github.com/thegodmouse/url-shortener/cache/mock"12	"github.com/thegodmouse/url-shortener/db"13	md "github.com/thegodmouse/url-shortener/db/mock"14	"github.com/thegodmouse/url-shortener/db/record"15)16func TestShortenerSuite(t *testing.T) {17	suite.Run(t, new(ShortenerTestSuite))18}19type ShortenerTestSuite struct {20	suite.Suite21	ctrl *gomock.Controller22	dbStore    *md.MockStore23	cacheStore *mc.MockStore24}25func (s *ShortenerTestSuite) SetupSuite() {26	s.ctrl = gomock.NewController(s.T())27}28func (s *ShortenerTestSuite) SetupTest() {29	s.dbStore = md.NewMockStore(s.ctrl)30	s.cacheStore = mc.NewMockStore(s.ctrl)31}32func (s *ShortenerTestSuite) TestShorten() {33	srv := NewService(s.dbStore, s.cacheStore)34	id := int64(123)35	url := "http://localhost:5678"36	createdAt := time.Now().Add(-time.Minute).Round(time.Second)37	expireAt := time.Now().Add(time.Minute).Round(time.Second)38	shortURL := &record.ShortURL{39		ID:        id,40		CreatedAt: createdAt,41		ExpireAt:  expireAt,42		URL:       url,43	}44	s.dbStore.45		EXPECT().46		Create(gomock.Any(), gomock.Eq(url), gomock.Eq(expireAt)).47		Return(shortURL, nil)48	s.cacheStore.49		EXPECT().50		Set(gomock.Any(), gomock.Eq(id), &recordMatcher{shortURL: shortURL}).51		Return(nil)52	// SUT53	gotID, gotErr := srv.Shorten(context.Background(), url, expireAt)54	s.NoError(gotErr)55	s.Equal(id, gotID)56}57func (s *ShortenerTestSuite) TestShorten_withDatabaseError() {58	srv := NewService(s.dbStore, s.cacheStore)59	url := "http://localhost:5678"60	expireAt := time.Now().Add(time.Minute).Round(time.Second)61	s.dbStore.62		EXPECT().63		Create(gomock.Any(), gomock.Eq(url), gomock.Eq(expireAt)).64		Return(nil, errors.New("db error"))65	// SUT66	gotID, gotErr := srv.Shorten(context.Background(), url, expireAt)67	s.Error(gotErr)68	s.Equal(int64(0), gotID)69}70func (s *ShortenerTestSuite) TestShorten_withCacheError() {71	srv := NewService(s.dbStore, s.cacheStore)72	id := int64(123)73	url := "http://localhost:5678"74	createdAt := time.Now().Add(-time.Minute).Round(time.Second)75	expireAt := time.Now().Add(time.Minute).Round(time.Second)76	shortURL := &record.ShortURL{77		ID:        id,78		CreatedAt: createdAt,79		ExpireAt:  expireAt,80		URL:       url,81	}82	s.dbStore.83		EXPECT().84		Create(gomock.Any(), gomock.Eq(url), gomock.Eq(expireAt)).85		Return(shortURL, nil)86	s.cacheStore.87		EXPECT().88		Set(gomock.Any(), gomock.Eq(id), &recordMatcher{shortURL: shortURL}).89		Return(errors.New("cache error"))90	// SUT91	gotID, gotErr := srv.Shorten(context.Background(), url, expireAt)92	s.NoError(gotErr)93	s.Equal(id, gotID)94}95func (s *ShortenerTestSuite) TestDelete() {96	srv := NewService(s.dbStore, s.cacheStore)97	id := int64(12345)98	s.cacheStore.99		EXPECT().100		Get(gomock.Any(), gomock.Eq(id)).101		Return(nil, cache.ErrKeyNotFound)102	s.dbStore.103		EXPECT().104		Delete(gomock.Any(), gomock.Eq(id)).105		Return(nil)106	s.cacheStore.107		EXPECT().108		Set(gomock.Any(), gomock.Eq(id), &recordMatcher{shortURL: &record.ShortURL{ID: id, IsDeleted: true}}).109		Return(nil)110	// SUT111	gotErr := srv.Delete(context.Background(), id)112	s.NoError(gotErr)113}114func (s *ShortenerTestSuite) TestDelete_withDatabaseError() {115	srv := NewService(s.dbStore, s.cacheStore)116	id := int64(12345)117	s.cacheStore.118		EXPECT().119		Get(gomock.Any(), gomock.Eq(id)).120		Return(nil, cache.ErrKeyNotFound)121	s.dbStore.122		EXPECT().123		Delete(gomock.Any(), gomock.Eq(id)).124		Return(errors.New("db error"))125	// SUT126	gotErr := srv.Delete(context.Background(), id)127	s.Error(gotErr)128}129func (s *ShortenerTestSuite) TestDelete_withCacheGetError() {130	srv := NewService(s.dbStore, s.cacheStore)131	id := int64(12345)132	s.cacheStore.133		EXPECT().134		Get(gomock.Any(), gomock.Eq(id)).135		Return(nil, errors.New("unknown cache error"))136	s.dbStore.137		EXPECT().138		Delete(gomock.Any(), gomock.Eq(id)).139		Return(nil)140	s.cacheStore.141		EXPECT().142		Set(gomock.Any(), gomock.Eq(id), &recordMatcher{shortURL: &record.ShortURL{ID: id, IsDeleted: true}}).143		Return(nil)144	// SUT145	gotErr := srv.Delete(context.Background(), id)146	s.NoError(gotErr)147}148func (s *ShortenerTestSuite) TestDelete_withCacheSetError() {149	srv := NewService(s.dbStore, s.cacheStore)150	id := int64(12345)151	s.cacheStore.152		EXPECT().153		Get(gomock.Any(), gomock.Eq(id)).154		Return(nil, cache.ErrKeyNotFound)155	s.dbStore.156		EXPECT().157		Delete(gomock.Any(), gomock.Eq(id)).158		Return(nil)159	s.cacheStore.160		EXPECT().161		Set(gomock.Any(), gomock.Eq(id), &recordMatcher{shortURL: &record.ShortURL{ID: id, IsDeleted: true}}).162		Return(errors.New("unknown cache err"))163	// SUT164	gotErr := srv.Delete(context.Background(), id)165	s.NoError(gotErr)166}167func (s *ShortenerTestSuite) TestDelete_withRecordDeleted() {168	srv := NewService(s.dbStore, s.cacheStore)169	id := int64(12345)170	url := "http://localhost:5678"171	createdAt := time.Now().Add(-time.Minute).Round(time.Second)172	expireAt := time.Now().Add(time.Minute).Round(time.Second)173	shortURL := &record.ShortURL{174		ID:        id,175		CreatedAt: createdAt,176		ExpireAt:  expireAt,177		URL:       url,178		IsDeleted: true,179	}180	s.cacheStore.181		EXPECT().182		Get(gomock.Any(), gomock.Eq(id)).183		Return(shortURL, nil)184	// SUT185	gotErr := srv.Delete(context.Background(), id)186	s.NoError(gotErr)187}188func (s *ShortenerTestSuite) TestDelete_withRecordNotExist_andCacheHit() {189	srv := NewService(s.dbStore, s.cacheStore)190	id := int64(12345)191	shortURL := &record.ShortURL{192		ID:         id,193		IsNotExist: true,194	}195	s.cacheStore.196		EXPECT().197		Get(gomock.Any(), gomock.Eq(id)).198		Return(shortURL, nil)199	// SUT200	gotErr := srv.Delete(context.Background(), id)201	s.NoError(gotErr)202}203func (s *ShortenerTestSuite) TestDelete_withRecordNotExist_andCacheMiss() {204	srv := NewService(s.dbStore, s.cacheStore)205	id := int64(12345)206	s.cacheStore.207		EXPECT().208		Get(gomock.Any(), gomock.Eq(id)).209		Return(nil, cache.ErrKeyNotFound)210	s.dbStore.211		EXPECT().212		Delete(gomock.Any(), gomock.Eq(id)).213		Return(db.ErrNoRows)214	s.cacheStore.215		EXPECT().216		Set(gomock.Any(), gomock.Eq(id), &recordMatcher{shortURL: &record.ShortURL{ID: id, IsNotExist: true}}).217		Return(nil)218	// SUT219	gotErr := srv.Delete(context.Background(), id)220	s.Error(gotErr)221}222func (s *ShortenerTestSuite) TestDelete_withRecordNotExist_andCacheError() {223	srv := NewService(s.dbStore, s.cacheStore)224	id := int64(12345)225	s.cacheStore.226		EXPECT().227		Get(gomock.Any(), gomock.Eq(id)).228		Return(nil, cache.ErrKeyNotFound)229	s.dbStore.230		EXPECT().231		Delete(gomock.Any(), gomock.Eq(id)).232		Return(db.ErrNoRows)233	s.cacheStore.234		EXPECT().235		Set(gomock.Any(), gomock.Eq(id), &recordMatcher{shortURL: &record.ShortURL{ID: id, IsNotExist: true}}).236		Return(errors.New("unknown cache error"))237	// SUT238	gotErr := srv.Delete(context.Background(), id)239	s.Error(gotErr)240}241type recordMatcher struct {242	shortURL *record.ShortURL243}244func (m recordMatcher) Matches(x interface{}) bool {245	shortURL, ok := x.(*record.ShortURL)246	if !ok {247		return false248	}249	return m.shortURL.ID == shortURL.ID &&250		m.shortURL.URL == shortURL.URL &&251		m.shortURL.ExpireAt.Equal(shortURL.ExpireAt) &&252		m.shortURL.CreatedAt.Equal(shortURL.CreatedAt)253}254func (m recordMatcher) String() string {255	return fmt.Sprintf("has record: %+v", m.shortURL)256}...

1import (2func main() {3	fmt.Println("Hello, playground")4	ctrl := gomock.NewController(t)5	defer ctrl.Finish()6	mock := NewMockMyInterface(ctrl)7	mock.EXPECT().Got(gomock.Any()).Do(func(i int) {8		fmt.Println("Got", i)9	})10	mock.Got(10)11}12import (13func main() {14	fmt.Println("Hello, playground")15	ctrl := gomock.NewController(t)16	defer ctrl.Finish()17	mock := NewMockMyInterface(ctrl)18	mock.EXPECT().Got(gomock.Any()).Do(func(i int) {19		fmt.Println("Got", i)20	})21	mock.Got(10)22}23import (24func main() {25	fmt.Println("Hello, playground")26	ctrl := gomock.NewController(t)27	defer ctrl.Finish()28	mock := NewMockMyInterface(ctrl)29	mock.EXPECT().Got(gomock.Any()).Do(func(i int) {30		fmt.Println("Got", i)31	})32	mock.Got(10)33}34import (35func main() {36	fmt.Println("Hello, playground")37	ctrl := gomock.NewController(t)38	defer ctrl.Finish()39	mock := NewMockMyInterface(ctrl)40	mock.EXPECT().Got(gomock.Any()).Do(func(i int) {41		fmt.Println("Got", i)42	})43	mock.Got(10)44}45import (46func main() {47	fmt.Println("Hello, playground")48	ctrl := gomock.NewController(t)49	defer ctrl.Finish()50	mock := NewMockMyInterface(ctrl)51	mock.EXPECT().Got(gomock.Any()).Do(func(i int)

1func main() {2    mockCtrl := gomock.NewController(t)3    defer mockCtrl.Finish()4    mock := NewMockGot(mockCtrl)5    mock.EXPECT().Got().Return(1)6    fmt.Println(mock.Got())7}8func main() {9    mockCtrl := gomock.NewController(t)10    defer mockCtrl.Finish()11    mock := NewMockGot(mockCtrl)12    mock.EXPECT().Got().Return(1)13    fmt.Println(mock.Got())14}15func main() {16    mockCtrl := gomock.NewController(t)17    defer mockCtrl.Finish()18    mock := NewMockGot(mockCtrl)19    mock.EXPECT().Got().Return(1)20    fmt.Println(mock.Got())21}22func main() {23    mockCtrl := gomock.NewController(t)24    defer mockCtrl.Finish()25    mock := NewMockGot(mockCtrl)26    mock.EXPECT().Got().Return(1)27    fmt.Println(mock.Got())28}29func main() {30    mockCtrl := gomock.NewController(t)31    defer mockCtrl.Finish()32    mock := NewMockGot(mockCtrl)33    mock.EXPECT().Got().Return(1)34    fmt.Println(mock.Got())35}36func main() {37    mockCtrl := gomock.NewController(t)38    defer mockCtrl.Finish()39    mock := NewMockGot(mockCtrl)40    mock.EXPECT().Got().Return(1)41    fmt.Println(mock.Got())42}43func main() {44    mockCtrl := gomock.NewController(t)45    defer mockCtrl.Finish()46    mock := NewMockGot(mockCtrl)47    mock.EXPECT().Got().Return(1)48    fmt.Println(mock.Got())49}50func main() {51    mockCtrl := gomock.NewController(t)

1func TestGot(t *testing.T) {2    ctrl := gomock.NewController(t)3    defer ctrl.Finish()4    m := NewMockGot(ctrl)5    m.EXPECT().Got().Return("Hello World")6    Got(m)7}8func Got(m *MockGot) {9    m.Got()10}11type Got interface {12    Got() string13}14type MockGot struct {15}16func (_m *MockGot) Got() string {17    ret := _m.Called()18    if rf, ok := ret.Get(0).(func() string); ok {19        r0 = rf()20    } else {21        r0 = ret.Get(0).(string)22    }23}24func someFunc(s []*SomeStruct) {25}26func main() {27    someFunc(s)28}29func someFunc(s []*SomeStruct) {30    if s == nil {31        s = make([]*SomeStruct, 0)32    }33}34func main() {35    someFunc(&s)36}

1func TestMock(t *testing.T) {2    mock := NewMockGomock(gomock.NewController(t))3    mock.EXPECT().Got("test").Return("test")4    mock.Got("test")5}6func TestMock(t *testing.T) {7    mock := NewMockGomock(gomock.NewController(t))8    mock.EXPECT().Got("test").Return("test")9    mock.Got("test")10}11func TestMock(t *testing.T) {12    mock := NewMockGomock(gomock.NewController(t))13    mock.EXPECT().Got("test").Return("test")14    mock.Got("test")15}16func TestMock(t *testing.T) {17    mock := NewMockGomock(gomock.NewController(t))18    mock.EXPECT().Got("test").Return("test")19    mock.Got("test")20}21func TestMock(t *testing.T) {22    mock := NewMockGomock(gomock.NewController(t))23    mock.EXPECT().Got("test").Return("test")24    mock.Got("test")25}26func TestMock(t *testing.T) {27    mock := NewMockGomock(gomock.NewController(t))28    mock.EXPECT().Got("test").Return("test")29    mock.Got("test")30}

1import (2var (3	test = &testing.T{}4func main() {5	ctrl := gomock.NewController(test)6	defer ctrl.Finish()7	mockObj := mock.NewMockGomock(ctrl)8	mockObj.EXPECT().Got().Return("Hello")9	fmt.Println(mockObj.Got())10}11import (12var (13	test = &testing.T{}14func main() {15	ctrl := gomock.NewController(test)16	defer ctrl.Finish()17	mockObj := mock.NewMockGomock(ctrl)18	mockObj.EXPECT().Got().Return("Hello")19	fmt.Println(mockObj.Got())20}21import (22var (23	test = &testing.T{}24func main() {25	ctrl := gomock.NewController(test)26	defer ctrl.Finish()27	mockObj := mock.NewMockGomock(ctrl)28	mockObj.EXPECT().Got().Return("Hello")29	fmt.Println(mockObj.Got())30}31import (32var (33	test = &testing.T{}34func main() {35	ctrl := gomock.NewController(test)36	defer ctrl.Finish()37	mockObj := mock.NewMockGomock(ctrl)38	mockObj.EXPECT().Got().Return("Hello")39	fmt.Println(mockObj.Got())40}41import (42var (43	test = &testing.T{}44func main() {45	ctrl := gomock.NewController(test)46	defer ctrl.Finish()47	mockObj := mock.NewMockGomock(ctrl)48	mockObj.EXPECT().Got().Return("Hello")49	fmt.Println(mockObj.Got())50}