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