1// Code generated by mockery; DO NOT EDIT.
2// github.com/vektra/mockery
3// template: testify
4
5package portsmocks
6
7import (
8 "context"
9
10 "github.com/bnema/vev/internal/domain"
11 "github.com/bnema/vev/internal/ports"
12 mock "github.com/stretchr/testify/mock"
13)
14
15// NewMockUIService creates a new instance of MockUIService. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
16// The first argument is typically a *testing.T value.
17func NewMockUIService(t interface {
18 mock.TestingT
19 Cleanup(func())
20}) *MockUIService {
21 if helper, ok := t.(interface{ Helper() }); ok {
22 helper.Helper()
23 }
24
25 mock := &MockUIService{}
26 mock.Mock.Test(t)
27
28 t.Cleanup(func() {
29 if helper, ok := t.(interface{ Helper() }); ok {
30 helper.Helper()
31 }
32 mock.AssertExpectations(t)
33 })
34
35 return mock
36}
37
38// MockUIService is an autogenerated mock type for the UIService type
39type MockUIService struct {
40 mock.Mock
41}
42
43type MockUIService_Expecter struct {
44 mock *mock.Mock
45}
46
47func (_m *MockUIService) EXPECT() *MockUIService_Expecter {
48 return &MockUIService_Expecter{mock: &_m.Mock}
49}
50
51// Action provides a mock function for the type MockUIService
52func (_mock *MockUIService) Action(ctx context.Context, request ports.UIActionRequest) (ports.UIActionResult, error) {
53 ret := _mock.Called(ctx, request)
54
55 if len(ret) == 0 {
56 panic("no return value specified for Action")
57 }
58
59 var r0 ports.UIActionResult
60 var r1 error
61 if returnFunc, ok := ret.Get(0).(func(context.Context, ports.UIActionRequest) (ports.UIActionResult, error)); ok {
62 return returnFunc(ctx, request)
63 }
64 if returnFunc, ok := ret.Get(0).(func(context.Context, ports.UIActionRequest) ports.UIActionResult); ok {
65 r0 = returnFunc(ctx, request)
66 } else {
67 r0 = ret.Get(0).(ports.UIActionResult)
68 }
69 if returnFunc, ok := ret.Get(1).(func(context.Context, ports.UIActionRequest) error); ok {
70 r1 = returnFunc(ctx, request)
71 } else {
72 r1 = ret.Error(1)
73 }
74 return r0, r1
75}
76
77// MockUIService_Action_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Action'
78type MockUIService_Action_Call struct {
79 *mock.Call
80}
81
82// Action is a helper method to define mock.On call
83// - ctx context.Context
84// - request ports.UIActionRequest
85func (_e *MockUIService_Expecter) Action(ctx any, request any) *MockUIService_Action_Call {
86 return &MockUIService_Action_Call{Call: _e.mock.On("Action", ctx, request)}
87}
88
89func (_c *MockUIService_Action_Call) Run(run func(ctx context.Context, request ports.UIActionRequest)) *MockUIService_Action_Call {
90 _c.Call.Run(func(args mock.Arguments) {
91 var arg0 context.Context
92 if args[0] != nil {
93 arg0 = args[0].(context.Context)
94 }
95 var arg1 ports.UIActionRequest
96 if args[1] != nil {
97 arg1 = args[1].(ports.UIActionRequest)
98 }
99 run(
100 arg0,
101 arg1,
102 )
103 })
104 return _c
105}
106
107func (_c *MockUIService_Action_Call) Return(uIActionResult ports.UIActionResult, err error) *MockUIService_Action_Call {
108 _c.Call.Return(uIActionResult, err)
109 return _c
110}
111
112func (_c *MockUIService_Action_Call) RunAndReturn(run func(ctx context.Context, request ports.UIActionRequest) (ports.UIActionResult, error)) *MockUIService_Action_Call {
113 _c.Call.Return(run)
114 return _c
115}
116
117// Capture provides a mock function for the type MockUIService
118func (_mock *MockUIService) Capture(attachment string) (ports.UISnapshot, error) {
119 ret := _mock.Called(attachment)
120
121 if len(ret) == 0 {
122 panic("no return value specified for Capture")
123 }
124
125 var r0 ports.UISnapshot
126 var r1 error
127 if returnFunc, ok := ret.Get(0).(func(string) (ports.UISnapshot, error)); ok {
128 return returnFunc(attachment)
129 }
130 if returnFunc, ok := ret.Get(0).(func(string) ports.UISnapshot); ok {
131 r0 = returnFunc(attachment)
132 } else {
133 r0 = ret.Get(0).(ports.UISnapshot)
134 }
135 if returnFunc, ok := ret.Get(1).(func(string) error); ok {
136 r1 = returnFunc(attachment)
137 } else {
138 r1 = ret.Error(1)
139 }
140 return r0, r1
141}
142
143// MockUIService_Capture_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Capture'
144type MockUIService_Capture_Call struct {
145 *mock.Call
146}
147
148// Capture is a helper method to define mock.On call
149// - attachment string
150func (_e *MockUIService_Expecter) Capture(attachment any) *MockUIService_Capture_Call {
151 return &MockUIService_Capture_Call{Call: _e.mock.On("Capture", attachment)}
152}
153
154func (_c *MockUIService_Capture_Call) Run(run func(attachment string)) *MockUIService_Capture_Call {
155 _c.Call.Run(func(args mock.Arguments) {
156 var arg0 string
157 if args[0] != nil {
158 arg0 = args[0].(string)
159 }
160 run(
161 arg0,
162 )
163 })
164 return _c
165}
166
167func (_c *MockUIService_Capture_Call) Return(uISnapshot ports.UISnapshot, err error) *MockUIService_Capture_Call {
168 _c.Call.Return(uISnapshot, err)
169 return _c
170}
171
172func (_c *MockUIService_Capture_Call) RunAndReturn(run func(attachment string) (ports.UISnapshot, error)) *MockUIService_Capture_Call {
173 _c.Call.Return(run)
174 return _c
175}
176
177// Wait provides a mock function for the type MockUIService
178func (_mock *MockUIService) Wait(ctx context.Context, request ports.UIWaitRequest) (ports.UIWaitResult, error) {
179 ret := _mock.Called(ctx, request)
180
181 if len(ret) == 0 {
182 panic("no return value specified for Wait")
183 }
184
185 var r0 ports.UIWaitResult
186 var r1 error
187 if returnFunc, ok := ret.Get(0).(func(context.Context, ports.UIWaitRequest) (ports.UIWaitResult, error)); ok {
188 return returnFunc(ctx, request)
189 }
190 if returnFunc, ok := ret.Get(0).(func(context.Context, ports.UIWaitRequest) ports.UIWaitResult); ok {
191 r0 = returnFunc(ctx, request)
192 } else {
193 r0 = ret.Get(0).(ports.UIWaitResult)
194 }
195 if returnFunc, ok := ret.Get(1).(func(context.Context, ports.UIWaitRequest) error); ok {
196 r1 = returnFunc(ctx, request)
197 } else {
198 r1 = ret.Error(1)
199 }
200 return r0, r1
201}
202
203// MockUIService_Wait_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Wait'
204type MockUIService_Wait_Call struct {
205 *mock.Call
206}
207
208// Wait is a helper method to define mock.On call
209// - ctx context.Context
210// - request ports.UIWaitRequest
211func (_e *MockUIService_Expecter) Wait(ctx any, request any) *MockUIService_Wait_Call {
212 return &MockUIService_Wait_Call{Call: _e.mock.On("Wait", ctx, request)}
213}
214
215func (_c *MockUIService_Wait_Call) Run(run func(ctx context.Context, request ports.UIWaitRequest)) *MockUIService_Wait_Call {
216 _c.Call.Run(func(args mock.Arguments) {
217 var arg0 context.Context
218 if args[0] != nil {
219 arg0 = args[0].(context.Context)
220 }
221 var arg1 ports.UIWaitRequest
222 if args[1] != nil {
223 arg1 = args[1].(ports.UIWaitRequest)
224 }
225 run(
226 arg0,
227 arg1,
228 )
229 })
230 return _c
231}
232
233func (_c *MockUIService_Wait_Call) Return(uIWaitResult ports.UIWaitResult, err error) *MockUIService_Wait_Call {
234 _c.Call.Return(uIWaitResult, err)
235 return _c
236}
237
238func (_c *MockUIService_Wait_Call) RunAndReturn(run func(ctx context.Context, request ports.UIWaitRequest) (ports.UIWaitResult, error)) *MockUIService_Wait_Call {
239 _c.Call.Return(run)
240 return _c
241}
242
243// NewMockUIObservationSink creates a new instance of MockUIObservationSink. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
244// The first argument is typically a *testing.T value.
245func NewMockUIObservationSink(t interface {
246 mock.TestingT
247 Cleanup(func())
248}) *MockUIObservationSink {
249 if helper, ok := t.(interface{ Helper() }); ok {
250 helper.Helper()
251 }
252
253 mock := &MockUIObservationSink{}
254 mock.Mock.Test(t)
255
256 t.Cleanup(func() {
257 if helper, ok := t.(interface{ Helper() }); ok {
258 helper.Helper()
259 }
260 mock.AssertExpectations(t)
261 })
262
263 return mock
264}
265
266// MockUIObservationSink is an autogenerated mock type for the UIObservationSink type
267type MockUIObservationSink struct {
268 mock.Mock
269}
270
271type MockUIObservationSink_Expecter struct {
272 mock *mock.Mock
273}
274
275func (_m *MockUIObservationSink) EXPECT() *MockUIObservationSink_Expecter {
276 return &MockUIObservationSink_Expecter{mock: &_m.Mock}
277}
278
279// InvalidateTerminalObservation provides a mock function for the type MockUIObservationSink
280func (_mock *MockUIObservationSink) InvalidateTerminalObservation() {
281 _mock.Called()
282 return
283}
284
285// MockUIObservationSink_InvalidateTerminalObservation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'InvalidateTerminalObservation'
286type MockUIObservationSink_InvalidateTerminalObservation_Call struct {
287 *mock.Call
288}
289
290// InvalidateTerminalObservation is a helper method to define mock.On call
291func (_e *MockUIObservationSink_Expecter) InvalidateTerminalObservation() *MockUIObservationSink_InvalidateTerminalObservation_Call {
292 return &MockUIObservationSink_InvalidateTerminalObservation_Call{Call: _e.mock.On("InvalidateTerminalObservation")}
293}
294
295func (_c *MockUIObservationSink_InvalidateTerminalObservation_Call) Run(run func()) *MockUIObservationSink_InvalidateTerminalObservation_Call {
296 _c.Call.Run(func(args mock.Arguments) {
297 run()
298 })
299 return _c
300}
301
302func (_c *MockUIObservationSink_InvalidateTerminalObservation_Call) Return() *MockUIObservationSink_InvalidateTerminalObservation_Call {
303 _c.Call.Return()
304 return _c
305}
306
307func (_c *MockUIObservationSink_InvalidateTerminalObservation_Call) RunAndReturn(run func()) *MockUIObservationSink_InvalidateTerminalObservation_Call {
308 _c.Run(run)
309 return _c
310}
311
312// ObserveTerminalFlush provides a mock function for the type MockUIObservationSink
313func (_mock *MockUIObservationSink) ObserveTerminalFlush() {
314 _mock.Called()
315 return
316}
317
318// MockUIObservationSink_ObserveTerminalFlush_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ObserveTerminalFlush'
319type MockUIObservationSink_ObserveTerminalFlush_Call struct {
320 *mock.Call
321}
322
323// ObserveTerminalFlush is a helper method to define mock.On call
324func (_e *MockUIObservationSink_Expecter) ObserveTerminalFlush() *MockUIObservationSink_ObserveTerminalFlush_Call {
325 return &MockUIObservationSink_ObserveTerminalFlush_Call{Call: _e.mock.On("ObserveTerminalFlush")}
326}
327
328func (_c *MockUIObservationSink_ObserveTerminalFlush_Call) Run(run func()) *MockUIObservationSink_ObserveTerminalFlush_Call {
329 _c.Call.Run(func(args mock.Arguments) {
330 run()
331 })
332 return _c
333}
334
335func (_c *MockUIObservationSink_ObserveTerminalFlush_Call) Return() *MockUIObservationSink_ObserveTerminalFlush_Call {
336 _c.Call.Return()
337 return _c
338}
339
340func (_c *MockUIObservationSink_ObserveTerminalFlush_Call) RunAndReturn(run func()) *MockUIObservationSink_ObserveTerminalFlush_Call {
341 _c.Run(run)
342 return _c
343}
344
345// ObserveTerminalResize provides a mock function for the type MockUIObservationSink
346func (_mock *MockUIObservationSink) ObserveTerminalResize(geometry domain.Geometry) {
347 _mock.Called(geometry)
348 return
349}
350
351// MockUIObservationSink_ObserveTerminalResize_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ObserveTerminalResize'
352type MockUIObservationSink_ObserveTerminalResize_Call struct {
353 *mock.Call
354}
355
356// ObserveTerminalResize is a helper method to define mock.On call
357// - geometry domain.Geometry
358func (_e *MockUIObservationSink_Expecter) ObserveTerminalResize(geometry any) *MockUIObservationSink_ObserveTerminalResize_Call {
359 return &MockUIObservationSink_ObserveTerminalResize_Call{Call: _e.mock.On("ObserveTerminalResize", geometry)}
360}
361
362func (_c *MockUIObservationSink_ObserveTerminalResize_Call) Run(run func(geometry domain.Geometry)) *MockUIObservationSink_ObserveTerminalResize_Call {
363 _c.Call.Run(func(args mock.Arguments) {
364 var arg0 domain.Geometry
365 if args[0] != nil {
366 arg0 = args[0].(domain.Geometry)
367 }
368 run(
369 arg0,
370 )
371 })
372 return _c
373}
374
375func (_c *MockUIObservationSink_ObserveTerminalResize_Call) Return() *MockUIObservationSink_ObserveTerminalResize_Call {
376 _c.Call.Return()
377 return _c
378}
379
380func (_c *MockUIObservationSink_ObserveTerminalResize_Call) RunAndReturn(run func(geometry domain.Geometry)) *MockUIObservationSink_ObserveTerminalResize_Call {
381 _c.Run(run)
382 return _c
383}
384
385// ObserveTerminalWrite provides a mock function for the type MockUIObservationSink
386func (_mock *MockUIObservationSink) ObserveTerminalWrite(data []byte) {
387 _mock.Called(data)
388 return
389}
390
391// MockUIObservationSink_ObserveTerminalWrite_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ObserveTerminalWrite'
392type MockUIObservationSink_ObserveTerminalWrite_Call struct {
393 *mock.Call
394}
395
396// ObserveTerminalWrite is a helper method to define mock.On call
397// - data []byte
398func (_e *MockUIObservationSink_Expecter) ObserveTerminalWrite(data any) *MockUIObservationSink_ObserveTerminalWrite_Call {
399 return &MockUIObservationSink_ObserveTerminalWrite_Call{Call: _e.mock.On("ObserveTerminalWrite", data)}
400}
401
402func (_c *MockUIObservationSink_ObserveTerminalWrite_Call) Run(run func(data []byte)) *MockUIObservationSink_ObserveTerminalWrite_Call {
403 _c.Call.Run(func(args mock.Arguments) {
404 var arg0 []byte
405 if args[0] != nil {
406 arg0 = args[0].([]byte)
407 }
408 run(
409 arg0,
410 )
411 })
412 return _c
413}
414
415func (_c *MockUIObservationSink_ObserveTerminalWrite_Call) Return() *MockUIObservationSink_ObserveTerminalWrite_Call {
416 _c.Call.Return()
417 return _c
418}
419
420func (_c *MockUIObservationSink_ObserveTerminalWrite_Call) RunAndReturn(run func(data []byte)) *MockUIObservationSink_ObserveTerminalWrite_Call {
421 _c.Run(run)
422 return _c
423}
424
425// NewMockUIOutputTransaction creates a new instance of MockUIOutputTransaction. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
426// The first argument is typically a *testing.T value.
427func NewMockUIOutputTransaction(t interface {
428 mock.TestingT
429 Cleanup(func())
430}) *MockUIOutputTransaction {
431 if helper, ok := t.(interface{ Helper() }); ok {
432 helper.Helper()
433 }
434
435 mock := &MockUIOutputTransaction{}
436 mock.Mock.Test(t)
437
438 t.Cleanup(func() {
439 if helper, ok := t.(interface{ Helper() }); ok {
440 helper.Helper()
441 }
442 mock.AssertExpectations(t)
443 })
444
445 return mock
446}
447
448// MockUIOutputTransaction is an autogenerated mock type for the UIOutputTransaction type
449type MockUIOutputTransaction struct {
450 mock.Mock
451}
452
453type MockUIOutputTransaction_Expecter struct {
454 mock *mock.Mock
455}
456
457func (_m *MockUIOutputTransaction) EXPECT() *MockUIOutputTransaction_Expecter {
458 return &MockUIOutputTransaction_Expecter{mock: &_m.Mock}
459}
460
461// BeginOutput provides a mock function for the type MockUIOutputTransaction
462func (_mock *MockUIOutputTransaction) BeginOutput(context1 ports.UIContext) {
463 _mock.Called(context1)
464 return
465}
466
467// MockUIOutputTransaction_BeginOutput_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BeginOutput'
468type MockUIOutputTransaction_BeginOutput_Call struct {
469 *mock.Call
470}
471
472// BeginOutput is a helper method to define mock.On call
473// - context1 ports.UIContext
474func (_e *MockUIOutputTransaction_Expecter) BeginOutput(context1 any) *MockUIOutputTransaction_BeginOutput_Call {
475 return &MockUIOutputTransaction_BeginOutput_Call{Call: _e.mock.On("BeginOutput", context1)}
476}
477
478func (_c *MockUIOutputTransaction_BeginOutput_Call) Run(run func(context1 ports.UIContext)) *MockUIOutputTransaction_BeginOutput_Call {
479 _c.Call.Run(func(args mock.Arguments) {
480 var arg0 ports.UIContext
481 if args[0] != nil {
482 arg0 = args[0].(ports.UIContext)
483 }
484 run(
485 arg0,
486 )
487 })
488 return _c
489}
490
491func (_c *MockUIOutputTransaction_BeginOutput_Call) Return() *MockUIOutputTransaction_BeginOutput_Call {
492 _c.Call.Return()
493 return _c
494}
495
496func (_c *MockUIOutputTransaction_BeginOutput_Call) RunAndReturn(run func(context1 ports.UIContext)) *MockUIOutputTransaction_BeginOutput_Call {
497 _c.Run(run)
498 return _c
499}
500
501// EndOutput provides a mock function for the type MockUIOutputTransaction
502func (_mock *MockUIOutputTransaction) EndOutput(success bool) {
503 _mock.Called(success)
504 return
505}
506
507// MockUIOutputTransaction_EndOutput_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EndOutput'
508type MockUIOutputTransaction_EndOutput_Call struct {
509 *mock.Call
510}
511
512// EndOutput is a helper method to define mock.On call
513// - success bool
514func (_e *MockUIOutputTransaction_Expecter) EndOutput(success any) *MockUIOutputTransaction_EndOutput_Call {
515 return &MockUIOutputTransaction_EndOutput_Call{Call: _e.mock.On("EndOutput", success)}
516}
517
518func (_c *MockUIOutputTransaction_EndOutput_Call) Run(run func(success bool)) *MockUIOutputTransaction_EndOutput_Call {
519 _c.Call.Run(func(args mock.Arguments) {
520 var arg0 bool
521 if args[0] != nil {
522 arg0 = args[0].(bool)
523 }
524 run(
525 arg0,
526 )
527 })
528 return _c
529}
530
531func (_c *MockUIOutputTransaction_EndOutput_Call) Return() *MockUIOutputTransaction_EndOutput_Call {
532 _c.Call.Return()
533 return _c
534}
535
536func (_c *MockUIOutputTransaction_EndOutput_Call) RunAndReturn(run func(success bool)) *MockUIOutputTransaction_EndOutput_Call {
537 _c.Run(run)
538 return _c
539}
540
541// PublishContext provides a mock function for the type MockUIOutputTransaction
542func (_mock *MockUIOutputTransaction) PublishContext(context1 ports.UIContext) error {
543 ret := _mock.Called(context1)
544
545 if len(ret) == 0 {
546 panic("no return value specified for PublishContext")
547 }
548
549 var r0 error
550 if returnFunc, ok := ret.Get(0).(func(ports.UIContext) error); ok {
551 r0 = returnFunc(context1)
552 } else {
553 r0 = ret.Error(0)
554 }
555 return r0
556}
557
558// MockUIOutputTransaction_PublishContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PublishContext'
559type MockUIOutputTransaction_PublishContext_Call struct {
560 *mock.Call
561}
562
563// PublishContext is a helper method to define mock.On call
564// - context1 ports.UIContext
565func (_e *MockUIOutputTransaction_Expecter) PublishContext(context1 any) *MockUIOutputTransaction_PublishContext_Call {
566 return &MockUIOutputTransaction_PublishContext_Call{Call: _e.mock.On("PublishContext", context1)}
567}
568
569func (_c *MockUIOutputTransaction_PublishContext_Call) Run(run func(context1 ports.UIContext)) *MockUIOutputTransaction_PublishContext_Call {
570 _c.Call.Run(func(args mock.Arguments) {
571 var arg0 ports.UIContext
572 if args[0] != nil {
573 arg0 = args[0].(ports.UIContext)
574 }
575 run(
576 arg0,
577 )
578 })
579 return _c
580}
581
582func (_c *MockUIOutputTransaction_PublishContext_Call) Return(err error) *MockUIOutputTransaction_PublishContext_Call {
583 _c.Call.Return(err)
584 return _c
585}
586
587func (_c *MockUIOutputTransaction_PublishContext_Call) RunAndReturn(run func(context1 ports.UIContext) error) *MockUIOutputTransaction_PublishContext_Call {
588 _c.Call.Return(run)
589 return _c
590}
591
592// NewMockUIState creates a new instance of MockUIState. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
593// The first argument is typically a *testing.T value.
594func NewMockUIState(t interface {
595 mock.TestingT
596 Cleanup(func())
597}) *MockUIState {
598 if helper, ok := t.(interface{ Helper() }); ok {
599 helper.Helper()
600 }
601
602 mock := &MockUIState{}
603 mock.Mock.Test(t)
604
605 t.Cleanup(func() {
606 if helper, ok := t.(interface{ Helper() }); ok {
607 helper.Helper()
608 }
609 mock.AssertExpectations(t)
610 })
611
612 return mock
613}
614
615// MockUIState is an autogenerated mock type for the UIState type
616type MockUIState struct {
617 mock.Mock
618}
619
620type MockUIState_Expecter struct {
621 mock *mock.Mock
622}
623
624func (_m *MockUIState) EXPECT() *MockUIState_Expecter {
625 return &MockUIState_Expecter{mock: &_m.Mock}
626}
627
628// Changes provides a mock function for the type MockUIState
629func (_mock *MockUIState) Changes() <-chan struct{} {
630 ret := _mock.Called()
631
632 if len(ret) == 0 {
633 panic("no return value specified for Changes")
634 }
635
636 var r0 <-chan struct{}
637 if returnFunc, ok := ret.Get(0).(func() <-chan struct{}); ok {
638 r0 = returnFunc()
639 } else {
640 if ret.Get(0) != nil {
641 r0 = ret.Get(0).(<-chan struct{})
642 }
643 }
644 return r0
645}
646
647// MockUIState_Changes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Changes'
648type MockUIState_Changes_Call struct {
649 *mock.Call
650}
651
652// Changes is a helper method to define mock.On call
653func (_e *MockUIState_Expecter) Changes() *MockUIState_Changes_Call {
654 return &MockUIState_Changes_Call{Call: _e.mock.On("Changes")}
655}
656
657func (_c *MockUIState_Changes_Call) Run(run func()) *MockUIState_Changes_Call {
658 _c.Call.Run(func(args mock.Arguments) {
659 run()
660 })
661 return _c
662}
663
664func (_c *MockUIState_Changes_Call) Return(valCh <-chan struct{}) *MockUIState_Changes_Call {
665 _c.Call.Return(valCh)
666 return _c
667}
668
669func (_c *MockUIState_Changes_Call) RunAndReturn(run func() <-chan struct{}) *MockUIState_Changes_Call {
670 _c.Call.Return(run)
671 return _c
672}
673
674// Snapshot provides a mock function for the type MockUIState
675func (_mock *MockUIState) Snapshot() (ports.UISnapshot, error) {
676 ret := _mock.Called()
677
678 if len(ret) == 0 {
679 panic("no return value specified for Snapshot")
680 }
681
682 var r0 ports.UISnapshot
683 var r1 error
684 if returnFunc, ok := ret.Get(0).(func() (ports.UISnapshot, error)); ok {
685 return returnFunc()
686 }
687 if returnFunc, ok := ret.Get(0).(func() ports.UISnapshot); ok {
688 r0 = returnFunc()
689 } else {
690 r0 = ret.Get(0).(ports.UISnapshot)
691 }
692 if returnFunc, ok := ret.Get(1).(func() error); ok {
693 r1 = returnFunc()
694 } else {
695 r1 = ret.Error(1)
696 }
697 return r0, r1
698}
699
700// MockUIState_Snapshot_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Snapshot'
701type MockUIState_Snapshot_Call struct {
702 *mock.Call
703}
704
705// Snapshot is a helper method to define mock.On call
706func (_e *MockUIState_Expecter) Snapshot() *MockUIState_Snapshot_Call {
707 return &MockUIState_Snapshot_Call{Call: _e.mock.On("Snapshot")}
708}
709
710func (_c *MockUIState_Snapshot_Call) Run(run func()) *MockUIState_Snapshot_Call {
711 _c.Call.Run(func(args mock.Arguments) {
712 run()
713 })
714 return _c
715}
716
717func (_c *MockUIState_Snapshot_Call) Return(uISnapshot ports.UISnapshot, err error) *MockUIState_Snapshot_Call {
718 _c.Call.Return(uISnapshot, err)
719 return _c
720}
721
722func (_c *MockUIState_Snapshot_Call) RunAndReturn(run func() (ports.UISnapshot, error)) *MockUIState_Snapshot_Call {
723 _c.Call.Return(run)
724 return _c
725}