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