1// Code generated by mockery; DO NOT EDIT.
2// github.com/vektra/mockery
3// template: testify
4
5package neferclient
6
7import (
8 mock "github.com/stretchr/testify/mock"
9)
10
11// newMocksurfaceRequests creates a new instance of mocksurfaceRequests. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
12// The first argument is typically a *testing.T value.
13func newMocksurfaceRequests(t interface {
14 mock.TestingT
15 Cleanup(func())
16}) *mocksurfaceRequests {
17 if helper, ok := t.(interface{ Helper() }); ok {
18 helper.Helper()
19 }
20
21 mock := &mocksurfaceRequests{}
22 mock.Mock.Test(t)
23
24 t.Cleanup(func() {
25 if helper, ok := t.(interface{ Helper() }); ok {
26 helper.Helper()
27 }
28 mock.AssertExpectations(t)
29 })
30
31 return mock
32}
33
34// mocksurfaceRequests is an autogenerated mock type for the surfaceRequests type
35type mocksurfaceRequests struct {
36 mock.Mock
37}
38
39type mocksurfaceRequests_Expecter struct {
40 mock *mock.Mock
41}
42
43func (_m *mocksurfaceRequests) EXPECT() *mocksurfaceRequests_Expecter {
44 return &mocksurfaceRequests_Expecter{mock: &_m.Mock}
45}
46
47// attach provides a mock function for the type mocksurfaceRequests
48func (_mock *mocksurfaceRequests) attach(buffer uint64) error {
49 ret := _mock.Called(buffer)
50
51 if len(ret) == 0 {
52 panic("no return value specified for attach")
53 }
54
55 var r0 error
56 if returnFunc, ok := ret.Get(0).(func(uint64) error); ok {
57 r0 = returnFunc(buffer)
58 } else {
59 r0 = ret.Error(0)
60 }
61 return r0
62}
63
64// mocksurfaceRequests_attach_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'attach'
65type mocksurfaceRequests_attach_Call struct {
66 *mock.Call
67}
68
69// attach is a helper method to define mock.On call
70// - buffer uint64
71func (_e *mocksurfaceRequests_Expecter) attach(buffer any) *mocksurfaceRequests_attach_Call {
72 return &mocksurfaceRequests_attach_Call{Call: _e.mock.On("attach", buffer)}
73}
74
75func (_c *mocksurfaceRequests_attach_Call) Run(run func(buffer uint64)) *mocksurfaceRequests_attach_Call {
76 _c.Call.Run(func(args mock.Arguments) {
77 var arg0 uint64
78 if args[0] != nil {
79 arg0 = args[0].(uint64)
80 }
81 run(
82 arg0,
83 )
84 })
85 return _c
86}
87
88func (_c *mocksurfaceRequests_attach_Call) Return(err error) *mocksurfaceRequests_attach_Call {
89 _c.Call.Return(err)
90 return _c
91}
92
93func (_c *mocksurfaceRequests_attach_Call) RunAndReturn(run func(buffer uint64) error) *mocksurfaceRequests_attach_Call {
94 _c.Call.Return(run)
95 return _c
96}
97
98// commit provides a mock function for the type mocksurfaceRequests
99func (_mock *mocksurfaceRequests) commit() error {
100 ret := _mock.Called()
101
102 if len(ret) == 0 {
103 panic("no return value specified for commit")
104 }
105
106 var r0 error
107 if returnFunc, ok := ret.Get(0).(func() error); ok {
108 r0 = returnFunc()
109 } else {
110 r0 = ret.Error(0)
111 }
112 return r0
113}
114
115// mocksurfaceRequests_commit_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'commit'
116type mocksurfaceRequests_commit_Call struct {
117 *mock.Call
118}
119
120// commit is a helper method to define mock.On call
121func (_e *mocksurfaceRequests_Expecter) commit() *mocksurfaceRequests_commit_Call {
122 return &mocksurfaceRequests_commit_Call{Call: _e.mock.On("commit")}
123}
124
125func (_c *mocksurfaceRequests_commit_Call) Run(run func()) *mocksurfaceRequests_commit_Call {
126 _c.Call.Run(func(args mock.Arguments) {
127 run()
128 })
129 return _c
130}
131
132func (_c *mocksurfaceRequests_commit_Call) Return(err error) *mocksurfaceRequests_commit_Call {
133 _c.Call.Return(err)
134 return _c
135}
136
137func (_c *mocksurfaceRequests_commit_Call) RunAndReturn(run func() error) *mocksurfaceRequests_commit_Call {
138 _c.Call.Return(run)
139 return _c
140}
141
142// damageBuffer provides a mock function for the type mocksurfaceRequests
143func (_mock *mocksurfaceRequests) damageBuffer(r Rect) error {
144 ret := _mock.Called(r)
145
146 if len(ret) == 0 {
147 panic("no return value specified for damageBuffer")
148 }
149
150 var r0 error
151 if returnFunc, ok := ret.Get(0).(func(Rect) error); ok {
152 r0 = returnFunc(r)
153 } else {
154 r0 = ret.Error(0)
155 }
156 return r0
157}
158
159// mocksurfaceRequests_damageBuffer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'damageBuffer'
160type mocksurfaceRequests_damageBuffer_Call struct {
161 *mock.Call
162}
163
164// damageBuffer is a helper method to define mock.On call
165// - r Rect
166func (_e *mocksurfaceRequests_Expecter) damageBuffer(r any) *mocksurfaceRequests_damageBuffer_Call {
167 return &mocksurfaceRequests_damageBuffer_Call{Call: _e.mock.On("damageBuffer", r)}
168}
169
170func (_c *mocksurfaceRequests_damageBuffer_Call) Run(run func(r Rect)) *mocksurfaceRequests_damageBuffer_Call {
171 _c.Call.Run(func(args mock.Arguments) {
172 var arg0 Rect
173 if args[0] != nil {
174 arg0 = args[0].(Rect)
175 }
176 run(
177 arg0,
178 )
179 })
180 return _c
181}
182
183func (_c *mocksurfaceRequests_damageBuffer_Call) Return(err error) *mocksurfaceRequests_damageBuffer_Call {
184 _c.Call.Return(err)
185 return _c
186}
187
188func (_c *mocksurfaceRequests_damageBuffer_Call) RunAndReturn(run func(r Rect) error) *mocksurfaceRequests_damageBuffer_Call {
189 _c.Call.Return(run)
190 return _c
191}
192
193// frame provides a mock function for the type mocksurfaceRequests
194func (_mock *mocksurfaceRequests) frame() error {
195 ret := _mock.Called()
196
197 if len(ret) == 0 {
198 panic("no return value specified for frame")
199 }
200
201 var r0 error
202 if returnFunc, ok := ret.Get(0).(func() error); ok {
203 r0 = returnFunc()
204 } else {
205 r0 = ret.Error(0)
206 }
207 return r0
208}
209
210// mocksurfaceRequests_frame_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'frame'
211type mocksurfaceRequests_frame_Call struct {
212 *mock.Call
213}
214
215// frame is a helper method to define mock.On call
216func (_e *mocksurfaceRequests_Expecter) frame() *mocksurfaceRequests_frame_Call {
217 return &mocksurfaceRequests_frame_Call{Call: _e.mock.On("frame")}
218}
219
220func (_c *mocksurfaceRequests_frame_Call) Run(run func()) *mocksurfaceRequests_frame_Call {
221 _c.Call.Run(func(args mock.Arguments) {
222 run()
223 })
224 return _c
225}
226
227func (_c *mocksurfaceRequests_frame_Call) Return(err error) *mocksurfaceRequests_frame_Call {
228 _c.Call.Return(err)
229 return _c
230}
231
232func (_c *mocksurfaceRequests_frame_Call) RunAndReturn(run func() error) *mocksurfaceRequests_frame_Call {
233 _c.Call.Return(run)
234 return _c
235}
236
237// setAcquire provides a mock function for the type mocksurfaceRequests
238func (_mock *mocksurfaceRequests) setAcquire(timeline uint64, point uint64) error {
239 ret := _mock.Called(timeline, point)
240
241 if len(ret) == 0 {
242 panic("no return value specified for setAcquire")
243 }
244
245 var r0 error
246 if returnFunc, ok := ret.Get(0).(func(uint64, uint64) error); ok {
247 r0 = returnFunc(timeline, point)
248 } else {
249 r0 = ret.Error(0)
250 }
251 return r0
252}
253
254// mocksurfaceRequests_setAcquire_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'setAcquire'
255type mocksurfaceRequests_setAcquire_Call struct {
256 *mock.Call
257}
258
259// setAcquire is a helper method to define mock.On call
260// - timeline uint64
261// - point uint64
262func (_e *mocksurfaceRequests_Expecter) setAcquire(timeline any, point any) *mocksurfaceRequests_setAcquire_Call {
263 return &mocksurfaceRequests_setAcquire_Call{Call: _e.mock.On("setAcquire", timeline, point)}
264}
265
266func (_c *mocksurfaceRequests_setAcquire_Call) Run(run func(timeline uint64, point uint64)) *mocksurfaceRequests_setAcquire_Call {
267 _c.Call.Run(func(args mock.Arguments) {
268 var arg0 uint64
269 if args[0] != nil {
270 arg0 = args[0].(uint64)
271 }
272 var arg1 uint64
273 if args[1] != nil {
274 arg1 = args[1].(uint64)
275 }
276 run(
277 arg0,
278 arg1,
279 )
280 })
281 return _c
282}
283
284func (_c *mocksurfaceRequests_setAcquire_Call) Return(err error) *mocksurfaceRequests_setAcquire_Call {
285 _c.Call.Return(err)
286 return _c
287}
288
289func (_c *mocksurfaceRequests_setAcquire_Call) RunAndReturn(run func(timeline uint64, point uint64) error) *mocksurfaceRequests_setAcquire_Call {
290 _c.Call.Return(run)
291 return _c
292}
293
294// setBufferScale provides a mock function for the type mocksurfaceRequests
295func (_mock *mocksurfaceRequests) setBufferScale(n int32) error {
296 ret := _mock.Called(n)
297
298 if len(ret) == 0 {
299 panic("no return value specified for setBufferScale")
300 }
301
302 var r0 error
303 if returnFunc, ok := ret.Get(0).(func(int32) error); ok {
304 r0 = returnFunc(n)
305 } else {
306 r0 = ret.Error(0)
307 }
308 return r0
309}
310
311// mocksurfaceRequests_setBufferScale_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'setBufferScale'
312type mocksurfaceRequests_setBufferScale_Call struct {
313 *mock.Call
314}
315
316// setBufferScale is a helper method to define mock.On call
317// - n int32
318func (_e *mocksurfaceRequests_Expecter) setBufferScale(n any) *mocksurfaceRequests_setBufferScale_Call {
319 return &mocksurfaceRequests_setBufferScale_Call{Call: _e.mock.On("setBufferScale", n)}
320}
321
322func (_c *mocksurfaceRequests_setBufferScale_Call) Run(run func(n int32)) *mocksurfaceRequests_setBufferScale_Call {
323 _c.Call.Run(func(args mock.Arguments) {
324 var arg0 int32
325 if args[0] != nil {
326 arg0 = args[0].(int32)
327 }
328 run(
329 arg0,
330 )
331 })
332 return _c
333}
334
335func (_c *mocksurfaceRequests_setBufferScale_Call) Return(err error) *mocksurfaceRequests_setBufferScale_Call {
336 _c.Call.Return(err)
337 return _c
338}
339
340func (_c *mocksurfaceRequests_setBufferScale_Call) RunAndReturn(run func(n int32) error) *mocksurfaceRequests_setBufferScale_Call {
341 _c.Call.Return(run)
342 return _c
343}
344
345// setDestination provides a mock function for the type mocksurfaceRequests
346func (_mock *mocksurfaceRequests) setDestination(w int32, h int32) error {
347 ret := _mock.Called(w, h)
348
349 if len(ret) == 0 {
350 panic("no return value specified for setDestination")
351 }
352
353 var r0 error
354 if returnFunc, ok := ret.Get(0).(func(int32, int32) error); ok {
355 r0 = returnFunc(w, h)
356 } else {
357 r0 = ret.Error(0)
358 }
359 return r0
360}
361
362// mocksurfaceRequests_setDestination_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'setDestination'
363type mocksurfaceRequests_setDestination_Call struct {
364 *mock.Call
365}
366
367// setDestination is a helper method to define mock.On call
368// - w int32
369// - h int32
370func (_e *mocksurfaceRequests_Expecter) setDestination(w any, h any) *mocksurfaceRequests_setDestination_Call {
371 return &mocksurfaceRequests_setDestination_Call{Call: _e.mock.On("setDestination", w, h)}
372}
373
374func (_c *mocksurfaceRequests_setDestination_Call) Run(run func(w int32, h int32)) *mocksurfaceRequests_setDestination_Call {
375 _c.Call.Run(func(args mock.Arguments) {
376 var arg0 int32
377 if args[0] != nil {
378 arg0 = args[0].(int32)
379 }
380 var arg1 int32
381 if args[1] != nil {
382 arg1 = args[1].(int32)
383 }
384 run(
385 arg0,
386 arg1,
387 )
388 })
389 return _c
390}
391
392func (_c *mocksurfaceRequests_setDestination_Call) Return(err error) *mocksurfaceRequests_setDestination_Call {
393 _c.Call.Return(err)
394 return _c
395}
396
397func (_c *mocksurfaceRequests_setDestination_Call) RunAndReturn(run func(w int32, h int32) error) *mocksurfaceRequests_setDestination_Call {
398 _c.Call.Return(run)
399 return _c
400}
401
402// setOpaqueRegion provides a mock function for the type mocksurfaceRequests
403func (_mock *mocksurfaceRequests) setOpaqueRegion(w int32, h int32, opaque bool) error {
404 ret := _mock.Called(w, h, opaque)
405
406 if len(ret) == 0 {
407 panic("no return value specified for setOpaqueRegion")
408 }
409
410 var r0 error
411 if returnFunc, ok := ret.Get(0).(func(int32, int32, bool) error); ok {
412 r0 = returnFunc(w, h, opaque)
413 } else {
414 r0 = ret.Error(0)
415 }
416 return r0
417}
418
419// mocksurfaceRequests_setOpaqueRegion_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'setOpaqueRegion'
420type mocksurfaceRequests_setOpaqueRegion_Call struct {
421 *mock.Call
422}
423
424// setOpaqueRegion is a helper method to define mock.On call
425// - w int32
426// - h int32
427// - opaque bool
428func (_e *mocksurfaceRequests_Expecter) setOpaqueRegion(w any, h any, opaque any) *mocksurfaceRequests_setOpaqueRegion_Call {
429 return &mocksurfaceRequests_setOpaqueRegion_Call{Call: _e.mock.On("setOpaqueRegion", w, h, opaque)}
430}
431
432func (_c *mocksurfaceRequests_setOpaqueRegion_Call) Run(run func(w int32, h int32, opaque bool)) *mocksurfaceRequests_setOpaqueRegion_Call {
433 _c.Call.Run(func(args mock.Arguments) {
434 var arg0 int32
435 if args[0] != nil {
436 arg0 = args[0].(int32)
437 }
438 var arg1 int32
439 if args[1] != nil {
440 arg1 = args[1].(int32)
441 }
442 var arg2 bool
443 if args[2] != nil {
444 arg2 = args[2].(bool)
445 }
446 run(
447 arg0,
448 arg1,
449 arg2,
450 )
451 })
452 return _c
453}
454
455func (_c *mocksurfaceRequests_setOpaqueRegion_Call) Return(err error) *mocksurfaceRequests_setOpaqueRegion_Call {
456 _c.Call.Return(err)
457 return _c
458}
459
460func (_c *mocksurfaceRequests_setOpaqueRegion_Call) RunAndReturn(run func(w int32, h int32, opaque bool) error) *mocksurfaceRequests_setOpaqueRegion_Call {
461 _c.Call.Return(run)
462 return _c
463}
464
465// setRelease provides a mock function for the type mocksurfaceRequests
466func (_mock *mocksurfaceRequests) setRelease(timeline uint64, point uint64) error {
467 ret := _mock.Called(timeline, point)
468
469 if len(ret) == 0 {
470 panic("no return value specified for setRelease")
471 }
472
473 var r0 error
474 if returnFunc, ok := ret.Get(0).(func(uint64, uint64) error); ok {
475 r0 = returnFunc(timeline, point)
476 } else {
477 r0 = ret.Error(0)
478 }
479 return r0
480}
481
482// mocksurfaceRequests_setRelease_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'setRelease'
483type mocksurfaceRequests_setRelease_Call struct {
484 *mock.Call
485}
486
487// setRelease is a helper method to define mock.On call
488// - timeline uint64
489// - point uint64
490func (_e *mocksurfaceRequests_Expecter) setRelease(timeline any, point any) *mocksurfaceRequests_setRelease_Call {
491 return &mocksurfaceRequests_setRelease_Call{Call: _e.mock.On("setRelease", timeline, point)}
492}
493
494func (_c *mocksurfaceRequests_setRelease_Call) Run(run func(timeline uint64, point uint64)) *mocksurfaceRequests_setRelease_Call {
495 _c.Call.Run(func(args mock.Arguments) {
496 var arg0 uint64
497 if args[0] != nil {
498 arg0 = args[0].(uint64)
499 }
500 var arg1 uint64
501 if args[1] != nil {
502 arg1 = args[1].(uint64)
503 }
504 run(
505 arg0,
506 arg1,
507 )
508 })
509 return _c
510}
511
512func (_c *mocksurfaceRequests_setRelease_Call) Return(err error) *mocksurfaceRequests_setRelease_Call {
513 _c.Call.Return(err)
514 return _c
515}
516
517func (_c *mocksurfaceRequests_setRelease_Call) RunAndReturn(run func(timeline uint64, point uint64) error) *mocksurfaceRequests_setRelease_Call {
518 _c.Call.Return(run)
519 return _c
520}