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