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) ([]ports.DMABuf, error) {
389 ret := _mock.Called(n, modifiers)
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) ([]ports.DMABuf, error)); ok {
398 return returnFunc(n, modifiers)
399 }
400 if returnFunc, ok := ret.Get(0).(func(int, []uint64) []ports.DMABuf); ok {
401 r0 = returnFunc(n, modifiers)
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) error); ok {
408 r1 = returnFunc(n, modifiers)
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
423func (_e *MockRenderer_Expecter) ExportTargets(n any, modifiers any) *MockRenderer_ExportTargets_Call {
424 return &MockRenderer_ExportTargets_Call{Call: _e.mock.On("ExportTargets", n, modifiers)}
425}
426
427func (_c *MockRenderer_ExportTargets_Call) Run(run func(n int, modifiers []uint64)) *MockRenderer_ExportTargets_Call {
428 _c.Call.Run(func(args mock.Arguments) {
429 var arg0 int
430 if args[0] != nil {
431 arg0 = args[0].(int)
432 }
433 var arg1 []uint64
434 if args[1] != nil {
435 arg1 = args[1].([]uint64)
436 }
437 run(
438 arg0,
439 arg1,
440 )
441 })
442 return _c
443}
444
445func (_c *MockRenderer_ExportTargets_Call) Return(dMABufs []ports.DMABuf, err error) *MockRenderer_ExportTargets_Call {
446 _c.Call.Return(dMABufs, err)
447 return _c
448}
449
450func (_c *MockRenderer_ExportTargets_Call) RunAndReturn(run func(n int, modifiers []uint64) ([]ports.DMABuf, error)) *MockRenderer_ExportTargets_Call {
451 _c.Call.Return(run)
452 return _c
453}
454
455// Pixels provides a mock function for the type MockRenderer
456func (_mock *MockRenderer) Pixels() *image.RGBA {
457 ret := _mock.Called()
458
459 if len(ret) == 0 {
460 panic("no return value specified for Pixels")
461 }
462
463 var r0 *image.RGBA
464 if returnFunc, ok := ret.Get(0).(func() *image.RGBA); ok {
465 r0 = returnFunc()
466 } else {
467 if ret.Get(0) != nil {
468 r0 = ret.Get(0).(*image.RGBA)
469 }
470 }
471 return r0
472}
473
474// MockRenderer_Pixels_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Pixels'
475type MockRenderer_Pixels_Call struct {
476 *mock.Call
477}
478
479// Pixels is a helper method to define mock.On call
480func (_e *MockRenderer_Expecter) Pixels() *MockRenderer_Pixels_Call {
481 return &MockRenderer_Pixels_Call{Call: _e.mock.On("Pixels")}
482}
483
484func (_c *MockRenderer_Pixels_Call) Run(run func()) *MockRenderer_Pixels_Call {
485 _c.Call.Run(func(args mock.Arguments) {
486 run()
487 })
488 return _c
489}
490
491func (_c *MockRenderer_Pixels_Call) Return(rGBA *image.RGBA) *MockRenderer_Pixels_Call {
492 _c.Call.Return(rGBA)
493 return _c
494}
495
496func (_c *MockRenderer_Pixels_Call) RunAndReturn(run func() *image.RGBA) *MockRenderer_Pixels_Call {
497 _c.Call.Return(run)
498 return _c
499}
500
501// Render provides a mock function for the type MockRenderer
502func (_mock *MockRenderer) Render(scene ports.Scene, windowIDToSurfaceContent map[ports.WindowID]ports.SurfaceContent) (*os.File, error) {
503 ret := _mock.Called(scene, windowIDToSurfaceContent)
504
505 if len(ret) == 0 {
506 panic("no return value specified for Render")
507 }
508
509 var r0 *os.File
510 var r1 error
511 if returnFunc, ok := ret.Get(0).(func(ports.Scene, map[ports.WindowID]ports.SurfaceContent) (*os.File, error)); ok {
512 return returnFunc(scene, windowIDToSurfaceContent)
513 }
514 if returnFunc, ok := ret.Get(0).(func(ports.Scene, map[ports.WindowID]ports.SurfaceContent) *os.File); ok {
515 r0 = returnFunc(scene, windowIDToSurfaceContent)
516 } else {
517 if ret.Get(0) != nil {
518 r0 = ret.Get(0).(*os.File)
519 }
520 }
521 if returnFunc, ok := ret.Get(1).(func(ports.Scene, map[ports.WindowID]ports.SurfaceContent) error); ok {
522 r1 = returnFunc(scene, windowIDToSurfaceContent)
523 } else {
524 r1 = ret.Error(1)
525 }
526 return r0, r1
527}
528
529// MockRenderer_Render_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Render'
530type MockRenderer_Render_Call struct {
531 *mock.Call
532}
533
534// Render is a helper method to define mock.On call
535// - scene ports.Scene
536// - windowIDToSurfaceContent map[ports.WindowID]ports.SurfaceContent
537func (_e *MockRenderer_Expecter) Render(scene any, windowIDToSurfaceContent any) *MockRenderer_Render_Call {
538 return &MockRenderer_Render_Call{Call: _e.mock.On("Render", scene, windowIDToSurfaceContent)}
539}
540
541func (_c *MockRenderer_Render_Call) Run(run func(scene ports.Scene, windowIDToSurfaceContent map[ports.WindowID]ports.SurfaceContent)) *MockRenderer_Render_Call {
542 _c.Call.Run(func(args mock.Arguments) {
543 var arg0 ports.Scene
544 if args[0] != nil {
545 arg0 = args[0].(ports.Scene)
546 }
547 var arg1 map[ports.WindowID]ports.SurfaceContent
548 if args[1] != nil {
549 arg1 = args[1].(map[ports.WindowID]ports.SurfaceContent)
550 }
551 run(
552 arg0,
553 arg1,
554 )
555 })
556 return _c
557}
558
559func (_c *MockRenderer_Render_Call) Return(done *os.File, err error) *MockRenderer_Render_Call {
560 _c.Call.Return(done, err)
561 return _c
562}
563
564func (_c *MockRenderer_Render_Call) RunAndReturn(run func(scene ports.Scene, windowIDToSurfaceContent map[ports.WindowID]ports.SurfaceContent) (*os.File, error)) *MockRenderer_Render_Call {
565 _c.Call.Return(run)
566 return _c
567}
568
569// SetHDR provides a mock function for the type MockRenderer
570func (_mock *MockRenderer) SetHDR(sdrNits float64) {
571 _mock.Called(sdrNits)
572 return
573}
574
575// MockRenderer_SetHDR_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHDR'
576type MockRenderer_SetHDR_Call struct {
577 *mock.Call
578}
579
580// SetHDR is a helper method to define mock.On call
581// - sdrNits float64
582func (_e *MockRenderer_Expecter) SetHDR(sdrNits any) *MockRenderer_SetHDR_Call {
583 return &MockRenderer_SetHDR_Call{Call: _e.mock.On("SetHDR", sdrNits)}
584}
585
586func (_c *MockRenderer_SetHDR_Call) Run(run func(sdrNits float64)) *MockRenderer_SetHDR_Call {
587 _c.Call.Run(func(args mock.Arguments) {
588 var arg0 float64
589 if args[0] != nil {
590 arg0 = args[0].(float64)
591 }
592 run(
593 arg0,
594 )
595 })
596 return _c
597}
598
599func (_c *MockRenderer_SetHDR_Call) Return() *MockRenderer_SetHDR_Call {
600 _c.Call.Return()
601 return _c
602}
603
604func (_c *MockRenderer_SetHDR_Call) RunAndReturn(run func(sdrNits float64)) *MockRenderer_SetHDR_Call {
605 _c.Run(run)
606 return _c
607}
608
609// Trim provides a mock function for the type MockRenderer
610func (_mock *MockRenderer) Trim(now time.Time) error {
611 ret := _mock.Called(now)
612
613 if len(ret) == 0 {
614 panic("no return value specified for Trim")
615 }
616
617 var r0 error
618 if returnFunc, ok := ret.Get(0).(func(time.Time) error); ok {
619 r0 = returnFunc(now)
620 } else {
621 r0 = ret.Error(0)
622 }
623 return r0
624}
625
626// MockRenderer_Trim_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Trim'
627type MockRenderer_Trim_Call struct {
628 *mock.Call
629}
630
631// Trim is a helper method to define mock.On call
632// - now time.Time
633func (_e *MockRenderer_Expecter) Trim(now any) *MockRenderer_Trim_Call {
634 return &MockRenderer_Trim_Call{Call: _e.mock.On("Trim", now)}
635}
636
637func (_c *MockRenderer_Trim_Call) Run(run func(now time.Time)) *MockRenderer_Trim_Call {
638 _c.Call.Run(func(args mock.Arguments) {
639 var arg0 time.Time
640 if args[0] != nil {
641 arg0 = args[0].(time.Time)
642 }
643 run(
644 arg0,
645 )
646 })
647 return _c
648}
649
650func (_c *MockRenderer_Trim_Call) Return(err error) *MockRenderer_Trim_Call {
651 _c.Call.Return(err)
652 return _c
653}
654
655func (_c *MockRenderer_Trim_Call) RunAndReturn(run func(now time.Time) error) *MockRenderer_Trim_Call {
656 _c.Call.Return(run)
657 return _c
658}
659
660// UseTarget provides a mock function for the type MockRenderer
661func (_mock *MockRenderer) UseTarget(i int) {
662 _mock.Called(i)
663 return
664}
665
666// MockRenderer_UseTarget_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UseTarget'
667type MockRenderer_UseTarget_Call struct {
668 *mock.Call
669}
670
671// UseTarget is a helper method to define mock.On call
672// - i int
673func (_e *MockRenderer_Expecter) UseTarget(i any) *MockRenderer_UseTarget_Call {
674 return &MockRenderer_UseTarget_Call{Call: _e.mock.On("UseTarget", i)}
675}
676
677func (_c *MockRenderer_UseTarget_Call) Run(run func(i int)) *MockRenderer_UseTarget_Call {
678 _c.Call.Run(func(args mock.Arguments) {
679 var arg0 int
680 if args[0] != nil {
681 arg0 = args[0].(int)
682 }
683 run(
684 arg0,
685 )
686 })
687 return _c
688}
689
690func (_c *MockRenderer_UseTarget_Call) Return() *MockRenderer_UseTarget_Call {
691 _c.Call.Return()
692 return _c
693}
694
695func (_c *MockRenderer_UseTarget_Call) RunAndReturn(run func(i int)) *MockRenderer_UseTarget_Call {
696 _c.Run(run)
697 return _c
698}
699
700// WriteCursor provides a mock function for the type MockRenderer
701func (_mock *MockRenderer) WriteCursor(i int, pixels []byte, w int, h int) error {
702 ret := _mock.Called(i, pixels, w, h)
703
704 if len(ret) == 0 {
705 panic("no return value specified for WriteCursor")
706 }
707
708 var r0 error
709 if returnFunc, ok := ret.Get(0).(func(int, []byte, int, int) error); ok {
710 r0 = returnFunc(i, pixels, w, h)
711 } else {
712 r0 = ret.Error(0)
713 }
714 return r0
715}
716
717// MockRenderer_WriteCursor_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WriteCursor'
718type MockRenderer_WriteCursor_Call struct {
719 *mock.Call
720}
721
722// WriteCursor is a helper method to define mock.On call
723// - i int
724// - pixels []byte
725// - w int
726// - h int
727func (_e *MockRenderer_Expecter) WriteCursor(i any, pixels any, w any, h any) *MockRenderer_WriteCursor_Call {
728 return &MockRenderer_WriteCursor_Call{Call: _e.mock.On("WriteCursor", i, pixels, w, h)}
729}
730
731func (_c *MockRenderer_WriteCursor_Call) Run(run func(i int, pixels []byte, w int, h int)) *MockRenderer_WriteCursor_Call {
732 _c.Call.Run(func(args mock.Arguments) {
733 var arg0 int
734 if args[0] != nil {
735 arg0 = args[0].(int)
736 }
737 var arg1 []byte
738 if args[1] != nil {
739 arg1 = args[1].([]byte)
740 }
741 var arg2 int
742 if args[2] != nil {
743 arg2 = args[2].(int)
744 }
745 var arg3 int
746 if args[3] != nil {
747 arg3 = args[3].(int)
748 }
749 run(
750 arg0,
751 arg1,
752 arg2,
753 arg3,
754 )
755 })
756 return _c
757}
758
759func (_c *MockRenderer_WriteCursor_Call) Return(err error) *MockRenderer_WriteCursor_Call {
760 _c.Call.Return(err)
761 return _c
762}
763
764func (_c *MockRenderer_WriteCursor_Call) RunAndReturn(run func(i int, pixels []byte, w int, h int) error) *MockRenderer_WriteCursor_Call {
765 _c.Call.Return(run)
766 return _c
767}
768
769// 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.
770// The first argument is typically a *testing.T value.
771func NewMockSeat(t interface {
772 mock.TestingT
773 Cleanup(func())
774}) *MockSeat {
775 if helper, ok := t.(interface{ Helper() }); ok {
776 helper.Helper()
777 }
778
779 mock := &MockSeat{}
780 mock.Mock.Test(t)
781
782 t.Cleanup(func() {
783 if helper, ok := t.(interface{ Helper() }); ok {
784 helper.Helper()
785 }
786 mock.AssertExpectations(t)
787 })
788
789 return mock
790}
791
792// MockSeat is an autogenerated mock type for the Seat type
793type MockSeat struct {
794 mock.Mock
795}
796
797type MockSeat_Expecter struct {
798 mock *mock.Mock
799}
800
801func (_m *MockSeat) EXPECT() *MockSeat_Expecter {
802 return &MockSeat_Expecter{mock: &_m.Mock}
803}
804
805// CloseDevice provides a mock function for the type MockSeat
806func (_mock *MockSeat) CloseDevice(fd int) {
807 _mock.Called(fd)
808 return
809}
810
811// MockSeat_CloseDevice_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CloseDevice'
812type MockSeat_CloseDevice_Call struct {
813 *mock.Call
814}
815
816// CloseDevice is a helper method to define mock.On call
817// - fd int
818func (_e *MockSeat_Expecter) CloseDevice(fd any) *MockSeat_CloseDevice_Call {
819 return &MockSeat_CloseDevice_Call{Call: _e.mock.On("CloseDevice", fd)}
820}
821
822func (_c *MockSeat_CloseDevice_Call) Run(run func(fd int)) *MockSeat_CloseDevice_Call {
823 _c.Call.Run(func(args mock.Arguments) {
824 var arg0 int
825 if args[0] != nil {
826 arg0 = args[0].(int)
827 }
828 run(
829 arg0,
830 )
831 })
832 return _c
833}
834
835func (_c *MockSeat_CloseDevice_Call) Return() *MockSeat_CloseDevice_Call {
836 _c.Call.Return()
837 return _c
838}
839
840func (_c *MockSeat_CloseDevice_Call) RunAndReturn(run func(fd int)) *MockSeat_CloseDevice_Call {
841 _c.Run(run)
842 return _c
843}
844
845// OpenDevice provides a mock function for the type MockSeat
846func (_mock *MockSeat) OpenDevice(path string) (int, error) {
847 ret := _mock.Called(path)
848
849 if len(ret) == 0 {
850 panic("no return value specified for OpenDevice")
851 }
852
853 var r0 int
854 var r1 error
855 if returnFunc, ok := ret.Get(0).(func(string) (int, error)); ok {
856 return returnFunc(path)
857 }
858 if returnFunc, ok := ret.Get(0).(func(string) int); ok {
859 r0 = returnFunc(path)
860 } else {
861 r0 = ret.Get(0).(int)
862 }
863 if returnFunc, ok := ret.Get(1).(func(string) error); ok {
864 r1 = returnFunc(path)
865 } else {
866 r1 = ret.Error(1)
867 }
868 return r0, r1
869}
870
871// MockSeat_OpenDevice_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OpenDevice'
872type MockSeat_OpenDevice_Call struct {
873 *mock.Call
874}
875
876// OpenDevice is a helper method to define mock.On call
877// - path string
878func (_e *MockSeat_Expecter) OpenDevice(path any) *MockSeat_OpenDevice_Call {
879 return &MockSeat_OpenDevice_Call{Call: _e.mock.On("OpenDevice", path)}
880}
881
882func (_c *MockSeat_OpenDevice_Call) Run(run func(path string)) *MockSeat_OpenDevice_Call {
883 _c.Call.Run(func(args mock.Arguments) {
884 var arg0 string
885 if args[0] != nil {
886 arg0 = args[0].(string)
887 }
888 run(
889 arg0,
890 )
891 })
892 return _c
893}
894
895func (_c *MockSeat_OpenDevice_Call) Return(n int, err error) *MockSeat_OpenDevice_Call {
896 _c.Call.Return(n, err)
897 return _c
898}
899
900func (_c *MockSeat_OpenDevice_Call) RunAndReturn(run func(path string) (int, error)) *MockSeat_OpenDevice_Call {
901 _c.Call.Return(run)
902 return _c
903}
904
905// SwitchVT provides a mock function for the type MockSeat
906func (_mock *MockSeat) SwitchVT(vt int) {
907 _mock.Called(vt)
908 return
909}
910
911// MockSeat_SwitchVT_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SwitchVT'
912type MockSeat_SwitchVT_Call struct {
913 *mock.Call
914}
915
916// SwitchVT is a helper method to define mock.On call
917// - vt int
918func (_e *MockSeat_Expecter) SwitchVT(vt any) *MockSeat_SwitchVT_Call {
919 return &MockSeat_SwitchVT_Call{Call: _e.mock.On("SwitchVT", vt)}
920}
921
922func (_c *MockSeat_SwitchVT_Call) Run(run func(vt int)) *MockSeat_SwitchVT_Call {
923 _c.Call.Run(func(args mock.Arguments) {
924 var arg0 int
925 if args[0] != nil {
926 arg0 = args[0].(int)
927 }
928 run(
929 arg0,
930 )
931 })
932 return _c
933}
934
935func (_c *MockSeat_SwitchVT_Call) Return() *MockSeat_SwitchVT_Call {
936 _c.Call.Return()
937 return _c
938}
939
940func (_c *MockSeat_SwitchVT_Call) RunAndReturn(run func(vt int)) *MockSeat_SwitchVT_Call {
941 _c.Run(run)
942 return _c
943}