1// Code generated by mockery; DO NOT EDIT.
2// github.com/vektra/mockery
3// template: testify
4
5package vulkan
6
7import (
8 "github.com/bnema/purego-vulkan/vulkan"
9 mock "github.com/stretchr/testify/mock"
10)
11
12// newMockcaptureSync creates a new instance of mockcaptureSync. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
13// The first argument is typically a *testing.T value.
14func newMockcaptureSync(t interface {
15 mock.TestingT
16 Cleanup(func())
17}) *mockcaptureSync {
18 if helper, ok := t.(interface{ Helper() }); ok {
19 helper.Helper()
20 }
21
22 mock := &mockcaptureSync{}
23 mock.Mock.Test(t)
24
25 t.Cleanup(func() {
26 if helper, ok := t.(interface{ Helper() }); ok {
27 helper.Helper()
28 }
29 mock.AssertExpectations(t)
30 })
31
32 return mock
33}
34
35// mockcaptureSync is an autogenerated mock type for the captureSync type
36type mockcaptureSync struct {
37 mock.Mock
38}
39
40type mockcaptureSync_Expecter struct {
41 mock *mock.Mock
42}
43
44func (_m *mockcaptureSync) EXPECT() *mockcaptureSync_Expecter {
45 return &mockcaptureSync_Expecter{mock: &_m.Mock}
46}
47
48// destroySemaphore provides a mock function for the type mockcaptureSync
49func (_mock *mockcaptureSync) destroySemaphore(s vulkan.Semaphore) {
50 _mock.Called(s)
51 return
52}
53
54// mockcaptureSync_destroySemaphore_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'destroySemaphore'
55type mockcaptureSync_destroySemaphore_Call struct {
56 *mock.Call
57}
58
59// destroySemaphore is a helper method to define mock.On call
60// - s vulkan.Semaphore
61func (_e *mockcaptureSync_Expecter) destroySemaphore(s any) *mockcaptureSync_destroySemaphore_Call {
62 return &mockcaptureSync_destroySemaphore_Call{Call: _e.mock.On("destroySemaphore", s)}
63}
64
65func (_c *mockcaptureSync_destroySemaphore_Call) Run(run func(s vulkan.Semaphore)) *mockcaptureSync_destroySemaphore_Call {
66 _c.Call.Run(func(args mock.Arguments) {
67 var arg0 vulkan.Semaphore
68 if args[0] != nil {
69 arg0 = args[0].(vulkan.Semaphore)
70 }
71 run(
72 arg0,
73 )
74 })
75 return _c
76}
77
78func (_c *mockcaptureSync_destroySemaphore_Call) Return() *mockcaptureSync_destroySemaphore_Call {
79 _c.Call.Return()
80 return _c
81}
82
83func (_c *mockcaptureSync_destroySemaphore_Call) RunAndReturn(run func(s vulkan.Semaphore)) *mockcaptureSync_destroySemaphore_Call {
84 _c.Run(run)
85 return _c
86}
87
88// exportSyncFD provides a mock function for the type mockcaptureSync
89func (_mock *mockcaptureSync) exportSyncFD(s vulkan.Semaphore) (int32, vulkan.Result) {
90 ret := _mock.Called(s)
91
92 if len(ret) == 0 {
93 panic("no return value specified for exportSyncFD")
94 }
95
96 var r0 int32
97 var r1 vulkan.Result
98 if returnFunc, ok := ret.Get(0).(func(vulkan.Semaphore) (int32, vulkan.Result)); ok {
99 return returnFunc(s)
100 }
101 if returnFunc, ok := ret.Get(0).(func(vulkan.Semaphore) int32); ok {
102 r0 = returnFunc(s)
103 } else {
104 r0 = ret.Get(0).(int32)
105 }
106 if returnFunc, ok := ret.Get(1).(func(vulkan.Semaphore) vulkan.Result); ok {
107 r1 = returnFunc(s)
108 } else {
109 r1 = ret.Get(1).(vulkan.Result)
110 }
111 return r0, r1
112}
113
114// mockcaptureSync_exportSyncFD_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'exportSyncFD'
115type mockcaptureSync_exportSyncFD_Call struct {
116 *mock.Call
117}
118
119// exportSyncFD is a helper method to define mock.On call
120// - s vulkan.Semaphore
121func (_e *mockcaptureSync_Expecter) exportSyncFD(s any) *mockcaptureSync_exportSyncFD_Call {
122 return &mockcaptureSync_exportSyncFD_Call{Call: _e.mock.On("exportSyncFD", s)}
123}
124
125func (_c *mockcaptureSync_exportSyncFD_Call) Run(run func(s vulkan.Semaphore)) *mockcaptureSync_exportSyncFD_Call {
126 _c.Call.Run(func(args mock.Arguments) {
127 var arg0 vulkan.Semaphore
128 if args[0] != nil {
129 arg0 = args[0].(vulkan.Semaphore)
130 }
131 run(
132 arg0,
133 )
134 })
135 return _c
136}
137
138func (_c *mockcaptureSync_exportSyncFD_Call) Return(n int32, result vulkan.Result) *mockcaptureSync_exportSyncFD_Call {
139 _c.Call.Return(n, result)
140 return _c
141}
142
143func (_c *mockcaptureSync_exportSyncFD_Call) RunAndReturn(run func(s vulkan.Semaphore) (int32, vulkan.Result)) *mockcaptureSync_exportSyncFD_Call {
144 _c.Call.Return(run)
145 return _c
146}
147
148// fenceStatus provides a mock function for the type mockcaptureSync
149func (_mock *mockcaptureSync) fenceStatus(f vulkan.Fence) vulkan.Result {
150 ret := _mock.Called(f)
151
152 if len(ret) == 0 {
153 panic("no return value specified for fenceStatus")
154 }
155
156 var r0 vulkan.Result
157 if returnFunc, ok := ret.Get(0).(func(vulkan.Fence) vulkan.Result); ok {
158 r0 = returnFunc(f)
159 } else {
160 r0 = ret.Get(0).(vulkan.Result)
161 }
162 return r0
163}
164
165// mockcaptureSync_fenceStatus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'fenceStatus'
166type mockcaptureSync_fenceStatus_Call struct {
167 *mock.Call
168}
169
170// fenceStatus is a helper method to define mock.On call
171// - f vulkan.Fence
172func (_e *mockcaptureSync_Expecter) fenceStatus(f any) *mockcaptureSync_fenceStatus_Call {
173 return &mockcaptureSync_fenceStatus_Call{Call: _e.mock.On("fenceStatus", f)}
174}
175
176func (_c *mockcaptureSync_fenceStatus_Call) Run(run func(f vulkan.Fence)) *mockcaptureSync_fenceStatus_Call {
177 _c.Call.Run(func(args mock.Arguments) {
178 var arg0 vulkan.Fence
179 if args[0] != nil {
180 arg0 = args[0].(vulkan.Fence)
181 }
182 run(
183 arg0,
184 )
185 })
186 return _c
187}
188
189func (_c *mockcaptureSync_fenceStatus_Call) Return(result vulkan.Result) *mockcaptureSync_fenceStatus_Call {
190 _c.Call.Return(result)
191 return _c
192}
193
194func (_c *mockcaptureSync_fenceStatus_Call) RunAndReturn(run func(f vulkan.Fence) vulkan.Result) *mockcaptureSync_fenceStatus_Call {
195 _c.Call.Return(run)
196 return _c
197}
198
199// newSemaphore provides a mock function for the type mockcaptureSync
200func (_mock *mockcaptureSync) newSemaphore() (vulkan.Semaphore, error) {
201 ret := _mock.Called()
202
203 if len(ret) == 0 {
204 panic("no return value specified for newSemaphore")
205 }
206
207 var r0 vulkan.Semaphore
208 var r1 error
209 if returnFunc, ok := ret.Get(0).(func() (vulkan.Semaphore, error)); ok {
210 return returnFunc()
211 }
212 if returnFunc, ok := ret.Get(0).(func() vulkan.Semaphore); ok {
213 r0 = returnFunc()
214 } else {
215 r0 = ret.Get(0).(vulkan.Semaphore)
216 }
217 if returnFunc, ok := ret.Get(1).(func() error); ok {
218 r1 = returnFunc()
219 } else {
220 r1 = ret.Error(1)
221 }
222 return r0, r1
223}
224
225// mockcaptureSync_newSemaphore_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'newSemaphore'
226type mockcaptureSync_newSemaphore_Call struct {
227 *mock.Call
228}
229
230// newSemaphore is a helper method to define mock.On call
231func (_e *mockcaptureSync_Expecter) newSemaphore() *mockcaptureSync_newSemaphore_Call {
232 return &mockcaptureSync_newSemaphore_Call{Call: _e.mock.On("newSemaphore")}
233}
234
235func (_c *mockcaptureSync_newSemaphore_Call) Run(run func()) *mockcaptureSync_newSemaphore_Call {
236 _c.Call.Run(func(args mock.Arguments) {
237 run()
238 })
239 return _c
240}
241
242func (_c *mockcaptureSync_newSemaphore_Call) Return(semaphore vulkan.Semaphore, err error) *mockcaptureSync_newSemaphore_Call {
243 _c.Call.Return(semaphore, err)
244 return _c
245}
246
247func (_c *mockcaptureSync_newSemaphore_Call) RunAndReturn(run func() (vulkan.Semaphore, error)) *mockcaptureSync_newSemaphore_Call {
248 _c.Call.Return(run)
249 return _c
250}
251
252// resetFence provides a mock function for the type mockcaptureSync
253func (_mock *mockcaptureSync) resetFence(f vulkan.Fence) vulkan.Result {
254 ret := _mock.Called(f)
255
256 if len(ret) == 0 {
257 panic("no return value specified for resetFence")
258 }
259
260 var r0 vulkan.Result
261 if returnFunc, ok := ret.Get(0).(func(vulkan.Fence) vulkan.Result); ok {
262 r0 = returnFunc(f)
263 } else {
264 r0 = ret.Get(0).(vulkan.Result)
265 }
266 return r0
267}
268
269// mockcaptureSync_resetFence_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'resetFence'
270type mockcaptureSync_resetFence_Call struct {
271 *mock.Call
272}
273
274// resetFence is a helper method to define mock.On call
275// - f vulkan.Fence
276func (_e *mockcaptureSync_Expecter) resetFence(f any) *mockcaptureSync_resetFence_Call {
277 return &mockcaptureSync_resetFence_Call{Call: _e.mock.On("resetFence", f)}
278}
279
280func (_c *mockcaptureSync_resetFence_Call) Run(run func(f vulkan.Fence)) *mockcaptureSync_resetFence_Call {
281 _c.Call.Run(func(args mock.Arguments) {
282 var arg0 vulkan.Fence
283 if args[0] != nil {
284 arg0 = args[0].(vulkan.Fence)
285 }
286 run(
287 arg0,
288 )
289 })
290 return _c
291}
292
293func (_c *mockcaptureSync_resetFence_Call) Return(result vulkan.Result) *mockcaptureSync_resetFence_Call {
294 _c.Call.Return(result)
295 return _c
296}
297
298func (_c *mockcaptureSync_resetFence_Call) RunAndReturn(run func(f vulkan.Fence) vulkan.Result) *mockcaptureSync_resetFence_Call {
299 _c.Call.Return(run)
300 return _c
301}