1// Code generated by mockery; DO NOT EDIT.
2// github.com/vektra/mockery
3// template: testify
4
5package drm
6
7import (
8 "os"
9
10 "github.com/bnema/neferwl/internal/ports"
11 mock "github.com/stretchr/testify/mock"
12)
13
14// newMockkms creates a new instance of mockkms. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
15// The first argument is typically a *testing.T value.
16func newMockkms(t interface {
17 mock.TestingT
18 Cleanup(func())
19}) *mockkms {
20 if helper, ok := t.(interface{ Helper() }); ok {
21 helper.Helper()
22 }
23
24 mock := &mockkms{}
25 mock.Mock.Test(t)
26
27 t.Cleanup(func() {
28 if helper, ok := t.(interface{ Helper() }); ok {
29 helper.Helper()
30 }
31 mock.AssertExpectations(t)
32 })
33
34 return mock
35}
36
37// mockkms is an autogenerated mock type for the kms type
38type mockkms struct {
39 mock.Mock
40}
41
42type mockkms_Expecter struct {
43 mock *mock.Mock
44}
45
46func (_m *mockkms) EXPECT() *mockkms_Expecter {
47 return &mockkms_Expecter{mock: &_m.Mock}
48}
49
50// addFB provides a mock function for the type mockkms
51func (_mock *mockkms) addFB(b *ports.DMABuf, format uint32) (uint32, error) {
52 ret := _mock.Called(b, format)
53
54 if len(ret) == 0 {
55 panic("no return value specified for addFB")
56 }
57
58 var r0 uint32
59 var r1 error
60 if returnFunc, ok := ret.Get(0).(func(*ports.DMABuf, uint32) (uint32, error)); ok {
61 return returnFunc(b, format)
62 }
63 if returnFunc, ok := ret.Get(0).(func(*ports.DMABuf, uint32) uint32); ok {
64 r0 = returnFunc(b, format)
65 } else {
66 r0 = ret.Get(0).(uint32)
67 }
68 if returnFunc, ok := ret.Get(1).(func(*ports.DMABuf, uint32) error); ok {
69 r1 = returnFunc(b, format)
70 } else {
71 r1 = ret.Error(1)
72 }
73 return r0, r1
74}
75
76// mockkms_addFB_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'addFB'
77type mockkms_addFB_Call struct {
78 *mock.Call
79}
80
81// addFB is a helper method to define mock.On call
82// - b *ports.DMABuf
83// - format uint32
84func (_e *mockkms_Expecter) addFB(b any, format any) *mockkms_addFB_Call {
85 return &mockkms_addFB_Call{Call: _e.mock.On("addFB", b, format)}
86}
87
88func (_c *mockkms_addFB_Call) Run(run func(b *ports.DMABuf, format uint32)) *mockkms_addFB_Call {
89 _c.Call.Run(func(args mock.Arguments) {
90 var arg0 *ports.DMABuf
91 if args[0] != nil {
92 arg0 = args[0].(*ports.DMABuf)
93 }
94 var arg1 uint32
95 if args[1] != nil {
96 arg1 = args[1].(uint32)
97 }
98 run(
99 arg0,
100 arg1,
101 )
102 })
103 return _c
104}
105
106func (_c *mockkms_addFB_Call) Return(v uint32, err error) *mockkms_addFB_Call {
107 _c.Call.Return(v, err)
108 return _c
109}
110
111func (_c *mockkms_addFB_Call) RunAndReturn(run func(b *ports.DMABuf, format uint32) (uint32, error)) *mockkms_addFB_Call {
112 _c.Call.Return(run)
113 return _c
114}
115
116// addFBHandle provides a mock function for the type mockkms
117func (_mock *mockkms) addFBHandle(b dumbBuffer, width int, height int, format uint32) (uint32, error) {
118 ret := _mock.Called(b, width, height, format)
119
120 if len(ret) == 0 {
121 panic("no return value specified for addFBHandle")
122 }
123
124 var r0 uint32
125 var r1 error
126 if returnFunc, ok := ret.Get(0).(func(dumbBuffer, int, int, uint32) (uint32, error)); ok {
127 return returnFunc(b, width, height, format)
128 }
129 if returnFunc, ok := ret.Get(0).(func(dumbBuffer, int, int, uint32) uint32); ok {
130 r0 = returnFunc(b, width, height, format)
131 } else {
132 r0 = ret.Get(0).(uint32)
133 }
134 if returnFunc, ok := ret.Get(1).(func(dumbBuffer, int, int, uint32) error); ok {
135 r1 = returnFunc(b, width, height, format)
136 } else {
137 r1 = ret.Error(1)
138 }
139 return r0, r1
140}
141
142// mockkms_addFBHandle_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'addFBHandle'
143type mockkms_addFBHandle_Call struct {
144 *mock.Call
145}
146
147// addFBHandle is a helper method to define mock.On call
148// - b dumbBuffer
149// - width int
150// - height int
151// - format uint32
152func (_e *mockkms_Expecter) addFBHandle(b any, width any, height any, format any) *mockkms_addFBHandle_Call {
153 return &mockkms_addFBHandle_Call{Call: _e.mock.On("addFBHandle", b, width, height, format)}
154}
155
156func (_c *mockkms_addFBHandle_Call) Run(run func(b dumbBuffer, width int, height int, format uint32)) *mockkms_addFBHandle_Call {
157 _c.Call.Run(func(args mock.Arguments) {
158 var arg0 dumbBuffer
159 if args[0] != nil {
160 arg0 = args[0].(dumbBuffer)
161 }
162 var arg1 int
163 if args[1] != nil {
164 arg1 = args[1].(int)
165 }
166 var arg2 int
167 if args[2] != nil {
168 arg2 = args[2].(int)
169 }
170 var arg3 uint32
171 if args[3] != nil {
172 arg3 = args[3].(uint32)
173 }
174 run(
175 arg0,
176 arg1,
177 arg2,
178 arg3,
179 )
180 })
181 return _c
182}
183
184func (_c *mockkms_addFBHandle_Call) Return(v uint32, err error) *mockkms_addFBHandle_Call {
185 _c.Call.Return(v, err)
186 return _c
187}
188
189func (_c *mockkms_addFBHandle_Call) RunAndReturn(run func(b dumbBuffer, width int, height int, format uint32) (uint32, error)) *mockkms_addFBHandle_Call {
190 _c.Call.Return(run)
191 return _c
192}
193
194// commit provides a mock function for the type mockkms
195func (_mock *mockkms) commit(req *atomicReq, flags uint32, userData uint64) error {
196 ret := _mock.Called(req, flags, userData)
197
198 if len(ret) == 0 {
199 panic("no return value specified for commit")
200 }
201
202 var r0 error
203 if returnFunc, ok := ret.Get(0).(func(*atomicReq, uint32, uint64) error); ok {
204 r0 = returnFunc(req, flags, userData)
205 } else {
206 r0 = ret.Error(0)
207 }
208 return r0
209}
210
211// mockkms_commit_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'commit'
212type mockkms_commit_Call struct {
213 *mock.Call
214}
215
216// commit is a helper method to define mock.On call
217// - req *atomicReq
218// - flags uint32
219// - userData uint64
220func (_e *mockkms_Expecter) commit(req any, flags any, userData any) *mockkms_commit_Call {
221 return &mockkms_commit_Call{Call: _e.mock.On("commit", req, flags, userData)}
222}
223
224func (_c *mockkms_commit_Call) Run(run func(req *atomicReq, flags uint32, userData uint64)) *mockkms_commit_Call {
225 _c.Call.Run(func(args mock.Arguments) {
226 var arg0 *atomicReq
227 if args[0] != nil {
228 arg0 = args[0].(*atomicReq)
229 }
230 var arg1 uint32
231 if args[1] != nil {
232 arg1 = args[1].(uint32)
233 }
234 var arg2 uint64
235 if args[2] != nil {
236 arg2 = args[2].(uint64)
237 }
238 run(
239 arg0,
240 arg1,
241 arg2,
242 )
243 })
244 return _c
245}
246
247func (_c *mockkms_commit_Call) Return(err error) *mockkms_commit_Call {
248 _c.Call.Return(err)
249 return _c
250}
251
252func (_c *mockkms_commit_Call) RunAndReturn(run func(req *atomicReq, flags uint32, userData uint64) error) *mockkms_commit_Call {
253 _c.Call.Return(run)
254 return _c
255}
256
257// connector provides a mock function for the type mockkms
258func (_mock *mockkms) connector(id uint32) (connector, error) {
259 ret := _mock.Called(id)
260
261 if len(ret) == 0 {
262 panic("no return value specified for connector")
263 }
264
265 var r0 connector
266 var r1 error
267 if returnFunc, ok := ret.Get(0).(func(uint32) (connector, error)); ok {
268 return returnFunc(id)
269 }
270 if returnFunc, ok := ret.Get(0).(func(uint32) connector); ok {
271 r0 = returnFunc(id)
272 } else {
273 r0 = ret.Get(0).(connector)
274 }
275 if returnFunc, ok := ret.Get(1).(func(uint32) error); ok {
276 r1 = returnFunc(id)
277 } else {
278 r1 = ret.Error(1)
279 }
280 return r0, r1
281}
282
283// mockkms_connector_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'connector'
284type mockkms_connector_Call struct {
285 *mock.Call
286}
287
288// connector is a helper method to define mock.On call
289// - id uint32
290func (_e *mockkms_Expecter) connector(id any) *mockkms_connector_Call {
291 return &mockkms_connector_Call{Call: _e.mock.On("connector", id)}
292}
293
294func (_c *mockkms_connector_Call) Run(run func(id uint32)) *mockkms_connector_Call {
295 _c.Call.Run(func(args mock.Arguments) {
296 var arg0 uint32
297 if args[0] != nil {
298 arg0 = args[0].(uint32)
299 }
300 run(
301 arg0,
302 )
303 })
304 return _c
305}
306
307func (_c *mockkms_connector_Call) Return(connectorMoqParam connector, err error) *mockkms_connector_Call {
308 _c.Call.Return(connectorMoqParam, err)
309 return _c
310}
311
312func (_c *mockkms_connector_Call) RunAndReturn(run func(id uint32) (connector, error)) *mockkms_connector_Call {
313 _c.Call.Return(run)
314 return _c
315}
316
317// createBlob provides a mock function for the type mockkms
318func (_mock *mockkms) createBlob(data []byte) (uint32, error) {
319 ret := _mock.Called(data)
320
321 if len(ret) == 0 {
322 panic("no return value specified for createBlob")
323 }
324
325 var r0 uint32
326 var r1 error
327 if returnFunc, ok := ret.Get(0).(func([]byte) (uint32, error)); ok {
328 return returnFunc(data)
329 }
330 if returnFunc, ok := ret.Get(0).(func([]byte) uint32); ok {
331 r0 = returnFunc(data)
332 } else {
333 r0 = ret.Get(0).(uint32)
334 }
335 if returnFunc, ok := ret.Get(1).(func([]byte) error); ok {
336 r1 = returnFunc(data)
337 } else {
338 r1 = ret.Error(1)
339 }
340 return r0, r1
341}
342
343// mockkms_createBlob_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'createBlob'
344type mockkms_createBlob_Call struct {
345 *mock.Call
346}
347
348// createBlob is a helper method to define mock.On call
349// - data []byte
350func (_e *mockkms_Expecter) createBlob(data any) *mockkms_createBlob_Call {
351 return &mockkms_createBlob_Call{Call: _e.mock.On("createBlob", data)}
352}
353
354func (_c *mockkms_createBlob_Call) Run(run func(data []byte)) *mockkms_createBlob_Call {
355 _c.Call.Run(func(args mock.Arguments) {
356 var arg0 []byte
357 if args[0] != nil {
358 arg0 = args[0].([]byte)
359 }
360 run(
361 arg0,
362 )
363 })
364 return _c
365}
366
367func (_c *mockkms_createBlob_Call) Return(v uint32, err error) *mockkms_createBlob_Call {
368 _c.Call.Return(v, err)
369 return _c
370}
371
372func (_c *mockkms_createBlob_Call) RunAndReturn(run func(data []byte) (uint32, error)) *mockkms_createBlob_Call {
373 _c.Call.Return(run)
374 return _c
375}
376
377// createDumb provides a mock function for the type mockkms
378func (_mock *mockkms) createDumb(width int, height int) (dumbBuffer, error) {
379 ret := _mock.Called(width, height)
380
381 if len(ret) == 0 {
382 panic("no return value specified for createDumb")
383 }
384
385 var r0 dumbBuffer
386 var r1 error
387 if returnFunc, ok := ret.Get(0).(func(int, int) (dumbBuffer, error)); ok {
388 return returnFunc(width, height)
389 }
390 if returnFunc, ok := ret.Get(0).(func(int, int) dumbBuffer); ok {
391 r0 = returnFunc(width, height)
392 } else {
393 r0 = ret.Get(0).(dumbBuffer)
394 }
395 if returnFunc, ok := ret.Get(1).(func(int, int) error); ok {
396 r1 = returnFunc(width, height)
397 } else {
398 r1 = ret.Error(1)
399 }
400 return r0, r1
401}
402
403// mockkms_createDumb_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'createDumb'
404type mockkms_createDumb_Call struct {
405 *mock.Call
406}
407
408// createDumb is a helper method to define mock.On call
409// - width int
410// - height int
411func (_e *mockkms_Expecter) createDumb(width any, height any) *mockkms_createDumb_Call {
412 return &mockkms_createDumb_Call{Call: _e.mock.On("createDumb", width, height)}
413}
414
415func (_c *mockkms_createDumb_Call) Run(run func(width int, height int)) *mockkms_createDumb_Call {
416 _c.Call.Run(func(args mock.Arguments) {
417 var arg0 int
418 if args[0] != nil {
419 arg0 = args[0].(int)
420 }
421 var arg1 int
422 if args[1] != nil {
423 arg1 = args[1].(int)
424 }
425 run(
426 arg0,
427 arg1,
428 )
429 })
430 return _c
431}
432
433func (_c *mockkms_createDumb_Call) Return(dumbBufferMoqParam dumbBuffer, err error) *mockkms_createDumb_Call {
434 _c.Call.Return(dumbBufferMoqParam, err)
435 return _c
436}
437
438func (_c *mockkms_createDumb_Call) RunAndReturn(run func(width int, height int) (dumbBuffer, error)) *mockkms_createDumb_Call {
439 _c.Call.Return(run)
440 return _c
441}
442
443// createLease provides a mock function for the type mockkms
444func (_mock *mockkms) createLease(objects []uint32) (*os.File, uint32, error) {
445 ret := _mock.Called(objects)
446
447 if len(ret) == 0 {
448 panic("no return value specified for createLease")
449 }
450
451 var r0 *os.File
452 var r1 uint32
453 var r2 error
454 if returnFunc, ok := ret.Get(0).(func([]uint32) (*os.File, uint32, error)); ok {
455 return returnFunc(objects)
456 }
457 if returnFunc, ok := ret.Get(0).(func([]uint32) *os.File); ok {
458 r0 = returnFunc(objects)
459 } else {
460 if ret.Get(0) != nil {
461 r0 = ret.Get(0).(*os.File)
462 }
463 }
464 if returnFunc, ok := ret.Get(1).(func([]uint32) uint32); ok {
465 r1 = returnFunc(objects)
466 } else {
467 r1 = ret.Get(1).(uint32)
468 }
469 if returnFunc, ok := ret.Get(2).(func([]uint32) error); ok {
470 r2 = returnFunc(objects)
471 } else {
472 r2 = ret.Error(2)
473 }
474 return r0, r1, r2
475}
476
477// mockkms_createLease_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'createLease'
478type mockkms_createLease_Call struct {
479 *mock.Call
480}
481
482// createLease is a helper method to define mock.On call
483// - objects []uint32
484func (_e *mockkms_Expecter) createLease(objects any) *mockkms_createLease_Call {
485 return &mockkms_createLease_Call{Call: _e.mock.On("createLease", objects)}
486}
487
488func (_c *mockkms_createLease_Call) Run(run func(objects []uint32)) *mockkms_createLease_Call {
489 _c.Call.Run(func(args mock.Arguments) {
490 var arg0 []uint32
491 if args[0] != nil {
492 arg0 = args[0].([]uint32)
493 }
494 run(
495 arg0,
496 )
497 })
498 return _c
499}
500
501func (_c *mockkms_createLease_Call) Return(file *os.File, v uint32, err error) *mockkms_createLease_Call {
502 _c.Call.Return(file, v, err)
503 return _c
504}
505
506func (_c *mockkms_createLease_Call) RunAndReturn(run func(objects []uint32) (*os.File, uint32, error)) *mockkms_createLease_Call {
507 _c.Call.Return(run)
508 return _c
509}
510
511// destroyBlob provides a mock function for the type mockkms
512func (_mock *mockkms) destroyBlob(id uint32) error {
513 ret := _mock.Called(id)
514
515 if len(ret) == 0 {
516 panic("no return value specified for destroyBlob")
517 }
518
519 var r0 error
520 if returnFunc, ok := ret.Get(0).(func(uint32) error); ok {
521 r0 = returnFunc(id)
522 } else {
523 r0 = ret.Error(0)
524 }
525 return r0
526}
527
528// mockkms_destroyBlob_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'destroyBlob'
529type mockkms_destroyBlob_Call struct {
530 *mock.Call
531}
532
533// destroyBlob is a helper method to define mock.On call
534// - id uint32
535func (_e *mockkms_Expecter) destroyBlob(id any) *mockkms_destroyBlob_Call {
536 return &mockkms_destroyBlob_Call{Call: _e.mock.On("destroyBlob", id)}
537}
538
539func (_c *mockkms_destroyBlob_Call) Run(run func(id uint32)) *mockkms_destroyBlob_Call {
540 _c.Call.Run(func(args mock.Arguments) {
541 var arg0 uint32
542 if args[0] != nil {
543 arg0 = args[0].(uint32)
544 }
545 run(
546 arg0,
547 )
548 })
549 return _c
550}
551
552func (_c *mockkms_destroyBlob_Call) Return(err error) *mockkms_destroyBlob_Call {
553 _c.Call.Return(err)
554 return _c
555}
556
557func (_c *mockkms_destroyBlob_Call) RunAndReturn(run func(id uint32) error) *mockkms_destroyBlob_Call {
558 _c.Call.Return(run)
559 return _c
560}
561
562// destroyDumb provides a mock function for the type mockkms
563func (_mock *mockkms) destroyDumb(handle uint32) error {
564 ret := _mock.Called(handle)
565
566 if len(ret) == 0 {
567 panic("no return value specified for destroyDumb")
568 }
569
570 var r0 error
571 if returnFunc, ok := ret.Get(0).(func(uint32) error); ok {
572 r0 = returnFunc(handle)
573 } else {
574 r0 = ret.Error(0)
575 }
576 return r0
577}
578
579// mockkms_destroyDumb_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'destroyDumb'
580type mockkms_destroyDumb_Call struct {
581 *mock.Call
582}
583
584// destroyDumb is a helper method to define mock.On call
585// - handle uint32
586func (_e *mockkms_Expecter) destroyDumb(handle any) *mockkms_destroyDumb_Call {
587 return &mockkms_destroyDumb_Call{Call: _e.mock.On("destroyDumb", handle)}
588}
589
590func (_c *mockkms_destroyDumb_Call) Run(run func(handle uint32)) *mockkms_destroyDumb_Call {
591 _c.Call.Run(func(args mock.Arguments) {
592 var arg0 uint32
593 if args[0] != nil {
594 arg0 = args[0].(uint32)
595 }
596 run(
597 arg0,
598 )
599 })
600 return _c
601}
602
603func (_c *mockkms_destroyDumb_Call) Return(err error) *mockkms_destroyDumb_Call {
604 _c.Call.Return(err)
605 return _c
606}
607
608func (_c *mockkms_destroyDumb_Call) RunAndReturn(run func(handle uint32) error) *mockkms_destroyDumb_Call {
609 _c.Call.Return(run)
610 return _c
611}
612
613// getBlob provides a mock function for the type mockkms
614func (_mock *mockkms) getBlob(id uint32) ([]byte, error) {
615 ret := _mock.Called(id)
616
617 if len(ret) == 0 {
618 panic("no return value specified for getBlob")
619 }
620
621 var r0 []byte
622 var r1 error
623 if returnFunc, ok := ret.Get(0).(func(uint32) ([]byte, error)); ok {
624 return returnFunc(id)
625 }
626 if returnFunc, ok := ret.Get(0).(func(uint32) []byte); ok {
627 r0 = returnFunc(id)
628 } else {
629 if ret.Get(0) != nil {
630 r0 = ret.Get(0).([]byte)
631 }
632 }
633 if returnFunc, ok := ret.Get(1).(func(uint32) error); ok {
634 r1 = returnFunc(id)
635 } else {
636 r1 = ret.Error(1)
637 }
638 return r0, r1
639}
640
641// mockkms_getBlob_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'getBlob'
642type mockkms_getBlob_Call struct {
643 *mock.Call
644}
645
646// getBlob is a helper method to define mock.On call
647// - id uint32
648func (_e *mockkms_Expecter) getBlob(id any) *mockkms_getBlob_Call {
649 return &mockkms_getBlob_Call{Call: _e.mock.On("getBlob", id)}
650}
651
652func (_c *mockkms_getBlob_Call) Run(run func(id uint32)) *mockkms_getBlob_Call {
653 _c.Call.Run(func(args mock.Arguments) {
654 var arg0 uint32
655 if args[0] != nil {
656 arg0 = args[0].(uint32)
657 }
658 run(
659 arg0,
660 )
661 })
662 return _c
663}
664
665func (_c *mockkms_getBlob_Call) Return(bytes []byte, err error) *mockkms_getBlob_Call {
666 _c.Call.Return(bytes, err)
667 return _c
668}
669
670func (_c *mockkms_getBlob_Call) RunAndReturn(run func(id uint32) ([]byte, error)) *mockkms_getBlob_Call {
671 _c.Call.Return(run)
672 return _c
673}
674
675// mapDumb provides a mock function for the type mockkms
676func (_mock *mockkms) mapDumb(b dumbBuffer) ([]byte, error) {
677 ret := _mock.Called(b)
678
679 if len(ret) == 0 {
680 panic("no return value specified for mapDumb")
681 }
682
683 var r0 []byte
684 var r1 error
685 if returnFunc, ok := ret.Get(0).(func(dumbBuffer) ([]byte, error)); ok {
686 return returnFunc(b)
687 }
688 if returnFunc, ok := ret.Get(0).(func(dumbBuffer) []byte); ok {
689 r0 = returnFunc(b)
690 } else {
691 if ret.Get(0) != nil {
692 r0 = ret.Get(0).([]byte)
693 }
694 }
695 if returnFunc, ok := ret.Get(1).(func(dumbBuffer) error); ok {
696 r1 = returnFunc(b)
697 } else {
698 r1 = ret.Error(1)
699 }
700 return r0, r1
701}
702
703// mockkms_mapDumb_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'mapDumb'
704type mockkms_mapDumb_Call struct {
705 *mock.Call
706}
707
708// mapDumb is a helper method to define mock.On call
709// - b dumbBuffer
710func (_e *mockkms_Expecter) mapDumb(b any) *mockkms_mapDumb_Call {
711 return &mockkms_mapDumb_Call{Call: _e.mock.On("mapDumb", b)}
712}
713
714func (_c *mockkms_mapDumb_Call) Run(run func(b dumbBuffer)) *mockkms_mapDumb_Call {
715 _c.Call.Run(func(args mock.Arguments) {
716 var arg0 dumbBuffer
717 if args[0] != nil {
718 arg0 = args[0].(dumbBuffer)
719 }
720 run(
721 arg0,
722 )
723 })
724 return _c
725}
726
727func (_c *mockkms_mapDumb_Call) Return(bytes []byte, err error) *mockkms_mapDumb_Call {
728 _c.Call.Return(bytes, err)
729 return _c
730}
731
732func (_c *mockkms_mapDumb_Call) RunAndReturn(run func(b dumbBuffer) ([]byte, error)) *mockkms_mapDumb_Call {
733 _c.Call.Return(run)
734 return _c
735}
736
737// objProps provides a mock function for the type mockkms
738func (_mock *mockkms) objProps(obj uint32, typ uint32) (map[string][2]uint64, error) {
739 ret := _mock.Called(obj, typ)
740
741 if len(ret) == 0 {
742 panic("no return value specified for objProps")
743 }
744
745 var r0 map[string][2]uint64
746 var r1 error
747 if returnFunc, ok := ret.Get(0).(func(uint32, uint32) (map[string][2]uint64, error)); ok {
748 return returnFunc(obj, typ)
749 }
750 if returnFunc, ok := ret.Get(0).(func(uint32, uint32) map[string][2]uint64); ok {
751 r0 = returnFunc(obj, typ)
752 } else {
753 if ret.Get(0) != nil {
754 r0 = ret.Get(0).(map[string][2]uint64)
755 }
756 }
757 if returnFunc, ok := ret.Get(1).(func(uint32, uint32) error); ok {
758 r1 = returnFunc(obj, typ)
759 } else {
760 r1 = ret.Error(1)
761 }
762 return r0, r1
763}
764
765// mockkms_objProps_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'objProps'
766type mockkms_objProps_Call struct {
767 *mock.Call
768}
769
770// objProps is a helper method to define mock.On call
771// - obj uint32
772// - typ uint32
773func (_e *mockkms_Expecter) objProps(obj any, typ any) *mockkms_objProps_Call {
774 return &mockkms_objProps_Call{Call: _e.mock.On("objProps", obj, typ)}
775}
776
777func (_c *mockkms_objProps_Call) Run(run func(obj uint32, typ uint32)) *mockkms_objProps_Call {
778 _c.Call.Run(func(args mock.Arguments) {
779 var arg0 uint32
780 if args[0] != nil {
781 arg0 = args[0].(uint32)
782 }
783 var arg1 uint32
784 if args[1] != nil {
785 arg1 = args[1].(uint32)
786 }
787 run(
788 arg0,
789 arg1,
790 )
791 })
792 return _c
793}
794
795func (_c *mockkms_objProps_Call) Return(stringToUint64s map[string][2]uint64, err error) *mockkms_objProps_Call {
796 _c.Call.Return(stringToUint64s, err)
797 return _c
798}
799
800func (_c *mockkms_objProps_Call) RunAndReturn(run func(obj uint32, typ uint32) (map[string][2]uint64, error)) *mockkms_objProps_Call {
801 _c.Call.Return(run)
802 return _c
803}
804
805// pickCrtc provides a mock function for the type mockkms
806func (_mock *mockkms) pickCrtc(c connector, crtcs []uint32, used map[uint32]bool) (uint32, error) {
807 ret := _mock.Called(c, crtcs, used)
808
809 if len(ret) == 0 {
810 panic("no return value specified for pickCrtc")
811 }
812
813 var r0 uint32
814 var r1 error
815 if returnFunc, ok := ret.Get(0).(func(connector, []uint32, map[uint32]bool) (uint32, error)); ok {
816 return returnFunc(c, crtcs, used)
817 }
818 if returnFunc, ok := ret.Get(0).(func(connector, []uint32, map[uint32]bool) uint32); ok {
819 r0 = returnFunc(c, crtcs, used)
820 } else {
821 r0 = ret.Get(0).(uint32)
822 }
823 if returnFunc, ok := ret.Get(1).(func(connector, []uint32, map[uint32]bool) error); ok {
824 r1 = returnFunc(c, crtcs, used)
825 } else {
826 r1 = ret.Error(1)
827 }
828 return r0, r1
829}
830
831// mockkms_pickCrtc_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'pickCrtc'
832type mockkms_pickCrtc_Call struct {
833 *mock.Call
834}
835
836// pickCrtc is a helper method to define mock.On call
837// - c connector
838// - crtcs []uint32
839// - used map[uint32]bool
840func (_e *mockkms_Expecter) pickCrtc(c any, crtcs any, used any) *mockkms_pickCrtc_Call {
841 return &mockkms_pickCrtc_Call{Call: _e.mock.On("pickCrtc", c, crtcs, used)}
842}
843
844func (_c *mockkms_pickCrtc_Call) Run(run func(c connector, crtcs []uint32, used map[uint32]bool)) *mockkms_pickCrtc_Call {
845 _c.Call.Run(func(args mock.Arguments) {
846 var arg0 connector
847 if args[0] != nil {
848 arg0 = args[0].(connector)
849 }
850 var arg1 []uint32
851 if args[1] != nil {
852 arg1 = args[1].([]uint32)
853 }
854 var arg2 map[uint32]bool
855 if args[2] != nil {
856 arg2 = args[2].(map[uint32]bool)
857 }
858 run(
859 arg0,
860 arg1,
861 arg2,
862 )
863 })
864 return _c
865}
866
867func (_c *mockkms_pickCrtc_Call) Return(v uint32, err error) *mockkms_pickCrtc_Call {
868 _c.Call.Return(v, err)
869 return _c
870}
871
872func (_c *mockkms_pickCrtc_Call) RunAndReturn(run func(c connector, crtcs []uint32, used map[uint32]bool) (uint32, error)) *mockkms_pickCrtc_Call {
873 _c.Call.Return(run)
874 return _c
875}
876
877// planes provides a mock function for the type mockkms
878func (_mock *mockkms) planes() ([]planeRes, error) {
879 ret := _mock.Called()
880
881 if len(ret) == 0 {
882 panic("no return value specified for planes")
883 }
884
885 var r0 []planeRes
886 var r1 error
887 if returnFunc, ok := ret.Get(0).(func() ([]planeRes, error)); ok {
888 return returnFunc()
889 }
890 if returnFunc, ok := ret.Get(0).(func() []planeRes); ok {
891 r0 = returnFunc()
892 } else {
893 if ret.Get(0) != nil {
894 r0 = ret.Get(0).([]planeRes)
895 }
896 }
897 if returnFunc, ok := ret.Get(1).(func() error); ok {
898 r1 = returnFunc()
899 } else {
900 r1 = ret.Error(1)
901 }
902 return r0, r1
903}
904
905// mockkms_planes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'planes'
906type mockkms_planes_Call struct {
907 *mock.Call
908}
909
910// planes is a helper method to define mock.On call
911func (_e *mockkms_Expecter) planes() *mockkms_planes_Call {
912 return &mockkms_planes_Call{Call: _e.mock.On("planes")}
913}
914
915func (_c *mockkms_planes_Call) Run(run func()) *mockkms_planes_Call {
916 _c.Call.Run(func(args mock.Arguments) {
917 run()
918 })
919 return _c
920}
921
922func (_c *mockkms_planes_Call) Return(planeResMoqParams []planeRes, err error) *mockkms_planes_Call {
923 _c.Call.Return(planeResMoqParams, err)
924 return _c
925}
926
927func (_c *mockkms_planes_Call) RunAndReturn(run func() ([]planeRes, error)) *mockkms_planes_Call {
928 _c.Call.Return(run)
929 return _c
930}
931
932// propEnums provides a mock function for the type mockkms
933func (_mock *mockkms) propEnums(prop uint32) (map[string]uint64, error) {
934 ret := _mock.Called(prop)
935
936 if len(ret) == 0 {
937 panic("no return value specified for propEnums")
938 }
939
940 var r0 map[string]uint64
941 var r1 error
942 if returnFunc, ok := ret.Get(0).(func(uint32) (map[string]uint64, error)); ok {
943 return returnFunc(prop)
944 }
945 if returnFunc, ok := ret.Get(0).(func(uint32) map[string]uint64); ok {
946 r0 = returnFunc(prop)
947 } else {
948 if ret.Get(0) != nil {
949 r0 = ret.Get(0).(map[string]uint64)
950 }
951 }
952 if returnFunc, ok := ret.Get(1).(func(uint32) error); ok {
953 r1 = returnFunc(prop)
954 } else {
955 r1 = ret.Error(1)
956 }
957 return r0, r1
958}
959
960// mockkms_propEnums_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'propEnums'
961type mockkms_propEnums_Call struct {
962 *mock.Call
963}
964
965// propEnums is a helper method to define mock.On call
966// - prop uint32
967func (_e *mockkms_Expecter) propEnums(prop any) *mockkms_propEnums_Call {
968 return &mockkms_propEnums_Call{Call: _e.mock.On("propEnums", prop)}
969}
970
971func (_c *mockkms_propEnums_Call) Run(run func(prop uint32)) *mockkms_propEnums_Call {
972 _c.Call.Run(func(args mock.Arguments) {
973 var arg0 uint32
974 if args[0] != nil {
975 arg0 = args[0].(uint32)
976 }
977 run(
978 arg0,
979 )
980 })
981 return _c
982}
983
984func (_c *mockkms_propEnums_Call) Return(stringToUint64 map[string]uint64, err error) *mockkms_propEnums_Call {
985 _c.Call.Return(stringToUint64, err)
986 return _c
987}
988
989func (_c *mockkms_propEnums_Call) RunAndReturn(run func(prop uint32) (map[string]uint64, error)) *mockkms_propEnums_Call {
990 _c.Call.Return(run)
991 return _c
992}
993
994// resources provides a mock function for the type mockkms
995func (_mock *mockkms) resources() ([]uint32, []uint32, error) {
996 ret := _mock.Called()
997
998 if len(ret) == 0 {
999 panic("no return value specified for resources")
1000 }
1001
1002 var r0 []uint32
1003 var r1 []uint32
1004 var r2 error
1005 if returnFunc, ok := ret.Get(0).(func() ([]uint32, []uint32, error)); ok {
1006 return returnFunc()
1007 }
1008 if returnFunc, ok := ret.Get(0).(func() []uint32); ok {
1009 r0 = returnFunc()
1010 } else {
1011 if ret.Get(0) != nil {
1012 r0 = ret.Get(0).([]uint32)
1013 }
1014 }
1015 if returnFunc, ok := ret.Get(1).(func() []uint32); ok {
1016 r1 = returnFunc()
1017 } else {
1018 if ret.Get(1) != nil {
1019 r1 = ret.Get(1).([]uint32)
1020 }
1021 }
1022 if returnFunc, ok := ret.Get(2).(func() error); ok {
1023 r2 = returnFunc()
1024 } else {
1025 r2 = ret.Error(2)
1026 }
1027 return r0, r1, r2
1028}
1029
1030// mockkms_resources_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'resources'
1031type mockkms_resources_Call struct {
1032 *mock.Call
1033}
1034
1035// resources is a helper method to define mock.On call
1036func (_e *mockkms_Expecter) resources() *mockkms_resources_Call {
1037 return &mockkms_resources_Call{Call: _e.mock.On("resources")}
1038}
1039
1040func (_c *mockkms_resources_Call) Run(run func()) *mockkms_resources_Call {
1041 _c.Call.Run(func(args mock.Arguments) {
1042 run()
1043 })
1044 return _c
1045}
1046
1047func (_c *mockkms_resources_Call) Return(uint32s []uint32, uint32s1 []uint32, err error) *mockkms_resources_Call {
1048 _c.Call.Return(uint32s, uint32s1, err)
1049 return _c
1050}
1051
1052func (_c *mockkms_resources_Call) RunAndReturn(run func() ([]uint32, []uint32, error)) *mockkms_resources_Call {
1053 _c.Call.Return(run)
1054 return _c
1055}
1056
1057// revokeLease provides a mock function for the type mockkms
1058func (_mock *mockkms) revokeLease(id uint32) error {
1059 ret := _mock.Called(id)
1060
1061 if len(ret) == 0 {
1062 panic("no return value specified for revokeLease")
1063 }
1064
1065 var r0 error
1066 if returnFunc, ok := ret.Get(0).(func(uint32) error); ok {
1067 r0 = returnFunc(id)
1068 } else {
1069 r0 = ret.Error(0)
1070 }
1071 return r0
1072}
1073
1074// mockkms_revokeLease_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'revokeLease'
1075type mockkms_revokeLease_Call struct {
1076 *mock.Call
1077}
1078
1079// revokeLease is a helper method to define mock.On call
1080// - id uint32
1081func (_e *mockkms_Expecter) revokeLease(id any) *mockkms_revokeLease_Call {
1082 return &mockkms_revokeLease_Call{Call: _e.mock.On("revokeLease", id)}
1083}
1084
1085func (_c *mockkms_revokeLease_Call) Run(run func(id uint32)) *mockkms_revokeLease_Call {
1086 _c.Call.Run(func(args mock.Arguments) {
1087 var arg0 uint32
1088 if args[0] != nil {
1089 arg0 = args[0].(uint32)
1090 }
1091 run(
1092 arg0,
1093 )
1094 })
1095 return _c
1096}
1097
1098func (_c *mockkms_revokeLease_Call) Return(err error) *mockkms_revokeLease_Call {
1099 _c.Call.Return(err)
1100 return _c
1101}
1102
1103func (_c *mockkms_revokeLease_Call) RunAndReturn(run func(id uint32) error) *mockkms_revokeLease_Call {
1104 _c.Call.Return(run)
1105 return _c
1106}
1107
1108// rmFB provides a mock function for the type mockkms
1109func (_mock *mockkms) rmFB(id uint32) error {
1110 ret := _mock.Called(id)
1111
1112 if len(ret) == 0 {
1113 panic("no return value specified for rmFB")
1114 }
1115
1116 var r0 error
1117 if returnFunc, ok := ret.Get(0).(func(uint32) error); ok {
1118 r0 = returnFunc(id)
1119 } else {
1120 r0 = ret.Error(0)
1121 }
1122 return r0
1123}
1124
1125// mockkms_rmFB_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'rmFB'
1126type mockkms_rmFB_Call struct {
1127 *mock.Call
1128}
1129
1130// rmFB is a helper method to define mock.On call
1131// - id uint32
1132func (_e *mockkms_Expecter) rmFB(id any) *mockkms_rmFB_Call {
1133 return &mockkms_rmFB_Call{Call: _e.mock.On("rmFB", id)}
1134}
1135
1136func (_c *mockkms_rmFB_Call) Run(run func(id uint32)) *mockkms_rmFB_Call {
1137 _c.Call.Run(func(args mock.Arguments) {
1138 var arg0 uint32
1139 if args[0] != nil {
1140 arg0 = args[0].(uint32)
1141 }
1142 run(
1143 arg0,
1144 )
1145 })
1146 return _c
1147}
1148
1149func (_c *mockkms_rmFB_Call) Return(err error) *mockkms_rmFB_Call {
1150 _c.Call.Return(err)
1151 return _c
1152}
1153
1154func (_c *mockkms_rmFB_Call) RunAndReturn(run func(id uint32) error) *mockkms_rmFB_Call {
1155 _c.Call.Return(run)
1156 return _c
1157}
1158
1159// unmapDumb provides a mock function for the type mockkms
1160func (_mock *mockkms) unmapDumb(mem []byte) error {
1161 ret := _mock.Called(mem)
1162
1163 if len(ret) == 0 {
1164 panic("no return value specified for unmapDumb")
1165 }
1166
1167 var r0 error
1168 if returnFunc, ok := ret.Get(0).(func([]byte) error); ok {
1169 r0 = returnFunc(mem)
1170 } else {
1171 r0 = ret.Error(0)
1172 }
1173 return r0
1174}
1175
1176// mockkms_unmapDumb_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'unmapDumb'
1177type mockkms_unmapDumb_Call struct {
1178 *mock.Call
1179}
1180
1181// unmapDumb is a helper method to define mock.On call
1182// - mem []byte
1183func (_e *mockkms_Expecter) unmapDumb(mem any) *mockkms_unmapDumb_Call {
1184 return &mockkms_unmapDumb_Call{Call: _e.mock.On("unmapDumb", mem)}
1185}
1186
1187func (_c *mockkms_unmapDumb_Call) Run(run func(mem []byte)) *mockkms_unmapDumb_Call {
1188 _c.Call.Run(func(args mock.Arguments) {
1189 var arg0 []byte
1190 if args[0] != nil {
1191 arg0 = args[0].([]byte)
1192 }
1193 run(
1194 arg0,
1195 )
1196 })
1197 return _c
1198}
1199
1200func (_c *mockkms_unmapDumb_Call) Return(err error) *mockkms_unmapDumb_Call {
1201 _c.Call.Return(err)
1202 return _c
1203}
1204
1205func (_c *mockkms_unmapDumb_Call) RunAndReturn(run func(mem []byte) error) *mockkms_unmapDumb_Call {
1206 _c.Call.Return(run)
1207 return _c
1208}