How to use setSlice method of gomock Package

...210	c.addAction(func(args []interface{}) []interface{} {211		v := reflect.ValueOf(value)212		switch reflect.TypeOf(args[n]).Kind() {213		case reflect.Slice:214			setSlice(args[n], v)215		default:216			reflect.ValueOf(args[n]).Elem().Set(v)217		}218		return nil219	})220	return c221}222// isPreReq returns true if other is a direct or indirect prerequisite to c.223func (c *Call) isPreReq(other *Call) bool {224	for _, preReq := range c.preReqs {225		if other == preReq || preReq.isPreReq(other) {226			return true227		}228	}229	return false230}231// After declares that the call may only match after preReq has been exhausted.232func (c *Call) After(preReq *Call) *Call {233	c.t.Helper()234	if c == preReq {235		c.t.Fatalf("A call isn't allowed to be its own prerequisite")236	}237	if preReq.isPreReq(c) {238		c.t.Fatalf("Loop in call order: %v is a prerequisite to %v (possibly indirectly).", c, preReq)239	}240	c.preReqs = append(c.preReqs, preReq)241	return c242}243// Returns true if the minimum number of calls have been made.244func (c *Call) satisfied() bool {245	return c.numCalls >= c.minCalls246}247// Returns true iff the maximum number of calls have been made.248func (c *Call) exhausted() bool {249	return c.numCalls >= c.maxCalls250}251func (c *Call) String() string {252	args := make([]string, len(c.args))253	for i, arg := range c.args {254		args[i] = arg.String()255	}256	arguments := strings.Join(args, ", ")257	return fmt.Sprintf("%T.%v(%s) %s", c.receiver, c.method, arguments, c.origin)258}259// Tests if the given call matches the expected call.260// If yes, returns nil. If no, returns error with message explaining why it does not match.261func (c *Call) matches(args []interface{}) error {262	if !c.methodType.IsVariadic() {263		if len(args) != len(c.args) {264			return fmt.Errorf("Expected call at %s has the wrong number of arguments. Got: %d, want: %d",265				c.origin, len(args), len(c.args))266		}267		for i, m := range c.args {268			if !m.Matches(args[i]) {269				return fmt.Errorf("Expected call at %s doesn't match the argument at index %s.\nGot: %v\nWant: %v",270					c.origin, strconv.Itoa(i), args[i], m)271			}272		}273	} else {274		if len(c.args) < c.methodType.NumIn()-1 {275			return fmt.Errorf("Expected call at %s has the wrong number of matchers. Got: %d, want: %d",276				c.origin, len(c.args), c.methodType.NumIn()-1)277		}278		if len(c.args) != c.methodType.NumIn() && len(args) != len(c.args) {279			return fmt.Errorf("Expected call at %s has the wrong number of arguments. Got: %d, want: %d",280				c.origin, len(args), len(c.args))281		}282		if len(args) < len(c.args)-1 {283			return fmt.Errorf("Expected call at %s has the wrong number of arguments. Got: %d, want: greater than or equal to %d",284				c.origin, len(args), len(c.args)-1)285		}286		for i, m := range c.args {287			if i < c.methodType.NumIn()-1 {288				// Non-variadic args289				if !m.Matches(args[i]) {290					return fmt.Errorf("Expected call at %s doesn't match the argument at index %s.\nGot: %v\nWant: %v",291						c.origin, strconv.Itoa(i), args[i], m)292				}293				continue294			}295			// The last arg has a possibility of a variadic argument, so let it branch296			// sample: Foo(a int, b int, c ...int)297			if i < len(c.args) && i < len(args) {298				if m.Matches(args[i]) {299					// Got Foo(a, b, c) want Foo(matcherA, matcherB, gomock.Any())300					// Got Foo(a, b, c) want Foo(matcherA, matcherB, someSliceMatcher)301					// Got Foo(a, b, c) want Foo(matcherA, matcherB, matcherC)302					// Got Foo(a, b) want Foo(matcherA, matcherB)303					// Got Foo(a, b, c, d) want Foo(matcherA, matcherB, matcherC, matcherD)304					continue305				}306			}307			// The number of actual args don't match the number of matchers,308			// or the last matcher is a slice and the last arg is not.309			// If this function still matches it is because the last matcher310			// matches all the remaining arguments or the lack of any.311			// Convert the remaining arguments, if any, into a slice of the312			// expected type.313			vargsType := c.methodType.In(c.methodType.NumIn() - 1)314			vargs := reflect.MakeSlice(vargsType, 0, len(args)-i)315			for _, arg := range args[i:] {316				vargs = reflect.Append(vargs, reflect.ValueOf(arg))317			}318			if m.Matches(vargs.Interface()) {319				// Got Foo(a, b, c, d, e) want Foo(matcherA, matcherB, gomock.Any())320				// Got Foo(a, b, c, d, e) want Foo(matcherA, matcherB, someSliceMatcher)321				// Got Foo(a, b) want Foo(matcherA, matcherB, gomock.Any())322				// Got Foo(a, b) want Foo(matcherA, matcherB, someEmptySliceMatcher)323				break324			}325			// Wrong number of matchers or not match. Fail.326			// Got Foo(a, b) want Foo(matcherA, matcherB, matcherC, matcherD)327			// Got Foo(a, b, c) want Foo(matcherA, matcherB, matcherC, matcherD)328			// Got Foo(a, b, c, d) want Foo(matcherA, matcherB, matcherC, matcherD, matcherE)329			// Got Foo(a, b, c, d, e) want Foo(matcherA, matcherB, matcherC, matcherD)330			// Got Foo(a, b, c) want Foo(matcherA, matcherB)331			return fmt.Errorf("Expected call at %s doesn't match the argument at index %s.\nGot: %v\nWant: %v",332				c.origin, strconv.Itoa(i), args[i:], c.args[i])333		}334	}335	// Check that all prerequisite calls have been satisfied.336	for _, preReqCall := range c.preReqs {337		if !preReqCall.satisfied() {338			return fmt.Errorf("Expected call at %s doesn't have a prerequisite call satisfied:\n%v\nshould be called before:\n%v",339				c.origin, preReqCall, c)340		}341	}342	// Check that the call is not exhausted.343	if c.exhausted() {344		return fmt.Errorf("Expected call at %s has already been called the max number of times.", c.origin)345	}346	return nil347}348// dropPrereqs tells the expected Call to not re-check prerequisite calls any349// longer, and to return its current set.350func (c *Call) dropPrereqs() (preReqs []*Call) {351	preReqs = c.preReqs352	c.preReqs = nil353	return354}355func (c *Call) call(args []interface{}) []func([]interface{}) []interface{} {356	c.numCalls++357	return c.actions358}359// InOrder declares that the given calls should occur in order.360func InOrder(calls ...*Call) {361	for i := 1; i < len(calls); i++ {362		calls[i].After(calls[i-1])363	}364}365func setSlice(arg interface{}, v reflect.Value) {366	va := reflect.ValueOf(arg)367	for i := 0; i < v.Len(); i++ {368		va.Index(i).Set(v.Index(i))369	}370}371func (c *Call) addAction(action func([]interface{}) []interface{}) {372	c.actions = append(c.actions, action)373}...

...76			require.Equal(t, uint64(1), v.FieldByName("descriptorSetCount").Uint())77			setLayoutPtr := (*driver.VkDescriptorSetLayout)(unsafe.Pointer(v.FieldByName("pSetLayouts").Elem().UnsafeAddr()))78			setLayoutSlice := ([]driver.VkDescriptorSetLayout)(unsafe.Slice(setLayoutPtr, 1))79			require.Equal(t, layout.Handle(), setLayoutSlice[0])80			setSlice := ([]driver.VkDescriptorSet)(unsafe.Slice(pSets, 1))81			setSlice[0] = setHandle82			return core1_0.VKSuccess, nil83		})84	mockDriver.EXPECT().VkFreeDescriptorSets(device.Handle(), pool.Handle(), driver.Uint32(1), gomock.Not(nil)).DoAndReturn(85		func(device driver.VkDevice, descriptorPool driver.VkDescriptorPool, setCount driver.Uint32, pSets *driver.VkDescriptorSet) (common.VkResult, error) {86			setSlice := ([]driver.VkDescriptorSet)(unsafe.Slice(pSets, 1))87			require.Equal(t, setHandle, setSlice[0])88			return core1_0.VKSuccess, nil89		})90	sets, _, err := device.AllocateDescriptorSets(core1_0.DescriptorSetAllocateOptions{91		DescriptorPool:    pool,92		AllocationLayouts: []core1_0.DescriptorSetLayout{layout},93	})94	require.NoError(t, err)95	require.Len(t, sets, 1)96	require.Equal(t, setHandle, sets[0].Handle())97	_, err = device.FreeDescriptorSets(sets)98	require.NoError(t, err)99}100func TestDescriptorPool_AllocAndFree_Multi(t *testing.T) {101	ctrl := gomock.NewController(t)102	defer ctrl.Finish()103	mockDriver := mock_driver.DriverForVersion(ctrl, common.Vulkan1_0)104	device := internal_mocks.EasyDummyDevice(mockDriver)105	pool := mocks.EasyMockDescriptorPool(ctrl, device)106	setHandle1 := mocks.NewFakeDescriptorSet()107	setHandle2 := mocks.NewFakeDescriptorSet()108	setHandle3 := mocks.NewFakeDescriptorSet()109	layout1 := mocks.EasyMockDescriptorSetLayout(ctrl)110	layout2 := mocks.EasyMockDescriptorSetLayout(ctrl)111	layout3 := mocks.EasyMockDescriptorSetLayout(ctrl)112	mockDriver.EXPECT().VkAllocateDescriptorSets(device.Handle(), gomock.Not(nil), gomock.Not(nil)).DoAndReturn(113		func(device driver.VkDevice, pAllocateInfo *driver.VkDescriptorSetAllocateInfo, pSets *driver.VkDescriptorSet) (common.VkResult, error) {114			v := reflect.ValueOf(*pAllocateInfo)115			require.Equal(t, uint64(34), v.FieldByName("sType").Uint()) // VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO116			require.True(t, v.FieldByName("pNext").IsNil())117			actualPool := (driver.VkDescriptorPool)(unsafe.Pointer(v.FieldByName("descriptorPool").Elem().UnsafeAddr()))118			require.Equal(t, pool.Handle(), actualPool)119			require.Equal(t, uint64(3), v.FieldByName("descriptorSetCount").Uint())120			setLayoutPtr := (*driver.VkDescriptorSetLayout)(unsafe.Pointer(v.FieldByName("pSetLayouts").Elem().UnsafeAddr()))121			setLayoutSlice := ([]driver.VkDescriptorSetLayout)(unsafe.Slice(setLayoutPtr, 3))122			require.Equal(t, layout1.Handle(), setLayoutSlice[0])123			require.Equal(t, layout2.Handle(), setLayoutSlice[1])124			require.Equal(t, layout3.Handle(), setLayoutSlice[2])125			setSlice := ([]driver.VkDescriptorSet)(unsafe.Slice(pSets, 3))126			setSlice[0] = setHandle1127			setSlice[1] = setHandle2128			setSlice[2] = setHandle3129			return core1_0.VKSuccess, nil130		})131	mockDriver.EXPECT().VkFreeDescriptorSets(device.Handle(), pool.Handle(), driver.Uint32(3), gomock.Not(nil)).DoAndReturn(132		func(device driver.VkDevice, descriptorPool driver.VkDescriptorPool, setCount driver.Uint32, pSets *driver.VkDescriptorSet) (common.VkResult, error) {133			setSlice := ([]driver.VkDescriptorSet)(unsafe.Slice(pSets, 3))134			require.Equal(t, setHandle1, setSlice[0])135			require.Equal(t, setHandle2, setSlice[1])136			require.Equal(t, setHandle3, setSlice[2])137			return core1_0.VKSuccess, nil138		})139	sets, _, err := device.AllocateDescriptorSets(core1_0.DescriptorSetAllocateOptions{140		DescriptorPool:    pool,141		AllocationLayouts: []core1_0.DescriptorSetLayout{layout1, layout2, layout3},142	})143	require.NoError(t, err)144	require.Len(t, sets, 3)145	require.Equal(t, setHandle1, sets[0].Handle())146	require.Equal(t, setHandle2, sets[1].Handle())147	require.Equal(t, setHandle3, sets[2].Handle())148	_, err = device.FreeDescriptorSets(sets)149	require.NoError(t, err)150}...

1import (2func TestSetSlice(t *testing.T) {3	ctrl := gomock.NewController(t)4	defer ctrl.Finish()5	mock := NewMockMyInterface(ctrl)6	mock.EXPECT().SetSlice(gomock.Any()).Return(nil)7	mock.SetSlice([]int{1, 2, 3})8}9import (10type MyInterface interface {11	SetSlice([]int) error12}13type MyStruct struct {14}15func (m *MyStruct) SetSlice(s []int) error {16	fmt.Println("Inside set slice")17}18func NewMockMyInterface() MyInterface {19	return &MyStruct{}20}

1func TestSetSlice(t *testing.T) {2    mockCtrl := gomock.NewController(t)3    defer mockCtrl.Finish()4    mock := NewMockInterface(mockCtrl)5    mock.EXPECT().SetSlice([]int{1, 2, 3}).Return(nil)6    err := mock.SetSlice([]int{1, 2, 3})7    if err != nil {8        t.Errorf("Error is not nil")9    }10}11func TestSetSlice(t *testing.T) {12    mockCtrl := gomock.NewController(t)13    defer mockCtrl.Finish()14    mock := NewMockInterface(mockCtrl)15    mock.EXPECT().SetSlice(gomock.Any()).Return(nil)16    err := mock.SetSlice([]int{1, 2, 3})17    if err != nil {18        t.Errorf("Error is not nil")19    }20}

1func TestSetSlice(t *testing.T) {2    var mock = NewMockMyInterface(ctrl.NewController(t))3    mock.EXPECT().setSlice(gomock.Any()).Return(nil)4    mock.setSlice([]string{"foo", "bar"})5}6func TestSetSlice(t *testing.T) {7    var mock = NewMockMyInterface(ctrl.NewController(t))8    mock.EXPECT().setSlice(gomock.Any()).Return(nil)9    mock.setSlice([]string{"foo", "bar"})10}11func TestSetSlice(t *testing.T) {12    var mock = NewMockMyInterface(ctrl.NewController(t))13    mock.EXPECT().setSlice(gomock.Any()).Return(nil)14    mock.setSlice([]string{"foo", "bar"})15}16func TestSetSlice(t *testing.T) {17    var mock = NewMockMyInterface(ctrl.NewController(t))18    mock.EXPECT().setSlice(gomock.Any()).Return(nil)19    mock.setSlice([]string{"foo", "bar"})20}21func TestSetSlice(t *testing.T) {22    var mock = NewMockMyInterface(ctrl.NewController(t))23    mock.EXPECT().setSlice(gomock.Any()).Return(nil)24    mock.setSlice([]string{"foo", "bar"})25}26func TestSetSlice(t *testing.T) {27    var mock = NewMockMyInterface(ctrl.NewController(t))28    mock.EXPECT().setSlice(gomock.Any()).Return(nil)29    mock.setSlice([]string{"foo", "bar"})30}31func TestSetSlice(t *testing.T) {32    var mock = NewMockMyInterface(ctrl.NewController(t))33    mock.EXPECT().setSlice(gomock.Any()).Return(nil)34    mock.setSlice([]string{"foo", "bar"})35}

1import (2func TestSetSlice(t *testing.T) {3    ctrl := gomock.NewController(t)4    mockObj := mock.NewMockTest(ctrl)5    slice := []model.Test{{"Test1", time.Now()}, {"Test2", time.Now()}}6    mockObj.EXPECT().SetSlice(slice).Return(nil)7    err := mockObj.SetSlice(slice)8    if err != nil {9        t.Errorf("Error is not nil")10    }11}12import (13func TestGetSlice(t *testing.T) {14    ctrl := gomock.NewController(t)15    mockObj := mock.NewMockTest(ctrl)16    slice := []model.Test{{"Test1", time.Now()}, {"Test2", time.Now()}}17    mockObj.EXPECT().SetSlice(slice).Return(nil)18    err := mockObj.SetSlice(slice)19    if err != nil {20        t.Errorf("Error is not nil")21    }22}23import (24func TestSetMap(t *testing.T) {25    ctrl := gomock.NewController(t)

1func TestSetSlice(t *testing.T) {2    mock := NewMockMyInterface(ctrl)3    mock.EXPECT().SetSlice([]string{"a", "b", "c"}).Return()4    mock.SetSlice([]string{"a", "b", "c"})5}6import (7type MyInterface interface {8    SetSlice([]string)9}10type MyStruct struct {11}12func (m *MyStruct) SetSlice(s []string) {13    m.MyInterface.SetSlice(s)14}15func TestSetSlice(t *testing.T) {16    mock := NewMockMyInterface(ctrl)17    mock.EXPECT().SetSlice([]string{"a", "b", "c"}).Return()18    MyStruct{mock}.SetSlice([]string{"a", "b", "c"})19}

1func main() {2    mock := NewMockInterface(gomock.NewController(nil))3    mock.EXPECT().setSlice().Return([]int{1, 2, 3})4    setSlice(mock)5}6func setSlice(mock Interface) {7    slice := mock.setSlice()8    fmt.Println(slice)9}10func (m *MockInterface) setSlice() []int {11    ret := m.ctrl.Call(m, "setSlice")12    return ret[0].([]int)13}14func (mr *MockInterfaceMockRecorder) setSlice() *gomock.Call {15    return mr.mock.ctrl.RecordCall(mr.mock, "setSlice")16}17import (18type MockInterface struct {19}20func (m *MockInterface) setSlice() []string {21    ret := m.Called()22    return ret.Get(0).([]string)23}24func TestSetSlice(t *testing.T) {25    mock := &MockInterface{}26    mock.On("setSlice").Return([]string{"a", "b", "c"})27    slice := mock.setSlice()28    assert.Equal(t, []string{"a", "b", "c"}, slice)29}30panic: interface conversion: interface {} is nil, not []string [recovered]31    panic: interface conversion: interface {} is nil, not []string32testing.tRunner.func1(0xc4200e4160)33panic(0x10c5ba0, 0xc4200a2b40)34github.com/stretchr/testify/mock.(*Mock).Called(0xc4200a2b