1// Code generated by mockery; DO NOT EDIT.
2// github.com/vektra/mockery
3// template: testify
4
5package mocks
6
7import (
8 "context"
9 "database/sql"
10 "time"
11
12 "github.com/bnema/dumber/internal/application/port"
13 "github.com/bnema/dumber/internal/domain/entity"
14 "github.com/rs/zerolog"
15 mock "github.com/stretchr/testify/mock"
16)
17
18// NewMockAccentPickerUI creates a new instance of MockAccentPickerUI. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
19// The first argument is typically a *testing.T value.
20func NewMockAccentPickerUI(t interface {
21 mock.TestingT
22 Cleanup(func())
23}) *MockAccentPickerUI {
24 mock := &MockAccentPickerUI{}
25 mock.Mock.Test(t)
26
27 t.Cleanup(func() { mock.AssertExpectations(t) })
28
29 return mock
30}
31
32// MockAccentPickerUI is an autogenerated mock type for the AccentPickerUI type
33type MockAccentPickerUI struct {
34 mock.Mock
35}
36
37type MockAccentPickerUI_Expecter struct {
38 mock *mock.Mock
39}
40
41func (_m *MockAccentPickerUI) EXPECT() *MockAccentPickerUI_Expecter {
42 return &MockAccentPickerUI_Expecter{mock: &_m.Mock}
43}
44
45// Hide provides a mock function for the type MockAccentPickerUI
46func (_mock *MockAccentPickerUI) Hide() {
47 _mock.Called()
48 return
49}
50
51// MockAccentPickerUI_Hide_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Hide'
52type MockAccentPickerUI_Hide_Call struct {
53 *mock.Call
54}
55
56// Hide is a helper method to define mock.On call
57func (_e *MockAccentPickerUI_Expecter) Hide() *MockAccentPickerUI_Hide_Call {
58 return &MockAccentPickerUI_Hide_Call{Call: _e.mock.On("Hide")}
59}
60
61func (_c *MockAccentPickerUI_Hide_Call) Run(run func()) *MockAccentPickerUI_Hide_Call {
62 _c.Call.Run(func(args mock.Arguments) {
63 run()
64 })
65 return _c
66}
67
68func (_c *MockAccentPickerUI_Hide_Call) Return() *MockAccentPickerUI_Hide_Call {
69 _c.Call.Return()
70 return _c
71}
72
73func (_c *MockAccentPickerUI_Hide_Call) RunAndReturn(run func()) *MockAccentPickerUI_Hide_Call {
74 _c.Run(run)
75 return _c
76}
77
78// IsVisible provides a mock function for the type MockAccentPickerUI
79func (_mock *MockAccentPickerUI) IsVisible() bool {
80 ret := _mock.Called()
81
82 if len(ret) == 0 {
83 panic("no return value specified for IsVisible")
84 }
85
86 var r0 bool
87 if returnFunc, ok := ret.Get(0).(func() bool); ok {
88 r0 = returnFunc()
89 } else {
90 r0 = ret.Get(0).(bool)
91 }
92 return r0
93}
94
95// MockAccentPickerUI_IsVisible_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsVisible'
96type MockAccentPickerUI_IsVisible_Call struct {
97 *mock.Call
98}
99
100// IsVisible is a helper method to define mock.On call
101func (_e *MockAccentPickerUI_Expecter) IsVisible() *MockAccentPickerUI_IsVisible_Call {
102 return &MockAccentPickerUI_IsVisible_Call{Call: _e.mock.On("IsVisible")}
103}
104
105func (_c *MockAccentPickerUI_IsVisible_Call) Run(run func()) *MockAccentPickerUI_IsVisible_Call {
106 _c.Call.Run(func(args mock.Arguments) {
107 run()
108 })
109 return _c
110}
111
112func (_c *MockAccentPickerUI_IsVisible_Call) Return(b bool) *MockAccentPickerUI_IsVisible_Call {
113 _c.Call.Return(b)
114 return _c
115}
116
117func (_c *MockAccentPickerUI_IsVisible_Call) RunAndReturn(run func() bool) *MockAccentPickerUI_IsVisible_Call {
118 _c.Call.Return(run)
119 return _c
120}
121
122// Show provides a mock function for the type MockAccentPickerUI
123func (_mock *MockAccentPickerUI) Show(accents []rune, selectedCallback func(accent rune), cancelCallback func()) {
124 _mock.Called(accents, selectedCallback, cancelCallback)
125 return
126}
127
128// MockAccentPickerUI_Show_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Show'
129type MockAccentPickerUI_Show_Call struct {
130 *mock.Call
131}
132
133// Show is a helper method to define mock.On call
134// - accents []rune
135// - selectedCallback func(accent rune)
136// - cancelCallback func()
137func (_e *MockAccentPickerUI_Expecter) Show(accents interface{}, selectedCallback interface{}, cancelCallback interface{}) *MockAccentPickerUI_Show_Call {
138 return &MockAccentPickerUI_Show_Call{Call: _e.mock.On("Show", accents, selectedCallback, cancelCallback)}
139}
140
141func (_c *MockAccentPickerUI_Show_Call) Run(run func(accents []rune, selectedCallback func(accent rune), cancelCallback func())) *MockAccentPickerUI_Show_Call {
142 _c.Call.Run(func(args mock.Arguments) {
143 var arg0 []rune
144 if args[0] != nil {
145 arg0 = args[0].([]rune)
146 }
147 var arg1 func(accent rune)
148 if args[1] != nil {
149 arg1 = args[1].(func(accent rune))
150 }
151 var arg2 func()
152 if args[2] != nil {
153 arg2 = args[2].(func())
154 }
155 run(
156 arg0,
157 arg1,
158 arg2,
159 )
160 })
161 return _c
162}
163
164func (_c *MockAccentPickerUI_Show_Call) Return() *MockAccentPickerUI_Show_Call {
165 _c.Call.Return()
166 return _c
167}
168
169func (_c *MockAccentPickerUI_Show_Call) RunAndReturn(run func(accents []rune, selectedCallback func(accent rune), cancelCallback func())) *MockAccentPickerUI_Show_Call {
170 _c.Run(run)
171 return _c
172}
173
174// NewMockClipboard creates a new instance of MockClipboard. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
175// The first argument is typically a *testing.T value.
176func NewMockClipboard(t interface {
177 mock.TestingT
178 Cleanup(func())
179}) *MockClipboard {
180 mock := &MockClipboard{}
181 mock.Mock.Test(t)
182
183 t.Cleanup(func() { mock.AssertExpectations(t) })
184
185 return mock
186}
187
188// MockClipboard is an autogenerated mock type for the Clipboard type
189type MockClipboard struct {
190 mock.Mock
191}
192
193type MockClipboard_Expecter struct {
194 mock *mock.Mock
195}
196
197func (_m *MockClipboard) EXPECT() *MockClipboard_Expecter {
198 return &MockClipboard_Expecter{mock: &_m.Mock}
199}
200
201// Clear provides a mock function for the type MockClipboard
202func (_mock *MockClipboard) Clear(ctx context.Context) error {
203 ret := _mock.Called(ctx)
204
205 if len(ret) == 0 {
206 panic("no return value specified for Clear")
207 }
208
209 var r0 error
210 if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
211 r0 = returnFunc(ctx)
212 } else {
213 r0 = ret.Error(0)
214 }
215 return r0
216}
217
218// MockClipboard_Clear_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Clear'
219type MockClipboard_Clear_Call struct {
220 *mock.Call
221}
222
223// Clear is a helper method to define mock.On call
224// - ctx context.Context
225func (_e *MockClipboard_Expecter) Clear(ctx interface{}) *MockClipboard_Clear_Call {
226 return &MockClipboard_Clear_Call{Call: _e.mock.On("Clear", ctx)}
227}
228
229func (_c *MockClipboard_Clear_Call) Run(run func(ctx context.Context)) *MockClipboard_Clear_Call {
230 _c.Call.Run(func(args mock.Arguments) {
231 var arg0 context.Context
232 if args[0] != nil {
233 arg0 = args[0].(context.Context)
234 }
235 run(
236 arg0,
237 )
238 })
239 return _c
240}
241
242func (_c *MockClipboard_Clear_Call) Return(err error) *MockClipboard_Clear_Call {
243 _c.Call.Return(err)
244 return _c
245}
246
247func (_c *MockClipboard_Clear_Call) RunAndReturn(run func(ctx context.Context) error) *MockClipboard_Clear_Call {
248 _c.Call.Return(run)
249 return _c
250}
251
252// HasText provides a mock function for the type MockClipboard
253func (_mock *MockClipboard) HasText(ctx context.Context) (bool, error) {
254 ret := _mock.Called(ctx)
255
256 if len(ret) == 0 {
257 panic("no return value specified for HasText")
258 }
259
260 var r0 bool
261 var r1 error
262 if returnFunc, ok := ret.Get(0).(func(context.Context) (bool, error)); ok {
263 return returnFunc(ctx)
264 }
265 if returnFunc, ok := ret.Get(0).(func(context.Context) bool); ok {
266 r0 = returnFunc(ctx)
267 } else {
268 r0 = ret.Get(0).(bool)
269 }
270 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
271 r1 = returnFunc(ctx)
272 } else {
273 r1 = ret.Error(1)
274 }
275 return r0, r1
276}
277
278// MockClipboard_HasText_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasText'
279type MockClipboard_HasText_Call struct {
280 *mock.Call
281}
282
283// HasText is a helper method to define mock.On call
284// - ctx context.Context
285func (_e *MockClipboard_Expecter) HasText(ctx interface{}) *MockClipboard_HasText_Call {
286 return &MockClipboard_HasText_Call{Call: _e.mock.On("HasText", ctx)}
287}
288
289func (_c *MockClipboard_HasText_Call) Run(run func(ctx context.Context)) *MockClipboard_HasText_Call {
290 _c.Call.Run(func(args mock.Arguments) {
291 var arg0 context.Context
292 if args[0] != nil {
293 arg0 = args[0].(context.Context)
294 }
295 run(
296 arg0,
297 )
298 })
299 return _c
300}
301
302func (_c *MockClipboard_HasText_Call) Return(b bool, err error) *MockClipboard_HasText_Call {
303 _c.Call.Return(b, err)
304 return _c
305}
306
307func (_c *MockClipboard_HasText_Call) RunAndReturn(run func(ctx context.Context) (bool, error)) *MockClipboard_HasText_Call {
308 _c.Call.Return(run)
309 return _c
310}
311
312// ReadText provides a mock function for the type MockClipboard
313func (_mock *MockClipboard) ReadText(ctx context.Context) (string, error) {
314 ret := _mock.Called(ctx)
315
316 if len(ret) == 0 {
317 panic("no return value specified for ReadText")
318 }
319
320 var r0 string
321 var r1 error
322 if returnFunc, ok := ret.Get(0).(func(context.Context) (string, error)); ok {
323 return returnFunc(ctx)
324 }
325 if returnFunc, ok := ret.Get(0).(func(context.Context) string); ok {
326 r0 = returnFunc(ctx)
327 } else {
328 r0 = ret.Get(0).(string)
329 }
330 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
331 r1 = returnFunc(ctx)
332 } else {
333 r1 = ret.Error(1)
334 }
335 return r0, r1
336}
337
338// MockClipboard_ReadText_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReadText'
339type MockClipboard_ReadText_Call struct {
340 *mock.Call
341}
342
343// ReadText is a helper method to define mock.On call
344// - ctx context.Context
345func (_e *MockClipboard_Expecter) ReadText(ctx interface{}) *MockClipboard_ReadText_Call {
346 return &MockClipboard_ReadText_Call{Call: _e.mock.On("ReadText", ctx)}
347}
348
349func (_c *MockClipboard_ReadText_Call) Run(run func(ctx context.Context)) *MockClipboard_ReadText_Call {
350 _c.Call.Run(func(args mock.Arguments) {
351 var arg0 context.Context
352 if args[0] != nil {
353 arg0 = args[0].(context.Context)
354 }
355 run(
356 arg0,
357 )
358 })
359 return _c
360}
361
362func (_c *MockClipboard_ReadText_Call) Return(s string, err error) *MockClipboard_ReadText_Call {
363 _c.Call.Return(s, err)
364 return _c
365}
366
367func (_c *MockClipboard_ReadText_Call) RunAndReturn(run func(ctx context.Context) (string, error)) *MockClipboard_ReadText_Call {
368 _c.Call.Return(run)
369 return _c
370}
371
372// WriteText provides a mock function for the type MockClipboard
373func (_mock *MockClipboard) WriteText(ctx context.Context, text string) error {
374 ret := _mock.Called(ctx, text)
375
376 if len(ret) == 0 {
377 panic("no return value specified for WriteText")
378 }
379
380 var r0 error
381 if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
382 r0 = returnFunc(ctx, text)
383 } else {
384 r0 = ret.Error(0)
385 }
386 return r0
387}
388
389// MockClipboard_WriteText_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WriteText'
390type MockClipboard_WriteText_Call struct {
391 *mock.Call
392}
393
394// WriteText is a helper method to define mock.On call
395// - ctx context.Context
396// - text string
397func (_e *MockClipboard_Expecter) WriteText(ctx interface{}, text interface{}) *MockClipboard_WriteText_Call {
398 return &MockClipboard_WriteText_Call{Call: _e.mock.On("WriteText", ctx, text)}
399}
400
401func (_c *MockClipboard_WriteText_Call) Run(run func(ctx context.Context, text string)) *MockClipboard_WriteText_Call {
402 _c.Call.Run(func(args mock.Arguments) {
403 var arg0 context.Context
404 if args[0] != nil {
405 arg0 = args[0].(context.Context)
406 }
407 var arg1 string
408 if args[1] != nil {
409 arg1 = args[1].(string)
410 }
411 run(
412 arg0,
413 arg1,
414 )
415 })
416 return _c
417}
418
419func (_c *MockClipboard_WriteText_Call) Return(err error) *MockClipboard_WriteText_Call {
420 _c.Call.Return(err)
421 return _c
422}
423
424func (_c *MockClipboard_WriteText_Call) RunAndReturn(run func(ctx context.Context, text string) error) *MockClipboard_WriteText_Call {
425 _c.Call.Return(run)
426 return _c
427}
428
429// NewMockColorSchemeDetector creates a new instance of MockColorSchemeDetector. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
430// The first argument is typically a *testing.T value.
431func NewMockColorSchemeDetector(t interface {
432 mock.TestingT
433 Cleanup(func())
434}) *MockColorSchemeDetector {
435 mock := &MockColorSchemeDetector{}
436 mock.Mock.Test(t)
437
438 t.Cleanup(func() { mock.AssertExpectations(t) })
439
440 return mock
441}
442
443// MockColorSchemeDetector is an autogenerated mock type for the ColorSchemeDetector type
444type MockColorSchemeDetector struct {
445 mock.Mock
446}
447
448type MockColorSchemeDetector_Expecter struct {
449 mock *mock.Mock
450}
451
452func (_m *MockColorSchemeDetector) EXPECT() *MockColorSchemeDetector_Expecter {
453 return &MockColorSchemeDetector_Expecter{mock: &_m.Mock}
454}
455
456// Available provides a mock function for the type MockColorSchemeDetector
457func (_mock *MockColorSchemeDetector) Available() bool {
458 ret := _mock.Called()
459
460 if len(ret) == 0 {
461 panic("no return value specified for Available")
462 }
463
464 var r0 bool
465 if returnFunc, ok := ret.Get(0).(func() bool); ok {
466 r0 = returnFunc()
467 } else {
468 r0 = ret.Get(0).(bool)
469 }
470 return r0
471}
472
473// MockColorSchemeDetector_Available_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Available'
474type MockColorSchemeDetector_Available_Call struct {
475 *mock.Call
476}
477
478// Available is a helper method to define mock.On call
479func (_e *MockColorSchemeDetector_Expecter) Available() *MockColorSchemeDetector_Available_Call {
480 return &MockColorSchemeDetector_Available_Call{Call: _e.mock.On("Available")}
481}
482
483func (_c *MockColorSchemeDetector_Available_Call) Run(run func()) *MockColorSchemeDetector_Available_Call {
484 _c.Call.Run(func(args mock.Arguments) {
485 run()
486 })
487 return _c
488}
489
490func (_c *MockColorSchemeDetector_Available_Call) Return(b bool) *MockColorSchemeDetector_Available_Call {
491 _c.Call.Return(b)
492 return _c
493}
494
495func (_c *MockColorSchemeDetector_Available_Call) RunAndReturn(run func() bool) *MockColorSchemeDetector_Available_Call {
496 _c.Call.Return(run)
497 return _c
498}
499
500// Detect provides a mock function for the type MockColorSchemeDetector
501func (_mock *MockColorSchemeDetector) Detect() (bool, bool) {
502 ret := _mock.Called()
503
504 if len(ret) == 0 {
505 panic("no return value specified for Detect")
506 }
507
508 var r0 bool
509 var r1 bool
510 if returnFunc, ok := ret.Get(0).(func() (bool, bool)); ok {
511 return returnFunc()
512 }
513 if returnFunc, ok := ret.Get(0).(func() bool); ok {
514 r0 = returnFunc()
515 } else {
516 r0 = ret.Get(0).(bool)
517 }
518 if returnFunc, ok := ret.Get(1).(func() bool); ok {
519 r1 = returnFunc()
520 } else {
521 r1 = ret.Get(1).(bool)
522 }
523 return r0, r1
524}
525
526// MockColorSchemeDetector_Detect_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Detect'
527type MockColorSchemeDetector_Detect_Call struct {
528 *mock.Call
529}
530
531// Detect is a helper method to define mock.On call
532func (_e *MockColorSchemeDetector_Expecter) Detect() *MockColorSchemeDetector_Detect_Call {
533 return &MockColorSchemeDetector_Detect_Call{Call: _e.mock.On("Detect")}
534}
535
536func (_c *MockColorSchemeDetector_Detect_Call) Run(run func()) *MockColorSchemeDetector_Detect_Call {
537 _c.Call.Run(func(args mock.Arguments) {
538 run()
539 })
540 return _c
541}
542
543func (_c *MockColorSchemeDetector_Detect_Call) Return(prefersDark bool, ok bool) *MockColorSchemeDetector_Detect_Call {
544 _c.Call.Return(prefersDark, ok)
545 return _c
546}
547
548func (_c *MockColorSchemeDetector_Detect_Call) RunAndReturn(run func() (bool, bool)) *MockColorSchemeDetector_Detect_Call {
549 _c.Call.Return(run)
550 return _c
551}
552
553// Name provides a mock function for the type MockColorSchemeDetector
554func (_mock *MockColorSchemeDetector) Name() string {
555 ret := _mock.Called()
556
557 if len(ret) == 0 {
558 panic("no return value specified for Name")
559 }
560
561 var r0 string
562 if returnFunc, ok := ret.Get(0).(func() string); ok {
563 r0 = returnFunc()
564 } else {
565 r0 = ret.Get(0).(string)
566 }
567 return r0
568}
569
570// MockColorSchemeDetector_Name_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Name'
571type MockColorSchemeDetector_Name_Call struct {
572 *mock.Call
573}
574
575// Name is a helper method to define mock.On call
576func (_e *MockColorSchemeDetector_Expecter) Name() *MockColorSchemeDetector_Name_Call {
577 return &MockColorSchemeDetector_Name_Call{Call: _e.mock.On("Name")}
578}
579
580func (_c *MockColorSchemeDetector_Name_Call) Run(run func()) *MockColorSchemeDetector_Name_Call {
581 _c.Call.Run(func(args mock.Arguments) {
582 run()
583 })
584 return _c
585}
586
587func (_c *MockColorSchemeDetector_Name_Call) Return(s string) *MockColorSchemeDetector_Name_Call {
588 _c.Call.Return(s)
589 return _c
590}
591
592func (_c *MockColorSchemeDetector_Name_Call) RunAndReturn(run func() string) *MockColorSchemeDetector_Name_Call {
593 _c.Call.Return(run)
594 return _c
595}
596
597// Priority provides a mock function for the type MockColorSchemeDetector
598func (_mock *MockColorSchemeDetector) Priority() int {
599 ret := _mock.Called()
600
601 if len(ret) == 0 {
602 panic("no return value specified for Priority")
603 }
604
605 var r0 int
606 if returnFunc, ok := ret.Get(0).(func() int); ok {
607 r0 = returnFunc()
608 } else {
609 r0 = ret.Get(0).(int)
610 }
611 return r0
612}
613
614// MockColorSchemeDetector_Priority_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Priority'
615type MockColorSchemeDetector_Priority_Call struct {
616 *mock.Call
617}
618
619// Priority is a helper method to define mock.On call
620func (_e *MockColorSchemeDetector_Expecter) Priority() *MockColorSchemeDetector_Priority_Call {
621 return &MockColorSchemeDetector_Priority_Call{Call: _e.mock.On("Priority")}
622}
623
624func (_c *MockColorSchemeDetector_Priority_Call) Run(run func()) *MockColorSchemeDetector_Priority_Call {
625 _c.Call.Run(func(args mock.Arguments) {
626 run()
627 })
628 return _c
629}
630
631func (_c *MockColorSchemeDetector_Priority_Call) Return(n int) *MockColorSchemeDetector_Priority_Call {
632 _c.Call.Return(n)
633 return _c
634}
635
636func (_c *MockColorSchemeDetector_Priority_Call) RunAndReturn(run func() int) *MockColorSchemeDetector_Priority_Call {
637 _c.Call.Return(run)
638 return _c
639}
640
641// NewMockToolkitAvailabilityNotifier creates a new instance of MockToolkitAvailabilityNotifier. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
642// The first argument is typically a *testing.T value.
643func NewMockToolkitAvailabilityNotifier(t interface {
644 mock.TestingT
645 Cleanup(func())
646}) *MockToolkitAvailabilityNotifier {
647 mock := &MockToolkitAvailabilityNotifier{}
648 mock.Mock.Test(t)
649
650 t.Cleanup(func() { mock.AssertExpectations(t) })
651
652 return mock
653}
654
655// MockToolkitAvailabilityNotifier is an autogenerated mock type for the ToolkitAvailabilityNotifier type
656type MockToolkitAvailabilityNotifier struct {
657 mock.Mock
658}
659
660type MockToolkitAvailabilityNotifier_Expecter struct {
661 mock *mock.Mock
662}
663
664func (_m *MockToolkitAvailabilityNotifier) EXPECT() *MockToolkitAvailabilityNotifier_Expecter {
665 return &MockToolkitAvailabilityNotifier_Expecter{mock: &_m.Mock}
666}
667
668// MarkAvailable provides a mock function for the type MockToolkitAvailabilityNotifier
669func (_mock *MockToolkitAvailabilityNotifier) MarkAvailable() {
670 _mock.Called()
671 return
672}
673
674// MockToolkitAvailabilityNotifier_MarkAvailable_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MarkAvailable'
675type MockToolkitAvailabilityNotifier_MarkAvailable_Call struct {
676 *mock.Call
677}
678
679// MarkAvailable is a helper method to define mock.On call
680func (_e *MockToolkitAvailabilityNotifier_Expecter) MarkAvailable() *MockToolkitAvailabilityNotifier_MarkAvailable_Call {
681 return &MockToolkitAvailabilityNotifier_MarkAvailable_Call{Call: _e.mock.On("MarkAvailable")}
682}
683
684func (_c *MockToolkitAvailabilityNotifier_MarkAvailable_Call) Run(run func()) *MockToolkitAvailabilityNotifier_MarkAvailable_Call {
685 _c.Call.Run(func(args mock.Arguments) {
686 run()
687 })
688 return _c
689}
690
691func (_c *MockToolkitAvailabilityNotifier_MarkAvailable_Call) Return() *MockToolkitAvailabilityNotifier_MarkAvailable_Call {
692 _c.Call.Return()
693 return _c
694}
695
696func (_c *MockToolkitAvailabilityNotifier_MarkAvailable_Call) RunAndReturn(run func()) *MockToolkitAvailabilityNotifier_MarkAvailable_Call {
697 _c.Run(run)
698 return _c
699}
700
701// NewMockColorSchemeResolver creates a new instance of MockColorSchemeResolver. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
702// The first argument is typically a *testing.T value.
703func NewMockColorSchemeResolver(t interface {
704 mock.TestingT
705 Cleanup(func())
706}) *MockColorSchemeResolver {
707 mock := &MockColorSchemeResolver{}
708 mock.Mock.Test(t)
709
710 t.Cleanup(func() { mock.AssertExpectations(t) })
711
712 return mock
713}
714
715// MockColorSchemeResolver is an autogenerated mock type for the ColorSchemeResolver type
716type MockColorSchemeResolver struct {
717 mock.Mock
718}
719
720type MockColorSchemeResolver_Expecter struct {
721 mock *mock.Mock
722}
723
724func (_m *MockColorSchemeResolver) EXPECT() *MockColorSchemeResolver_Expecter {
725 return &MockColorSchemeResolver_Expecter{mock: &_m.Mock}
726}
727
728// OnChange provides a mock function for the type MockColorSchemeResolver
729func (_mock *MockColorSchemeResolver) OnChange(callback func(port.ColorSchemePreference)) func() {
730 ret := _mock.Called(callback)
731
732 if len(ret) == 0 {
733 panic("no return value specified for OnChange")
734 }
735
736 var r0 func()
737 if returnFunc, ok := ret.Get(0).(func(func(port.ColorSchemePreference)) func()); ok {
738 r0 = returnFunc(callback)
739 } else {
740 if ret.Get(0) != nil {
741 r0 = ret.Get(0).(func())
742 }
743 }
744 return r0
745}
746
747// MockColorSchemeResolver_OnChange_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OnChange'
748type MockColorSchemeResolver_OnChange_Call struct {
749 *mock.Call
750}
751
752// OnChange is a helper method to define mock.On call
753// - callback func(port.ColorSchemePreference)
754func (_e *MockColorSchemeResolver_Expecter) OnChange(callback interface{}) *MockColorSchemeResolver_OnChange_Call {
755 return &MockColorSchemeResolver_OnChange_Call{Call: _e.mock.On("OnChange", callback)}
756}
757
758func (_c *MockColorSchemeResolver_OnChange_Call) Run(run func(callback func(port.ColorSchemePreference))) *MockColorSchemeResolver_OnChange_Call {
759 _c.Call.Run(func(args mock.Arguments) {
760 var arg0 func(port.ColorSchemePreference)
761 if args[0] != nil {
762 arg0 = args[0].(func(port.ColorSchemePreference))
763 }
764 run(
765 arg0,
766 )
767 })
768 return _c
769}
770
771func (_c *MockColorSchemeResolver_OnChange_Call) Return(fn func()) *MockColorSchemeResolver_OnChange_Call {
772 _c.Call.Return(fn)
773 return _c
774}
775
776func (_c *MockColorSchemeResolver_OnChange_Call) RunAndReturn(run func(callback func(port.ColorSchemePreference)) func()) *MockColorSchemeResolver_OnChange_Call {
777 _c.Call.Return(run)
778 return _c
779}
780
781// Refresh provides a mock function for the type MockColorSchemeResolver
782func (_mock *MockColorSchemeResolver) Refresh() port.ColorSchemePreference {
783 ret := _mock.Called()
784
785 if len(ret) == 0 {
786 panic("no return value specified for Refresh")
787 }
788
789 var r0 port.ColorSchemePreference
790 if returnFunc, ok := ret.Get(0).(func() port.ColorSchemePreference); ok {
791 r0 = returnFunc()
792 } else {
793 r0 = ret.Get(0).(port.ColorSchemePreference)
794 }
795 return r0
796}
797
798// MockColorSchemeResolver_Refresh_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Refresh'
799type MockColorSchemeResolver_Refresh_Call struct {
800 *mock.Call
801}
802
803// Refresh is a helper method to define mock.On call
804func (_e *MockColorSchemeResolver_Expecter) Refresh() *MockColorSchemeResolver_Refresh_Call {
805 return &MockColorSchemeResolver_Refresh_Call{Call: _e.mock.On("Refresh")}
806}
807
808func (_c *MockColorSchemeResolver_Refresh_Call) Run(run func()) *MockColorSchemeResolver_Refresh_Call {
809 _c.Call.Run(func(args mock.Arguments) {
810 run()
811 })
812 return _c
813}
814
815func (_c *MockColorSchemeResolver_Refresh_Call) Return(colorSchemePreference port.ColorSchemePreference) *MockColorSchemeResolver_Refresh_Call {
816 _c.Call.Return(colorSchemePreference)
817 return _c
818}
819
820func (_c *MockColorSchemeResolver_Refresh_Call) RunAndReturn(run func() port.ColorSchemePreference) *MockColorSchemeResolver_Refresh_Call {
821 _c.Call.Return(run)
822 return _c
823}
824
825// RegisterDetector provides a mock function for the type MockColorSchemeResolver
826func (_mock *MockColorSchemeResolver) RegisterDetector(detector port.ColorSchemeDetector) {
827 _mock.Called(detector)
828 return
829}
830
831// MockColorSchemeResolver_RegisterDetector_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterDetector'
832type MockColorSchemeResolver_RegisterDetector_Call struct {
833 *mock.Call
834}
835
836// RegisterDetector is a helper method to define mock.On call
837// - detector port.ColorSchemeDetector
838func (_e *MockColorSchemeResolver_Expecter) RegisterDetector(detector interface{}) *MockColorSchemeResolver_RegisterDetector_Call {
839 return &MockColorSchemeResolver_RegisterDetector_Call{Call: _e.mock.On("RegisterDetector", detector)}
840}
841
842func (_c *MockColorSchemeResolver_RegisterDetector_Call) Run(run func(detector port.ColorSchemeDetector)) *MockColorSchemeResolver_RegisterDetector_Call {
843 _c.Call.Run(func(args mock.Arguments) {
844 var arg0 port.ColorSchemeDetector
845 if args[0] != nil {
846 arg0 = args[0].(port.ColorSchemeDetector)
847 }
848 run(
849 arg0,
850 )
851 })
852 return _c
853}
854
855func (_c *MockColorSchemeResolver_RegisterDetector_Call) Return() *MockColorSchemeResolver_RegisterDetector_Call {
856 _c.Call.Return()
857 return _c
858}
859
860func (_c *MockColorSchemeResolver_RegisterDetector_Call) RunAndReturn(run func(detector port.ColorSchemeDetector)) *MockColorSchemeResolver_RegisterDetector_Call {
861 _c.Run(run)
862 return _c
863}
864
865// Resolve provides a mock function for the type MockColorSchemeResolver
866func (_mock *MockColorSchemeResolver) Resolve() port.ColorSchemePreference {
867 ret := _mock.Called()
868
869 if len(ret) == 0 {
870 panic("no return value specified for Resolve")
871 }
872
873 var r0 port.ColorSchemePreference
874 if returnFunc, ok := ret.Get(0).(func() port.ColorSchemePreference); ok {
875 r0 = returnFunc()
876 } else {
877 r0 = ret.Get(0).(port.ColorSchemePreference)
878 }
879 return r0
880}
881
882// MockColorSchemeResolver_Resolve_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Resolve'
883type MockColorSchemeResolver_Resolve_Call struct {
884 *mock.Call
885}
886
887// Resolve is a helper method to define mock.On call
888func (_e *MockColorSchemeResolver_Expecter) Resolve() *MockColorSchemeResolver_Resolve_Call {
889 return &MockColorSchemeResolver_Resolve_Call{Call: _e.mock.On("Resolve")}
890}
891
892func (_c *MockColorSchemeResolver_Resolve_Call) Run(run func()) *MockColorSchemeResolver_Resolve_Call {
893 _c.Call.Run(func(args mock.Arguments) {
894 run()
895 })
896 return _c
897}
898
899func (_c *MockColorSchemeResolver_Resolve_Call) Return(colorSchemePreference port.ColorSchemePreference) *MockColorSchemeResolver_Resolve_Call {
900 _c.Call.Return(colorSchemePreference)
901 return _c
902}
903
904func (_c *MockColorSchemeResolver_Resolve_Call) RunAndReturn(run func() port.ColorSchemePreference) *MockColorSchemeResolver_Resolve_Call {
905 _c.Call.Return(run)
906 return _c
907}
908
909// NewMockConfigMigrator creates a new instance of MockConfigMigrator. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
910// The first argument is typically a *testing.T value.
911func NewMockConfigMigrator(t interface {
912 mock.TestingT
913 Cleanup(func())
914}) *MockConfigMigrator {
915 mock := &MockConfigMigrator{}
916 mock.Mock.Test(t)
917
918 t.Cleanup(func() { mock.AssertExpectations(t) })
919
920 return mock
921}
922
923// MockConfigMigrator is an autogenerated mock type for the ConfigMigrator type
924type MockConfigMigrator struct {
925 mock.Mock
926}
927
928type MockConfigMigrator_Expecter struct {
929 mock *mock.Mock
930}
931
932func (_m *MockConfigMigrator) EXPECT() *MockConfigMigrator_Expecter {
933 return &MockConfigMigrator_Expecter{mock: &_m.Mock}
934}
935
936// CheckMigration provides a mock function for the type MockConfigMigrator
937func (_mock *MockConfigMigrator) CheckMigration() (*port.MigrationResult, error) {
938 ret := _mock.Called()
939
940 if len(ret) == 0 {
941 panic("no return value specified for CheckMigration")
942 }
943
944 var r0 *port.MigrationResult
945 var r1 error
946 if returnFunc, ok := ret.Get(0).(func() (*port.MigrationResult, error)); ok {
947 return returnFunc()
948 }
949 if returnFunc, ok := ret.Get(0).(func() *port.MigrationResult); ok {
950 r0 = returnFunc()
951 } else {
952 if ret.Get(0) != nil {
953 r0 = ret.Get(0).(*port.MigrationResult)
954 }
955 }
956 if returnFunc, ok := ret.Get(1).(func() error); ok {
957 r1 = returnFunc()
958 } else {
959 r1 = ret.Error(1)
960 }
961 return r0, r1
962}
963
964// MockConfigMigrator_CheckMigration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CheckMigration'
965type MockConfigMigrator_CheckMigration_Call struct {
966 *mock.Call
967}
968
969// CheckMigration is a helper method to define mock.On call
970func (_e *MockConfigMigrator_Expecter) CheckMigration() *MockConfigMigrator_CheckMigration_Call {
971 return &MockConfigMigrator_CheckMigration_Call{Call: _e.mock.On("CheckMigration")}
972}
973
974func (_c *MockConfigMigrator_CheckMigration_Call) Run(run func()) *MockConfigMigrator_CheckMigration_Call {
975 _c.Call.Run(func(args mock.Arguments) {
976 run()
977 })
978 return _c
979}
980
981func (_c *MockConfigMigrator_CheckMigration_Call) Return(migrationResult *port.MigrationResult, err error) *MockConfigMigrator_CheckMigration_Call {
982 _c.Call.Return(migrationResult, err)
983 return _c
984}
985
986func (_c *MockConfigMigrator_CheckMigration_Call) RunAndReturn(run func() (*port.MigrationResult, error)) *MockConfigMigrator_CheckMigration_Call {
987 _c.Call.Return(run)
988 return _c
989}
990
991// DetectChanges provides a mock function for the type MockConfigMigrator
992func (_mock *MockConfigMigrator) DetectChanges() ([]port.KeyChange, error) {
993 ret := _mock.Called()
994
995 if len(ret) == 0 {
996 panic("no return value specified for DetectChanges")
997 }
998
999 var r0 []port.KeyChange
1000 var r1 error
1001 if returnFunc, ok := ret.Get(0).(func() ([]port.KeyChange, error)); ok {
1002 return returnFunc()
1003 }
1004 if returnFunc, ok := ret.Get(0).(func() []port.KeyChange); ok {
1005 r0 = returnFunc()
1006 } else {
1007 if ret.Get(0) != nil {
1008 r0 = ret.Get(0).([]port.KeyChange)
1009 }
1010 }
1011 if returnFunc, ok := ret.Get(1).(func() error); ok {
1012 r1 = returnFunc()
1013 } else {
1014 r1 = ret.Error(1)
1015 }
1016 return r0, r1
1017}
1018
1019// MockConfigMigrator_DetectChanges_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DetectChanges'
1020type MockConfigMigrator_DetectChanges_Call struct {
1021 *mock.Call
1022}
1023
1024// DetectChanges is a helper method to define mock.On call
1025func (_e *MockConfigMigrator_Expecter) DetectChanges() *MockConfigMigrator_DetectChanges_Call {
1026 return &MockConfigMigrator_DetectChanges_Call{Call: _e.mock.On("DetectChanges")}
1027}
1028
1029func (_c *MockConfigMigrator_DetectChanges_Call) Run(run func()) *MockConfigMigrator_DetectChanges_Call {
1030 _c.Call.Run(func(args mock.Arguments) {
1031 run()
1032 })
1033 return _c
1034}
1035
1036func (_c *MockConfigMigrator_DetectChanges_Call) Return(keyChanges []port.KeyChange, err error) *MockConfigMigrator_DetectChanges_Call {
1037 _c.Call.Return(keyChanges, err)
1038 return _c
1039}
1040
1041func (_c *MockConfigMigrator_DetectChanges_Call) RunAndReturn(run func() ([]port.KeyChange, error)) *MockConfigMigrator_DetectChanges_Call {
1042 _c.Call.Return(run)
1043 return _c
1044}
1045
1046// GetConfigFile provides a mock function for the type MockConfigMigrator
1047func (_mock *MockConfigMigrator) GetConfigFile() (string, error) {
1048 ret := _mock.Called()
1049
1050 if len(ret) == 0 {
1051 panic("no return value specified for GetConfigFile")
1052 }
1053
1054 var r0 string
1055 var r1 error
1056 if returnFunc, ok := ret.Get(0).(func() (string, error)); ok {
1057 return returnFunc()
1058 }
1059 if returnFunc, ok := ret.Get(0).(func() string); ok {
1060 r0 = returnFunc()
1061 } else {
1062 r0 = ret.Get(0).(string)
1063 }
1064 if returnFunc, ok := ret.Get(1).(func() error); ok {
1065 r1 = returnFunc()
1066 } else {
1067 r1 = ret.Error(1)
1068 }
1069 return r0, r1
1070}
1071
1072// MockConfigMigrator_GetConfigFile_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetConfigFile'
1073type MockConfigMigrator_GetConfigFile_Call struct {
1074 *mock.Call
1075}
1076
1077// GetConfigFile is a helper method to define mock.On call
1078func (_e *MockConfigMigrator_Expecter) GetConfigFile() *MockConfigMigrator_GetConfigFile_Call {
1079 return &MockConfigMigrator_GetConfigFile_Call{Call: _e.mock.On("GetConfigFile")}
1080}
1081
1082func (_c *MockConfigMigrator_GetConfigFile_Call) Run(run func()) *MockConfigMigrator_GetConfigFile_Call {
1083 _c.Call.Run(func(args mock.Arguments) {
1084 run()
1085 })
1086 return _c
1087}
1088
1089func (_c *MockConfigMigrator_GetConfigFile_Call) Return(s string, err error) *MockConfigMigrator_GetConfigFile_Call {
1090 _c.Call.Return(s, err)
1091 return _c
1092}
1093
1094func (_c *MockConfigMigrator_GetConfigFile_Call) RunAndReturn(run func() (string, error)) *MockConfigMigrator_GetConfigFile_Call {
1095 _c.Call.Return(run)
1096 return _c
1097}
1098
1099// GetKeyInfo provides a mock function for the type MockConfigMigrator
1100func (_mock *MockConfigMigrator) GetKeyInfo(key string) port.KeyInfo {
1101 ret := _mock.Called(key)
1102
1103 if len(ret) == 0 {
1104 panic("no return value specified for GetKeyInfo")
1105 }
1106
1107 var r0 port.KeyInfo
1108 if returnFunc, ok := ret.Get(0).(func(string) port.KeyInfo); ok {
1109 r0 = returnFunc(key)
1110 } else {
1111 r0 = ret.Get(0).(port.KeyInfo)
1112 }
1113 return r0
1114}
1115
1116// MockConfigMigrator_GetKeyInfo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetKeyInfo'
1117type MockConfigMigrator_GetKeyInfo_Call struct {
1118 *mock.Call
1119}
1120
1121// GetKeyInfo is a helper method to define mock.On call
1122// - key string
1123func (_e *MockConfigMigrator_Expecter) GetKeyInfo(key interface{}) *MockConfigMigrator_GetKeyInfo_Call {
1124 return &MockConfigMigrator_GetKeyInfo_Call{Call: _e.mock.On("GetKeyInfo", key)}
1125}
1126
1127func (_c *MockConfigMigrator_GetKeyInfo_Call) Run(run func(key string)) *MockConfigMigrator_GetKeyInfo_Call {
1128 _c.Call.Run(func(args mock.Arguments) {
1129 var arg0 string
1130 if args[0] != nil {
1131 arg0 = args[0].(string)
1132 }
1133 run(
1134 arg0,
1135 )
1136 })
1137 return _c
1138}
1139
1140func (_c *MockConfigMigrator_GetKeyInfo_Call) Return(keyInfo port.KeyInfo) *MockConfigMigrator_GetKeyInfo_Call {
1141 _c.Call.Return(keyInfo)
1142 return _c
1143}
1144
1145func (_c *MockConfigMigrator_GetKeyInfo_Call) RunAndReturn(run func(key string) port.KeyInfo) *MockConfigMigrator_GetKeyInfo_Call {
1146 _c.Call.Return(run)
1147 return _c
1148}
1149
1150// Migrate provides a mock function for the type MockConfigMigrator
1151func (_mock *MockConfigMigrator) Migrate() ([]string, error) {
1152 ret := _mock.Called()
1153
1154 if len(ret) == 0 {
1155 panic("no return value specified for Migrate")
1156 }
1157
1158 var r0 []string
1159 var r1 error
1160 if returnFunc, ok := ret.Get(0).(func() ([]string, error)); ok {
1161 return returnFunc()
1162 }
1163 if returnFunc, ok := ret.Get(0).(func() []string); ok {
1164 r0 = returnFunc()
1165 } else {
1166 if ret.Get(0) != nil {
1167 r0 = ret.Get(0).([]string)
1168 }
1169 }
1170 if returnFunc, ok := ret.Get(1).(func() error); ok {
1171 r1 = returnFunc()
1172 } else {
1173 r1 = ret.Error(1)
1174 }
1175 return r0, r1
1176}
1177
1178// MockConfigMigrator_Migrate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Migrate'
1179type MockConfigMigrator_Migrate_Call struct {
1180 *mock.Call
1181}
1182
1183// Migrate is a helper method to define mock.On call
1184func (_e *MockConfigMigrator_Expecter) Migrate() *MockConfigMigrator_Migrate_Call {
1185 return &MockConfigMigrator_Migrate_Call{Call: _e.mock.On("Migrate")}
1186}
1187
1188func (_c *MockConfigMigrator_Migrate_Call) Run(run func()) *MockConfigMigrator_Migrate_Call {
1189 _c.Call.Run(func(args mock.Arguments) {
1190 run()
1191 })
1192 return _c
1193}
1194
1195func (_c *MockConfigMigrator_Migrate_Call) Return(strings []string, err error) *MockConfigMigrator_Migrate_Call {
1196 _c.Call.Return(strings, err)
1197 return _c
1198}
1199
1200func (_c *MockConfigMigrator_Migrate_Call) RunAndReturn(run func() ([]string, error)) *MockConfigMigrator_Migrate_Call {
1201 _c.Call.Return(run)
1202 return _c
1203}
1204
1205// NewMockDiffFormatter creates a new instance of MockDiffFormatter. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
1206// The first argument is typically a *testing.T value.
1207func NewMockDiffFormatter(t interface {
1208 mock.TestingT
1209 Cleanup(func())
1210}) *MockDiffFormatter {
1211 mock := &MockDiffFormatter{}
1212 mock.Mock.Test(t)
1213
1214 t.Cleanup(func() { mock.AssertExpectations(t) })
1215
1216 return mock
1217}
1218
1219// MockDiffFormatter is an autogenerated mock type for the DiffFormatter type
1220type MockDiffFormatter struct {
1221 mock.Mock
1222}
1223
1224type MockDiffFormatter_Expecter struct {
1225 mock *mock.Mock
1226}
1227
1228func (_m *MockDiffFormatter) EXPECT() *MockDiffFormatter_Expecter {
1229 return &MockDiffFormatter_Expecter{mock: &_m.Mock}
1230}
1231
1232// FormatChangesAsDiff provides a mock function for the type MockDiffFormatter
1233func (_mock *MockDiffFormatter) FormatChangesAsDiff(changes []port.KeyChange) string {
1234 ret := _mock.Called(changes)
1235
1236 if len(ret) == 0 {
1237 panic("no return value specified for FormatChangesAsDiff")
1238 }
1239
1240 var r0 string
1241 if returnFunc, ok := ret.Get(0).(func([]port.KeyChange) string); ok {
1242 r0 = returnFunc(changes)
1243 } else {
1244 r0 = ret.Get(0).(string)
1245 }
1246 return r0
1247}
1248
1249// MockDiffFormatter_FormatChangesAsDiff_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FormatChangesAsDiff'
1250type MockDiffFormatter_FormatChangesAsDiff_Call struct {
1251 *mock.Call
1252}
1253
1254// FormatChangesAsDiff is a helper method to define mock.On call
1255// - changes []port.KeyChange
1256func (_e *MockDiffFormatter_Expecter) FormatChangesAsDiff(changes interface{}) *MockDiffFormatter_FormatChangesAsDiff_Call {
1257 return &MockDiffFormatter_FormatChangesAsDiff_Call{Call: _e.mock.On("FormatChangesAsDiff", changes)}
1258}
1259
1260func (_c *MockDiffFormatter_FormatChangesAsDiff_Call) Run(run func(changes []port.KeyChange)) *MockDiffFormatter_FormatChangesAsDiff_Call {
1261 _c.Call.Run(func(args mock.Arguments) {
1262 var arg0 []port.KeyChange
1263 if args[0] != nil {
1264 arg0 = args[0].([]port.KeyChange)
1265 }
1266 run(
1267 arg0,
1268 )
1269 })
1270 return _c
1271}
1272
1273func (_c *MockDiffFormatter_FormatChangesAsDiff_Call) Return(s string) *MockDiffFormatter_FormatChangesAsDiff_Call {
1274 _c.Call.Return(s)
1275 return _c
1276}
1277
1278func (_c *MockDiffFormatter_FormatChangesAsDiff_Call) RunAndReturn(run func(changes []port.KeyChange) string) *MockDiffFormatter_FormatChangesAsDiff_Call {
1279 _c.Call.Return(run)
1280 return _c
1281}
1282
1283// NewMockConfigSchemaProvider creates a new instance of MockConfigSchemaProvider. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
1284// The first argument is typically a *testing.T value.
1285func NewMockConfigSchemaProvider(t interface {
1286 mock.TestingT
1287 Cleanup(func())
1288}) *MockConfigSchemaProvider {
1289 mock := &MockConfigSchemaProvider{}
1290 mock.Mock.Test(t)
1291
1292 t.Cleanup(func() { mock.AssertExpectations(t) })
1293
1294 return mock
1295}
1296
1297// MockConfigSchemaProvider is an autogenerated mock type for the ConfigSchemaProvider type
1298type MockConfigSchemaProvider struct {
1299 mock.Mock
1300}
1301
1302type MockConfigSchemaProvider_Expecter struct {
1303 mock *mock.Mock
1304}
1305
1306func (_m *MockConfigSchemaProvider) EXPECT() *MockConfigSchemaProvider_Expecter {
1307 return &MockConfigSchemaProvider_Expecter{mock: &_m.Mock}
1308}
1309
1310// GetSchema provides a mock function for the type MockConfigSchemaProvider
1311func (_mock *MockConfigSchemaProvider) GetSchema() []entity.ConfigKeyInfo {
1312 ret := _mock.Called()
1313
1314 if len(ret) == 0 {
1315 panic("no return value specified for GetSchema")
1316 }
1317
1318 var r0 []entity.ConfigKeyInfo
1319 if returnFunc, ok := ret.Get(0).(func() []entity.ConfigKeyInfo); ok {
1320 r0 = returnFunc()
1321 } else {
1322 if ret.Get(0) != nil {
1323 r0 = ret.Get(0).([]entity.ConfigKeyInfo)
1324 }
1325 }
1326 return r0
1327}
1328
1329// MockConfigSchemaProvider_GetSchema_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSchema'
1330type MockConfigSchemaProvider_GetSchema_Call struct {
1331 *mock.Call
1332}
1333
1334// GetSchema is a helper method to define mock.On call
1335func (_e *MockConfigSchemaProvider_Expecter) GetSchema() *MockConfigSchemaProvider_GetSchema_Call {
1336 return &MockConfigSchemaProvider_GetSchema_Call{Call: _e.mock.On("GetSchema")}
1337}
1338
1339func (_c *MockConfigSchemaProvider_GetSchema_Call) Run(run func()) *MockConfigSchemaProvider_GetSchema_Call {
1340 _c.Call.Run(func(args mock.Arguments) {
1341 run()
1342 })
1343 return _c
1344}
1345
1346func (_c *MockConfigSchemaProvider_GetSchema_Call) Return(configKeyInfos []entity.ConfigKeyInfo) *MockConfigSchemaProvider_GetSchema_Call {
1347 _c.Call.Return(configKeyInfos)
1348 return _c
1349}
1350
1351func (_c *MockConfigSchemaProvider_GetSchema_Call) RunAndReturn(run func() []entity.ConfigKeyInfo) *MockConfigSchemaProvider_GetSchema_Call {
1352 _c.Call.Return(run)
1353 return _c
1354}
1355
1356// NewMockConfigTransformer creates a new instance of MockConfigTransformer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
1357// The first argument is typically a *testing.T value.
1358func NewMockConfigTransformer(t interface {
1359 mock.TestingT
1360 Cleanup(func())
1361}) *MockConfigTransformer {
1362 mock := &MockConfigTransformer{}
1363 mock.Mock.Test(t)
1364
1365 t.Cleanup(func() { mock.AssertExpectations(t) })
1366
1367 return mock
1368}
1369
1370// MockConfigTransformer is an autogenerated mock type for the ConfigTransformer type
1371type MockConfigTransformer struct {
1372 mock.Mock
1373}
1374
1375type MockConfigTransformer_Expecter struct {
1376 mock *mock.Mock
1377}
1378
1379func (_m *MockConfigTransformer) EXPECT() *MockConfigTransformer_Expecter {
1380 return &MockConfigTransformer_Expecter{mock: &_m.Mock}
1381}
1382
1383// TransformLegacyActions provides a mock function for the type MockConfigTransformer
1384func (_mock *MockConfigTransformer) TransformLegacyActions(rawConfig map[string]any) {
1385 _mock.Called(rawConfig)
1386 return
1387}
1388
1389// MockConfigTransformer_TransformLegacyActions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TransformLegacyActions'
1390type MockConfigTransformer_TransformLegacyActions_Call struct {
1391 *mock.Call
1392}
1393
1394// TransformLegacyActions is a helper method to define mock.On call
1395// - rawConfig map[string]any
1396func (_e *MockConfigTransformer_Expecter) TransformLegacyActions(rawConfig interface{}) *MockConfigTransformer_TransformLegacyActions_Call {
1397 return &MockConfigTransformer_TransformLegacyActions_Call{Call: _e.mock.On("TransformLegacyActions", rawConfig)}
1398}
1399
1400func (_c *MockConfigTransformer_TransformLegacyActions_Call) Run(run func(rawConfig map[string]any)) *MockConfigTransformer_TransformLegacyActions_Call {
1401 _c.Call.Run(func(args mock.Arguments) {
1402 var arg0 map[string]any
1403 if args[0] != nil {
1404 arg0 = args[0].(map[string]any)
1405 }
1406 run(
1407 arg0,
1408 )
1409 })
1410 return _c
1411}
1412
1413func (_c *MockConfigTransformer_TransformLegacyActions_Call) Return() *MockConfigTransformer_TransformLegacyActions_Call {
1414 _c.Call.Return()
1415 return _c
1416}
1417
1418func (_c *MockConfigTransformer_TransformLegacyActions_Call) RunAndReturn(run func(rawConfig map[string]any)) *MockConfigTransformer_TransformLegacyActions_Call {
1419 _c.Run(run)
1420 return _c
1421}
1422
1423// NewMockContentInjector creates a new instance of MockContentInjector. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
1424// The first argument is typically a *testing.T value.
1425func NewMockContentInjector(t interface {
1426 mock.TestingT
1427 Cleanup(func())
1428}) *MockContentInjector {
1429 mock := &MockContentInjector{}
1430 mock.Mock.Test(t)
1431
1432 t.Cleanup(func() { mock.AssertExpectations(t) })
1433
1434 return mock
1435}
1436
1437// MockContentInjector is an autogenerated mock type for the ContentInjector type
1438type MockContentInjector struct {
1439 mock.Mock
1440}
1441
1442type MockContentInjector_Expecter struct {
1443 mock *mock.Mock
1444}
1445
1446func (_m *MockContentInjector) EXPECT() *MockContentInjector_Expecter {
1447 return &MockContentInjector_Expecter{mock: &_m.Mock}
1448}
1449
1450// InjectFindHighlightCSS provides a mock function for the type MockContentInjector
1451func (_mock *MockContentInjector) InjectFindHighlightCSS(ctx context.Context, css string) error {
1452 ret := _mock.Called(ctx, css)
1453
1454 if len(ret) == 0 {
1455 panic("no return value specified for InjectFindHighlightCSS")
1456 }
1457
1458 var r0 error
1459 if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
1460 r0 = returnFunc(ctx, css)
1461 } else {
1462 r0 = ret.Error(0)
1463 }
1464 return r0
1465}
1466
1467// MockContentInjector_InjectFindHighlightCSS_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'InjectFindHighlightCSS'
1468type MockContentInjector_InjectFindHighlightCSS_Call struct {
1469 *mock.Call
1470}
1471
1472// InjectFindHighlightCSS is a helper method to define mock.On call
1473// - ctx context.Context
1474// - css string
1475func (_e *MockContentInjector_Expecter) InjectFindHighlightCSS(ctx interface{}, css interface{}) *MockContentInjector_InjectFindHighlightCSS_Call {
1476 return &MockContentInjector_InjectFindHighlightCSS_Call{Call: _e.mock.On("InjectFindHighlightCSS", ctx, css)}
1477}
1478
1479func (_c *MockContentInjector_InjectFindHighlightCSS_Call) Run(run func(ctx context.Context, css string)) *MockContentInjector_InjectFindHighlightCSS_Call {
1480 _c.Call.Run(func(args mock.Arguments) {
1481 var arg0 context.Context
1482 if args[0] != nil {
1483 arg0 = args[0].(context.Context)
1484 }
1485 var arg1 string
1486 if args[1] != nil {
1487 arg1 = args[1].(string)
1488 }
1489 run(
1490 arg0,
1491 arg1,
1492 )
1493 })
1494 return _c
1495}
1496
1497func (_c *MockContentInjector_InjectFindHighlightCSS_Call) Return(err error) *MockContentInjector_InjectFindHighlightCSS_Call {
1498 _c.Call.Return(err)
1499 return _c
1500}
1501
1502func (_c *MockContentInjector_InjectFindHighlightCSS_Call) RunAndReturn(run func(ctx context.Context, css string) error) *MockContentInjector_InjectFindHighlightCSS_Call {
1503 _c.Call.Return(run)
1504 return _c
1505}
1506
1507// InjectThemeCSS provides a mock function for the type MockContentInjector
1508func (_mock *MockContentInjector) InjectThemeCSS(ctx context.Context, css string) error {
1509 ret := _mock.Called(ctx, css)
1510
1511 if len(ret) == 0 {
1512 panic("no return value specified for InjectThemeCSS")
1513 }
1514
1515 var r0 error
1516 if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
1517 r0 = returnFunc(ctx, css)
1518 } else {
1519 r0 = ret.Error(0)
1520 }
1521 return r0
1522}
1523
1524// MockContentInjector_InjectThemeCSS_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'InjectThemeCSS'
1525type MockContentInjector_InjectThemeCSS_Call struct {
1526 *mock.Call
1527}
1528
1529// InjectThemeCSS is a helper method to define mock.On call
1530// - ctx context.Context
1531// - css string
1532func (_e *MockContentInjector_Expecter) InjectThemeCSS(ctx interface{}, css interface{}) *MockContentInjector_InjectThemeCSS_Call {
1533 return &MockContentInjector_InjectThemeCSS_Call{Call: _e.mock.On("InjectThemeCSS", ctx, css)}
1534}
1535
1536func (_c *MockContentInjector_InjectThemeCSS_Call) Run(run func(ctx context.Context, css string)) *MockContentInjector_InjectThemeCSS_Call {
1537 _c.Call.Run(func(args mock.Arguments) {
1538 var arg0 context.Context
1539 if args[0] != nil {
1540 arg0 = args[0].(context.Context)
1541 }
1542 var arg1 string
1543 if args[1] != nil {
1544 arg1 = args[1].(string)
1545 }
1546 run(
1547 arg0,
1548 arg1,
1549 )
1550 })
1551 return _c
1552}
1553
1554func (_c *MockContentInjector_InjectThemeCSS_Call) Return(err error) *MockContentInjector_InjectThemeCSS_Call {
1555 _c.Call.Return(err)
1556 return _c
1557}
1558
1559func (_c *MockContentInjector_InjectThemeCSS_Call) RunAndReturn(run func(ctx context.Context, css string) error) *MockContentInjector_InjectThemeCSS_Call {
1560 _c.Call.Return(run)
1561 return _c
1562}
1563
1564// RefreshScripts provides a mock function for the type MockContentInjector
1565func (_mock *MockContentInjector) RefreshScripts(ctx context.Context, wv port.WebView) error {
1566 ret := _mock.Called(ctx, wv)
1567
1568 if len(ret) == 0 {
1569 panic("no return value specified for RefreshScripts")
1570 }
1571
1572 var r0 error
1573 if returnFunc, ok := ret.Get(0).(func(context.Context, port.WebView) error); ok {
1574 r0 = returnFunc(ctx, wv)
1575 } else {
1576 r0 = ret.Error(0)
1577 }
1578 return r0
1579}
1580
1581// MockContentInjector_RefreshScripts_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RefreshScripts'
1582type MockContentInjector_RefreshScripts_Call struct {
1583 *mock.Call
1584}
1585
1586// RefreshScripts is a helper method to define mock.On call
1587// - ctx context.Context
1588// - wv port.WebView
1589func (_e *MockContentInjector_Expecter) RefreshScripts(ctx interface{}, wv interface{}) *MockContentInjector_RefreshScripts_Call {
1590 return &MockContentInjector_RefreshScripts_Call{Call: _e.mock.On("RefreshScripts", ctx, wv)}
1591}
1592
1593func (_c *MockContentInjector_RefreshScripts_Call) Run(run func(ctx context.Context, wv port.WebView)) *MockContentInjector_RefreshScripts_Call {
1594 _c.Call.Run(func(args mock.Arguments) {
1595 var arg0 context.Context
1596 if args[0] != nil {
1597 arg0 = args[0].(context.Context)
1598 }
1599 var arg1 port.WebView
1600 if args[1] != nil {
1601 arg1 = args[1].(port.WebView)
1602 }
1603 run(
1604 arg0,
1605 arg1,
1606 )
1607 })
1608 return _c
1609}
1610
1611func (_c *MockContentInjector_RefreshScripts_Call) Return(err error) *MockContentInjector_RefreshScripts_Call {
1612 _c.Call.Return(err)
1613 return _c
1614}
1615
1616func (_c *MockContentInjector_RefreshScripts_Call) RunAndReturn(run func(ctx context.Context, wv port.WebView) error) *MockContentInjector_RefreshScripts_Call {
1617 _c.Call.Return(run)
1618 return _c
1619}
1620
1621// NewMockDatabaseProvider creates a new instance of MockDatabaseProvider. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
1622// The first argument is typically a *testing.T value.
1623func NewMockDatabaseProvider(t interface {
1624 mock.TestingT
1625 Cleanup(func())
1626}) *MockDatabaseProvider {
1627 mock := &MockDatabaseProvider{}
1628 mock.Mock.Test(t)
1629
1630 t.Cleanup(func() { mock.AssertExpectations(t) })
1631
1632 return mock
1633}
1634
1635// MockDatabaseProvider is an autogenerated mock type for the DatabaseProvider type
1636type MockDatabaseProvider struct {
1637 mock.Mock
1638}
1639
1640type MockDatabaseProvider_Expecter struct {
1641 mock *mock.Mock
1642}
1643
1644func (_m *MockDatabaseProvider) EXPECT() *MockDatabaseProvider_Expecter {
1645 return &MockDatabaseProvider_Expecter{mock: &_m.Mock}
1646}
1647
1648// Close provides a mock function for the type MockDatabaseProvider
1649func (_mock *MockDatabaseProvider) Close() error {
1650 ret := _mock.Called()
1651
1652 if len(ret) == 0 {
1653 panic("no return value specified for Close")
1654 }
1655
1656 var r0 error
1657 if returnFunc, ok := ret.Get(0).(func() error); ok {
1658 r0 = returnFunc()
1659 } else {
1660 r0 = ret.Error(0)
1661 }
1662 return r0
1663}
1664
1665// MockDatabaseProvider_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
1666type MockDatabaseProvider_Close_Call struct {
1667 *mock.Call
1668}
1669
1670// Close is a helper method to define mock.On call
1671func (_e *MockDatabaseProvider_Expecter) Close() *MockDatabaseProvider_Close_Call {
1672 return &MockDatabaseProvider_Close_Call{Call: _e.mock.On("Close")}
1673}
1674
1675func (_c *MockDatabaseProvider_Close_Call) Run(run func()) *MockDatabaseProvider_Close_Call {
1676 _c.Call.Run(func(args mock.Arguments) {
1677 run()
1678 })
1679 return _c
1680}
1681
1682func (_c *MockDatabaseProvider_Close_Call) Return(err error) *MockDatabaseProvider_Close_Call {
1683 _c.Call.Return(err)
1684 return _c
1685}
1686
1687func (_c *MockDatabaseProvider_Close_Call) RunAndReturn(run func() error) *MockDatabaseProvider_Close_Call {
1688 _c.Call.Return(run)
1689 return _c
1690}
1691
1692// DB provides a mock function for the type MockDatabaseProvider
1693func (_mock *MockDatabaseProvider) DB(ctx context.Context) (*sql.DB, error) {
1694 ret := _mock.Called(ctx)
1695
1696 if len(ret) == 0 {
1697 panic("no return value specified for DB")
1698 }
1699
1700 var r0 *sql.DB
1701 var r1 error
1702 if returnFunc, ok := ret.Get(0).(func(context.Context) (*sql.DB, error)); ok {
1703 return returnFunc(ctx)
1704 }
1705 if returnFunc, ok := ret.Get(0).(func(context.Context) *sql.DB); ok {
1706 r0 = returnFunc(ctx)
1707 } else {
1708 if ret.Get(0) != nil {
1709 r0 = ret.Get(0).(*sql.DB)
1710 }
1711 }
1712 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
1713 r1 = returnFunc(ctx)
1714 } else {
1715 r1 = ret.Error(1)
1716 }
1717 return r0, r1
1718}
1719
1720// MockDatabaseProvider_DB_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DB'
1721type MockDatabaseProvider_DB_Call struct {
1722 *mock.Call
1723}
1724
1725// DB is a helper method to define mock.On call
1726// - ctx context.Context
1727func (_e *MockDatabaseProvider_Expecter) DB(ctx interface{}) *MockDatabaseProvider_DB_Call {
1728 return &MockDatabaseProvider_DB_Call{Call: _e.mock.On("DB", ctx)}
1729}
1730
1731func (_c *MockDatabaseProvider_DB_Call) Run(run func(ctx context.Context)) *MockDatabaseProvider_DB_Call {
1732 _c.Call.Run(func(args mock.Arguments) {
1733 var arg0 context.Context
1734 if args[0] != nil {
1735 arg0 = args[0].(context.Context)
1736 }
1737 run(
1738 arg0,
1739 )
1740 })
1741 return _c
1742}
1743
1744func (_c *MockDatabaseProvider_DB_Call) Return(dB *sql.DB, err error) *MockDatabaseProvider_DB_Call {
1745 _c.Call.Return(dB, err)
1746 return _c
1747}
1748
1749func (_c *MockDatabaseProvider_DB_Call) RunAndReturn(run func(ctx context.Context) (*sql.DB, error)) *MockDatabaseProvider_DB_Call {
1750 _c.Call.Return(run)
1751 return _c
1752}
1753
1754// IsInitialized provides a mock function for the type MockDatabaseProvider
1755func (_mock *MockDatabaseProvider) IsInitialized() bool {
1756 ret := _mock.Called()
1757
1758 if len(ret) == 0 {
1759 panic("no return value specified for IsInitialized")
1760 }
1761
1762 var r0 bool
1763 if returnFunc, ok := ret.Get(0).(func() bool); ok {
1764 r0 = returnFunc()
1765 } else {
1766 r0 = ret.Get(0).(bool)
1767 }
1768 return r0
1769}
1770
1771// MockDatabaseProvider_IsInitialized_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsInitialized'
1772type MockDatabaseProvider_IsInitialized_Call struct {
1773 *mock.Call
1774}
1775
1776// IsInitialized is a helper method to define mock.On call
1777func (_e *MockDatabaseProvider_Expecter) IsInitialized() *MockDatabaseProvider_IsInitialized_Call {
1778 return &MockDatabaseProvider_IsInitialized_Call{Call: _e.mock.On("IsInitialized")}
1779}
1780
1781func (_c *MockDatabaseProvider_IsInitialized_Call) Run(run func()) *MockDatabaseProvider_IsInitialized_Call {
1782 _c.Call.Run(func(args mock.Arguments) {
1783 run()
1784 })
1785 return _c
1786}
1787
1788func (_c *MockDatabaseProvider_IsInitialized_Call) Return(b bool) *MockDatabaseProvider_IsInitialized_Call {
1789 _c.Call.Return(b)
1790 return _c
1791}
1792
1793func (_c *MockDatabaseProvider_IsInitialized_Call) RunAndReturn(run func() bool) *MockDatabaseProvider_IsInitialized_Call {
1794 _c.Call.Return(run)
1795 return _c
1796}
1797
1798// NewMockDesktopIntegration creates a new instance of MockDesktopIntegration. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
1799// The first argument is typically a *testing.T value.
1800func NewMockDesktopIntegration(t interface {
1801 mock.TestingT
1802 Cleanup(func())
1803}) *MockDesktopIntegration {
1804 mock := &MockDesktopIntegration{}
1805 mock.Mock.Test(t)
1806
1807 t.Cleanup(func() { mock.AssertExpectations(t) })
1808
1809 return mock
1810}
1811
1812// MockDesktopIntegration is an autogenerated mock type for the DesktopIntegration type
1813type MockDesktopIntegration struct {
1814 mock.Mock
1815}
1816
1817type MockDesktopIntegration_Expecter struct {
1818 mock *mock.Mock
1819}
1820
1821func (_m *MockDesktopIntegration) EXPECT() *MockDesktopIntegration_Expecter {
1822 return &MockDesktopIntegration_Expecter{mock: &_m.Mock}
1823}
1824
1825// GetStatus provides a mock function for the type MockDesktopIntegration
1826func (_mock *MockDesktopIntegration) GetStatus(ctx context.Context) (*port.DesktopIntegrationStatus, error) {
1827 ret := _mock.Called(ctx)
1828
1829 if len(ret) == 0 {
1830 panic("no return value specified for GetStatus")
1831 }
1832
1833 var r0 *port.DesktopIntegrationStatus
1834 var r1 error
1835 if returnFunc, ok := ret.Get(0).(func(context.Context) (*port.DesktopIntegrationStatus, error)); ok {
1836 return returnFunc(ctx)
1837 }
1838 if returnFunc, ok := ret.Get(0).(func(context.Context) *port.DesktopIntegrationStatus); ok {
1839 r0 = returnFunc(ctx)
1840 } else {
1841 if ret.Get(0) != nil {
1842 r0 = ret.Get(0).(*port.DesktopIntegrationStatus)
1843 }
1844 }
1845 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
1846 r1 = returnFunc(ctx)
1847 } else {
1848 r1 = ret.Error(1)
1849 }
1850 return r0, r1
1851}
1852
1853// MockDesktopIntegration_GetStatus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetStatus'
1854type MockDesktopIntegration_GetStatus_Call struct {
1855 *mock.Call
1856}
1857
1858// GetStatus is a helper method to define mock.On call
1859// - ctx context.Context
1860func (_e *MockDesktopIntegration_Expecter) GetStatus(ctx interface{}) *MockDesktopIntegration_GetStatus_Call {
1861 return &MockDesktopIntegration_GetStatus_Call{Call: _e.mock.On("GetStatus", ctx)}
1862}
1863
1864func (_c *MockDesktopIntegration_GetStatus_Call) Run(run func(ctx context.Context)) *MockDesktopIntegration_GetStatus_Call {
1865 _c.Call.Run(func(args mock.Arguments) {
1866 var arg0 context.Context
1867 if args[0] != nil {
1868 arg0 = args[0].(context.Context)
1869 }
1870 run(
1871 arg0,
1872 )
1873 })
1874 return _c
1875}
1876
1877func (_c *MockDesktopIntegration_GetStatus_Call) Return(desktopIntegrationStatus *port.DesktopIntegrationStatus, err error) *MockDesktopIntegration_GetStatus_Call {
1878 _c.Call.Return(desktopIntegrationStatus, err)
1879 return _c
1880}
1881
1882func (_c *MockDesktopIntegration_GetStatus_Call) RunAndReturn(run func(ctx context.Context) (*port.DesktopIntegrationStatus, error)) *MockDesktopIntegration_GetStatus_Call {
1883 _c.Call.Return(run)
1884 return _c
1885}
1886
1887// InstallDesktopFile provides a mock function for the type MockDesktopIntegration
1888func (_mock *MockDesktopIntegration) InstallDesktopFile(ctx context.Context) (string, error) {
1889 ret := _mock.Called(ctx)
1890
1891 if len(ret) == 0 {
1892 panic("no return value specified for InstallDesktopFile")
1893 }
1894
1895 var r0 string
1896 var r1 error
1897 if returnFunc, ok := ret.Get(0).(func(context.Context) (string, error)); ok {
1898 return returnFunc(ctx)
1899 }
1900 if returnFunc, ok := ret.Get(0).(func(context.Context) string); ok {
1901 r0 = returnFunc(ctx)
1902 } else {
1903 r0 = ret.Get(0).(string)
1904 }
1905 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
1906 r1 = returnFunc(ctx)
1907 } else {
1908 r1 = ret.Error(1)
1909 }
1910 return r0, r1
1911}
1912
1913// MockDesktopIntegration_InstallDesktopFile_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'InstallDesktopFile'
1914type MockDesktopIntegration_InstallDesktopFile_Call struct {
1915 *mock.Call
1916}
1917
1918// InstallDesktopFile is a helper method to define mock.On call
1919// - ctx context.Context
1920func (_e *MockDesktopIntegration_Expecter) InstallDesktopFile(ctx interface{}) *MockDesktopIntegration_InstallDesktopFile_Call {
1921 return &MockDesktopIntegration_InstallDesktopFile_Call{Call: _e.mock.On("InstallDesktopFile", ctx)}
1922}
1923
1924func (_c *MockDesktopIntegration_InstallDesktopFile_Call) Run(run func(ctx context.Context)) *MockDesktopIntegration_InstallDesktopFile_Call {
1925 _c.Call.Run(func(args mock.Arguments) {
1926 var arg0 context.Context
1927 if args[0] != nil {
1928 arg0 = args[0].(context.Context)
1929 }
1930 run(
1931 arg0,
1932 )
1933 })
1934 return _c
1935}
1936
1937func (_c *MockDesktopIntegration_InstallDesktopFile_Call) Return(s string, err error) *MockDesktopIntegration_InstallDesktopFile_Call {
1938 _c.Call.Return(s, err)
1939 return _c
1940}
1941
1942func (_c *MockDesktopIntegration_InstallDesktopFile_Call) RunAndReturn(run func(ctx context.Context) (string, error)) *MockDesktopIntegration_InstallDesktopFile_Call {
1943 _c.Call.Return(run)
1944 return _c
1945}
1946
1947// InstallIcon provides a mock function for the type MockDesktopIntegration
1948func (_mock *MockDesktopIntegration) InstallIcon(ctx context.Context, svgData []byte) (string, error) {
1949 ret := _mock.Called(ctx, svgData)
1950
1951 if len(ret) == 0 {
1952 panic("no return value specified for InstallIcon")
1953 }
1954
1955 var r0 string
1956 var r1 error
1957 if returnFunc, ok := ret.Get(0).(func(context.Context, []byte) (string, error)); ok {
1958 return returnFunc(ctx, svgData)
1959 }
1960 if returnFunc, ok := ret.Get(0).(func(context.Context, []byte) string); ok {
1961 r0 = returnFunc(ctx, svgData)
1962 } else {
1963 r0 = ret.Get(0).(string)
1964 }
1965 if returnFunc, ok := ret.Get(1).(func(context.Context, []byte) error); ok {
1966 r1 = returnFunc(ctx, svgData)
1967 } else {
1968 r1 = ret.Error(1)
1969 }
1970 return r0, r1
1971}
1972
1973// MockDesktopIntegration_InstallIcon_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'InstallIcon'
1974type MockDesktopIntegration_InstallIcon_Call struct {
1975 *mock.Call
1976}
1977
1978// InstallIcon is a helper method to define mock.On call
1979// - ctx context.Context
1980// - svgData []byte
1981func (_e *MockDesktopIntegration_Expecter) InstallIcon(ctx interface{}, svgData interface{}) *MockDesktopIntegration_InstallIcon_Call {
1982 return &MockDesktopIntegration_InstallIcon_Call{Call: _e.mock.On("InstallIcon", ctx, svgData)}
1983}
1984
1985func (_c *MockDesktopIntegration_InstallIcon_Call) Run(run func(ctx context.Context, svgData []byte)) *MockDesktopIntegration_InstallIcon_Call {
1986 _c.Call.Run(func(args mock.Arguments) {
1987 var arg0 context.Context
1988 if args[0] != nil {
1989 arg0 = args[0].(context.Context)
1990 }
1991 var arg1 []byte
1992 if args[1] != nil {
1993 arg1 = args[1].([]byte)
1994 }
1995 run(
1996 arg0,
1997 arg1,
1998 )
1999 })
2000 return _c
2001}
2002
2003func (_c *MockDesktopIntegration_InstallIcon_Call) Return(s string, err error) *MockDesktopIntegration_InstallIcon_Call {
2004 _c.Call.Return(s, err)
2005 return _c
2006}
2007
2008func (_c *MockDesktopIntegration_InstallIcon_Call) RunAndReturn(run func(ctx context.Context, svgData []byte) (string, error)) *MockDesktopIntegration_InstallIcon_Call {
2009 _c.Call.Return(run)
2010 return _c
2011}
2012
2013// RemoveDesktopFile provides a mock function for the type MockDesktopIntegration
2014func (_mock *MockDesktopIntegration) RemoveDesktopFile(ctx context.Context) error {
2015 ret := _mock.Called(ctx)
2016
2017 if len(ret) == 0 {
2018 panic("no return value specified for RemoveDesktopFile")
2019 }
2020
2021 var r0 error
2022 if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
2023 r0 = returnFunc(ctx)
2024 } else {
2025 r0 = ret.Error(0)
2026 }
2027 return r0
2028}
2029
2030// MockDesktopIntegration_RemoveDesktopFile_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveDesktopFile'
2031type MockDesktopIntegration_RemoveDesktopFile_Call struct {
2032 *mock.Call
2033}
2034
2035// RemoveDesktopFile is a helper method to define mock.On call
2036// - ctx context.Context
2037func (_e *MockDesktopIntegration_Expecter) RemoveDesktopFile(ctx interface{}) *MockDesktopIntegration_RemoveDesktopFile_Call {
2038 return &MockDesktopIntegration_RemoveDesktopFile_Call{Call: _e.mock.On("RemoveDesktopFile", ctx)}
2039}
2040
2041func (_c *MockDesktopIntegration_RemoveDesktopFile_Call) Run(run func(ctx context.Context)) *MockDesktopIntegration_RemoveDesktopFile_Call {
2042 _c.Call.Run(func(args mock.Arguments) {
2043 var arg0 context.Context
2044 if args[0] != nil {
2045 arg0 = args[0].(context.Context)
2046 }
2047 run(
2048 arg0,
2049 )
2050 })
2051 return _c
2052}
2053
2054func (_c *MockDesktopIntegration_RemoveDesktopFile_Call) Return(err error) *MockDesktopIntegration_RemoveDesktopFile_Call {
2055 _c.Call.Return(err)
2056 return _c
2057}
2058
2059func (_c *MockDesktopIntegration_RemoveDesktopFile_Call) RunAndReturn(run func(ctx context.Context) error) *MockDesktopIntegration_RemoveDesktopFile_Call {
2060 _c.Call.Return(run)
2061 return _c
2062}
2063
2064// RemoveIcon provides a mock function for the type MockDesktopIntegration
2065func (_mock *MockDesktopIntegration) RemoveIcon(ctx context.Context) error {
2066 ret := _mock.Called(ctx)
2067
2068 if len(ret) == 0 {
2069 panic("no return value specified for RemoveIcon")
2070 }
2071
2072 var r0 error
2073 if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
2074 r0 = returnFunc(ctx)
2075 } else {
2076 r0 = ret.Error(0)
2077 }
2078 return r0
2079}
2080
2081// MockDesktopIntegration_RemoveIcon_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveIcon'
2082type MockDesktopIntegration_RemoveIcon_Call struct {
2083 *mock.Call
2084}
2085
2086// RemoveIcon is a helper method to define mock.On call
2087// - ctx context.Context
2088func (_e *MockDesktopIntegration_Expecter) RemoveIcon(ctx interface{}) *MockDesktopIntegration_RemoveIcon_Call {
2089 return &MockDesktopIntegration_RemoveIcon_Call{Call: _e.mock.On("RemoveIcon", ctx)}
2090}
2091
2092func (_c *MockDesktopIntegration_RemoveIcon_Call) Run(run func(ctx context.Context)) *MockDesktopIntegration_RemoveIcon_Call {
2093 _c.Call.Run(func(args mock.Arguments) {
2094 var arg0 context.Context
2095 if args[0] != nil {
2096 arg0 = args[0].(context.Context)
2097 }
2098 run(
2099 arg0,
2100 )
2101 })
2102 return _c
2103}
2104
2105func (_c *MockDesktopIntegration_RemoveIcon_Call) Return(err error) *MockDesktopIntegration_RemoveIcon_Call {
2106 _c.Call.Return(err)
2107 return _c
2108}
2109
2110func (_c *MockDesktopIntegration_RemoveIcon_Call) RunAndReturn(run func(ctx context.Context) error) *MockDesktopIntegration_RemoveIcon_Call {
2111 _c.Call.Return(run)
2112 return _c
2113}
2114
2115// SetAsDefaultBrowser provides a mock function for the type MockDesktopIntegration
2116func (_mock *MockDesktopIntegration) SetAsDefaultBrowser(ctx context.Context) error {
2117 ret := _mock.Called(ctx)
2118
2119 if len(ret) == 0 {
2120 panic("no return value specified for SetAsDefaultBrowser")
2121 }
2122
2123 var r0 error
2124 if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
2125 r0 = returnFunc(ctx)
2126 } else {
2127 r0 = ret.Error(0)
2128 }
2129 return r0
2130}
2131
2132// MockDesktopIntegration_SetAsDefaultBrowser_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetAsDefaultBrowser'
2133type MockDesktopIntegration_SetAsDefaultBrowser_Call struct {
2134 *mock.Call
2135}
2136
2137// SetAsDefaultBrowser is a helper method to define mock.On call
2138// - ctx context.Context
2139func (_e *MockDesktopIntegration_Expecter) SetAsDefaultBrowser(ctx interface{}) *MockDesktopIntegration_SetAsDefaultBrowser_Call {
2140 return &MockDesktopIntegration_SetAsDefaultBrowser_Call{Call: _e.mock.On("SetAsDefaultBrowser", ctx)}
2141}
2142
2143func (_c *MockDesktopIntegration_SetAsDefaultBrowser_Call) Run(run func(ctx context.Context)) *MockDesktopIntegration_SetAsDefaultBrowser_Call {
2144 _c.Call.Run(func(args mock.Arguments) {
2145 var arg0 context.Context
2146 if args[0] != nil {
2147 arg0 = args[0].(context.Context)
2148 }
2149 run(
2150 arg0,
2151 )
2152 })
2153 return _c
2154}
2155
2156func (_c *MockDesktopIntegration_SetAsDefaultBrowser_Call) Return(err error) *MockDesktopIntegration_SetAsDefaultBrowser_Call {
2157 _c.Call.Return(err)
2158 return _c
2159}
2160
2161func (_c *MockDesktopIntegration_SetAsDefaultBrowser_Call) RunAndReturn(run func(ctx context.Context) error) *MockDesktopIntegration_SetAsDefaultBrowser_Call {
2162 _c.Call.Return(run)
2163 return _c
2164}
2165
2166// UnsetAsDefaultBrowser provides a mock function for the type MockDesktopIntegration
2167func (_mock *MockDesktopIntegration) UnsetAsDefaultBrowser(ctx context.Context) error {
2168 ret := _mock.Called(ctx)
2169
2170 if len(ret) == 0 {
2171 panic("no return value specified for UnsetAsDefaultBrowser")
2172 }
2173
2174 var r0 error
2175 if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
2176 r0 = returnFunc(ctx)
2177 } else {
2178 r0 = ret.Error(0)
2179 }
2180 return r0
2181}
2182
2183// MockDesktopIntegration_UnsetAsDefaultBrowser_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UnsetAsDefaultBrowser'
2184type MockDesktopIntegration_UnsetAsDefaultBrowser_Call struct {
2185 *mock.Call
2186}
2187
2188// UnsetAsDefaultBrowser is a helper method to define mock.On call
2189// - ctx context.Context
2190func (_e *MockDesktopIntegration_Expecter) UnsetAsDefaultBrowser(ctx interface{}) *MockDesktopIntegration_UnsetAsDefaultBrowser_Call {
2191 return &MockDesktopIntegration_UnsetAsDefaultBrowser_Call{Call: _e.mock.On("UnsetAsDefaultBrowser", ctx)}
2192}
2193
2194func (_c *MockDesktopIntegration_UnsetAsDefaultBrowser_Call) Run(run func(ctx context.Context)) *MockDesktopIntegration_UnsetAsDefaultBrowser_Call {
2195 _c.Call.Run(func(args mock.Arguments) {
2196 var arg0 context.Context
2197 if args[0] != nil {
2198 arg0 = args[0].(context.Context)
2199 }
2200 run(
2201 arg0,
2202 )
2203 })
2204 return _c
2205}
2206
2207func (_c *MockDesktopIntegration_UnsetAsDefaultBrowser_Call) Return(err error) *MockDesktopIntegration_UnsetAsDefaultBrowser_Call {
2208 _c.Call.Return(err)
2209 return _c
2210}
2211
2212func (_c *MockDesktopIntegration_UnsetAsDefaultBrowser_Call) RunAndReturn(run func(ctx context.Context) error) *MockDesktopIntegration_UnsetAsDefaultBrowser_Call {
2213 _c.Call.Return(run)
2214 return _c
2215}
2216
2217// NewMockDownloadEventHandler creates a new instance of MockDownloadEventHandler. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
2218// The first argument is typically a *testing.T value.
2219func NewMockDownloadEventHandler(t interface {
2220 mock.TestingT
2221 Cleanup(func())
2222}) *MockDownloadEventHandler {
2223 mock := &MockDownloadEventHandler{}
2224 mock.Mock.Test(t)
2225
2226 t.Cleanup(func() { mock.AssertExpectations(t) })
2227
2228 return mock
2229}
2230
2231// MockDownloadEventHandler is an autogenerated mock type for the DownloadEventHandler type
2232type MockDownloadEventHandler struct {
2233 mock.Mock
2234}
2235
2236type MockDownloadEventHandler_Expecter struct {
2237 mock *mock.Mock
2238}
2239
2240func (_m *MockDownloadEventHandler) EXPECT() *MockDownloadEventHandler_Expecter {
2241 return &MockDownloadEventHandler_Expecter{mock: &_m.Mock}
2242}
2243
2244// OnDownloadEvent provides a mock function for the type MockDownloadEventHandler
2245func (_mock *MockDownloadEventHandler) OnDownloadEvent(ctx context.Context, event port.DownloadEvent) {
2246 _mock.Called(ctx, event)
2247 return
2248}
2249
2250// MockDownloadEventHandler_OnDownloadEvent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OnDownloadEvent'
2251type MockDownloadEventHandler_OnDownloadEvent_Call struct {
2252 *mock.Call
2253}
2254
2255// OnDownloadEvent is a helper method to define mock.On call
2256// - ctx context.Context
2257// - event port.DownloadEvent
2258func (_e *MockDownloadEventHandler_Expecter) OnDownloadEvent(ctx interface{}, event interface{}) *MockDownloadEventHandler_OnDownloadEvent_Call {
2259 return &MockDownloadEventHandler_OnDownloadEvent_Call{Call: _e.mock.On("OnDownloadEvent", ctx, event)}
2260}
2261
2262func (_c *MockDownloadEventHandler_OnDownloadEvent_Call) Run(run func(ctx context.Context, event port.DownloadEvent)) *MockDownloadEventHandler_OnDownloadEvent_Call {
2263 _c.Call.Run(func(args mock.Arguments) {
2264 var arg0 context.Context
2265 if args[0] != nil {
2266 arg0 = args[0].(context.Context)
2267 }
2268 var arg1 port.DownloadEvent
2269 if args[1] != nil {
2270 arg1 = args[1].(port.DownloadEvent)
2271 }
2272 run(
2273 arg0,
2274 arg1,
2275 )
2276 })
2277 return _c
2278}
2279
2280func (_c *MockDownloadEventHandler_OnDownloadEvent_Call) Return() *MockDownloadEventHandler_OnDownloadEvent_Call {
2281 _c.Call.Return()
2282 return _c
2283}
2284
2285func (_c *MockDownloadEventHandler_OnDownloadEvent_Call) RunAndReturn(run func(ctx context.Context, event port.DownloadEvent)) *MockDownloadEventHandler_OnDownloadEvent_Call {
2286 _c.Run(run)
2287 return _c
2288}
2289
2290// NewMockDownloadResponse creates a new instance of MockDownloadResponse. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
2291// The first argument is typically a *testing.T value.
2292func NewMockDownloadResponse(t interface {
2293 mock.TestingT
2294 Cleanup(func())
2295}) *MockDownloadResponse {
2296 mock := &MockDownloadResponse{}
2297 mock.Mock.Test(t)
2298
2299 t.Cleanup(func() { mock.AssertExpectations(t) })
2300
2301 return mock
2302}
2303
2304// MockDownloadResponse is an autogenerated mock type for the DownloadResponse type
2305type MockDownloadResponse struct {
2306 mock.Mock
2307}
2308
2309type MockDownloadResponse_Expecter struct {
2310 mock *mock.Mock
2311}
2312
2313func (_m *MockDownloadResponse) EXPECT() *MockDownloadResponse_Expecter {
2314 return &MockDownloadResponse_Expecter{mock: &_m.Mock}
2315}
2316
2317// GetMimeType provides a mock function for the type MockDownloadResponse
2318func (_mock *MockDownloadResponse) GetMimeType() string {
2319 ret := _mock.Called()
2320
2321 if len(ret) == 0 {
2322 panic("no return value specified for GetMimeType")
2323 }
2324
2325 var r0 string
2326 if returnFunc, ok := ret.Get(0).(func() string); ok {
2327 r0 = returnFunc()
2328 } else {
2329 r0 = ret.Get(0).(string)
2330 }
2331 return r0
2332}
2333
2334// MockDownloadResponse_GetMimeType_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetMimeType'
2335type MockDownloadResponse_GetMimeType_Call struct {
2336 *mock.Call
2337}
2338
2339// GetMimeType is a helper method to define mock.On call
2340func (_e *MockDownloadResponse_Expecter) GetMimeType() *MockDownloadResponse_GetMimeType_Call {
2341 return &MockDownloadResponse_GetMimeType_Call{Call: _e.mock.On("GetMimeType")}
2342}
2343
2344func (_c *MockDownloadResponse_GetMimeType_Call) Run(run func()) *MockDownloadResponse_GetMimeType_Call {
2345 _c.Call.Run(func(args mock.Arguments) {
2346 run()
2347 })
2348 return _c
2349}
2350
2351func (_c *MockDownloadResponse_GetMimeType_Call) Return(s string) *MockDownloadResponse_GetMimeType_Call {
2352 _c.Call.Return(s)
2353 return _c
2354}
2355
2356func (_c *MockDownloadResponse_GetMimeType_Call) RunAndReturn(run func() string) *MockDownloadResponse_GetMimeType_Call {
2357 _c.Call.Return(run)
2358 return _c
2359}
2360
2361// GetSuggestedFilename provides a mock function for the type MockDownloadResponse
2362func (_mock *MockDownloadResponse) GetSuggestedFilename() string {
2363 ret := _mock.Called()
2364
2365 if len(ret) == 0 {
2366 panic("no return value specified for GetSuggestedFilename")
2367 }
2368
2369 var r0 string
2370 if returnFunc, ok := ret.Get(0).(func() string); ok {
2371 r0 = returnFunc()
2372 } else {
2373 r0 = ret.Get(0).(string)
2374 }
2375 return r0
2376}
2377
2378// MockDownloadResponse_GetSuggestedFilename_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSuggestedFilename'
2379type MockDownloadResponse_GetSuggestedFilename_Call struct {
2380 *mock.Call
2381}
2382
2383// GetSuggestedFilename is a helper method to define mock.On call
2384func (_e *MockDownloadResponse_Expecter) GetSuggestedFilename() *MockDownloadResponse_GetSuggestedFilename_Call {
2385 return &MockDownloadResponse_GetSuggestedFilename_Call{Call: _e.mock.On("GetSuggestedFilename")}
2386}
2387
2388func (_c *MockDownloadResponse_GetSuggestedFilename_Call) Run(run func()) *MockDownloadResponse_GetSuggestedFilename_Call {
2389 _c.Call.Run(func(args mock.Arguments) {
2390 run()
2391 })
2392 return _c
2393}
2394
2395func (_c *MockDownloadResponse_GetSuggestedFilename_Call) Return(s string) *MockDownloadResponse_GetSuggestedFilename_Call {
2396 _c.Call.Return(s)
2397 return _c
2398}
2399
2400func (_c *MockDownloadResponse_GetSuggestedFilename_Call) RunAndReturn(run func() string) *MockDownloadResponse_GetSuggestedFilename_Call {
2401 _c.Call.Return(run)
2402 return _c
2403}
2404
2405// GetUri provides a mock function for the type MockDownloadResponse
2406func (_mock *MockDownloadResponse) GetUri() string {
2407 ret := _mock.Called()
2408
2409 if len(ret) == 0 {
2410 panic("no return value specified for GetUri")
2411 }
2412
2413 var r0 string
2414 if returnFunc, ok := ret.Get(0).(func() string); ok {
2415 r0 = returnFunc()
2416 } else {
2417 r0 = ret.Get(0).(string)
2418 }
2419 return r0
2420}
2421
2422// MockDownloadResponse_GetUri_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetUri'
2423type MockDownloadResponse_GetUri_Call struct {
2424 *mock.Call
2425}
2426
2427// GetUri is a helper method to define mock.On call
2428func (_e *MockDownloadResponse_Expecter) GetUri() *MockDownloadResponse_GetUri_Call {
2429 return &MockDownloadResponse_GetUri_Call{Call: _e.mock.On("GetUri")}
2430}
2431
2432func (_c *MockDownloadResponse_GetUri_Call) Run(run func()) *MockDownloadResponse_GetUri_Call {
2433 _c.Call.Run(func(args mock.Arguments) {
2434 run()
2435 })
2436 return _c
2437}
2438
2439func (_c *MockDownloadResponse_GetUri_Call) Return(s string) *MockDownloadResponse_GetUri_Call {
2440 _c.Call.Return(s)
2441 return _c
2442}
2443
2444func (_c *MockDownloadResponse_GetUri_Call) RunAndReturn(run func() string) *MockDownloadResponse_GetUri_Call {
2445 _c.Call.Return(run)
2446 return _c
2447}
2448
2449// NewMockMemoryPressureApplier creates a new instance of MockMemoryPressureApplier. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
2450// The first argument is typically a *testing.T value.
2451func NewMockMemoryPressureApplier(t interface {
2452 mock.TestingT
2453 Cleanup(func())
2454}) *MockMemoryPressureApplier {
2455 mock := &MockMemoryPressureApplier{}
2456 mock.Mock.Test(t)
2457
2458 t.Cleanup(func() { mock.AssertExpectations(t) })
2459
2460 return mock
2461}
2462
2463// MockMemoryPressureApplier is an autogenerated mock type for the MemoryPressureApplier type
2464type MockMemoryPressureApplier struct {
2465 mock.Mock
2466}
2467
2468type MockMemoryPressureApplier_Expecter struct {
2469 mock *mock.Mock
2470}
2471
2472func (_m *MockMemoryPressureApplier) EXPECT() *MockMemoryPressureApplier_Expecter {
2473 return &MockMemoryPressureApplier_Expecter{mock: &_m.Mock}
2474}
2475
2476// ApplyNetworkProcessSettings provides a mock function for the type MockMemoryPressureApplier
2477func (_mock *MockMemoryPressureApplier) ApplyNetworkProcessSettings(ctx context.Context, cfg *port.MemoryPressureConfig) error {
2478 ret := _mock.Called(ctx, cfg)
2479
2480 if len(ret) == 0 {
2481 panic("no return value specified for ApplyNetworkProcessSettings")
2482 }
2483
2484 var r0 error
2485 if returnFunc, ok := ret.Get(0).(func(context.Context, *port.MemoryPressureConfig) error); ok {
2486 r0 = returnFunc(ctx, cfg)
2487 } else {
2488 r0 = ret.Error(0)
2489 }
2490 return r0
2491}
2492
2493// MockMemoryPressureApplier_ApplyNetworkProcessSettings_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ApplyNetworkProcessSettings'
2494type MockMemoryPressureApplier_ApplyNetworkProcessSettings_Call struct {
2495 *mock.Call
2496}
2497
2498// ApplyNetworkProcessSettings is a helper method to define mock.On call
2499// - ctx context.Context
2500// - cfg *port.MemoryPressureConfig
2501func (_e *MockMemoryPressureApplier_Expecter) ApplyNetworkProcessSettings(ctx interface{}, cfg interface{}) *MockMemoryPressureApplier_ApplyNetworkProcessSettings_Call {
2502 return &MockMemoryPressureApplier_ApplyNetworkProcessSettings_Call{Call: _e.mock.On("ApplyNetworkProcessSettings", ctx, cfg)}
2503}
2504
2505func (_c *MockMemoryPressureApplier_ApplyNetworkProcessSettings_Call) Run(run func(ctx context.Context, cfg *port.MemoryPressureConfig)) *MockMemoryPressureApplier_ApplyNetworkProcessSettings_Call {
2506 _c.Call.Run(func(args mock.Arguments) {
2507 var arg0 context.Context
2508 if args[0] != nil {
2509 arg0 = args[0].(context.Context)
2510 }
2511 var arg1 *port.MemoryPressureConfig
2512 if args[1] != nil {
2513 arg1 = args[1].(*port.MemoryPressureConfig)
2514 }
2515 run(
2516 arg0,
2517 arg1,
2518 )
2519 })
2520 return _c
2521}
2522
2523func (_c *MockMemoryPressureApplier_ApplyNetworkProcessSettings_Call) Return(err error) *MockMemoryPressureApplier_ApplyNetworkProcessSettings_Call {
2524 _c.Call.Return(err)
2525 return _c
2526}
2527
2528func (_c *MockMemoryPressureApplier_ApplyNetworkProcessSettings_Call) RunAndReturn(run func(ctx context.Context, cfg *port.MemoryPressureConfig) error) *MockMemoryPressureApplier_ApplyNetworkProcessSettings_Call {
2529 _c.Call.Return(run)
2530 return _c
2531}
2532
2533// ApplyWebProcessSettings provides a mock function for the type MockMemoryPressureApplier
2534func (_mock *MockMemoryPressureApplier) ApplyWebProcessSettings(ctx context.Context, cfg *port.MemoryPressureConfig) (any, error) {
2535 ret := _mock.Called(ctx, cfg)
2536
2537 if len(ret) == 0 {
2538 panic("no return value specified for ApplyWebProcessSettings")
2539 }
2540
2541 var r0 any
2542 var r1 error
2543 if returnFunc, ok := ret.Get(0).(func(context.Context, *port.MemoryPressureConfig) (any, error)); ok {
2544 return returnFunc(ctx, cfg)
2545 }
2546 if returnFunc, ok := ret.Get(0).(func(context.Context, *port.MemoryPressureConfig) any); ok {
2547 r0 = returnFunc(ctx, cfg)
2548 } else {
2549 if ret.Get(0) != nil {
2550 r0 = ret.Get(0).(any)
2551 }
2552 }
2553 if returnFunc, ok := ret.Get(1).(func(context.Context, *port.MemoryPressureConfig) error); ok {
2554 r1 = returnFunc(ctx, cfg)
2555 } else {
2556 r1 = ret.Error(1)
2557 }
2558 return r0, r1
2559}
2560
2561// MockMemoryPressureApplier_ApplyWebProcessSettings_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ApplyWebProcessSettings'
2562type MockMemoryPressureApplier_ApplyWebProcessSettings_Call struct {
2563 *mock.Call
2564}
2565
2566// ApplyWebProcessSettings is a helper method to define mock.On call
2567// - ctx context.Context
2568// - cfg *port.MemoryPressureConfig
2569func (_e *MockMemoryPressureApplier_Expecter) ApplyWebProcessSettings(ctx interface{}, cfg interface{}) *MockMemoryPressureApplier_ApplyWebProcessSettings_Call {
2570 return &MockMemoryPressureApplier_ApplyWebProcessSettings_Call{Call: _e.mock.On("ApplyWebProcessSettings", ctx, cfg)}
2571}
2572
2573func (_c *MockMemoryPressureApplier_ApplyWebProcessSettings_Call) Run(run func(ctx context.Context, cfg *port.MemoryPressureConfig)) *MockMemoryPressureApplier_ApplyWebProcessSettings_Call {
2574 _c.Call.Run(func(args mock.Arguments) {
2575 var arg0 context.Context
2576 if args[0] != nil {
2577 arg0 = args[0].(context.Context)
2578 }
2579 var arg1 *port.MemoryPressureConfig
2580 if args[1] != nil {
2581 arg1 = args[1].(*port.MemoryPressureConfig)
2582 }
2583 run(
2584 arg0,
2585 arg1,
2586 )
2587 })
2588 return _c
2589}
2590
2591func (_c *MockMemoryPressureApplier_ApplyWebProcessSettings_Call) Return(v any, err error) *MockMemoryPressureApplier_ApplyWebProcessSettings_Call {
2592 _c.Call.Return(v, err)
2593 return _c
2594}
2595
2596func (_c *MockMemoryPressureApplier_ApplyWebProcessSettings_Call) RunAndReturn(run func(ctx context.Context, cfg *port.MemoryPressureConfig) (any, error)) *MockMemoryPressureApplier_ApplyWebProcessSettings_Call {
2597 _c.Call.Return(run)
2598 return _c
2599}
2600
2601// NewMockEngine creates a new instance of MockEngine. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
2602// The first argument is typically a *testing.T value.
2603func NewMockEngine(t interface {
2604 mock.TestingT
2605 Cleanup(func())
2606}) *MockEngine {
2607 mock := &MockEngine{}
2608 mock.Mock.Test(t)
2609
2610 t.Cleanup(func() { mock.AssertExpectations(t) })
2611
2612 return mock
2613}
2614
2615// MockEngine is an autogenerated mock type for the Engine type
2616type MockEngine struct {
2617 mock.Mock
2618}
2619
2620type MockEngine_Expecter struct {
2621 mock *mock.Mock
2622}
2623
2624func (_m *MockEngine) EXPECT() *MockEngine_Expecter {
2625 return &MockEngine_Expecter{mock: &_m.Mock}
2626}
2627
2628// Close provides a mock function for the type MockEngine
2629func (_mock *MockEngine) Close() error {
2630 ret := _mock.Called()
2631
2632 if len(ret) == 0 {
2633 panic("no return value specified for Close")
2634 }
2635
2636 var r0 error
2637 if returnFunc, ok := ret.Get(0).(func() error); ok {
2638 r0 = returnFunc()
2639 } else {
2640 r0 = ret.Error(0)
2641 }
2642 return r0
2643}
2644
2645// MockEngine_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
2646type MockEngine_Close_Call struct {
2647 *mock.Call
2648}
2649
2650// Close is a helper method to define mock.On call
2651func (_e *MockEngine_Expecter) Close() *MockEngine_Close_Call {
2652 return &MockEngine_Close_Call{Call: _e.mock.On("Close")}
2653}
2654
2655func (_c *MockEngine_Close_Call) Run(run func()) *MockEngine_Close_Call {
2656 _c.Call.Run(func(args mock.Arguments) {
2657 run()
2658 })
2659 return _c
2660}
2661
2662func (_c *MockEngine_Close_Call) Return(err error) *MockEngine_Close_Call {
2663 _c.Call.Return(err)
2664 return _c
2665}
2666
2667func (_c *MockEngine_Close_Call) RunAndReturn(run func() error) *MockEngine_Close_Call {
2668 _c.Call.Return(run)
2669 return _c
2670}
2671
2672// ConfigureDownloads provides a mock function for the type MockEngine
2673func (_mock *MockEngine) ConfigureDownloads(ctx context.Context, downloadPath string, eventHandler port.DownloadEventHandler, preparer port.DownloadPreparer) error {
2674 ret := _mock.Called(ctx, downloadPath, eventHandler, preparer)
2675
2676 if len(ret) == 0 {
2677 panic("no return value specified for ConfigureDownloads")
2678 }
2679
2680 var r0 error
2681 if returnFunc, ok := ret.Get(0).(func(context.Context, string, port.DownloadEventHandler, port.DownloadPreparer) error); ok {
2682 r0 = returnFunc(ctx, downloadPath, eventHandler, preparer)
2683 } else {
2684 r0 = ret.Error(0)
2685 }
2686 return r0
2687}
2688
2689// MockEngine_ConfigureDownloads_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ConfigureDownloads'
2690type MockEngine_ConfigureDownloads_Call struct {
2691 *mock.Call
2692}
2693
2694// ConfigureDownloads is a helper method to define mock.On call
2695// - ctx context.Context
2696// - downloadPath string
2697// - eventHandler port.DownloadEventHandler
2698// - preparer port.DownloadPreparer
2699func (_e *MockEngine_Expecter) ConfigureDownloads(ctx interface{}, downloadPath interface{}, eventHandler interface{}, preparer interface{}) *MockEngine_ConfigureDownloads_Call {
2700 return &MockEngine_ConfigureDownloads_Call{Call: _e.mock.On("ConfigureDownloads", ctx, downloadPath, eventHandler, preparer)}
2701}
2702
2703func (_c *MockEngine_ConfigureDownloads_Call) Run(run func(ctx context.Context, downloadPath string, eventHandler port.DownloadEventHandler, preparer port.DownloadPreparer)) *MockEngine_ConfigureDownloads_Call {
2704 _c.Call.Run(func(args mock.Arguments) {
2705 var arg0 context.Context
2706 if args[0] != nil {
2707 arg0 = args[0].(context.Context)
2708 }
2709 var arg1 string
2710 if args[1] != nil {
2711 arg1 = args[1].(string)
2712 }
2713 var arg2 port.DownloadEventHandler
2714 if args[2] != nil {
2715 arg2 = args[2].(port.DownloadEventHandler)
2716 }
2717 var arg3 port.DownloadPreparer
2718 if args[3] != nil {
2719 arg3 = args[3].(port.DownloadPreparer)
2720 }
2721 run(
2722 arg0,
2723 arg1,
2724 arg2,
2725 arg3,
2726 )
2727 })
2728 return _c
2729}
2730
2731func (_c *MockEngine_ConfigureDownloads_Call) Return(err error) *MockEngine_ConfigureDownloads_Call {
2732 _c.Call.Return(err)
2733 return _c
2734}
2735
2736func (_c *MockEngine_ConfigureDownloads_Call) RunAndReturn(run func(ctx context.Context, downloadPath string, eventHandler port.DownloadEventHandler, preparer port.DownloadPreparer) error) *MockEngine_ConfigureDownloads_Call {
2737 _c.Call.Return(run)
2738 return _c
2739}
2740
2741// ContentInjector provides a mock function for the type MockEngine
2742func (_mock *MockEngine) ContentInjector() port.ContentInjector {
2743 ret := _mock.Called()
2744
2745 if len(ret) == 0 {
2746 panic("no return value specified for ContentInjector")
2747 }
2748
2749 var r0 port.ContentInjector
2750 if returnFunc, ok := ret.Get(0).(func() port.ContentInjector); ok {
2751 r0 = returnFunc()
2752 } else {
2753 if ret.Get(0) != nil {
2754 r0 = ret.Get(0).(port.ContentInjector)
2755 }
2756 }
2757 return r0
2758}
2759
2760// MockEngine_ContentInjector_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ContentInjector'
2761type MockEngine_ContentInjector_Call struct {
2762 *mock.Call
2763}
2764
2765// ContentInjector is a helper method to define mock.On call
2766func (_e *MockEngine_Expecter) ContentInjector() *MockEngine_ContentInjector_Call {
2767 return &MockEngine_ContentInjector_Call{Call: _e.mock.On("ContentInjector")}
2768}
2769
2770func (_c *MockEngine_ContentInjector_Call) Run(run func()) *MockEngine_ContentInjector_Call {
2771 _c.Call.Run(func(args mock.Arguments) {
2772 run()
2773 })
2774 return _c
2775}
2776
2777func (_c *MockEngine_ContentInjector_Call) Return(contentInjector port.ContentInjector) *MockEngine_ContentInjector_Call {
2778 _c.Call.Return(contentInjector)
2779 return _c
2780}
2781
2782func (_c *MockEngine_ContentInjector_Call) RunAndReturn(run func() port.ContentInjector) *MockEngine_ContentInjector_Call {
2783 _c.Call.Return(run)
2784 return _c
2785}
2786
2787// Factory provides a mock function for the type MockEngine
2788func (_mock *MockEngine) Factory() port.WebViewFactory {
2789 ret := _mock.Called()
2790
2791 if len(ret) == 0 {
2792 panic("no return value specified for Factory")
2793 }
2794
2795 var r0 port.WebViewFactory
2796 if returnFunc, ok := ret.Get(0).(func() port.WebViewFactory); ok {
2797 r0 = returnFunc()
2798 } else {
2799 if ret.Get(0) != nil {
2800 r0 = ret.Get(0).(port.WebViewFactory)
2801 }
2802 }
2803 return r0
2804}
2805
2806// MockEngine_Factory_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Factory'
2807type MockEngine_Factory_Call struct {
2808 *mock.Call
2809}
2810
2811// Factory is a helper method to define mock.On call
2812func (_e *MockEngine_Expecter) Factory() *MockEngine_Factory_Call {
2813 return &MockEngine_Factory_Call{Call: _e.mock.On("Factory")}
2814}
2815
2816func (_c *MockEngine_Factory_Call) Run(run func()) *MockEngine_Factory_Call {
2817 _c.Call.Run(func(args mock.Arguments) {
2818 run()
2819 })
2820 return _c
2821}
2822
2823func (_c *MockEngine_Factory_Call) Return(webViewFactory port.WebViewFactory) *MockEngine_Factory_Call {
2824 _c.Call.Return(webViewFactory)
2825 return _c
2826}
2827
2828func (_c *MockEngine_Factory_Call) RunAndReturn(run func() port.WebViewFactory) *MockEngine_Factory_Call {
2829 _c.Call.Return(run)
2830 return _c
2831}
2832
2833// FaviconDatabase provides a mock function for the type MockEngine
2834func (_mock *MockEngine) FaviconDatabase() port.FaviconDatabase {
2835 ret := _mock.Called()
2836
2837 if len(ret) == 0 {
2838 panic("no return value specified for FaviconDatabase")
2839 }
2840
2841 var r0 port.FaviconDatabase
2842 if returnFunc, ok := ret.Get(0).(func() port.FaviconDatabase); ok {
2843 r0 = returnFunc()
2844 } else {
2845 if ret.Get(0) != nil {
2846 r0 = ret.Get(0).(port.FaviconDatabase)
2847 }
2848 }
2849 return r0
2850}
2851
2852// MockEngine_FaviconDatabase_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FaviconDatabase'
2853type MockEngine_FaviconDatabase_Call struct {
2854 *mock.Call
2855}
2856
2857// FaviconDatabase is a helper method to define mock.On call
2858func (_e *MockEngine_Expecter) FaviconDatabase() *MockEngine_FaviconDatabase_Call {
2859 return &MockEngine_FaviconDatabase_Call{Call: _e.mock.On("FaviconDatabase")}
2860}
2861
2862func (_c *MockEngine_FaviconDatabase_Call) Run(run func()) *MockEngine_FaviconDatabase_Call {
2863 _c.Call.Run(func(args mock.Arguments) {
2864 run()
2865 })
2866 return _c
2867}
2868
2869func (_c *MockEngine_FaviconDatabase_Call) Return(faviconDatabase port.FaviconDatabase) *MockEngine_FaviconDatabase_Call {
2870 _c.Call.Return(faviconDatabase)
2871 return _c
2872}
2873
2874func (_c *MockEngine_FaviconDatabase_Call) RunAndReturn(run func() port.FaviconDatabase) *MockEngine_FaviconDatabase_Call {
2875 _c.Call.Return(run)
2876 return _c
2877}
2878
2879// FilterApplier provides a mock function for the type MockEngine
2880func (_mock *MockEngine) FilterApplier() port.FilterApplier {
2881 ret := _mock.Called()
2882
2883 if len(ret) == 0 {
2884 panic("no return value specified for FilterApplier")
2885 }
2886
2887 var r0 port.FilterApplier
2888 if returnFunc, ok := ret.Get(0).(func() port.FilterApplier); ok {
2889 r0 = returnFunc()
2890 } else {
2891 if ret.Get(0) != nil {
2892 r0 = ret.Get(0).(port.FilterApplier)
2893 }
2894 }
2895 return r0
2896}
2897
2898// MockEngine_FilterApplier_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FilterApplier'
2899type MockEngine_FilterApplier_Call struct {
2900 *mock.Call
2901}
2902
2903// FilterApplier is a helper method to define mock.On call
2904func (_e *MockEngine_Expecter) FilterApplier() *MockEngine_FilterApplier_Call {
2905 return &MockEngine_FilterApplier_Call{Call: _e.mock.On("FilterApplier")}
2906}
2907
2908func (_c *MockEngine_FilterApplier_Call) Run(run func()) *MockEngine_FilterApplier_Call {
2909 _c.Call.Run(func(args mock.Arguments) {
2910 run()
2911 })
2912 return _c
2913}
2914
2915func (_c *MockEngine_FilterApplier_Call) Return(filterApplier port.FilterApplier) *MockEngine_FilterApplier_Call {
2916 _c.Call.Return(filterApplier)
2917 return _c
2918}
2919
2920func (_c *MockEngine_FilterApplier_Call) RunAndReturn(run func() port.FilterApplier) *MockEngine_FilterApplier_Call {
2921 _c.Call.Return(run)
2922 return _c
2923}
2924
2925// InternalSchemePath provides a mock function for the type MockEngine
2926func (_mock *MockEngine) InternalSchemePath() string {
2927 ret := _mock.Called()
2928
2929 if len(ret) == 0 {
2930 panic("no return value specified for InternalSchemePath")
2931 }
2932
2933 var r0 string
2934 if returnFunc, ok := ret.Get(0).(func() string); ok {
2935 r0 = returnFunc()
2936 } else {
2937 r0 = ret.Get(0).(string)
2938 }
2939 return r0
2940}
2941
2942// MockEngine_InternalSchemePath_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'InternalSchemePath'
2943type MockEngine_InternalSchemePath_Call struct {
2944 *mock.Call
2945}
2946
2947// InternalSchemePath is a helper method to define mock.On call
2948func (_e *MockEngine_Expecter) InternalSchemePath() *MockEngine_InternalSchemePath_Call {
2949 return &MockEngine_InternalSchemePath_Call{Call: _e.mock.On("InternalSchemePath")}
2950}
2951
2952func (_c *MockEngine_InternalSchemePath_Call) Run(run func()) *MockEngine_InternalSchemePath_Call {
2953 _c.Call.Run(func(args mock.Arguments) {
2954 run()
2955 })
2956 return _c
2957}
2958
2959func (_c *MockEngine_InternalSchemePath_Call) Return(s string) *MockEngine_InternalSchemePath_Call {
2960 _c.Call.Return(s)
2961 return _c
2962}
2963
2964func (_c *MockEngine_InternalSchemePath_Call) RunAndReturn(run func() string) *MockEngine_InternalSchemePath_Call {
2965 _c.Call.Return(run)
2966 return _c
2967}
2968
2969// OnToolkitReady provides a mock function for the type MockEngine
2970func (_mock *MockEngine) OnToolkitReady(ctx context.Context) error {
2971 ret := _mock.Called(ctx)
2972
2973 if len(ret) == 0 {
2974 panic("no return value specified for OnToolkitReady")
2975 }
2976
2977 var r0 error
2978 if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
2979 r0 = returnFunc(ctx)
2980 } else {
2981 r0 = ret.Error(0)
2982 }
2983 return r0
2984}
2985
2986// MockEngine_OnToolkitReady_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OnToolkitReady'
2987type MockEngine_OnToolkitReady_Call struct {
2988 *mock.Call
2989}
2990
2991// OnToolkitReady is a helper method to define mock.On call
2992// - ctx context.Context
2993func (_e *MockEngine_Expecter) OnToolkitReady(ctx interface{}) *MockEngine_OnToolkitReady_Call {
2994 return &MockEngine_OnToolkitReady_Call{Call: _e.mock.On("OnToolkitReady", ctx)}
2995}
2996
2997func (_c *MockEngine_OnToolkitReady_Call) Run(run func(ctx context.Context)) *MockEngine_OnToolkitReady_Call {
2998 _c.Call.Run(func(args mock.Arguments) {
2999 var arg0 context.Context
3000 if args[0] != nil {
3001 arg0 = args[0].(context.Context)
3002 }
3003 run(
3004 arg0,
3005 )
3006 })
3007 return _c
3008}
3009
3010func (_c *MockEngine_OnToolkitReady_Call) Return(err error) *MockEngine_OnToolkitReady_Call {
3011 _c.Call.Return(err)
3012 return _c
3013}
3014
3015func (_c *MockEngine_OnToolkitReady_Call) RunAndReturn(run func(ctx context.Context) error) *MockEngine_OnToolkitReady_Call {
3016 _c.Call.Return(run)
3017 return _c
3018}
3019
3020// Pool provides a mock function for the type MockEngine
3021func (_mock *MockEngine) Pool() port.WebViewPool {
3022 ret := _mock.Called()
3023
3024 if len(ret) == 0 {
3025 panic("no return value specified for Pool")
3026 }
3027
3028 var r0 port.WebViewPool
3029 if returnFunc, ok := ret.Get(0).(func() port.WebViewPool); ok {
3030 r0 = returnFunc()
3031 } else {
3032 if ret.Get(0) != nil {
3033 r0 = ret.Get(0).(port.WebViewPool)
3034 }
3035 }
3036 return r0
3037}
3038
3039// MockEngine_Pool_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Pool'
3040type MockEngine_Pool_Call struct {
3041 *mock.Call
3042}
3043
3044// Pool is a helper method to define mock.On call
3045func (_e *MockEngine_Expecter) Pool() *MockEngine_Pool_Call {
3046 return &MockEngine_Pool_Call{Call: _e.mock.On("Pool")}
3047}
3048
3049func (_c *MockEngine_Pool_Call) Run(run func()) *MockEngine_Pool_Call {
3050 _c.Call.Run(func(args mock.Arguments) {
3051 run()
3052 })
3053 return _c
3054}
3055
3056func (_c *MockEngine_Pool_Call) Return(webViewPool port.WebViewPool) *MockEngine_Pool_Call {
3057 _c.Call.Return(webViewPool)
3058 return _c
3059}
3060
3061func (_c *MockEngine_Pool_Call) RunAndReturn(run func() port.WebViewPool) *MockEngine_Pool_Call {
3062 _c.Call.Return(run)
3063 return _c
3064}
3065
3066// RegisterAccentHandlers provides a mock function for the type MockEngine
3067func (_mock *MockEngine) RegisterAccentHandlers(ctx context.Context, handler port.AccentKeyHandler) error {
3068 ret := _mock.Called(ctx, handler)
3069
3070 if len(ret) == 0 {
3071 panic("no return value specified for RegisterAccentHandlers")
3072 }
3073
3074 var r0 error
3075 if returnFunc, ok := ret.Get(0).(func(context.Context, port.AccentKeyHandler) error); ok {
3076 r0 = returnFunc(ctx, handler)
3077 } else {
3078 r0 = ret.Error(0)
3079 }
3080 return r0
3081}
3082
3083// MockEngine_RegisterAccentHandlers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterAccentHandlers'
3084type MockEngine_RegisterAccentHandlers_Call struct {
3085 *mock.Call
3086}
3087
3088// RegisterAccentHandlers is a helper method to define mock.On call
3089// - ctx context.Context
3090// - handler port.AccentKeyHandler
3091func (_e *MockEngine_Expecter) RegisterAccentHandlers(ctx interface{}, handler interface{}) *MockEngine_RegisterAccentHandlers_Call {
3092 return &MockEngine_RegisterAccentHandlers_Call{Call: _e.mock.On("RegisterAccentHandlers", ctx, handler)}
3093}
3094
3095func (_c *MockEngine_RegisterAccentHandlers_Call) Run(run func(ctx context.Context, handler port.AccentKeyHandler)) *MockEngine_RegisterAccentHandlers_Call {
3096 _c.Call.Run(func(args mock.Arguments) {
3097 var arg0 context.Context
3098 if args[0] != nil {
3099 arg0 = args[0].(context.Context)
3100 }
3101 var arg1 port.AccentKeyHandler
3102 if args[1] != nil {
3103 arg1 = args[1].(port.AccentKeyHandler)
3104 }
3105 run(
3106 arg0,
3107 arg1,
3108 )
3109 })
3110 return _c
3111}
3112
3113func (_c *MockEngine_RegisterAccentHandlers_Call) Return(err error) *MockEngine_RegisterAccentHandlers_Call {
3114 _c.Call.Return(err)
3115 return _c
3116}
3117
3118func (_c *MockEngine_RegisterAccentHandlers_Call) RunAndReturn(run func(ctx context.Context, handler port.AccentKeyHandler) error) *MockEngine_RegisterAccentHandlers_Call {
3119 _c.Call.Return(run)
3120 return _c
3121}
3122
3123// RegisterHandlers provides a mock function for the type MockEngine
3124func (_mock *MockEngine) RegisterHandlers(ctx context.Context, deps port.HandlerDependencies) error {
3125 ret := _mock.Called(ctx, deps)
3126
3127 if len(ret) == 0 {
3128 panic("no return value specified for RegisterHandlers")
3129 }
3130
3131 var r0 error
3132 if returnFunc, ok := ret.Get(0).(func(context.Context, port.HandlerDependencies) error); ok {
3133 r0 = returnFunc(ctx, deps)
3134 } else {
3135 r0 = ret.Error(0)
3136 }
3137 return r0
3138}
3139
3140// MockEngine_RegisterHandlers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterHandlers'
3141type MockEngine_RegisterHandlers_Call struct {
3142 *mock.Call
3143}
3144
3145// RegisterHandlers is a helper method to define mock.On call
3146// - ctx context.Context
3147// - deps port.HandlerDependencies
3148func (_e *MockEngine_Expecter) RegisterHandlers(ctx interface{}, deps interface{}) *MockEngine_RegisterHandlers_Call {
3149 return &MockEngine_RegisterHandlers_Call{Call: _e.mock.On("RegisterHandlers", ctx, deps)}
3150}
3151
3152func (_c *MockEngine_RegisterHandlers_Call) Run(run func(ctx context.Context, deps port.HandlerDependencies)) *MockEngine_RegisterHandlers_Call {
3153 _c.Call.Run(func(args mock.Arguments) {
3154 var arg0 context.Context
3155 if args[0] != nil {
3156 arg0 = args[0].(context.Context)
3157 }
3158 var arg1 port.HandlerDependencies
3159 if args[1] != nil {
3160 arg1 = args[1].(port.HandlerDependencies)
3161 }
3162 run(
3163 arg0,
3164 arg1,
3165 )
3166 })
3167 return _c
3168}
3169
3170func (_c *MockEngine_RegisterHandlers_Call) Return(err error) *MockEngine_RegisterHandlers_Call {
3171 _c.Call.Return(err)
3172 return _c
3173}
3174
3175func (_c *MockEngine_RegisterHandlers_Call) RunAndReturn(run func(ctx context.Context, deps port.HandlerDependencies) error) *MockEngine_RegisterHandlers_Call {
3176 _c.Call.Return(run)
3177 return _c
3178}
3179
3180// SetHandlerContext provides a mock function for the type MockEngine
3181func (_mock *MockEngine) SetHandlerContext(ctx context.Context) {
3182 _mock.Called(ctx)
3183 return
3184}
3185
3186// MockEngine_SetHandlerContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHandlerContext'
3187type MockEngine_SetHandlerContext_Call struct {
3188 *mock.Call
3189}
3190
3191// SetHandlerContext is a helper method to define mock.On call
3192// - ctx context.Context
3193func (_e *MockEngine_Expecter) SetHandlerContext(ctx interface{}) *MockEngine_SetHandlerContext_Call {
3194 return &MockEngine_SetHandlerContext_Call{Call: _e.mock.On("SetHandlerContext", ctx)}
3195}
3196
3197func (_c *MockEngine_SetHandlerContext_Call) Run(run func(ctx context.Context)) *MockEngine_SetHandlerContext_Call {
3198 _c.Call.Run(func(args mock.Arguments) {
3199 var arg0 context.Context
3200 if args[0] != nil {
3201 arg0 = args[0].(context.Context)
3202 }
3203 run(
3204 arg0,
3205 )
3206 })
3207 return _c
3208}
3209
3210func (_c *MockEngine_SetHandlerContext_Call) Return() *MockEngine_SetHandlerContext_Call {
3211 _c.Call.Return()
3212 return _c
3213}
3214
3215func (_c *MockEngine_SetHandlerContext_Call) RunAndReturn(run func(ctx context.Context)) *MockEngine_SetHandlerContext_Call {
3216 _c.Run(run)
3217 return _c
3218}
3219
3220// SettingsApplier provides a mock function for the type MockEngine
3221func (_mock *MockEngine) SettingsApplier() port.SettingsApplier {
3222 ret := _mock.Called()
3223
3224 if len(ret) == 0 {
3225 panic("no return value specified for SettingsApplier")
3226 }
3227
3228 var r0 port.SettingsApplier
3229 if returnFunc, ok := ret.Get(0).(func() port.SettingsApplier); ok {
3230 r0 = returnFunc()
3231 } else {
3232 if ret.Get(0) != nil {
3233 r0 = ret.Get(0).(port.SettingsApplier)
3234 }
3235 }
3236 return r0
3237}
3238
3239// MockEngine_SettingsApplier_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SettingsApplier'
3240type MockEngine_SettingsApplier_Call struct {
3241 *mock.Call
3242}
3243
3244// SettingsApplier is a helper method to define mock.On call
3245func (_e *MockEngine_Expecter) SettingsApplier() *MockEngine_SettingsApplier_Call {
3246 return &MockEngine_SettingsApplier_Call{Call: _e.mock.On("SettingsApplier")}
3247}
3248
3249func (_c *MockEngine_SettingsApplier_Call) Run(run func()) *MockEngine_SettingsApplier_Call {
3250 _c.Call.Run(func(args mock.Arguments) {
3251 run()
3252 })
3253 return _c
3254}
3255
3256func (_c *MockEngine_SettingsApplier_Call) Return(settingsApplier port.SettingsApplier) *MockEngine_SettingsApplier_Call {
3257 _c.Call.Return(settingsApplier)
3258 return _c
3259}
3260
3261func (_c *MockEngine_SettingsApplier_Call) RunAndReturn(run func() port.SettingsApplier) *MockEngine_SettingsApplier_Call {
3262 _c.Call.Return(run)
3263 return _c
3264}
3265
3266// UpdateAppearance provides a mock function for the type MockEngine
3267func (_mock *MockEngine) UpdateAppearance(ctx context.Context, r float64, g float64, b float64, alpha float64) error {
3268 ret := _mock.Called(ctx, r, g, b, alpha)
3269
3270 if len(ret) == 0 {
3271 panic("no return value specified for UpdateAppearance")
3272 }
3273
3274 var r0 error
3275 if returnFunc, ok := ret.Get(0).(func(context.Context, float64, float64, float64, float64) error); ok {
3276 r0 = returnFunc(ctx, r, g, b, alpha)
3277 } else {
3278 r0 = ret.Error(0)
3279 }
3280 return r0
3281}
3282
3283// MockEngine_UpdateAppearance_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateAppearance'
3284type MockEngine_UpdateAppearance_Call struct {
3285 *mock.Call
3286}
3287
3288// UpdateAppearance is a helper method to define mock.On call
3289// - ctx context.Context
3290// - r float64
3291// - g float64
3292// - b float64
3293// - alpha float64
3294func (_e *MockEngine_Expecter) UpdateAppearance(ctx interface{}, r interface{}, g interface{}, b interface{}, alpha interface{}) *MockEngine_UpdateAppearance_Call {
3295 return &MockEngine_UpdateAppearance_Call{Call: _e.mock.On("UpdateAppearance", ctx, r, g, b, alpha)}
3296}
3297
3298func (_c *MockEngine_UpdateAppearance_Call) Run(run func(ctx context.Context, r float64, g float64, b float64, alpha float64)) *MockEngine_UpdateAppearance_Call {
3299 _c.Call.Run(func(args mock.Arguments) {
3300 var arg0 context.Context
3301 if args[0] != nil {
3302 arg0 = args[0].(context.Context)
3303 }
3304 var arg1 float64
3305 if args[1] != nil {
3306 arg1 = args[1].(float64)
3307 }
3308 var arg2 float64
3309 if args[2] != nil {
3310 arg2 = args[2].(float64)
3311 }
3312 var arg3 float64
3313 if args[3] != nil {
3314 arg3 = args[3].(float64)
3315 }
3316 var arg4 float64
3317 if args[4] != nil {
3318 arg4 = args[4].(float64)
3319 }
3320 run(
3321 arg0,
3322 arg1,
3323 arg2,
3324 arg3,
3325 arg4,
3326 )
3327 })
3328 return _c
3329}
3330
3331func (_c *MockEngine_UpdateAppearance_Call) Return(err error) *MockEngine_UpdateAppearance_Call {
3332 _c.Call.Return(err)
3333 return _c
3334}
3335
3336func (_c *MockEngine_UpdateAppearance_Call) RunAndReturn(run func(ctx context.Context, r float64, g float64, b float64, alpha float64) error) *MockEngine_UpdateAppearance_Call {
3337 _c.Call.Return(run)
3338 return _c
3339}
3340
3341// UpdateSettings provides a mock function for the type MockEngine
3342func (_mock *MockEngine) UpdateSettings(ctx context.Context, update port.EngineSettingsUpdate) error {
3343 ret := _mock.Called(ctx, update)
3344
3345 if len(ret) == 0 {
3346 panic("no return value specified for UpdateSettings")
3347 }
3348
3349 var r0 error
3350 if returnFunc, ok := ret.Get(0).(func(context.Context, port.EngineSettingsUpdate) error); ok {
3351 r0 = returnFunc(ctx, update)
3352 } else {
3353 r0 = ret.Error(0)
3354 }
3355 return r0
3356}
3357
3358// MockEngine_UpdateSettings_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateSettings'
3359type MockEngine_UpdateSettings_Call struct {
3360 *mock.Call
3361}
3362
3363// UpdateSettings is a helper method to define mock.On call
3364// - ctx context.Context
3365// - update port.EngineSettingsUpdate
3366func (_e *MockEngine_Expecter) UpdateSettings(ctx interface{}, update interface{}) *MockEngine_UpdateSettings_Call {
3367 return &MockEngine_UpdateSettings_Call{Call: _e.mock.On("UpdateSettings", ctx, update)}
3368}
3369
3370func (_c *MockEngine_UpdateSettings_Call) Run(run func(ctx context.Context, update port.EngineSettingsUpdate)) *MockEngine_UpdateSettings_Call {
3371 _c.Call.Run(func(args mock.Arguments) {
3372 var arg0 context.Context
3373 if args[0] != nil {
3374 arg0 = args[0].(context.Context)
3375 }
3376 var arg1 port.EngineSettingsUpdate
3377 if args[1] != nil {
3378 arg1 = args[1].(port.EngineSettingsUpdate)
3379 }
3380 run(
3381 arg0,
3382 arg1,
3383 )
3384 })
3385 return _c
3386}
3387
3388func (_c *MockEngine_UpdateSettings_Call) Return(err error) *MockEngine_UpdateSettings_Call {
3389 _c.Call.Return(err)
3390 return _c
3391}
3392
3393func (_c *MockEngine_UpdateSettings_Call) RunAndReturn(run func(ctx context.Context, update port.EngineSettingsUpdate) error) *MockEngine_UpdateSettings_Call {
3394 _c.Call.Return(run)
3395 return _c
3396}
3397
3398// NewMockSchemeHandler creates a new instance of MockSchemeHandler. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
3399// The first argument is typically a *testing.T value.
3400func NewMockSchemeHandler(t interface {
3401 mock.TestingT
3402 Cleanup(func())
3403}) *MockSchemeHandler {
3404 mock := &MockSchemeHandler{}
3405 mock.Mock.Test(t)
3406
3407 t.Cleanup(func() { mock.AssertExpectations(t) })
3408
3409 return mock
3410}
3411
3412// MockSchemeHandler is an autogenerated mock type for the SchemeHandler type
3413type MockSchemeHandler struct {
3414 mock.Mock
3415}
3416
3417type MockSchemeHandler_Expecter struct {
3418 mock *mock.Mock
3419}
3420
3421func (_m *MockSchemeHandler) EXPECT() *MockSchemeHandler_Expecter {
3422 return &MockSchemeHandler_Expecter{mock: &_m.Mock}
3423}
3424
3425// RegisterScheme provides a mock function for the type MockSchemeHandler
3426func (_mock *MockSchemeHandler) RegisterScheme(scheme string, handler func(uri string) ([]byte, string, error)) {
3427 _mock.Called(scheme, handler)
3428 return
3429}
3430
3431// MockSchemeHandler_RegisterScheme_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterScheme'
3432type MockSchemeHandler_RegisterScheme_Call struct {
3433 *mock.Call
3434}
3435
3436// RegisterScheme is a helper method to define mock.On call
3437// - scheme string
3438// - handler func(uri string) ([]byte, string, error)
3439func (_e *MockSchemeHandler_Expecter) RegisterScheme(scheme interface{}, handler interface{}) *MockSchemeHandler_RegisterScheme_Call {
3440 return &MockSchemeHandler_RegisterScheme_Call{Call: _e.mock.On("RegisterScheme", scheme, handler)}
3441}
3442
3443func (_c *MockSchemeHandler_RegisterScheme_Call) Run(run func(scheme string, handler func(uri string) ([]byte, string, error))) *MockSchemeHandler_RegisterScheme_Call {
3444 _c.Call.Run(func(args mock.Arguments) {
3445 var arg0 string
3446 if args[0] != nil {
3447 arg0 = args[0].(string)
3448 }
3449 var arg1 func(uri string) ([]byte, string, error)
3450 if args[1] != nil {
3451 arg1 = args[1].(func(uri string) ([]byte, string, error))
3452 }
3453 run(
3454 arg0,
3455 arg1,
3456 )
3457 })
3458 return _c
3459}
3460
3461func (_c *MockSchemeHandler_RegisterScheme_Call) Return() *MockSchemeHandler_RegisterScheme_Call {
3462 _c.Call.Return()
3463 return _c
3464}
3465
3466func (_c *MockSchemeHandler_RegisterScheme_Call) RunAndReturn(run func(scheme string, handler func(uri string) ([]byte, string, error))) *MockSchemeHandler_RegisterScheme_Call {
3467 _c.Run(run)
3468 return _c
3469}
3470
3471// NewMockMessageRouter creates a new instance of MockMessageRouter. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
3472// The first argument is typically a *testing.T value.
3473func NewMockMessageRouter(t interface {
3474 mock.TestingT
3475 Cleanup(func())
3476}) *MockMessageRouter {
3477 mock := &MockMessageRouter{}
3478 mock.Mock.Test(t)
3479
3480 t.Cleanup(func() { mock.AssertExpectations(t) })
3481
3482 return mock
3483}
3484
3485// MockMessageRouter is an autogenerated mock type for the MessageRouter type
3486type MockMessageRouter struct {
3487 mock.Mock
3488}
3489
3490type MockMessageRouter_Expecter struct {
3491 mock *mock.Mock
3492}
3493
3494func (_m *MockMessageRouter) EXPECT() *MockMessageRouter_Expecter {
3495 return &MockMessageRouter_Expecter{mock: &_m.Mock}
3496}
3497
3498// PostMessage provides a mock function for the type MockMessageRouter
3499func (_mock *MockMessageRouter) PostMessage(webviewID port.WebViewID, message string) error {
3500 ret := _mock.Called(webviewID, message)
3501
3502 if len(ret) == 0 {
3503 panic("no return value specified for PostMessage")
3504 }
3505
3506 var r0 error
3507 if returnFunc, ok := ret.Get(0).(func(port.WebViewID, string) error); ok {
3508 r0 = returnFunc(webviewID, message)
3509 } else {
3510 r0 = ret.Error(0)
3511 }
3512 return r0
3513}
3514
3515// MockMessageRouter_PostMessage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PostMessage'
3516type MockMessageRouter_PostMessage_Call struct {
3517 *mock.Call
3518}
3519
3520// PostMessage is a helper method to define mock.On call
3521// - webviewID port.WebViewID
3522// - message string
3523func (_e *MockMessageRouter_Expecter) PostMessage(webviewID interface{}, message interface{}) *MockMessageRouter_PostMessage_Call {
3524 return &MockMessageRouter_PostMessage_Call{Call: _e.mock.On("PostMessage", webviewID, message)}
3525}
3526
3527func (_c *MockMessageRouter_PostMessage_Call) Run(run func(webviewID port.WebViewID, message string)) *MockMessageRouter_PostMessage_Call {
3528 _c.Call.Run(func(args mock.Arguments) {
3529 var arg0 port.WebViewID
3530 if args[0] != nil {
3531 arg0 = args[0].(port.WebViewID)
3532 }
3533 var arg1 string
3534 if args[1] != nil {
3535 arg1 = args[1].(string)
3536 }
3537 run(
3538 arg0,
3539 arg1,
3540 )
3541 })
3542 return _c
3543}
3544
3545func (_c *MockMessageRouter_PostMessage_Call) Return(err error) *MockMessageRouter_PostMessage_Call {
3546 _c.Call.Return(err)
3547 return _c
3548}
3549
3550func (_c *MockMessageRouter_PostMessage_Call) RunAndReturn(run func(webviewID port.WebViewID, message string) error) *MockMessageRouter_PostMessage_Call {
3551 _c.Call.Return(run)
3552 return _c
3553}
3554
3555// RegisterHandler provides a mock function for the type MockMessageRouter
3556func (_mock *MockMessageRouter) RegisterHandler(name string, handler func(message string) (string, error)) {
3557 _mock.Called(name, handler)
3558 return
3559}
3560
3561// MockMessageRouter_RegisterHandler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterHandler'
3562type MockMessageRouter_RegisterHandler_Call struct {
3563 *mock.Call
3564}
3565
3566// RegisterHandler is a helper method to define mock.On call
3567// - name string
3568// - handler func(message string) (string, error)
3569func (_e *MockMessageRouter_Expecter) RegisterHandler(name interface{}, handler interface{}) *MockMessageRouter_RegisterHandler_Call {
3570 return &MockMessageRouter_RegisterHandler_Call{Call: _e.mock.On("RegisterHandler", name, handler)}
3571}
3572
3573func (_c *MockMessageRouter_RegisterHandler_Call) Run(run func(name string, handler func(message string) (string, error))) *MockMessageRouter_RegisterHandler_Call {
3574 _c.Call.Run(func(args mock.Arguments) {
3575 var arg0 string
3576 if args[0] != nil {
3577 arg0 = args[0].(string)
3578 }
3579 var arg1 func(message string) (string, error)
3580 if args[1] != nil {
3581 arg1 = args[1].(func(message string) (string, error))
3582 }
3583 run(
3584 arg0,
3585 arg1,
3586 )
3587 })
3588 return _c
3589}
3590
3591func (_c *MockMessageRouter_RegisterHandler_Call) Return() *MockMessageRouter_RegisterHandler_Call {
3592 _c.Call.Return()
3593 return _c
3594}
3595
3596func (_c *MockMessageRouter_RegisterHandler_Call) RunAndReturn(run func(name string, handler func(message string) (string, error))) *MockMessageRouter_RegisterHandler_Call {
3597 _c.Run(run)
3598 return _c
3599}
3600
3601// NewMockSettingsApplier creates a new instance of MockSettingsApplier. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
3602// The first argument is typically a *testing.T value.
3603func NewMockSettingsApplier(t interface {
3604 mock.TestingT
3605 Cleanup(func())
3606}) *MockSettingsApplier {
3607 mock := &MockSettingsApplier{}
3608 mock.Mock.Test(t)
3609
3610 t.Cleanup(func() { mock.AssertExpectations(t) })
3611
3612 return mock
3613}
3614
3615// MockSettingsApplier is an autogenerated mock type for the SettingsApplier type
3616type MockSettingsApplier struct {
3617 mock.Mock
3618}
3619
3620type MockSettingsApplier_Expecter struct {
3621 mock *mock.Mock
3622}
3623
3624func (_m *MockSettingsApplier) EXPECT() *MockSettingsApplier_Expecter {
3625 return &MockSettingsApplier_Expecter{mock: &_m.Mock}
3626}
3627
3628// ApplyToAll provides a mock function for the type MockSettingsApplier
3629func (_mock *MockSettingsApplier) ApplyToAll(ctx context.Context, webviews []port.WebView) {
3630 _mock.Called(ctx, webviews)
3631 return
3632}
3633
3634// MockSettingsApplier_ApplyToAll_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ApplyToAll'
3635type MockSettingsApplier_ApplyToAll_Call struct {
3636 *mock.Call
3637}
3638
3639// ApplyToAll is a helper method to define mock.On call
3640// - ctx context.Context
3641// - webviews []port.WebView
3642func (_e *MockSettingsApplier_Expecter) ApplyToAll(ctx interface{}, webviews interface{}) *MockSettingsApplier_ApplyToAll_Call {
3643 return &MockSettingsApplier_ApplyToAll_Call{Call: _e.mock.On("ApplyToAll", ctx, webviews)}
3644}
3645
3646func (_c *MockSettingsApplier_ApplyToAll_Call) Run(run func(ctx context.Context, webviews []port.WebView)) *MockSettingsApplier_ApplyToAll_Call {
3647 _c.Call.Run(func(args mock.Arguments) {
3648 var arg0 context.Context
3649 if args[0] != nil {
3650 arg0 = args[0].(context.Context)
3651 }
3652 var arg1 []port.WebView
3653 if args[1] != nil {
3654 arg1 = args[1].([]port.WebView)
3655 }
3656 run(
3657 arg0,
3658 arg1,
3659 )
3660 })
3661 return _c
3662}
3663
3664func (_c *MockSettingsApplier_ApplyToAll_Call) Return() *MockSettingsApplier_ApplyToAll_Call {
3665 _c.Call.Return()
3666 return _c
3667}
3668
3669func (_c *MockSettingsApplier_ApplyToAll_Call) RunAndReturn(run func(ctx context.Context, webviews []port.WebView)) *MockSettingsApplier_ApplyToAll_Call {
3670 _c.Run(run)
3671 return _c
3672}
3673
3674// NewMockFilterApplier creates a new instance of MockFilterApplier. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
3675// The first argument is typically a *testing.T value.
3676func NewMockFilterApplier(t interface {
3677 mock.TestingT
3678 Cleanup(func())
3679}) *MockFilterApplier {
3680 mock := &MockFilterApplier{}
3681 mock.Mock.Test(t)
3682
3683 t.Cleanup(func() { mock.AssertExpectations(t) })
3684
3685 return mock
3686}
3687
3688// MockFilterApplier is an autogenerated mock type for the FilterApplier type
3689type MockFilterApplier struct {
3690 mock.Mock
3691}
3692
3693type MockFilterApplier_Expecter struct {
3694 mock *mock.Mock
3695}
3696
3697func (_m *MockFilterApplier) EXPECT() *MockFilterApplier_Expecter {
3698 return &MockFilterApplier_Expecter{mock: &_m.Mock}
3699}
3700
3701// ApplyToAll provides a mock function for the type MockFilterApplier
3702func (_mock *MockFilterApplier) ApplyToAll(ctx context.Context, webviews []port.WebView) {
3703 _mock.Called(ctx, webviews)
3704 return
3705}
3706
3707// MockFilterApplier_ApplyToAll_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ApplyToAll'
3708type MockFilterApplier_ApplyToAll_Call struct {
3709 *mock.Call
3710}
3711
3712// ApplyToAll is a helper method to define mock.On call
3713// - ctx context.Context
3714// - webviews []port.WebView
3715func (_e *MockFilterApplier_Expecter) ApplyToAll(ctx interface{}, webviews interface{}) *MockFilterApplier_ApplyToAll_Call {
3716 return &MockFilterApplier_ApplyToAll_Call{Call: _e.mock.On("ApplyToAll", ctx, webviews)}
3717}
3718
3719func (_c *MockFilterApplier_ApplyToAll_Call) Run(run func(ctx context.Context, webviews []port.WebView)) *MockFilterApplier_ApplyToAll_Call {
3720 _c.Call.Run(func(args mock.Arguments) {
3721 var arg0 context.Context
3722 if args[0] != nil {
3723 arg0 = args[0].(context.Context)
3724 }
3725 var arg1 []port.WebView
3726 if args[1] != nil {
3727 arg1 = args[1].([]port.WebView)
3728 }
3729 run(
3730 arg0,
3731 arg1,
3732 )
3733 })
3734 return _c
3735}
3736
3737func (_c *MockFilterApplier_ApplyToAll_Call) Return() *MockFilterApplier_ApplyToAll_Call {
3738 _c.Call.Return()
3739 return _c
3740}
3741
3742func (_c *MockFilterApplier_ApplyToAll_Call) RunAndReturn(run func(ctx context.Context, webviews []port.WebView)) *MockFilterApplier_ApplyToAll_Call {
3743 _c.Run(run)
3744 return _c
3745}
3746
3747// NewMockFaviconDatabase creates a new instance of MockFaviconDatabase. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
3748// The first argument is typically a *testing.T value.
3749func NewMockFaviconDatabase(t interface {
3750 mock.TestingT
3751 Cleanup(func())
3752}) *MockFaviconDatabase {
3753 mock := &MockFaviconDatabase{}
3754 mock.Mock.Test(t)
3755
3756 t.Cleanup(func() { mock.AssertExpectations(t) })
3757
3758 return mock
3759}
3760
3761// MockFaviconDatabase is an autogenerated mock type for the FaviconDatabase type
3762type MockFaviconDatabase struct {
3763 mock.Mock
3764}
3765
3766type MockFaviconDatabase_Expecter struct {
3767 mock *mock.Mock
3768}
3769
3770func (_m *MockFaviconDatabase) EXPECT() *MockFaviconDatabase_Expecter {
3771 return &MockFaviconDatabase_Expecter{mock: &_m.Mock}
3772}
3773
3774// GetFaviconAsync provides a mock function for the type MockFaviconDatabase
3775func (_mock *MockFaviconDatabase) GetFaviconAsync(pageURL string, callback func(port.Texture)) {
3776 _mock.Called(pageURL, callback)
3777 return
3778}
3779
3780// MockFaviconDatabase_GetFaviconAsync_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetFaviconAsync'
3781type MockFaviconDatabase_GetFaviconAsync_Call struct {
3782 *mock.Call
3783}
3784
3785// GetFaviconAsync is a helper method to define mock.On call
3786// - pageURL string
3787// - callback func(port.Texture)
3788func (_e *MockFaviconDatabase_Expecter) GetFaviconAsync(pageURL interface{}, callback interface{}) *MockFaviconDatabase_GetFaviconAsync_Call {
3789 return &MockFaviconDatabase_GetFaviconAsync_Call{Call: _e.mock.On("GetFaviconAsync", pageURL, callback)}
3790}
3791
3792func (_c *MockFaviconDatabase_GetFaviconAsync_Call) Run(run func(pageURL string, callback func(port.Texture))) *MockFaviconDatabase_GetFaviconAsync_Call {
3793 _c.Call.Run(func(args mock.Arguments) {
3794 var arg0 string
3795 if args[0] != nil {
3796 arg0 = args[0].(string)
3797 }
3798 var arg1 func(port.Texture)
3799 if args[1] != nil {
3800 arg1 = args[1].(func(port.Texture))
3801 }
3802 run(
3803 arg0,
3804 arg1,
3805 )
3806 })
3807 return _c
3808}
3809
3810func (_c *MockFaviconDatabase_GetFaviconAsync_Call) Return() *MockFaviconDatabase_GetFaviconAsync_Call {
3811 _c.Call.Return()
3812 return _c
3813}
3814
3815func (_c *MockFaviconDatabase_GetFaviconAsync_Call) RunAndReturn(run func(pageURL string, callback func(port.Texture))) *MockFaviconDatabase_GetFaviconAsync_Call {
3816 _c.Run(run)
3817 return _c
3818}
3819
3820// NewMockScriptRefresher creates a new instance of MockScriptRefresher. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
3821// The first argument is typically a *testing.T value.
3822func NewMockScriptRefresher(t interface {
3823 mock.TestingT
3824 Cleanup(func())
3825}) *MockScriptRefresher {
3826 mock := &MockScriptRefresher{}
3827 mock.Mock.Test(t)
3828
3829 t.Cleanup(func() { mock.AssertExpectations(t) })
3830
3831 return mock
3832}
3833
3834// MockScriptRefresher is an autogenerated mock type for the ScriptRefresher type
3835type MockScriptRefresher struct {
3836 mock.Mock
3837}
3838
3839type MockScriptRefresher_Expecter struct {
3840 mock *mock.Mock
3841}
3842
3843func (_m *MockScriptRefresher) EXPECT() *MockScriptRefresher_Expecter {
3844 return &MockScriptRefresher_Expecter{mock: &_m.Mock}
3845}
3846
3847// RefreshAll provides a mock function for the type MockScriptRefresher
3848func (_mock *MockScriptRefresher) RefreshAll(ctx context.Context, webviews []port.WebView) {
3849 _mock.Called(ctx, webviews)
3850 return
3851}
3852
3853// MockScriptRefresher_RefreshAll_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RefreshAll'
3854type MockScriptRefresher_RefreshAll_Call struct {
3855 *mock.Call
3856}
3857
3858// RefreshAll is a helper method to define mock.On call
3859// - ctx context.Context
3860// - webviews []port.WebView
3861func (_e *MockScriptRefresher_Expecter) RefreshAll(ctx interface{}, webviews interface{}) *MockScriptRefresher_RefreshAll_Call {
3862 return &MockScriptRefresher_RefreshAll_Call{Call: _e.mock.On("RefreshAll", ctx, webviews)}
3863}
3864
3865func (_c *MockScriptRefresher_RefreshAll_Call) Run(run func(ctx context.Context, webviews []port.WebView)) *MockScriptRefresher_RefreshAll_Call {
3866 _c.Call.Run(func(args mock.Arguments) {
3867 var arg0 context.Context
3868 if args[0] != nil {
3869 arg0 = args[0].(context.Context)
3870 }
3871 var arg1 []port.WebView
3872 if args[1] != nil {
3873 arg1 = args[1].([]port.WebView)
3874 }
3875 run(
3876 arg0,
3877 arg1,
3878 )
3879 })
3880 return _c
3881}
3882
3883func (_c *MockScriptRefresher_RefreshAll_Call) Return() *MockScriptRefresher_RefreshAll_Call {
3884 _c.Call.Return()
3885 return _c
3886}
3887
3888func (_c *MockScriptRefresher_RefreshAll_Call) RunAndReturn(run func(ctx context.Context, webviews []port.WebView)) *MockScriptRefresher_RefreshAll_Call {
3889 _c.Run(run)
3890 return _c
3891}
3892
3893// NewMockNativeWidgetProvider creates a new instance of MockNativeWidgetProvider. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
3894// The first argument is typically a *testing.T value.
3895func NewMockNativeWidgetProvider(t interface {
3896 mock.TestingT
3897 Cleanup(func())
3898}) *MockNativeWidgetProvider {
3899 mock := &MockNativeWidgetProvider{}
3900 mock.Mock.Test(t)
3901
3902 t.Cleanup(func() { mock.AssertExpectations(t) })
3903
3904 return mock
3905}
3906
3907// MockNativeWidgetProvider is an autogenerated mock type for the NativeWidgetProvider type
3908type MockNativeWidgetProvider struct {
3909 mock.Mock
3910}
3911
3912type MockNativeWidgetProvider_Expecter struct {
3913 mock *mock.Mock
3914}
3915
3916func (_m *MockNativeWidgetProvider) EXPECT() *MockNativeWidgetProvider_Expecter {
3917 return &MockNativeWidgetProvider_Expecter{mock: &_m.Mock}
3918}
3919
3920// NativeWidget provides a mock function for the type MockNativeWidgetProvider
3921func (_mock *MockNativeWidgetProvider) NativeWidget() uintptr {
3922 ret := _mock.Called()
3923
3924 if len(ret) == 0 {
3925 panic("no return value specified for NativeWidget")
3926 }
3927
3928 var r0 uintptr
3929 if returnFunc, ok := ret.Get(0).(func() uintptr); ok {
3930 r0 = returnFunc()
3931 } else {
3932 r0 = ret.Get(0).(uintptr)
3933 }
3934 return r0
3935}
3936
3937// MockNativeWidgetProvider_NativeWidget_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NativeWidget'
3938type MockNativeWidgetProvider_NativeWidget_Call struct {
3939 *mock.Call
3940}
3941
3942// NativeWidget is a helper method to define mock.On call
3943func (_e *MockNativeWidgetProvider_Expecter) NativeWidget() *MockNativeWidgetProvider_NativeWidget_Call {
3944 return &MockNativeWidgetProvider_NativeWidget_Call{Call: _e.mock.On("NativeWidget")}
3945}
3946
3947func (_c *MockNativeWidgetProvider_NativeWidget_Call) Run(run func()) *MockNativeWidgetProvider_NativeWidget_Call {
3948 _c.Call.Run(func(args mock.Arguments) {
3949 run()
3950 })
3951 return _c
3952}
3953
3954func (_c *MockNativeWidgetProvider_NativeWidget_Call) Return(v uintptr) *MockNativeWidgetProvider_NativeWidget_Call {
3955 _c.Call.Return(v)
3956 return _c
3957}
3958
3959func (_c *MockNativeWidgetProvider_NativeWidget_Call) RunAndReturn(run func() uintptr) *MockNativeWidgetProvider_NativeWidget_Call {
3960 _c.Call.Return(run)
3961 return _c
3962}
3963
3964// NewMockFaviconService creates a new instance of MockFaviconService. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
3965// The first argument is typically a *testing.T value.
3966func NewMockFaviconService(t interface {
3967 mock.TestingT
3968 Cleanup(func())
3969}) *MockFaviconService {
3970 mock := &MockFaviconService{}
3971 mock.Mock.Test(t)
3972
3973 t.Cleanup(func() { mock.AssertExpectations(t) })
3974
3975 return mock
3976}
3977
3978// MockFaviconService is an autogenerated mock type for the FaviconService type
3979type MockFaviconService struct {
3980 mock.Mock
3981}
3982
3983type MockFaviconService_Expecter struct {
3984 mock *mock.Mock
3985}
3986
3987func (_m *MockFaviconService) EXPECT() *MockFaviconService_Expecter {
3988 return &MockFaviconService_Expecter{mock: &_m.Mock}
3989}
3990
3991// Close provides a mock function for the type MockFaviconService
3992func (_mock *MockFaviconService) Close() {
3993 _mock.Called()
3994 return
3995}
3996
3997// MockFaviconService_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
3998type MockFaviconService_Close_Call struct {
3999 *mock.Call
4000}
4001
4002// Close is a helper method to define mock.On call
4003func (_e *MockFaviconService_Expecter) Close() *MockFaviconService_Close_Call {
4004 return &MockFaviconService_Close_Call{Call: _e.mock.On("Close")}
4005}
4006
4007func (_c *MockFaviconService_Close_Call) Run(run func()) *MockFaviconService_Close_Call {
4008 _c.Call.Run(func(args mock.Arguments) {
4009 run()
4010 })
4011 return _c
4012}
4013
4014func (_c *MockFaviconService_Close_Call) Return() *MockFaviconService_Close_Call {
4015 _c.Call.Return()
4016 return _c
4017}
4018
4019func (_c *MockFaviconService_Close_Call) RunAndReturn(run func()) *MockFaviconService_Close_Call {
4020 _c.Run(run)
4021 return _c
4022}
4023
4024// DiskPathPNG provides a mock function for the type MockFaviconService
4025func (_mock *MockFaviconService) DiskPathPNG(domain string) string {
4026 ret := _mock.Called(domain)
4027
4028 if len(ret) == 0 {
4029 panic("no return value specified for DiskPathPNG")
4030 }
4031
4032 var r0 string
4033 if returnFunc, ok := ret.Get(0).(func(string) string); ok {
4034 r0 = returnFunc(domain)
4035 } else {
4036 r0 = ret.Get(0).(string)
4037 }
4038 return r0
4039}
4040
4041// MockFaviconService_DiskPathPNG_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DiskPathPNG'
4042type MockFaviconService_DiskPathPNG_Call struct {
4043 *mock.Call
4044}
4045
4046// DiskPathPNG is a helper method to define mock.On call
4047// - domain string
4048func (_e *MockFaviconService_Expecter) DiskPathPNG(domain interface{}) *MockFaviconService_DiskPathPNG_Call {
4049 return &MockFaviconService_DiskPathPNG_Call{Call: _e.mock.On("DiskPathPNG", domain)}
4050}
4051
4052func (_c *MockFaviconService_DiskPathPNG_Call) Run(run func(domain string)) *MockFaviconService_DiskPathPNG_Call {
4053 _c.Call.Run(func(args mock.Arguments) {
4054 var arg0 string
4055 if args[0] != nil {
4056 arg0 = args[0].(string)
4057 }
4058 run(
4059 arg0,
4060 )
4061 })
4062 return _c
4063}
4064
4065func (_c *MockFaviconService_DiskPathPNG_Call) Return(s string) *MockFaviconService_DiskPathPNG_Call {
4066 _c.Call.Return(s)
4067 return _c
4068}
4069
4070func (_c *MockFaviconService_DiskPathPNG_Call) RunAndReturn(run func(domain string) string) *MockFaviconService_DiskPathPNG_Call {
4071 _c.Call.Return(run)
4072 return _c
4073}
4074
4075// EnsureCacheDir provides a mock function for the type MockFaviconService
4076func (_mock *MockFaviconService) EnsureCacheDir() error {
4077 ret := _mock.Called()
4078
4079 if len(ret) == 0 {
4080 panic("no return value specified for EnsureCacheDir")
4081 }
4082
4083 var r0 error
4084 if returnFunc, ok := ret.Get(0).(func() error); ok {
4085 r0 = returnFunc()
4086 } else {
4087 r0 = ret.Error(0)
4088 }
4089 return r0
4090}
4091
4092// MockFaviconService_EnsureCacheDir_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EnsureCacheDir'
4093type MockFaviconService_EnsureCacheDir_Call struct {
4094 *mock.Call
4095}
4096
4097// EnsureCacheDir is a helper method to define mock.On call
4098func (_e *MockFaviconService_Expecter) EnsureCacheDir() *MockFaviconService_EnsureCacheDir_Call {
4099 return &MockFaviconService_EnsureCacheDir_Call{Call: _e.mock.On("EnsureCacheDir")}
4100}
4101
4102func (_c *MockFaviconService_EnsureCacheDir_Call) Run(run func()) *MockFaviconService_EnsureCacheDir_Call {
4103 _c.Call.Run(func(args mock.Arguments) {
4104 run()
4105 })
4106 return _c
4107}
4108
4109func (_c *MockFaviconService_EnsureCacheDir_Call) Return(err error) *MockFaviconService_EnsureCacheDir_Call {
4110 _c.Call.Return(err)
4111 return _c
4112}
4113
4114func (_c *MockFaviconService_EnsureCacheDir_Call) RunAndReturn(run func() error) *MockFaviconService_EnsureCacheDir_Call {
4115 _c.Call.Return(run)
4116 return _c
4117}
4118
4119// EnsureDiskCache provides a mock function for the type MockFaviconService
4120func (_mock *MockFaviconService) EnsureDiskCache(ctx context.Context, domain string) {
4121 _mock.Called(ctx, domain)
4122 return
4123}
4124
4125// MockFaviconService_EnsureDiskCache_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EnsureDiskCache'
4126type MockFaviconService_EnsureDiskCache_Call struct {
4127 *mock.Call
4128}
4129
4130// EnsureDiskCache is a helper method to define mock.On call
4131// - ctx context.Context
4132// - domain string
4133func (_e *MockFaviconService_Expecter) EnsureDiskCache(ctx interface{}, domain interface{}) *MockFaviconService_EnsureDiskCache_Call {
4134 return &MockFaviconService_EnsureDiskCache_Call{Call: _e.mock.On("EnsureDiskCache", ctx, domain)}
4135}
4136
4137func (_c *MockFaviconService_EnsureDiskCache_Call) Run(run func(ctx context.Context, domain string)) *MockFaviconService_EnsureDiskCache_Call {
4138 _c.Call.Run(func(args mock.Arguments) {
4139 var arg0 context.Context
4140 if args[0] != nil {
4141 arg0 = args[0].(context.Context)
4142 }
4143 var arg1 string
4144 if args[1] != nil {
4145 arg1 = args[1].(string)
4146 }
4147 run(
4148 arg0,
4149 arg1,
4150 )
4151 })
4152 return _c
4153}
4154
4155func (_c *MockFaviconService_EnsureDiskCache_Call) Return() *MockFaviconService_EnsureDiskCache_Call {
4156 _c.Call.Return()
4157 return _c
4158}
4159
4160func (_c *MockFaviconService_EnsureDiskCache_Call) RunAndReturn(run func(ctx context.Context, domain string)) *MockFaviconService_EnsureDiskCache_Call {
4161 _c.Run(run)
4162 return _c
4163}
4164
4165// EnsureSizedPNG provides a mock function for the type MockFaviconService
4166func (_mock *MockFaviconService) EnsureSizedPNG(ctx context.Context, domain string, size int) error {
4167 ret := _mock.Called(ctx, domain, size)
4168
4169 if len(ret) == 0 {
4170 panic("no return value specified for EnsureSizedPNG")
4171 }
4172
4173 var r0 error
4174 if returnFunc, ok := ret.Get(0).(func(context.Context, string, int) error); ok {
4175 r0 = returnFunc(ctx, domain, size)
4176 } else {
4177 r0 = ret.Error(0)
4178 }
4179 return r0
4180}
4181
4182// MockFaviconService_EnsureSizedPNG_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EnsureSizedPNG'
4183type MockFaviconService_EnsureSizedPNG_Call struct {
4184 *mock.Call
4185}
4186
4187// EnsureSizedPNG is a helper method to define mock.On call
4188// - ctx context.Context
4189// - domain string
4190// - size int
4191func (_e *MockFaviconService_Expecter) EnsureSizedPNG(ctx interface{}, domain interface{}, size interface{}) *MockFaviconService_EnsureSizedPNG_Call {
4192 return &MockFaviconService_EnsureSizedPNG_Call{Call: _e.mock.On("EnsureSizedPNG", ctx, domain, size)}
4193}
4194
4195func (_c *MockFaviconService_EnsureSizedPNG_Call) Run(run func(ctx context.Context, domain string, size int)) *MockFaviconService_EnsureSizedPNG_Call {
4196 _c.Call.Run(func(args mock.Arguments) {
4197 var arg0 context.Context
4198 if args[0] != nil {
4199 arg0 = args[0].(context.Context)
4200 }
4201 var arg1 string
4202 if args[1] != nil {
4203 arg1 = args[1].(string)
4204 }
4205 var arg2 int
4206 if args[2] != nil {
4207 arg2 = args[2].(int)
4208 }
4209 run(
4210 arg0,
4211 arg1,
4212 arg2,
4213 )
4214 })
4215 return _c
4216}
4217
4218func (_c *MockFaviconService_EnsureSizedPNG_Call) Return(err error) *MockFaviconService_EnsureSizedPNG_Call {
4219 _c.Call.Return(err)
4220 return _c
4221}
4222
4223func (_c *MockFaviconService_EnsureSizedPNG_Call) RunAndReturn(run func(ctx context.Context, domain string, size int) error) *MockFaviconService_EnsureSizedPNG_Call {
4224 _c.Call.Return(run)
4225 return _c
4226}
4227
4228// Get provides a mock function for the type MockFaviconService
4229func (_mock *MockFaviconService) Get(ctx context.Context, domain string) ([]byte, error) {
4230 ret := _mock.Called(ctx, domain)
4231
4232 if len(ret) == 0 {
4233 panic("no return value specified for Get")
4234 }
4235
4236 var r0 []byte
4237 var r1 error
4238 if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]byte, error)); ok {
4239 return returnFunc(ctx, domain)
4240 }
4241 if returnFunc, ok := ret.Get(0).(func(context.Context, string) []byte); ok {
4242 r0 = returnFunc(ctx, domain)
4243 } else {
4244 if ret.Get(0) != nil {
4245 r0 = ret.Get(0).([]byte)
4246 }
4247 }
4248 if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
4249 r1 = returnFunc(ctx, domain)
4250 } else {
4251 r1 = ret.Error(1)
4252 }
4253 return r0, r1
4254}
4255
4256// MockFaviconService_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get'
4257type MockFaviconService_Get_Call struct {
4258 *mock.Call
4259}
4260
4261// Get is a helper method to define mock.On call
4262// - ctx context.Context
4263// - domain string
4264func (_e *MockFaviconService_Expecter) Get(ctx interface{}, domain interface{}) *MockFaviconService_Get_Call {
4265 return &MockFaviconService_Get_Call{Call: _e.mock.On("Get", ctx, domain)}
4266}
4267
4268func (_c *MockFaviconService_Get_Call) Run(run func(ctx context.Context, domain string)) *MockFaviconService_Get_Call {
4269 _c.Call.Run(func(args mock.Arguments) {
4270 var arg0 context.Context
4271 if args[0] != nil {
4272 arg0 = args[0].(context.Context)
4273 }
4274 var arg1 string
4275 if args[1] != nil {
4276 arg1 = args[1].(string)
4277 }
4278 run(
4279 arg0,
4280 arg1,
4281 )
4282 })
4283 return _c
4284}
4285
4286func (_c *MockFaviconService_Get_Call) Return(bytes []byte, err error) *MockFaviconService_Get_Call {
4287 _c.Call.Return(bytes, err)
4288 return _c
4289}
4290
4291func (_c *MockFaviconService_Get_Call) RunAndReturn(run func(ctx context.Context, domain string) ([]byte, error)) *MockFaviconService_Get_Call {
4292 _c.Call.Return(run)
4293 return _c
4294}
4295
4296// GetCached provides a mock function for the type MockFaviconService
4297func (_mock *MockFaviconService) GetCached(domain string) ([]byte, bool) {
4298 ret := _mock.Called(domain)
4299
4300 if len(ret) == 0 {
4301 panic("no return value specified for GetCached")
4302 }
4303
4304 var r0 []byte
4305 var r1 bool
4306 if returnFunc, ok := ret.Get(0).(func(string) ([]byte, bool)); ok {
4307 return returnFunc(domain)
4308 }
4309 if returnFunc, ok := ret.Get(0).(func(string) []byte); ok {
4310 r0 = returnFunc(domain)
4311 } else {
4312 if ret.Get(0) != nil {
4313 r0 = ret.Get(0).([]byte)
4314 }
4315 }
4316 if returnFunc, ok := ret.Get(1).(func(string) bool); ok {
4317 r1 = returnFunc(domain)
4318 } else {
4319 r1 = ret.Get(1).(bool)
4320 }
4321 return r0, r1
4322}
4323
4324// MockFaviconService_GetCached_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetCached'
4325type MockFaviconService_GetCached_Call struct {
4326 *mock.Call
4327}
4328
4329// GetCached is a helper method to define mock.On call
4330// - domain string
4331func (_e *MockFaviconService_Expecter) GetCached(domain interface{}) *MockFaviconService_GetCached_Call {
4332 return &MockFaviconService_GetCached_Call{Call: _e.mock.On("GetCached", domain)}
4333}
4334
4335func (_c *MockFaviconService_GetCached_Call) Run(run func(domain string)) *MockFaviconService_GetCached_Call {
4336 _c.Call.Run(func(args mock.Arguments) {
4337 var arg0 string
4338 if args[0] != nil {
4339 arg0 = args[0].(string)
4340 }
4341 run(
4342 arg0,
4343 )
4344 })
4345 return _c
4346}
4347
4348func (_c *MockFaviconService_GetCached_Call) Return(bytes []byte, b bool) *MockFaviconService_GetCached_Call {
4349 _c.Call.Return(bytes, b)
4350 return _c
4351}
4352
4353func (_c *MockFaviconService_GetCached_Call) RunAndReturn(run func(domain string) ([]byte, bool)) *MockFaviconService_GetCached_Call {
4354 _c.Call.Return(run)
4355 return _c
4356}
4357
4358// HasPNGOnDisk provides a mock function for the type MockFaviconService
4359func (_mock *MockFaviconService) HasPNGOnDisk(domain string) bool {
4360 ret := _mock.Called(domain)
4361
4362 if len(ret) == 0 {
4363 panic("no return value specified for HasPNGOnDisk")
4364 }
4365
4366 var r0 bool
4367 if returnFunc, ok := ret.Get(0).(func(string) bool); ok {
4368 r0 = returnFunc(domain)
4369 } else {
4370 r0 = ret.Get(0).(bool)
4371 }
4372 return r0
4373}
4374
4375// MockFaviconService_HasPNGOnDisk_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasPNGOnDisk'
4376type MockFaviconService_HasPNGOnDisk_Call struct {
4377 *mock.Call
4378}
4379
4380// HasPNGOnDisk is a helper method to define mock.On call
4381// - domain string
4382func (_e *MockFaviconService_Expecter) HasPNGOnDisk(domain interface{}) *MockFaviconService_HasPNGOnDisk_Call {
4383 return &MockFaviconService_HasPNGOnDisk_Call{Call: _e.mock.On("HasPNGOnDisk", domain)}
4384}
4385
4386func (_c *MockFaviconService_HasPNGOnDisk_Call) Run(run func(domain string)) *MockFaviconService_HasPNGOnDisk_Call {
4387 _c.Call.Run(func(args mock.Arguments) {
4388 var arg0 string
4389 if args[0] != nil {
4390 arg0 = args[0].(string)
4391 }
4392 run(
4393 arg0,
4394 )
4395 })
4396 return _c
4397}
4398
4399func (_c *MockFaviconService_HasPNGOnDisk_Call) Return(b bool) *MockFaviconService_HasPNGOnDisk_Call {
4400 _c.Call.Return(b)
4401 return _c
4402}
4403
4404func (_c *MockFaviconService_HasPNGOnDisk_Call) RunAndReturn(run func(domain string) bool) *MockFaviconService_HasPNGOnDisk_Call {
4405 _c.Call.Return(run)
4406 return _c
4407}
4408
4409// HasPNGSizedOnDisk provides a mock function for the type MockFaviconService
4410func (_mock *MockFaviconService) HasPNGSizedOnDisk(domain string, size int) bool {
4411 ret := _mock.Called(domain, size)
4412
4413 if len(ret) == 0 {
4414 panic("no return value specified for HasPNGSizedOnDisk")
4415 }
4416
4417 var r0 bool
4418 if returnFunc, ok := ret.Get(0).(func(string, int) bool); ok {
4419 r0 = returnFunc(domain, size)
4420 } else {
4421 r0 = ret.Get(0).(bool)
4422 }
4423 return r0
4424}
4425
4426// MockFaviconService_HasPNGSizedOnDisk_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasPNGSizedOnDisk'
4427type MockFaviconService_HasPNGSizedOnDisk_Call struct {
4428 *mock.Call
4429}
4430
4431// HasPNGSizedOnDisk is a helper method to define mock.On call
4432// - domain string
4433// - size int
4434func (_e *MockFaviconService_Expecter) HasPNGSizedOnDisk(domain interface{}, size interface{}) *MockFaviconService_HasPNGSizedOnDisk_Call {
4435 return &MockFaviconService_HasPNGSizedOnDisk_Call{Call: _e.mock.On("HasPNGSizedOnDisk", domain, size)}
4436}
4437
4438func (_c *MockFaviconService_HasPNGSizedOnDisk_Call) Run(run func(domain string, size int)) *MockFaviconService_HasPNGSizedOnDisk_Call {
4439 _c.Call.Run(func(args mock.Arguments) {
4440 var arg0 string
4441 if args[0] != nil {
4442 arg0 = args[0].(string)
4443 }
4444 var arg1 int
4445 if args[1] != nil {
4446 arg1 = args[1].(int)
4447 }
4448 run(
4449 arg0,
4450 arg1,
4451 )
4452 })
4453 return _c
4454}
4455
4456func (_c *MockFaviconService_HasPNGSizedOnDisk_Call) Return(b bool) *MockFaviconService_HasPNGSizedOnDisk_Call {
4457 _c.Call.Return(b)
4458 return _c
4459}
4460
4461func (_c *MockFaviconService_HasPNGSizedOnDisk_Call) RunAndReturn(run func(domain string, size int) bool) *MockFaviconService_HasPNGSizedOnDisk_Call {
4462 _c.Call.Return(run)
4463 return _c
4464}
4465
4466// NewMockFileSystem creates a new instance of MockFileSystem. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
4467// The first argument is typically a *testing.T value.
4468func NewMockFileSystem(t interface {
4469 mock.TestingT
4470 Cleanup(func())
4471}) *MockFileSystem {
4472 mock := &MockFileSystem{}
4473 mock.Mock.Test(t)
4474
4475 t.Cleanup(func() { mock.AssertExpectations(t) })
4476
4477 return mock
4478}
4479
4480// MockFileSystem is an autogenerated mock type for the FileSystem type
4481type MockFileSystem struct {
4482 mock.Mock
4483}
4484
4485type MockFileSystem_Expecter struct {
4486 mock *mock.Mock
4487}
4488
4489func (_m *MockFileSystem) EXPECT() *MockFileSystem_Expecter {
4490 return &MockFileSystem_Expecter{mock: &_m.Mock}
4491}
4492
4493// Exists provides a mock function for the type MockFileSystem
4494func (_mock *MockFileSystem) Exists(ctx context.Context, path string) (bool, error) {
4495 ret := _mock.Called(ctx, path)
4496
4497 if len(ret) == 0 {
4498 panic("no return value specified for Exists")
4499 }
4500
4501 var r0 bool
4502 var r1 error
4503 if returnFunc, ok := ret.Get(0).(func(context.Context, string) (bool, error)); ok {
4504 return returnFunc(ctx, path)
4505 }
4506 if returnFunc, ok := ret.Get(0).(func(context.Context, string) bool); ok {
4507 r0 = returnFunc(ctx, path)
4508 } else {
4509 r0 = ret.Get(0).(bool)
4510 }
4511 if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
4512 r1 = returnFunc(ctx, path)
4513 } else {
4514 r1 = ret.Error(1)
4515 }
4516 return r0, r1
4517}
4518
4519// MockFileSystem_Exists_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Exists'
4520type MockFileSystem_Exists_Call struct {
4521 *mock.Call
4522}
4523
4524// Exists is a helper method to define mock.On call
4525// - ctx context.Context
4526// - path string
4527func (_e *MockFileSystem_Expecter) Exists(ctx interface{}, path interface{}) *MockFileSystem_Exists_Call {
4528 return &MockFileSystem_Exists_Call{Call: _e.mock.On("Exists", ctx, path)}
4529}
4530
4531func (_c *MockFileSystem_Exists_Call) Run(run func(ctx context.Context, path string)) *MockFileSystem_Exists_Call {
4532 _c.Call.Run(func(args mock.Arguments) {
4533 var arg0 context.Context
4534 if args[0] != nil {
4535 arg0 = args[0].(context.Context)
4536 }
4537 var arg1 string
4538 if args[1] != nil {
4539 arg1 = args[1].(string)
4540 }
4541 run(
4542 arg0,
4543 arg1,
4544 )
4545 })
4546 return _c
4547}
4548
4549func (_c *MockFileSystem_Exists_Call) Return(b bool, err error) *MockFileSystem_Exists_Call {
4550 _c.Call.Return(b, err)
4551 return _c
4552}
4553
4554func (_c *MockFileSystem_Exists_Call) RunAndReturn(run func(ctx context.Context, path string) (bool, error)) *MockFileSystem_Exists_Call {
4555 _c.Call.Return(run)
4556 return _c
4557}
4558
4559// GetSize provides a mock function for the type MockFileSystem
4560func (_mock *MockFileSystem) GetSize(ctx context.Context, path string) (int64, error) {
4561 ret := _mock.Called(ctx, path)
4562
4563 if len(ret) == 0 {
4564 panic("no return value specified for GetSize")
4565 }
4566
4567 var r0 int64
4568 var r1 error
4569 if returnFunc, ok := ret.Get(0).(func(context.Context, string) (int64, error)); ok {
4570 return returnFunc(ctx, path)
4571 }
4572 if returnFunc, ok := ret.Get(0).(func(context.Context, string) int64); ok {
4573 r0 = returnFunc(ctx, path)
4574 } else {
4575 r0 = ret.Get(0).(int64)
4576 }
4577 if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
4578 r1 = returnFunc(ctx, path)
4579 } else {
4580 r1 = ret.Error(1)
4581 }
4582 return r0, r1
4583}
4584
4585// MockFileSystem_GetSize_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSize'
4586type MockFileSystem_GetSize_Call struct {
4587 *mock.Call
4588}
4589
4590// GetSize is a helper method to define mock.On call
4591// - ctx context.Context
4592// - path string
4593func (_e *MockFileSystem_Expecter) GetSize(ctx interface{}, path interface{}) *MockFileSystem_GetSize_Call {
4594 return &MockFileSystem_GetSize_Call{Call: _e.mock.On("GetSize", ctx, path)}
4595}
4596
4597func (_c *MockFileSystem_GetSize_Call) Run(run func(ctx context.Context, path string)) *MockFileSystem_GetSize_Call {
4598 _c.Call.Run(func(args mock.Arguments) {
4599 var arg0 context.Context
4600 if args[0] != nil {
4601 arg0 = args[0].(context.Context)
4602 }
4603 var arg1 string
4604 if args[1] != nil {
4605 arg1 = args[1].(string)
4606 }
4607 run(
4608 arg0,
4609 arg1,
4610 )
4611 })
4612 return _c
4613}
4614
4615func (_c *MockFileSystem_GetSize_Call) Return(n int64, err error) *MockFileSystem_GetSize_Call {
4616 _c.Call.Return(n, err)
4617 return _c
4618}
4619
4620func (_c *MockFileSystem_GetSize_Call) RunAndReturn(run func(ctx context.Context, path string) (int64, error)) *MockFileSystem_GetSize_Call {
4621 _c.Call.Return(run)
4622 return _c
4623}
4624
4625// IsDirectory provides a mock function for the type MockFileSystem
4626func (_mock *MockFileSystem) IsDirectory(ctx context.Context, path string) (bool, error) {
4627 ret := _mock.Called(ctx, path)
4628
4629 if len(ret) == 0 {
4630 panic("no return value specified for IsDirectory")
4631 }
4632
4633 var r0 bool
4634 var r1 error
4635 if returnFunc, ok := ret.Get(0).(func(context.Context, string) (bool, error)); ok {
4636 return returnFunc(ctx, path)
4637 }
4638 if returnFunc, ok := ret.Get(0).(func(context.Context, string) bool); ok {
4639 r0 = returnFunc(ctx, path)
4640 } else {
4641 r0 = ret.Get(0).(bool)
4642 }
4643 if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
4644 r1 = returnFunc(ctx, path)
4645 } else {
4646 r1 = ret.Error(1)
4647 }
4648 return r0, r1
4649}
4650
4651// MockFileSystem_IsDirectory_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsDirectory'
4652type MockFileSystem_IsDirectory_Call struct {
4653 *mock.Call
4654}
4655
4656// IsDirectory is a helper method to define mock.On call
4657// - ctx context.Context
4658// - path string
4659func (_e *MockFileSystem_Expecter) IsDirectory(ctx interface{}, path interface{}) *MockFileSystem_IsDirectory_Call {
4660 return &MockFileSystem_IsDirectory_Call{Call: _e.mock.On("IsDirectory", ctx, path)}
4661}
4662
4663func (_c *MockFileSystem_IsDirectory_Call) Run(run func(ctx context.Context, path string)) *MockFileSystem_IsDirectory_Call {
4664 _c.Call.Run(func(args mock.Arguments) {
4665 var arg0 context.Context
4666 if args[0] != nil {
4667 arg0 = args[0].(context.Context)
4668 }
4669 var arg1 string
4670 if args[1] != nil {
4671 arg1 = args[1].(string)
4672 }
4673 run(
4674 arg0,
4675 arg1,
4676 )
4677 })
4678 return _c
4679}
4680
4681func (_c *MockFileSystem_IsDirectory_Call) Return(b bool, err error) *MockFileSystem_IsDirectory_Call {
4682 _c.Call.Return(b, err)
4683 return _c
4684}
4685
4686func (_c *MockFileSystem_IsDirectory_Call) RunAndReturn(run func(ctx context.Context, path string) (bool, error)) *MockFileSystem_IsDirectory_Call {
4687 _c.Call.Return(run)
4688 return _c
4689}
4690
4691// RemoveAll provides a mock function for the type MockFileSystem
4692func (_mock *MockFileSystem) RemoveAll(ctx context.Context, path string) error {
4693 ret := _mock.Called(ctx, path)
4694
4695 if len(ret) == 0 {
4696 panic("no return value specified for RemoveAll")
4697 }
4698
4699 var r0 error
4700 if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
4701 r0 = returnFunc(ctx, path)
4702 } else {
4703 r0 = ret.Error(0)
4704 }
4705 return r0
4706}
4707
4708// MockFileSystem_RemoveAll_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveAll'
4709type MockFileSystem_RemoveAll_Call struct {
4710 *mock.Call
4711}
4712
4713// RemoveAll is a helper method to define mock.On call
4714// - ctx context.Context
4715// - path string
4716func (_e *MockFileSystem_Expecter) RemoveAll(ctx interface{}, path interface{}) *MockFileSystem_RemoveAll_Call {
4717 return &MockFileSystem_RemoveAll_Call{Call: _e.mock.On("RemoveAll", ctx, path)}
4718}
4719
4720func (_c *MockFileSystem_RemoveAll_Call) Run(run func(ctx context.Context, path string)) *MockFileSystem_RemoveAll_Call {
4721 _c.Call.Run(func(args mock.Arguments) {
4722 var arg0 context.Context
4723 if args[0] != nil {
4724 arg0 = args[0].(context.Context)
4725 }
4726 var arg1 string
4727 if args[1] != nil {
4728 arg1 = args[1].(string)
4729 }
4730 run(
4731 arg0,
4732 arg1,
4733 )
4734 })
4735 return _c
4736}
4737
4738func (_c *MockFileSystem_RemoveAll_Call) Return(err error) *MockFileSystem_RemoveAll_Call {
4739 _c.Call.Return(err)
4740 return _c
4741}
4742
4743func (_c *MockFileSystem_RemoveAll_Call) RunAndReturn(run func(ctx context.Context, path string) error) *MockFileSystem_RemoveAll_Call {
4744 _c.Call.Return(run)
4745 return _c
4746}
4747
4748// NewMockFilterManager creates a new instance of MockFilterManager. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
4749// The first argument is typically a *testing.T value.
4750func NewMockFilterManager(t interface {
4751 mock.TestingT
4752 Cleanup(func())
4753}) *MockFilterManager {
4754 mock := &MockFilterManager{}
4755 mock.Mock.Test(t)
4756
4757 t.Cleanup(func() { mock.AssertExpectations(t) })
4758
4759 return mock
4760}
4761
4762// MockFilterManager is an autogenerated mock type for the FilterManager type
4763type MockFilterManager struct {
4764 mock.Mock
4765}
4766
4767type MockFilterManager_Expecter struct {
4768 mock *mock.Mock
4769}
4770
4771func (_m *MockFilterManager) EXPECT() *MockFilterManager_Expecter {
4772 return &MockFilterManager_Expecter{mock: &_m.Mock}
4773}
4774
4775// LoadAsync provides a mock function for the type MockFilterManager
4776func (_mock *MockFilterManager) LoadAsync(ctx context.Context) {
4777 _mock.Called(ctx)
4778 return
4779}
4780
4781// MockFilterManager_LoadAsync_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LoadAsync'
4782type MockFilterManager_LoadAsync_Call struct {
4783 *mock.Call
4784}
4785
4786// LoadAsync is a helper method to define mock.On call
4787// - ctx context.Context
4788func (_e *MockFilterManager_Expecter) LoadAsync(ctx interface{}) *MockFilterManager_LoadAsync_Call {
4789 return &MockFilterManager_LoadAsync_Call{Call: _e.mock.On("LoadAsync", ctx)}
4790}
4791
4792func (_c *MockFilterManager_LoadAsync_Call) Run(run func(ctx context.Context)) *MockFilterManager_LoadAsync_Call {
4793 _c.Call.Run(func(args mock.Arguments) {
4794 var arg0 context.Context
4795 if args[0] != nil {
4796 arg0 = args[0].(context.Context)
4797 }
4798 run(
4799 arg0,
4800 )
4801 })
4802 return _c
4803}
4804
4805func (_c *MockFilterManager_LoadAsync_Call) Return() *MockFilterManager_LoadAsync_Call {
4806 _c.Call.Return()
4807 return _c
4808}
4809
4810func (_c *MockFilterManager_LoadAsync_Call) RunAndReturn(run func(ctx context.Context)) *MockFilterManager_LoadAsync_Call {
4811 _c.Run(run)
4812 return _c
4813}
4814
4815// SetStatusCallback provides a mock function for the type MockFilterManager
4816func (_mock *MockFilterManager) SetStatusCallback(fn func(port.FilterStatus)) {
4817 _mock.Called(fn)
4818 return
4819}
4820
4821// MockFilterManager_SetStatusCallback_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetStatusCallback'
4822type MockFilterManager_SetStatusCallback_Call struct {
4823 *mock.Call
4824}
4825
4826// SetStatusCallback is a helper method to define mock.On call
4827// - fn func(port.FilterStatus)
4828func (_e *MockFilterManager_Expecter) SetStatusCallback(fn interface{}) *MockFilterManager_SetStatusCallback_Call {
4829 return &MockFilterManager_SetStatusCallback_Call{Call: _e.mock.On("SetStatusCallback", fn)}
4830}
4831
4832func (_c *MockFilterManager_SetStatusCallback_Call) Run(run func(fn func(port.FilterStatus))) *MockFilterManager_SetStatusCallback_Call {
4833 _c.Call.Run(func(args mock.Arguments) {
4834 var arg0 func(port.FilterStatus)
4835 if args[0] != nil {
4836 arg0 = args[0].(func(port.FilterStatus))
4837 }
4838 run(
4839 arg0,
4840 )
4841 })
4842 return _c
4843}
4844
4845func (_c *MockFilterManager_SetStatusCallback_Call) Return() *MockFilterManager_SetStatusCallback_Call {
4846 _c.Call.Return()
4847 return _c
4848}
4849
4850func (_c *MockFilterManager_SetStatusCallback_Call) RunAndReturn(run func(fn func(port.FilterStatus))) *MockFilterManager_SetStatusCallback_Call {
4851 _c.Run(run)
4852 return _c
4853}
4854
4855// NewMockFontDetector creates a new instance of MockFontDetector. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
4856// The first argument is typically a *testing.T value.
4857func NewMockFontDetector(t interface {
4858 mock.TestingT
4859 Cleanup(func())
4860}) *MockFontDetector {
4861 mock := &MockFontDetector{}
4862 mock.Mock.Test(t)
4863
4864 t.Cleanup(func() { mock.AssertExpectations(t) })
4865
4866 return mock
4867}
4868
4869// MockFontDetector is an autogenerated mock type for the FontDetector type
4870type MockFontDetector struct {
4871 mock.Mock
4872}
4873
4874type MockFontDetector_Expecter struct {
4875 mock *mock.Mock
4876}
4877
4878func (_m *MockFontDetector) EXPECT() *MockFontDetector_Expecter {
4879 return &MockFontDetector_Expecter{mock: &_m.Mock}
4880}
4881
4882// GetAvailableFonts provides a mock function for the type MockFontDetector
4883func (_mock *MockFontDetector) GetAvailableFonts(ctx context.Context) ([]string, error) {
4884 ret := _mock.Called(ctx)
4885
4886 if len(ret) == 0 {
4887 panic("no return value specified for GetAvailableFonts")
4888 }
4889
4890 var r0 []string
4891 var r1 error
4892 if returnFunc, ok := ret.Get(0).(func(context.Context) ([]string, error)); ok {
4893 return returnFunc(ctx)
4894 }
4895 if returnFunc, ok := ret.Get(0).(func(context.Context) []string); ok {
4896 r0 = returnFunc(ctx)
4897 } else {
4898 if ret.Get(0) != nil {
4899 r0 = ret.Get(0).([]string)
4900 }
4901 }
4902 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
4903 r1 = returnFunc(ctx)
4904 } else {
4905 r1 = ret.Error(1)
4906 }
4907 return r0, r1
4908}
4909
4910// MockFontDetector_GetAvailableFonts_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAvailableFonts'
4911type MockFontDetector_GetAvailableFonts_Call struct {
4912 *mock.Call
4913}
4914
4915// GetAvailableFonts is a helper method to define mock.On call
4916// - ctx context.Context
4917func (_e *MockFontDetector_Expecter) GetAvailableFonts(ctx interface{}) *MockFontDetector_GetAvailableFonts_Call {
4918 return &MockFontDetector_GetAvailableFonts_Call{Call: _e.mock.On("GetAvailableFonts", ctx)}
4919}
4920
4921func (_c *MockFontDetector_GetAvailableFonts_Call) Run(run func(ctx context.Context)) *MockFontDetector_GetAvailableFonts_Call {
4922 _c.Call.Run(func(args mock.Arguments) {
4923 var arg0 context.Context
4924 if args[0] != nil {
4925 arg0 = args[0].(context.Context)
4926 }
4927 run(
4928 arg0,
4929 )
4930 })
4931 return _c
4932}
4933
4934func (_c *MockFontDetector_GetAvailableFonts_Call) Return(strings []string, err error) *MockFontDetector_GetAvailableFonts_Call {
4935 _c.Call.Return(strings, err)
4936 return _c
4937}
4938
4939func (_c *MockFontDetector_GetAvailableFonts_Call) RunAndReturn(run func(ctx context.Context) ([]string, error)) *MockFontDetector_GetAvailableFonts_Call {
4940 _c.Call.Return(run)
4941 return _c
4942}
4943
4944// IsAvailable provides a mock function for the type MockFontDetector
4945func (_mock *MockFontDetector) IsAvailable(ctx context.Context) bool {
4946 ret := _mock.Called(ctx)
4947
4948 if len(ret) == 0 {
4949 panic("no return value specified for IsAvailable")
4950 }
4951
4952 var r0 bool
4953 if returnFunc, ok := ret.Get(0).(func(context.Context) bool); ok {
4954 r0 = returnFunc(ctx)
4955 } else {
4956 r0 = ret.Get(0).(bool)
4957 }
4958 return r0
4959}
4960
4961// MockFontDetector_IsAvailable_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsAvailable'
4962type MockFontDetector_IsAvailable_Call struct {
4963 *mock.Call
4964}
4965
4966// IsAvailable is a helper method to define mock.On call
4967// - ctx context.Context
4968func (_e *MockFontDetector_Expecter) IsAvailable(ctx interface{}) *MockFontDetector_IsAvailable_Call {
4969 return &MockFontDetector_IsAvailable_Call{Call: _e.mock.On("IsAvailable", ctx)}
4970}
4971
4972func (_c *MockFontDetector_IsAvailable_Call) Run(run func(ctx context.Context)) *MockFontDetector_IsAvailable_Call {
4973 _c.Call.Run(func(args mock.Arguments) {
4974 var arg0 context.Context
4975 if args[0] != nil {
4976 arg0 = args[0].(context.Context)
4977 }
4978 run(
4979 arg0,
4980 )
4981 })
4982 return _c
4983}
4984
4985func (_c *MockFontDetector_IsAvailable_Call) Return(b bool) *MockFontDetector_IsAvailable_Call {
4986 _c.Call.Return(b)
4987 return _c
4988}
4989
4990func (_c *MockFontDetector_IsAvailable_Call) RunAndReturn(run func(ctx context.Context) bool) *MockFontDetector_IsAvailable_Call {
4991 _c.Call.Return(run)
4992 return _c
4993}
4994
4995// SelectBestFont provides a mock function for the type MockFontDetector
4996func (_mock *MockFontDetector) SelectBestFont(ctx context.Context, category port.FontCategory, fallbackChain []string) string {
4997 ret := _mock.Called(ctx, category, fallbackChain)
4998
4999 if len(ret) == 0 {
5000 panic("no return value specified for SelectBestFont")
5001 }
5002
5003 var r0 string
5004 if returnFunc, ok := ret.Get(0).(func(context.Context, port.FontCategory, []string) string); ok {
5005 r0 = returnFunc(ctx, category, fallbackChain)
5006 } else {
5007 r0 = ret.Get(0).(string)
5008 }
5009 return r0
5010}
5011
5012// MockFontDetector_SelectBestFont_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SelectBestFont'
5013type MockFontDetector_SelectBestFont_Call struct {
5014 *mock.Call
5015}
5016
5017// SelectBestFont is a helper method to define mock.On call
5018// - ctx context.Context
5019// - category port.FontCategory
5020// - fallbackChain []string
5021func (_e *MockFontDetector_Expecter) SelectBestFont(ctx interface{}, category interface{}, fallbackChain interface{}) *MockFontDetector_SelectBestFont_Call {
5022 return &MockFontDetector_SelectBestFont_Call{Call: _e.mock.On("SelectBestFont", ctx, category, fallbackChain)}
5023}
5024
5025func (_c *MockFontDetector_SelectBestFont_Call) Run(run func(ctx context.Context, category port.FontCategory, fallbackChain []string)) *MockFontDetector_SelectBestFont_Call {
5026 _c.Call.Run(func(args mock.Arguments) {
5027 var arg0 context.Context
5028 if args[0] != nil {
5029 arg0 = args[0].(context.Context)
5030 }
5031 var arg1 port.FontCategory
5032 if args[1] != nil {
5033 arg1 = args[1].(port.FontCategory)
5034 }
5035 var arg2 []string
5036 if args[2] != nil {
5037 arg2 = args[2].([]string)
5038 }
5039 run(
5040 arg0,
5041 arg1,
5042 arg2,
5043 )
5044 })
5045 return _c
5046}
5047
5048func (_c *MockFontDetector_SelectBestFont_Call) Return(s string) *MockFontDetector_SelectBestFont_Call {
5049 _c.Call.Return(s)
5050 return _c
5051}
5052
5053func (_c *MockFontDetector_SelectBestFont_Call) RunAndReturn(run func(ctx context.Context, category port.FontCategory, fallbackChain []string) string) *MockFontDetector_SelectBestFont_Call {
5054 _c.Call.Return(run)
5055 return _c
5056}
5057
5058// NewMockAccentKeyHandler creates a new instance of MockAccentKeyHandler. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
5059// The first argument is typically a *testing.T value.
5060func NewMockAccentKeyHandler(t interface {
5061 mock.TestingT
5062 Cleanup(func())
5063}) *MockAccentKeyHandler {
5064 mock := &MockAccentKeyHandler{}
5065 mock.Mock.Test(t)
5066
5067 t.Cleanup(func() { mock.AssertExpectations(t) })
5068
5069 return mock
5070}
5071
5072// MockAccentKeyHandler is an autogenerated mock type for the AccentKeyHandler type
5073type MockAccentKeyHandler struct {
5074 mock.Mock
5075}
5076
5077type MockAccentKeyHandler_Expecter struct {
5078 mock *mock.Mock
5079}
5080
5081func (_m *MockAccentKeyHandler) EXPECT() *MockAccentKeyHandler_Expecter {
5082 return &MockAccentKeyHandler_Expecter{mock: &_m.Mock}
5083}
5084
5085// OnKeyPressed provides a mock function for the type MockAccentKeyHandler
5086func (_mock *MockAccentKeyHandler) OnKeyPressed(ctx context.Context, char rune, shiftHeld bool) bool {
5087 ret := _mock.Called(ctx, char, shiftHeld)
5088
5089 if len(ret) == 0 {
5090 panic("no return value specified for OnKeyPressed")
5091 }
5092
5093 var r0 bool
5094 if returnFunc, ok := ret.Get(0).(func(context.Context, rune, bool) bool); ok {
5095 r0 = returnFunc(ctx, char, shiftHeld)
5096 } else {
5097 r0 = ret.Get(0).(bool)
5098 }
5099 return r0
5100}
5101
5102// MockAccentKeyHandler_OnKeyPressed_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OnKeyPressed'
5103type MockAccentKeyHandler_OnKeyPressed_Call struct {
5104 *mock.Call
5105}
5106
5107// OnKeyPressed is a helper method to define mock.On call
5108// - ctx context.Context
5109// - char rune
5110// - shiftHeld bool
5111func (_e *MockAccentKeyHandler_Expecter) OnKeyPressed(ctx interface{}, char interface{}, shiftHeld interface{}) *MockAccentKeyHandler_OnKeyPressed_Call {
5112 return &MockAccentKeyHandler_OnKeyPressed_Call{Call: _e.mock.On("OnKeyPressed", ctx, char, shiftHeld)}
5113}
5114
5115func (_c *MockAccentKeyHandler_OnKeyPressed_Call) Run(run func(ctx context.Context, char rune, shiftHeld bool)) *MockAccentKeyHandler_OnKeyPressed_Call {
5116 _c.Call.Run(func(args mock.Arguments) {
5117 var arg0 context.Context
5118 if args[0] != nil {
5119 arg0 = args[0].(context.Context)
5120 }
5121 var arg1 rune
5122 if args[1] != nil {
5123 arg1 = args[1].(rune)
5124 }
5125 var arg2 bool
5126 if args[2] != nil {
5127 arg2 = args[2].(bool)
5128 }
5129 run(
5130 arg0,
5131 arg1,
5132 arg2,
5133 )
5134 })
5135 return _c
5136}
5137
5138func (_c *MockAccentKeyHandler_OnKeyPressed_Call) Return(b bool) *MockAccentKeyHandler_OnKeyPressed_Call {
5139 _c.Call.Return(b)
5140 return _c
5141}
5142
5143func (_c *MockAccentKeyHandler_OnKeyPressed_Call) RunAndReturn(run func(ctx context.Context, char rune, shiftHeld bool) bool) *MockAccentKeyHandler_OnKeyPressed_Call {
5144 _c.Call.Return(run)
5145 return _c
5146}
5147
5148// OnKeyReleased provides a mock function for the type MockAccentKeyHandler
5149func (_mock *MockAccentKeyHandler) OnKeyReleased(ctx context.Context, char rune) {
5150 _mock.Called(ctx, char)
5151 return
5152}
5153
5154// MockAccentKeyHandler_OnKeyReleased_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OnKeyReleased'
5155type MockAccentKeyHandler_OnKeyReleased_Call struct {
5156 *mock.Call
5157}
5158
5159// OnKeyReleased is a helper method to define mock.On call
5160// - ctx context.Context
5161// - char rune
5162func (_e *MockAccentKeyHandler_Expecter) OnKeyReleased(ctx interface{}, char interface{}) *MockAccentKeyHandler_OnKeyReleased_Call {
5163 return &MockAccentKeyHandler_OnKeyReleased_Call{Call: _e.mock.On("OnKeyReleased", ctx, char)}
5164}
5165
5166func (_c *MockAccentKeyHandler_OnKeyReleased_Call) Run(run func(ctx context.Context, char rune)) *MockAccentKeyHandler_OnKeyReleased_Call {
5167 _c.Call.Run(func(args mock.Arguments) {
5168 var arg0 context.Context
5169 if args[0] != nil {
5170 arg0 = args[0].(context.Context)
5171 }
5172 var arg1 rune
5173 if args[1] != nil {
5174 arg1 = args[1].(rune)
5175 }
5176 run(
5177 arg0,
5178 arg1,
5179 )
5180 })
5181 return _c
5182}
5183
5184func (_c *MockAccentKeyHandler_OnKeyReleased_Call) Return() *MockAccentKeyHandler_OnKeyReleased_Call {
5185 _c.Call.Return()
5186 return _c
5187}
5188
5189func (_c *MockAccentKeyHandler_OnKeyReleased_Call) RunAndReturn(run func(ctx context.Context, char rune)) *MockAccentKeyHandler_OnKeyReleased_Call {
5190 _c.Run(run)
5191 return _c
5192}
5193
5194// NewMockDownloadPreparer creates a new instance of MockDownloadPreparer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
5195// The first argument is typically a *testing.T value.
5196func NewMockDownloadPreparer(t interface {
5197 mock.TestingT
5198 Cleanup(func())
5199}) *MockDownloadPreparer {
5200 mock := &MockDownloadPreparer{}
5201 mock.Mock.Test(t)
5202
5203 t.Cleanup(func() { mock.AssertExpectations(t) })
5204
5205 return mock
5206}
5207
5208// MockDownloadPreparer is an autogenerated mock type for the DownloadPreparer type
5209type MockDownloadPreparer struct {
5210 mock.Mock
5211}
5212
5213type MockDownloadPreparer_Expecter struct {
5214 mock *mock.Mock
5215}
5216
5217func (_m *MockDownloadPreparer) EXPECT() *MockDownloadPreparer_Expecter {
5218 return &MockDownloadPreparer_Expecter{mock: &_m.Mock}
5219}
5220
5221// Execute provides a mock function for the type MockDownloadPreparer
5222func (_mock *MockDownloadPreparer) Execute(ctx context.Context, input port.DownloadPrepareInput) *port.DownloadPrepareOutput {
5223 ret := _mock.Called(ctx, input)
5224
5225 if len(ret) == 0 {
5226 panic("no return value specified for Execute")
5227 }
5228
5229 var r0 *port.DownloadPrepareOutput
5230 if returnFunc, ok := ret.Get(0).(func(context.Context, port.DownloadPrepareInput) *port.DownloadPrepareOutput); ok {
5231 r0 = returnFunc(ctx, input)
5232 } else {
5233 if ret.Get(0) != nil {
5234 r0 = ret.Get(0).(*port.DownloadPrepareOutput)
5235 }
5236 }
5237 return r0
5238}
5239
5240// MockDownloadPreparer_Execute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Execute'
5241type MockDownloadPreparer_Execute_Call struct {
5242 *mock.Call
5243}
5244
5245// Execute is a helper method to define mock.On call
5246// - ctx context.Context
5247// - input port.DownloadPrepareInput
5248func (_e *MockDownloadPreparer_Expecter) Execute(ctx interface{}, input interface{}) *MockDownloadPreparer_Execute_Call {
5249 return &MockDownloadPreparer_Execute_Call{Call: _e.mock.On("Execute", ctx, input)}
5250}
5251
5252func (_c *MockDownloadPreparer_Execute_Call) Run(run func(ctx context.Context, input port.DownloadPrepareInput)) *MockDownloadPreparer_Execute_Call {
5253 _c.Call.Run(func(args mock.Arguments) {
5254 var arg0 context.Context
5255 if args[0] != nil {
5256 arg0 = args[0].(context.Context)
5257 }
5258 var arg1 port.DownloadPrepareInput
5259 if args[1] != nil {
5260 arg1 = args[1].(port.DownloadPrepareInput)
5261 }
5262 run(
5263 arg0,
5264 arg1,
5265 )
5266 })
5267 return _c
5268}
5269
5270func (_c *MockDownloadPreparer_Execute_Call) Return(downloadPrepareOutput *port.DownloadPrepareOutput) *MockDownloadPreparer_Execute_Call {
5271 _c.Call.Return(downloadPrepareOutput)
5272 return _c
5273}
5274
5275func (_c *MockDownloadPreparer_Execute_Call) RunAndReturn(run func(ctx context.Context, input port.DownloadPrepareInput) *port.DownloadPrepareOutput) *MockDownloadPreparer_Execute_Call {
5276 _c.Call.Return(run)
5277 return _c
5278}
5279
5280// NewMockAutoCopyConfig creates a new instance of MockAutoCopyConfig. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
5281// The first argument is typically a *testing.T value.
5282func NewMockAutoCopyConfig(t interface {
5283 mock.TestingT
5284 Cleanup(func())
5285}) *MockAutoCopyConfig {
5286 mock := &MockAutoCopyConfig{}
5287 mock.Mock.Test(t)
5288
5289 t.Cleanup(func() { mock.AssertExpectations(t) })
5290
5291 return mock
5292}
5293
5294// MockAutoCopyConfig is an autogenerated mock type for the AutoCopyConfig type
5295type MockAutoCopyConfig struct {
5296 mock.Mock
5297}
5298
5299type MockAutoCopyConfig_Expecter struct {
5300 mock *mock.Mock
5301}
5302
5303func (_m *MockAutoCopyConfig) EXPECT() *MockAutoCopyConfig_Expecter {
5304 return &MockAutoCopyConfig_Expecter{mock: &_m.Mock}
5305}
5306
5307// IsAutoCopyEnabled provides a mock function for the type MockAutoCopyConfig
5308func (_mock *MockAutoCopyConfig) IsAutoCopyEnabled() bool {
5309 ret := _mock.Called()
5310
5311 if len(ret) == 0 {
5312 panic("no return value specified for IsAutoCopyEnabled")
5313 }
5314
5315 var r0 bool
5316 if returnFunc, ok := ret.Get(0).(func() bool); ok {
5317 r0 = returnFunc()
5318 } else {
5319 r0 = ret.Get(0).(bool)
5320 }
5321 return r0
5322}
5323
5324// MockAutoCopyConfig_IsAutoCopyEnabled_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsAutoCopyEnabled'
5325type MockAutoCopyConfig_IsAutoCopyEnabled_Call struct {
5326 *mock.Call
5327}
5328
5329// IsAutoCopyEnabled is a helper method to define mock.On call
5330func (_e *MockAutoCopyConfig_Expecter) IsAutoCopyEnabled() *MockAutoCopyConfig_IsAutoCopyEnabled_Call {
5331 return &MockAutoCopyConfig_IsAutoCopyEnabled_Call{Call: _e.mock.On("IsAutoCopyEnabled")}
5332}
5333
5334func (_c *MockAutoCopyConfig_IsAutoCopyEnabled_Call) Run(run func()) *MockAutoCopyConfig_IsAutoCopyEnabled_Call {
5335 _c.Call.Run(func(args mock.Arguments) {
5336 run()
5337 })
5338 return _c
5339}
5340
5341func (_c *MockAutoCopyConfig_IsAutoCopyEnabled_Call) Return(b bool) *MockAutoCopyConfig_IsAutoCopyEnabled_Call {
5342 _c.Call.Return(b)
5343 return _c
5344}
5345
5346func (_c *MockAutoCopyConfig_IsAutoCopyEnabled_Call) RunAndReturn(run func() bool) *MockAutoCopyConfig_IsAutoCopyEnabled_Call {
5347 _c.Call.Return(run)
5348 return _c
5349}
5350
5351// NewMockHardwareSurveyor creates a new instance of MockHardwareSurveyor. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
5352// The first argument is typically a *testing.T value.
5353func NewMockHardwareSurveyor(t interface {
5354 mock.TestingT
5355 Cleanup(func())
5356}) *MockHardwareSurveyor {
5357 mock := &MockHardwareSurveyor{}
5358 mock.Mock.Test(t)
5359
5360 t.Cleanup(func() { mock.AssertExpectations(t) })
5361
5362 return mock
5363}
5364
5365// MockHardwareSurveyor is an autogenerated mock type for the HardwareSurveyor type
5366type MockHardwareSurveyor struct {
5367 mock.Mock
5368}
5369
5370type MockHardwareSurveyor_Expecter struct {
5371 mock *mock.Mock
5372}
5373
5374func (_m *MockHardwareSurveyor) EXPECT() *MockHardwareSurveyor_Expecter {
5375 return &MockHardwareSurveyor_Expecter{mock: &_m.Mock}
5376}
5377
5378// Survey provides a mock function for the type MockHardwareSurveyor
5379func (_mock *MockHardwareSurveyor) Survey(ctx context.Context) port.HardwareInfo {
5380 ret := _mock.Called(ctx)
5381
5382 if len(ret) == 0 {
5383 panic("no return value specified for Survey")
5384 }
5385
5386 var r0 port.HardwareInfo
5387 if returnFunc, ok := ret.Get(0).(func(context.Context) port.HardwareInfo); ok {
5388 r0 = returnFunc(ctx)
5389 } else {
5390 r0 = ret.Get(0).(port.HardwareInfo)
5391 }
5392 return r0
5393}
5394
5395// MockHardwareSurveyor_Survey_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Survey'
5396type MockHardwareSurveyor_Survey_Call struct {
5397 *mock.Call
5398}
5399
5400// Survey is a helper method to define mock.On call
5401// - ctx context.Context
5402func (_e *MockHardwareSurveyor_Expecter) Survey(ctx interface{}) *MockHardwareSurveyor_Survey_Call {
5403 return &MockHardwareSurveyor_Survey_Call{Call: _e.mock.On("Survey", ctx)}
5404}
5405
5406func (_c *MockHardwareSurveyor_Survey_Call) Run(run func(ctx context.Context)) *MockHardwareSurveyor_Survey_Call {
5407 _c.Call.Run(func(args mock.Arguments) {
5408 var arg0 context.Context
5409 if args[0] != nil {
5410 arg0 = args[0].(context.Context)
5411 }
5412 run(
5413 arg0,
5414 )
5415 })
5416 return _c
5417}
5418
5419func (_c *MockHardwareSurveyor_Survey_Call) Return(hardwareInfo port.HardwareInfo) *MockHardwareSurveyor_Survey_Call {
5420 _c.Call.Return(hardwareInfo)
5421 return _c
5422}
5423
5424func (_c *MockHardwareSurveyor_Survey_Call) RunAndReturn(run func(ctx context.Context) port.HardwareInfo) *MockHardwareSurveyor_Survey_Call {
5425 _c.Call.Return(run)
5426 return _c
5427}
5428
5429// NewMockHomepageHistory creates a new instance of MockHomepageHistory. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
5430// The first argument is typically a *testing.T value.
5431func NewMockHomepageHistory(t interface {
5432 mock.TestingT
5433 Cleanup(func())
5434}) *MockHomepageHistory {
5435 mock := &MockHomepageHistory{}
5436 mock.Mock.Test(t)
5437
5438 t.Cleanup(func() { mock.AssertExpectations(t) })
5439
5440 return mock
5441}
5442
5443// MockHomepageHistory is an autogenerated mock type for the HomepageHistory type
5444type MockHomepageHistory struct {
5445 mock.Mock
5446}
5447
5448type MockHomepageHistory_Expecter struct {
5449 mock *mock.Mock
5450}
5451
5452func (_m *MockHomepageHistory) EXPECT() *MockHomepageHistory_Expecter {
5453 return &MockHomepageHistory_Expecter{mock: &_m.Mock}
5454}
5455
5456// ClearAll provides a mock function for the type MockHomepageHistory
5457func (_mock *MockHomepageHistory) ClearAll(ctx context.Context) error {
5458 ret := _mock.Called(ctx)
5459
5460 if len(ret) == 0 {
5461 panic("no return value specified for ClearAll")
5462 }
5463
5464 var r0 error
5465 if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
5466 r0 = returnFunc(ctx)
5467 } else {
5468 r0 = ret.Error(0)
5469 }
5470 return r0
5471}
5472
5473// MockHomepageHistory_ClearAll_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClearAll'
5474type MockHomepageHistory_ClearAll_Call struct {
5475 *mock.Call
5476}
5477
5478// ClearAll is a helper method to define mock.On call
5479// - ctx context.Context
5480func (_e *MockHomepageHistory_Expecter) ClearAll(ctx interface{}) *MockHomepageHistory_ClearAll_Call {
5481 return &MockHomepageHistory_ClearAll_Call{Call: _e.mock.On("ClearAll", ctx)}
5482}
5483
5484func (_c *MockHomepageHistory_ClearAll_Call) Run(run func(ctx context.Context)) *MockHomepageHistory_ClearAll_Call {
5485 _c.Call.Run(func(args mock.Arguments) {
5486 var arg0 context.Context
5487 if args[0] != nil {
5488 arg0 = args[0].(context.Context)
5489 }
5490 run(
5491 arg0,
5492 )
5493 })
5494 return _c
5495}
5496
5497func (_c *MockHomepageHistory_ClearAll_Call) Return(err error) *MockHomepageHistory_ClearAll_Call {
5498 _c.Call.Return(err)
5499 return _c
5500}
5501
5502func (_c *MockHomepageHistory_ClearAll_Call) RunAndReturn(run func(ctx context.Context) error) *MockHomepageHistory_ClearAll_Call {
5503 _c.Call.Return(run)
5504 return _c
5505}
5506
5507// ClearOlderThan provides a mock function for the type MockHomepageHistory
5508func (_mock *MockHomepageHistory) ClearOlderThan(ctx context.Context, before time.Time) error {
5509 ret := _mock.Called(ctx, before)
5510
5511 if len(ret) == 0 {
5512 panic("no return value specified for ClearOlderThan")
5513 }
5514
5515 var r0 error
5516 if returnFunc, ok := ret.Get(0).(func(context.Context, time.Time) error); ok {
5517 r0 = returnFunc(ctx, before)
5518 } else {
5519 r0 = ret.Error(0)
5520 }
5521 return r0
5522}
5523
5524// MockHomepageHistory_ClearOlderThan_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClearOlderThan'
5525type MockHomepageHistory_ClearOlderThan_Call struct {
5526 *mock.Call
5527}
5528
5529// ClearOlderThan is a helper method to define mock.On call
5530// - ctx context.Context
5531// - before time.Time
5532func (_e *MockHomepageHistory_Expecter) ClearOlderThan(ctx interface{}, before interface{}) *MockHomepageHistory_ClearOlderThan_Call {
5533 return &MockHomepageHistory_ClearOlderThan_Call{Call: _e.mock.On("ClearOlderThan", ctx, before)}
5534}
5535
5536func (_c *MockHomepageHistory_ClearOlderThan_Call) Run(run func(ctx context.Context, before time.Time)) *MockHomepageHistory_ClearOlderThan_Call {
5537 _c.Call.Run(func(args mock.Arguments) {
5538 var arg0 context.Context
5539 if args[0] != nil {
5540 arg0 = args[0].(context.Context)
5541 }
5542 var arg1 time.Time
5543 if args[1] != nil {
5544 arg1 = args[1].(time.Time)
5545 }
5546 run(
5547 arg0,
5548 arg1,
5549 )
5550 })
5551 return _c
5552}
5553
5554func (_c *MockHomepageHistory_ClearOlderThan_Call) Return(err error) *MockHomepageHistory_ClearOlderThan_Call {
5555 _c.Call.Return(err)
5556 return _c
5557}
5558
5559func (_c *MockHomepageHistory_ClearOlderThan_Call) RunAndReturn(run func(ctx context.Context, before time.Time) error) *MockHomepageHistory_ClearOlderThan_Call {
5560 _c.Call.Return(run)
5561 return _c
5562}
5563
5564// Delete provides a mock function for the type MockHomepageHistory
5565func (_mock *MockHomepageHistory) Delete(ctx context.Context, id int64) error {
5566 ret := _mock.Called(ctx, id)
5567
5568 if len(ret) == 0 {
5569 panic("no return value specified for Delete")
5570 }
5571
5572 var r0 error
5573 if returnFunc, ok := ret.Get(0).(func(context.Context, int64) error); ok {
5574 r0 = returnFunc(ctx, id)
5575 } else {
5576 r0 = ret.Error(0)
5577 }
5578 return r0
5579}
5580
5581// MockHomepageHistory_Delete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Delete'
5582type MockHomepageHistory_Delete_Call struct {
5583 *mock.Call
5584}
5585
5586// Delete is a helper method to define mock.On call
5587// - ctx context.Context
5588// - id int64
5589func (_e *MockHomepageHistory_Expecter) Delete(ctx interface{}, id interface{}) *MockHomepageHistory_Delete_Call {
5590 return &MockHomepageHistory_Delete_Call{Call: _e.mock.On("Delete", ctx, id)}
5591}
5592
5593func (_c *MockHomepageHistory_Delete_Call) Run(run func(ctx context.Context, id int64)) *MockHomepageHistory_Delete_Call {
5594 _c.Call.Run(func(args mock.Arguments) {
5595 var arg0 context.Context
5596 if args[0] != nil {
5597 arg0 = args[0].(context.Context)
5598 }
5599 var arg1 int64
5600 if args[1] != nil {
5601 arg1 = args[1].(int64)
5602 }
5603 run(
5604 arg0,
5605 arg1,
5606 )
5607 })
5608 return _c
5609}
5610
5611func (_c *MockHomepageHistory_Delete_Call) Return(err error) *MockHomepageHistory_Delete_Call {
5612 _c.Call.Return(err)
5613 return _c
5614}
5615
5616func (_c *MockHomepageHistory_Delete_Call) RunAndReturn(run func(ctx context.Context, id int64) error) *MockHomepageHistory_Delete_Call {
5617 _c.Call.Return(run)
5618 return _c
5619}
5620
5621// DeleteByDomain provides a mock function for the type MockHomepageHistory
5622func (_mock *MockHomepageHistory) DeleteByDomain(ctx context.Context, domain string) error {
5623 ret := _mock.Called(ctx, domain)
5624
5625 if len(ret) == 0 {
5626 panic("no return value specified for DeleteByDomain")
5627 }
5628
5629 var r0 error
5630 if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
5631 r0 = returnFunc(ctx, domain)
5632 } else {
5633 r0 = ret.Error(0)
5634 }
5635 return r0
5636}
5637
5638// MockHomepageHistory_DeleteByDomain_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteByDomain'
5639type MockHomepageHistory_DeleteByDomain_Call struct {
5640 *mock.Call
5641}
5642
5643// DeleteByDomain is a helper method to define mock.On call
5644// - ctx context.Context
5645// - domain string
5646func (_e *MockHomepageHistory_Expecter) DeleteByDomain(ctx interface{}, domain interface{}) *MockHomepageHistory_DeleteByDomain_Call {
5647 return &MockHomepageHistory_DeleteByDomain_Call{Call: _e.mock.On("DeleteByDomain", ctx, domain)}
5648}
5649
5650func (_c *MockHomepageHistory_DeleteByDomain_Call) Run(run func(ctx context.Context, domain string)) *MockHomepageHistory_DeleteByDomain_Call {
5651 _c.Call.Run(func(args mock.Arguments) {
5652 var arg0 context.Context
5653 if args[0] != nil {
5654 arg0 = args[0].(context.Context)
5655 }
5656 var arg1 string
5657 if args[1] != nil {
5658 arg1 = args[1].(string)
5659 }
5660 run(
5661 arg0,
5662 arg1,
5663 )
5664 })
5665 return _c
5666}
5667
5668func (_c *MockHomepageHistory_DeleteByDomain_Call) Return(err error) *MockHomepageHistory_DeleteByDomain_Call {
5669 _c.Call.Return(err)
5670 return _c
5671}
5672
5673func (_c *MockHomepageHistory_DeleteByDomain_Call) RunAndReturn(run func(ctx context.Context, domain string) error) *MockHomepageHistory_DeleteByDomain_Call {
5674 _c.Call.Return(run)
5675 return _c
5676}
5677
5678// GetAnalytics provides a mock function for the type MockHomepageHistory
5679func (_mock *MockHomepageHistory) GetAnalytics(ctx context.Context) (*entity.HistoryAnalytics, error) {
5680 ret := _mock.Called(ctx)
5681
5682 if len(ret) == 0 {
5683 panic("no return value specified for GetAnalytics")
5684 }
5685
5686 var r0 *entity.HistoryAnalytics
5687 var r1 error
5688 if returnFunc, ok := ret.Get(0).(func(context.Context) (*entity.HistoryAnalytics, error)); ok {
5689 return returnFunc(ctx)
5690 }
5691 if returnFunc, ok := ret.Get(0).(func(context.Context) *entity.HistoryAnalytics); ok {
5692 r0 = returnFunc(ctx)
5693 } else {
5694 if ret.Get(0) != nil {
5695 r0 = ret.Get(0).(*entity.HistoryAnalytics)
5696 }
5697 }
5698 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
5699 r1 = returnFunc(ctx)
5700 } else {
5701 r1 = ret.Error(1)
5702 }
5703 return r0, r1
5704}
5705
5706// MockHomepageHistory_GetAnalytics_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAnalytics'
5707type MockHomepageHistory_GetAnalytics_Call struct {
5708 *mock.Call
5709}
5710
5711// GetAnalytics is a helper method to define mock.On call
5712// - ctx context.Context
5713func (_e *MockHomepageHistory_Expecter) GetAnalytics(ctx interface{}) *MockHomepageHistory_GetAnalytics_Call {
5714 return &MockHomepageHistory_GetAnalytics_Call{Call: _e.mock.On("GetAnalytics", ctx)}
5715}
5716
5717func (_c *MockHomepageHistory_GetAnalytics_Call) Run(run func(ctx context.Context)) *MockHomepageHistory_GetAnalytics_Call {
5718 _c.Call.Run(func(args mock.Arguments) {
5719 var arg0 context.Context
5720 if args[0] != nil {
5721 arg0 = args[0].(context.Context)
5722 }
5723 run(
5724 arg0,
5725 )
5726 })
5727 return _c
5728}
5729
5730func (_c *MockHomepageHistory_GetAnalytics_Call) Return(historyAnalytics *entity.HistoryAnalytics, err error) *MockHomepageHistory_GetAnalytics_Call {
5731 _c.Call.Return(historyAnalytics, err)
5732 return _c
5733}
5734
5735func (_c *MockHomepageHistory_GetAnalytics_Call) RunAndReturn(run func(ctx context.Context) (*entity.HistoryAnalytics, error)) *MockHomepageHistory_GetAnalytics_Call {
5736 _c.Call.Return(run)
5737 return _c
5738}
5739
5740// GetDomainStats provides a mock function for the type MockHomepageHistory
5741func (_mock *MockHomepageHistory) GetDomainStats(ctx context.Context, limit int) ([]*entity.DomainStat, error) {
5742 ret := _mock.Called(ctx, limit)
5743
5744 if len(ret) == 0 {
5745 panic("no return value specified for GetDomainStats")
5746 }
5747
5748 var r0 []*entity.DomainStat
5749 var r1 error
5750 if returnFunc, ok := ret.Get(0).(func(context.Context, int) ([]*entity.DomainStat, error)); ok {
5751 return returnFunc(ctx, limit)
5752 }
5753 if returnFunc, ok := ret.Get(0).(func(context.Context, int) []*entity.DomainStat); ok {
5754 r0 = returnFunc(ctx, limit)
5755 } else {
5756 if ret.Get(0) != nil {
5757 r0 = ret.Get(0).([]*entity.DomainStat)
5758 }
5759 }
5760 if returnFunc, ok := ret.Get(1).(func(context.Context, int) error); ok {
5761 r1 = returnFunc(ctx, limit)
5762 } else {
5763 r1 = ret.Error(1)
5764 }
5765 return r0, r1
5766}
5767
5768// MockHomepageHistory_GetDomainStats_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetDomainStats'
5769type MockHomepageHistory_GetDomainStats_Call struct {
5770 *mock.Call
5771}
5772
5773// GetDomainStats is a helper method to define mock.On call
5774// - ctx context.Context
5775// - limit int
5776func (_e *MockHomepageHistory_Expecter) GetDomainStats(ctx interface{}, limit interface{}) *MockHomepageHistory_GetDomainStats_Call {
5777 return &MockHomepageHistory_GetDomainStats_Call{Call: _e.mock.On("GetDomainStats", ctx, limit)}
5778}
5779
5780func (_c *MockHomepageHistory_GetDomainStats_Call) Run(run func(ctx context.Context, limit int)) *MockHomepageHistory_GetDomainStats_Call {
5781 _c.Call.Run(func(args mock.Arguments) {
5782 var arg0 context.Context
5783 if args[0] != nil {
5784 arg0 = args[0].(context.Context)
5785 }
5786 var arg1 int
5787 if args[1] != nil {
5788 arg1 = args[1].(int)
5789 }
5790 run(
5791 arg0,
5792 arg1,
5793 )
5794 })
5795 return _c
5796}
5797
5798func (_c *MockHomepageHistory_GetDomainStats_Call) Return(domainStats []*entity.DomainStat, err error) *MockHomepageHistory_GetDomainStats_Call {
5799 _c.Call.Return(domainStats, err)
5800 return _c
5801}
5802
5803func (_c *MockHomepageHistory_GetDomainStats_Call) RunAndReturn(run func(ctx context.Context, limit int) ([]*entity.DomainStat, error)) *MockHomepageHistory_GetDomainStats_Call {
5804 _c.Call.Return(run)
5805 return _c
5806}
5807
5808// GetRecent provides a mock function for the type MockHomepageHistory
5809func (_mock *MockHomepageHistory) GetRecent(ctx context.Context, limit int, offset int) ([]*entity.HistoryEntry, error) {
5810 ret := _mock.Called(ctx, limit, offset)
5811
5812 if len(ret) == 0 {
5813 panic("no return value specified for GetRecent")
5814 }
5815
5816 var r0 []*entity.HistoryEntry
5817 var r1 error
5818 if returnFunc, ok := ret.Get(0).(func(context.Context, int, int) ([]*entity.HistoryEntry, error)); ok {
5819 return returnFunc(ctx, limit, offset)
5820 }
5821 if returnFunc, ok := ret.Get(0).(func(context.Context, int, int) []*entity.HistoryEntry); ok {
5822 r0 = returnFunc(ctx, limit, offset)
5823 } else {
5824 if ret.Get(0) != nil {
5825 r0 = ret.Get(0).([]*entity.HistoryEntry)
5826 }
5827 }
5828 if returnFunc, ok := ret.Get(1).(func(context.Context, int, int) error); ok {
5829 r1 = returnFunc(ctx, limit, offset)
5830 } else {
5831 r1 = ret.Error(1)
5832 }
5833 return r0, r1
5834}
5835
5836// MockHomepageHistory_GetRecent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRecent'
5837type MockHomepageHistory_GetRecent_Call struct {
5838 *mock.Call
5839}
5840
5841// GetRecent is a helper method to define mock.On call
5842// - ctx context.Context
5843// - limit int
5844// - offset int
5845func (_e *MockHomepageHistory_Expecter) GetRecent(ctx interface{}, limit interface{}, offset interface{}) *MockHomepageHistory_GetRecent_Call {
5846 return &MockHomepageHistory_GetRecent_Call{Call: _e.mock.On("GetRecent", ctx, limit, offset)}
5847}
5848
5849func (_c *MockHomepageHistory_GetRecent_Call) Run(run func(ctx context.Context, limit int, offset int)) *MockHomepageHistory_GetRecent_Call {
5850 _c.Call.Run(func(args mock.Arguments) {
5851 var arg0 context.Context
5852 if args[0] != nil {
5853 arg0 = args[0].(context.Context)
5854 }
5855 var arg1 int
5856 if args[1] != nil {
5857 arg1 = args[1].(int)
5858 }
5859 var arg2 int
5860 if args[2] != nil {
5861 arg2 = args[2].(int)
5862 }
5863 run(
5864 arg0,
5865 arg1,
5866 arg2,
5867 )
5868 })
5869 return _c
5870}
5871
5872func (_c *MockHomepageHistory_GetRecent_Call) Return(historyEntrys []*entity.HistoryEntry, err error) *MockHomepageHistory_GetRecent_Call {
5873 _c.Call.Return(historyEntrys, err)
5874 return _c
5875}
5876
5877func (_c *MockHomepageHistory_GetRecent_Call) RunAndReturn(run func(ctx context.Context, limit int, offset int) ([]*entity.HistoryEntry, error)) *MockHomepageHistory_GetRecent_Call {
5878 _c.Call.Return(run)
5879 return _c
5880}
5881
5882// Search provides a mock function for the type MockHomepageHistory
5883func (_mock *MockHomepageHistory) Search(ctx context.Context, input port.HistorySearchInput) (*port.HistorySearchOutput, error) {
5884 ret := _mock.Called(ctx, input)
5885
5886 if len(ret) == 0 {
5887 panic("no return value specified for Search")
5888 }
5889
5890 var r0 *port.HistorySearchOutput
5891 var r1 error
5892 if returnFunc, ok := ret.Get(0).(func(context.Context, port.HistorySearchInput) (*port.HistorySearchOutput, error)); ok {
5893 return returnFunc(ctx, input)
5894 }
5895 if returnFunc, ok := ret.Get(0).(func(context.Context, port.HistorySearchInput) *port.HistorySearchOutput); ok {
5896 r0 = returnFunc(ctx, input)
5897 } else {
5898 if ret.Get(0) != nil {
5899 r0 = ret.Get(0).(*port.HistorySearchOutput)
5900 }
5901 }
5902 if returnFunc, ok := ret.Get(1).(func(context.Context, port.HistorySearchInput) error); ok {
5903 r1 = returnFunc(ctx, input)
5904 } else {
5905 r1 = ret.Error(1)
5906 }
5907 return r0, r1
5908}
5909
5910// MockHomepageHistory_Search_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Search'
5911type MockHomepageHistory_Search_Call struct {
5912 *mock.Call
5913}
5914
5915// Search is a helper method to define mock.On call
5916// - ctx context.Context
5917// - input port.HistorySearchInput
5918func (_e *MockHomepageHistory_Expecter) Search(ctx interface{}, input interface{}) *MockHomepageHistory_Search_Call {
5919 return &MockHomepageHistory_Search_Call{Call: _e.mock.On("Search", ctx, input)}
5920}
5921
5922func (_c *MockHomepageHistory_Search_Call) Run(run func(ctx context.Context, input port.HistorySearchInput)) *MockHomepageHistory_Search_Call {
5923 _c.Call.Run(func(args mock.Arguments) {
5924 var arg0 context.Context
5925 if args[0] != nil {
5926 arg0 = args[0].(context.Context)
5927 }
5928 var arg1 port.HistorySearchInput
5929 if args[1] != nil {
5930 arg1 = args[1].(port.HistorySearchInput)
5931 }
5932 run(
5933 arg0,
5934 arg1,
5935 )
5936 })
5937 return _c
5938}
5939
5940func (_c *MockHomepageHistory_Search_Call) Return(historySearchOutput *port.HistorySearchOutput, err error) *MockHomepageHistory_Search_Call {
5941 _c.Call.Return(historySearchOutput, err)
5942 return _c
5943}
5944
5945func (_c *MockHomepageHistory_Search_Call) RunAndReturn(run func(ctx context.Context, input port.HistorySearchInput) (*port.HistorySearchOutput, error)) *MockHomepageHistory_Search_Call {
5946 _c.Call.Return(run)
5947 return _c
5948}
5949
5950// NewMockHomepageFavorites creates a new instance of MockHomepageFavorites. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
5951// The first argument is typically a *testing.T value.
5952func NewMockHomepageFavorites(t interface {
5953 mock.TestingT
5954 Cleanup(func())
5955}) *MockHomepageFavorites {
5956 mock := &MockHomepageFavorites{}
5957 mock.Mock.Test(t)
5958
5959 t.Cleanup(func() { mock.AssertExpectations(t) })
5960
5961 return mock
5962}
5963
5964// MockHomepageFavorites is an autogenerated mock type for the HomepageFavorites type
5965type MockHomepageFavorites struct {
5966 mock.Mock
5967}
5968
5969type MockHomepageFavorites_Expecter struct {
5970 mock *mock.Mock
5971}
5972
5973func (_m *MockHomepageFavorites) EXPECT() *MockHomepageFavorites_Expecter {
5974 return &MockHomepageFavorites_Expecter{mock: &_m.Mock}
5975}
5976
5977// AddTag provides a mock function for the type MockHomepageFavorites
5978func (_mock *MockHomepageFavorites) AddTag(ctx context.Context, name string, color string) (*entity.Tag, error) {
5979 ret := _mock.Called(ctx, name, color)
5980
5981 if len(ret) == 0 {
5982 panic("no return value specified for AddTag")
5983 }
5984
5985 var r0 *entity.Tag
5986 var r1 error
5987 if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (*entity.Tag, error)); ok {
5988 return returnFunc(ctx, name, color)
5989 }
5990 if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) *entity.Tag); ok {
5991 r0 = returnFunc(ctx, name, color)
5992 } else {
5993 if ret.Get(0) != nil {
5994 r0 = ret.Get(0).(*entity.Tag)
5995 }
5996 }
5997 if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
5998 r1 = returnFunc(ctx, name, color)
5999 } else {
6000 r1 = ret.Error(1)
6001 }
6002 return r0, r1
6003}
6004
6005// MockHomepageFavorites_AddTag_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddTag'
6006type MockHomepageFavorites_AddTag_Call struct {
6007 *mock.Call
6008}
6009
6010// AddTag is a helper method to define mock.On call
6011// - ctx context.Context
6012// - name string
6013// - color string
6014func (_e *MockHomepageFavorites_Expecter) AddTag(ctx interface{}, name interface{}, color interface{}) *MockHomepageFavorites_AddTag_Call {
6015 return &MockHomepageFavorites_AddTag_Call{Call: _e.mock.On("AddTag", ctx, name, color)}
6016}
6017
6018func (_c *MockHomepageFavorites_AddTag_Call) Run(run func(ctx context.Context, name string, color string)) *MockHomepageFavorites_AddTag_Call {
6019 _c.Call.Run(func(args mock.Arguments) {
6020 var arg0 context.Context
6021 if args[0] != nil {
6022 arg0 = args[0].(context.Context)
6023 }
6024 var arg1 string
6025 if args[1] != nil {
6026 arg1 = args[1].(string)
6027 }
6028 var arg2 string
6029 if args[2] != nil {
6030 arg2 = args[2].(string)
6031 }
6032 run(
6033 arg0,
6034 arg1,
6035 arg2,
6036 )
6037 })
6038 return _c
6039}
6040
6041func (_c *MockHomepageFavorites_AddTag_Call) Return(tag *entity.Tag, err error) *MockHomepageFavorites_AddTag_Call {
6042 _c.Call.Return(tag, err)
6043 return _c
6044}
6045
6046func (_c *MockHomepageFavorites_AddTag_Call) RunAndReturn(run func(ctx context.Context, name string, color string) (*entity.Tag, error)) *MockHomepageFavorites_AddTag_Call {
6047 _c.Call.Return(run)
6048 return _c
6049}
6050
6051// CreateFolder provides a mock function for the type MockHomepageFavorites
6052func (_mock *MockHomepageFavorites) CreateFolder(ctx context.Context, name string, parentID *entity.FolderID) (*entity.Folder, error) {
6053 ret := _mock.Called(ctx, name, parentID)
6054
6055 if len(ret) == 0 {
6056 panic("no return value specified for CreateFolder")
6057 }
6058
6059 var r0 *entity.Folder
6060 var r1 error
6061 if returnFunc, ok := ret.Get(0).(func(context.Context, string, *entity.FolderID) (*entity.Folder, error)); ok {
6062 return returnFunc(ctx, name, parentID)
6063 }
6064 if returnFunc, ok := ret.Get(0).(func(context.Context, string, *entity.FolderID) *entity.Folder); ok {
6065 r0 = returnFunc(ctx, name, parentID)
6066 } else {
6067 if ret.Get(0) != nil {
6068 r0 = ret.Get(0).(*entity.Folder)
6069 }
6070 }
6071 if returnFunc, ok := ret.Get(1).(func(context.Context, string, *entity.FolderID) error); ok {
6072 r1 = returnFunc(ctx, name, parentID)
6073 } else {
6074 r1 = ret.Error(1)
6075 }
6076 return r0, r1
6077}
6078
6079// MockHomepageFavorites_CreateFolder_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateFolder'
6080type MockHomepageFavorites_CreateFolder_Call struct {
6081 *mock.Call
6082}
6083
6084// CreateFolder is a helper method to define mock.On call
6085// - ctx context.Context
6086// - name string
6087// - parentID *entity.FolderID
6088func (_e *MockHomepageFavorites_Expecter) CreateFolder(ctx interface{}, name interface{}, parentID interface{}) *MockHomepageFavorites_CreateFolder_Call {
6089 return &MockHomepageFavorites_CreateFolder_Call{Call: _e.mock.On("CreateFolder", ctx, name, parentID)}
6090}
6091
6092func (_c *MockHomepageFavorites_CreateFolder_Call) Run(run func(ctx context.Context, name string, parentID *entity.FolderID)) *MockHomepageFavorites_CreateFolder_Call {
6093 _c.Call.Run(func(args mock.Arguments) {
6094 var arg0 context.Context
6095 if args[0] != nil {
6096 arg0 = args[0].(context.Context)
6097 }
6098 var arg1 string
6099 if args[1] != nil {
6100 arg1 = args[1].(string)
6101 }
6102 var arg2 *entity.FolderID
6103 if args[2] != nil {
6104 arg2 = args[2].(*entity.FolderID)
6105 }
6106 run(
6107 arg0,
6108 arg1,
6109 arg2,
6110 )
6111 })
6112 return _c
6113}
6114
6115func (_c *MockHomepageFavorites_CreateFolder_Call) Return(folder *entity.Folder, err error) *MockHomepageFavorites_CreateFolder_Call {
6116 _c.Call.Return(folder, err)
6117 return _c
6118}
6119
6120func (_c *MockHomepageFavorites_CreateFolder_Call) RunAndReturn(run func(ctx context.Context, name string, parentID *entity.FolderID) (*entity.Folder, error)) *MockHomepageFavorites_CreateFolder_Call {
6121 _c.Call.Return(run)
6122 return _c
6123}
6124
6125// DeleteFolder provides a mock function for the type MockHomepageFavorites
6126func (_mock *MockHomepageFavorites) DeleteFolder(ctx context.Context, id entity.FolderID) error {
6127 ret := _mock.Called(ctx, id)
6128
6129 if len(ret) == 0 {
6130 panic("no return value specified for DeleteFolder")
6131 }
6132
6133 var r0 error
6134 if returnFunc, ok := ret.Get(0).(func(context.Context, entity.FolderID) error); ok {
6135 r0 = returnFunc(ctx, id)
6136 } else {
6137 r0 = ret.Error(0)
6138 }
6139 return r0
6140}
6141
6142// MockHomepageFavorites_DeleteFolder_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteFolder'
6143type MockHomepageFavorites_DeleteFolder_Call struct {
6144 *mock.Call
6145}
6146
6147// DeleteFolder is a helper method to define mock.On call
6148// - ctx context.Context
6149// - id entity.FolderID
6150func (_e *MockHomepageFavorites_Expecter) DeleteFolder(ctx interface{}, id interface{}) *MockHomepageFavorites_DeleteFolder_Call {
6151 return &MockHomepageFavorites_DeleteFolder_Call{Call: _e.mock.On("DeleteFolder", ctx, id)}
6152}
6153
6154func (_c *MockHomepageFavorites_DeleteFolder_Call) Run(run func(ctx context.Context, id entity.FolderID)) *MockHomepageFavorites_DeleteFolder_Call {
6155 _c.Call.Run(func(args mock.Arguments) {
6156 var arg0 context.Context
6157 if args[0] != nil {
6158 arg0 = args[0].(context.Context)
6159 }
6160 var arg1 entity.FolderID
6161 if args[1] != nil {
6162 arg1 = args[1].(entity.FolderID)
6163 }
6164 run(
6165 arg0,
6166 arg1,
6167 )
6168 })
6169 return _c
6170}
6171
6172func (_c *MockHomepageFavorites_DeleteFolder_Call) Return(err error) *MockHomepageFavorites_DeleteFolder_Call {
6173 _c.Call.Return(err)
6174 return _c
6175}
6176
6177func (_c *MockHomepageFavorites_DeleteFolder_Call) RunAndReturn(run func(ctx context.Context, id entity.FolderID) error) *MockHomepageFavorites_DeleteFolder_Call {
6178 _c.Call.Return(run)
6179 return _c
6180}
6181
6182// DeleteTag provides a mock function for the type MockHomepageFavorites
6183func (_mock *MockHomepageFavorites) DeleteTag(ctx context.Context, id entity.TagID) error {
6184 ret := _mock.Called(ctx, id)
6185
6186 if len(ret) == 0 {
6187 panic("no return value specified for DeleteTag")
6188 }
6189
6190 var r0 error
6191 if returnFunc, ok := ret.Get(0).(func(context.Context, entity.TagID) error); ok {
6192 r0 = returnFunc(ctx, id)
6193 } else {
6194 r0 = ret.Error(0)
6195 }
6196 return r0
6197}
6198
6199// MockHomepageFavorites_DeleteTag_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteTag'
6200type MockHomepageFavorites_DeleteTag_Call struct {
6201 *mock.Call
6202}
6203
6204// DeleteTag is a helper method to define mock.On call
6205// - ctx context.Context
6206// - id entity.TagID
6207func (_e *MockHomepageFavorites_Expecter) DeleteTag(ctx interface{}, id interface{}) *MockHomepageFavorites_DeleteTag_Call {
6208 return &MockHomepageFavorites_DeleteTag_Call{Call: _e.mock.On("DeleteTag", ctx, id)}
6209}
6210
6211func (_c *MockHomepageFavorites_DeleteTag_Call) Run(run func(ctx context.Context, id entity.TagID)) *MockHomepageFavorites_DeleteTag_Call {
6212 _c.Call.Run(func(args mock.Arguments) {
6213 var arg0 context.Context
6214 if args[0] != nil {
6215 arg0 = args[0].(context.Context)
6216 }
6217 var arg1 entity.TagID
6218 if args[1] != nil {
6219 arg1 = args[1].(entity.TagID)
6220 }
6221 run(
6222 arg0,
6223 arg1,
6224 )
6225 })
6226 return _c
6227}
6228
6229func (_c *MockHomepageFavorites_DeleteTag_Call) Return(err error) *MockHomepageFavorites_DeleteTag_Call {
6230 _c.Call.Return(err)
6231 return _c
6232}
6233
6234func (_c *MockHomepageFavorites_DeleteTag_Call) RunAndReturn(run func(ctx context.Context, id entity.TagID) error) *MockHomepageFavorites_DeleteTag_Call {
6235 _c.Call.Return(run)
6236 return _c
6237}
6238
6239// GetAll provides a mock function for the type MockHomepageFavorites
6240func (_mock *MockHomepageFavorites) GetAll(ctx context.Context) ([]*entity.Favorite, error) {
6241 ret := _mock.Called(ctx)
6242
6243 if len(ret) == 0 {
6244 panic("no return value specified for GetAll")
6245 }
6246
6247 var r0 []*entity.Favorite
6248 var r1 error
6249 if returnFunc, ok := ret.Get(0).(func(context.Context) ([]*entity.Favorite, error)); ok {
6250 return returnFunc(ctx)
6251 }
6252 if returnFunc, ok := ret.Get(0).(func(context.Context) []*entity.Favorite); ok {
6253 r0 = returnFunc(ctx)
6254 } else {
6255 if ret.Get(0) != nil {
6256 r0 = ret.Get(0).([]*entity.Favorite)
6257 }
6258 }
6259 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
6260 r1 = returnFunc(ctx)
6261 } else {
6262 r1 = ret.Error(1)
6263 }
6264 return r0, r1
6265}
6266
6267// MockHomepageFavorites_GetAll_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAll'
6268type MockHomepageFavorites_GetAll_Call struct {
6269 *mock.Call
6270}
6271
6272// GetAll is a helper method to define mock.On call
6273// - ctx context.Context
6274func (_e *MockHomepageFavorites_Expecter) GetAll(ctx interface{}) *MockHomepageFavorites_GetAll_Call {
6275 return &MockHomepageFavorites_GetAll_Call{Call: _e.mock.On("GetAll", ctx)}
6276}
6277
6278func (_c *MockHomepageFavorites_GetAll_Call) Run(run func(ctx context.Context)) *MockHomepageFavorites_GetAll_Call {
6279 _c.Call.Run(func(args mock.Arguments) {
6280 var arg0 context.Context
6281 if args[0] != nil {
6282 arg0 = args[0].(context.Context)
6283 }
6284 run(
6285 arg0,
6286 )
6287 })
6288 return _c
6289}
6290
6291func (_c *MockHomepageFavorites_GetAll_Call) Return(favorites []*entity.Favorite, err error) *MockHomepageFavorites_GetAll_Call {
6292 _c.Call.Return(favorites, err)
6293 return _c
6294}
6295
6296func (_c *MockHomepageFavorites_GetAll_Call) RunAndReturn(run func(ctx context.Context) ([]*entity.Favorite, error)) *MockHomepageFavorites_GetAll_Call {
6297 _c.Call.Return(run)
6298 return _c
6299}
6300
6301// GetAllFolders provides a mock function for the type MockHomepageFavorites
6302func (_mock *MockHomepageFavorites) GetAllFolders(ctx context.Context) ([]*entity.Folder, error) {
6303 ret := _mock.Called(ctx)
6304
6305 if len(ret) == 0 {
6306 panic("no return value specified for GetAllFolders")
6307 }
6308
6309 var r0 []*entity.Folder
6310 var r1 error
6311 if returnFunc, ok := ret.Get(0).(func(context.Context) ([]*entity.Folder, error)); ok {
6312 return returnFunc(ctx)
6313 }
6314 if returnFunc, ok := ret.Get(0).(func(context.Context) []*entity.Folder); ok {
6315 r0 = returnFunc(ctx)
6316 } else {
6317 if ret.Get(0) != nil {
6318 r0 = ret.Get(0).([]*entity.Folder)
6319 }
6320 }
6321 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
6322 r1 = returnFunc(ctx)
6323 } else {
6324 r1 = ret.Error(1)
6325 }
6326 return r0, r1
6327}
6328
6329// MockHomepageFavorites_GetAllFolders_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllFolders'
6330type MockHomepageFavorites_GetAllFolders_Call struct {
6331 *mock.Call
6332}
6333
6334// GetAllFolders is a helper method to define mock.On call
6335// - ctx context.Context
6336func (_e *MockHomepageFavorites_Expecter) GetAllFolders(ctx interface{}) *MockHomepageFavorites_GetAllFolders_Call {
6337 return &MockHomepageFavorites_GetAllFolders_Call{Call: _e.mock.On("GetAllFolders", ctx)}
6338}
6339
6340func (_c *MockHomepageFavorites_GetAllFolders_Call) Run(run func(ctx context.Context)) *MockHomepageFavorites_GetAllFolders_Call {
6341 _c.Call.Run(func(args mock.Arguments) {
6342 var arg0 context.Context
6343 if args[0] != nil {
6344 arg0 = args[0].(context.Context)
6345 }
6346 run(
6347 arg0,
6348 )
6349 })
6350 return _c
6351}
6352
6353func (_c *MockHomepageFavorites_GetAllFolders_Call) Return(folders []*entity.Folder, err error) *MockHomepageFavorites_GetAllFolders_Call {
6354 _c.Call.Return(folders, err)
6355 return _c
6356}
6357
6358func (_c *MockHomepageFavorites_GetAllFolders_Call) RunAndReturn(run func(ctx context.Context) ([]*entity.Folder, error)) *MockHomepageFavorites_GetAllFolders_Call {
6359 _c.Call.Return(run)
6360 return _c
6361}
6362
6363// GetAllTags provides a mock function for the type MockHomepageFavorites
6364func (_mock *MockHomepageFavorites) GetAllTags(ctx context.Context) ([]*entity.Tag, error) {
6365 ret := _mock.Called(ctx)
6366
6367 if len(ret) == 0 {
6368 panic("no return value specified for GetAllTags")
6369 }
6370
6371 var r0 []*entity.Tag
6372 var r1 error
6373 if returnFunc, ok := ret.Get(0).(func(context.Context) ([]*entity.Tag, error)); ok {
6374 return returnFunc(ctx)
6375 }
6376 if returnFunc, ok := ret.Get(0).(func(context.Context) []*entity.Tag); ok {
6377 r0 = returnFunc(ctx)
6378 } else {
6379 if ret.Get(0) != nil {
6380 r0 = ret.Get(0).([]*entity.Tag)
6381 }
6382 }
6383 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
6384 r1 = returnFunc(ctx)
6385 } else {
6386 r1 = ret.Error(1)
6387 }
6388 return r0, r1
6389}
6390
6391// MockHomepageFavorites_GetAllTags_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllTags'
6392type MockHomepageFavorites_GetAllTags_Call struct {
6393 *mock.Call
6394}
6395
6396// GetAllTags is a helper method to define mock.On call
6397// - ctx context.Context
6398func (_e *MockHomepageFavorites_Expecter) GetAllTags(ctx interface{}) *MockHomepageFavorites_GetAllTags_Call {
6399 return &MockHomepageFavorites_GetAllTags_Call{Call: _e.mock.On("GetAllTags", ctx)}
6400}
6401
6402func (_c *MockHomepageFavorites_GetAllTags_Call) Run(run func(ctx context.Context)) *MockHomepageFavorites_GetAllTags_Call {
6403 _c.Call.Run(func(args mock.Arguments) {
6404 var arg0 context.Context
6405 if args[0] != nil {
6406 arg0 = args[0].(context.Context)
6407 }
6408 run(
6409 arg0,
6410 )
6411 })
6412 return _c
6413}
6414
6415func (_c *MockHomepageFavorites_GetAllTags_Call) Return(tags []*entity.Tag, err error) *MockHomepageFavorites_GetAllTags_Call {
6416 _c.Call.Return(tags, err)
6417 return _c
6418}
6419
6420func (_c *MockHomepageFavorites_GetAllTags_Call) RunAndReturn(run func(ctx context.Context) ([]*entity.Tag, error)) *MockHomepageFavorites_GetAllTags_Call {
6421 _c.Call.Return(run)
6422 return _c
6423}
6424
6425// GetByShortcut provides a mock function for the type MockHomepageFavorites
6426func (_mock *MockHomepageFavorites) GetByShortcut(ctx context.Context, key int) (*entity.Favorite, error) {
6427 ret := _mock.Called(ctx, key)
6428
6429 if len(ret) == 0 {
6430 panic("no return value specified for GetByShortcut")
6431 }
6432
6433 var r0 *entity.Favorite
6434 var r1 error
6435 if returnFunc, ok := ret.Get(0).(func(context.Context, int) (*entity.Favorite, error)); ok {
6436 return returnFunc(ctx, key)
6437 }
6438 if returnFunc, ok := ret.Get(0).(func(context.Context, int) *entity.Favorite); ok {
6439 r0 = returnFunc(ctx, key)
6440 } else {
6441 if ret.Get(0) != nil {
6442 r0 = ret.Get(0).(*entity.Favorite)
6443 }
6444 }
6445 if returnFunc, ok := ret.Get(1).(func(context.Context, int) error); ok {
6446 r1 = returnFunc(ctx, key)
6447 } else {
6448 r1 = ret.Error(1)
6449 }
6450 return r0, r1
6451}
6452
6453// MockHomepageFavorites_GetByShortcut_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetByShortcut'
6454type MockHomepageFavorites_GetByShortcut_Call struct {
6455 *mock.Call
6456}
6457
6458// GetByShortcut is a helper method to define mock.On call
6459// - ctx context.Context
6460// - key int
6461func (_e *MockHomepageFavorites_Expecter) GetByShortcut(ctx interface{}, key interface{}) *MockHomepageFavorites_GetByShortcut_Call {
6462 return &MockHomepageFavorites_GetByShortcut_Call{Call: _e.mock.On("GetByShortcut", ctx, key)}
6463}
6464
6465func (_c *MockHomepageFavorites_GetByShortcut_Call) Run(run func(ctx context.Context, key int)) *MockHomepageFavorites_GetByShortcut_Call {
6466 _c.Call.Run(func(args mock.Arguments) {
6467 var arg0 context.Context
6468 if args[0] != nil {
6469 arg0 = args[0].(context.Context)
6470 }
6471 var arg1 int
6472 if args[1] != nil {
6473 arg1 = args[1].(int)
6474 }
6475 run(
6476 arg0,
6477 arg1,
6478 )
6479 })
6480 return _c
6481}
6482
6483func (_c *MockHomepageFavorites_GetByShortcut_Call) Return(favorite *entity.Favorite, err error) *MockHomepageFavorites_GetByShortcut_Call {
6484 _c.Call.Return(favorite, err)
6485 return _c
6486}
6487
6488func (_c *MockHomepageFavorites_GetByShortcut_Call) RunAndReturn(run func(ctx context.Context, key int) (*entity.Favorite, error)) *MockHomepageFavorites_GetByShortcut_Call {
6489 _c.Call.Return(run)
6490 return _c
6491}
6492
6493// Move provides a mock function for the type MockHomepageFavorites
6494func (_mock *MockHomepageFavorites) Move(ctx context.Context, id entity.FavoriteID, folderID *entity.FolderID) error {
6495 ret := _mock.Called(ctx, id, folderID)
6496
6497 if len(ret) == 0 {
6498 panic("no return value specified for Move")
6499 }
6500
6501 var r0 error
6502 if returnFunc, ok := ret.Get(0).(func(context.Context, entity.FavoriteID, *entity.FolderID) error); ok {
6503 r0 = returnFunc(ctx, id, folderID)
6504 } else {
6505 r0 = ret.Error(0)
6506 }
6507 return r0
6508}
6509
6510// MockHomepageFavorites_Move_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Move'
6511type MockHomepageFavorites_Move_Call struct {
6512 *mock.Call
6513}
6514
6515// Move is a helper method to define mock.On call
6516// - ctx context.Context
6517// - id entity.FavoriteID
6518// - folderID *entity.FolderID
6519func (_e *MockHomepageFavorites_Expecter) Move(ctx interface{}, id interface{}, folderID interface{}) *MockHomepageFavorites_Move_Call {
6520 return &MockHomepageFavorites_Move_Call{Call: _e.mock.On("Move", ctx, id, folderID)}
6521}
6522
6523func (_c *MockHomepageFavorites_Move_Call) Run(run func(ctx context.Context, id entity.FavoriteID, folderID *entity.FolderID)) *MockHomepageFavorites_Move_Call {
6524 _c.Call.Run(func(args mock.Arguments) {
6525 var arg0 context.Context
6526 if args[0] != nil {
6527 arg0 = args[0].(context.Context)
6528 }
6529 var arg1 entity.FavoriteID
6530 if args[1] != nil {
6531 arg1 = args[1].(entity.FavoriteID)
6532 }
6533 var arg2 *entity.FolderID
6534 if args[2] != nil {
6535 arg2 = args[2].(*entity.FolderID)
6536 }
6537 run(
6538 arg0,
6539 arg1,
6540 arg2,
6541 )
6542 })
6543 return _c
6544}
6545
6546func (_c *MockHomepageFavorites_Move_Call) Return(err error) *MockHomepageFavorites_Move_Call {
6547 _c.Call.Return(err)
6548 return _c
6549}
6550
6551func (_c *MockHomepageFavorites_Move_Call) RunAndReturn(run func(ctx context.Context, id entity.FavoriteID, folderID *entity.FolderID) error) *MockHomepageFavorites_Move_Call {
6552 _c.Call.Return(run)
6553 return _c
6554}
6555
6556// SetShortcut provides a mock function for the type MockHomepageFavorites
6557func (_mock *MockHomepageFavorites) SetShortcut(ctx context.Context, id entity.FavoriteID, key *int) error {
6558 ret := _mock.Called(ctx, id, key)
6559
6560 if len(ret) == 0 {
6561 panic("no return value specified for SetShortcut")
6562 }
6563
6564 var r0 error
6565 if returnFunc, ok := ret.Get(0).(func(context.Context, entity.FavoriteID, *int) error); ok {
6566 r0 = returnFunc(ctx, id, key)
6567 } else {
6568 r0 = ret.Error(0)
6569 }
6570 return r0
6571}
6572
6573// MockHomepageFavorites_SetShortcut_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetShortcut'
6574type MockHomepageFavorites_SetShortcut_Call struct {
6575 *mock.Call
6576}
6577
6578// SetShortcut is a helper method to define mock.On call
6579// - ctx context.Context
6580// - id entity.FavoriteID
6581// - key *int
6582func (_e *MockHomepageFavorites_Expecter) SetShortcut(ctx interface{}, id interface{}, key interface{}) *MockHomepageFavorites_SetShortcut_Call {
6583 return &MockHomepageFavorites_SetShortcut_Call{Call: _e.mock.On("SetShortcut", ctx, id, key)}
6584}
6585
6586func (_c *MockHomepageFavorites_SetShortcut_Call) Run(run func(ctx context.Context, id entity.FavoriteID, key *int)) *MockHomepageFavorites_SetShortcut_Call {
6587 _c.Call.Run(func(args mock.Arguments) {
6588 var arg0 context.Context
6589 if args[0] != nil {
6590 arg0 = args[0].(context.Context)
6591 }
6592 var arg1 entity.FavoriteID
6593 if args[1] != nil {
6594 arg1 = args[1].(entity.FavoriteID)
6595 }
6596 var arg2 *int
6597 if args[2] != nil {
6598 arg2 = args[2].(*int)
6599 }
6600 run(
6601 arg0,
6602 arg1,
6603 arg2,
6604 )
6605 })
6606 return _c
6607}
6608
6609func (_c *MockHomepageFavorites_SetShortcut_Call) Return(err error) *MockHomepageFavorites_SetShortcut_Call {
6610 _c.Call.Return(err)
6611 return _c
6612}
6613
6614func (_c *MockHomepageFavorites_SetShortcut_Call) RunAndReturn(run func(ctx context.Context, id entity.FavoriteID, key *int) error) *MockHomepageFavorites_SetShortcut_Call {
6615 _c.Call.Return(run)
6616 return _c
6617}
6618
6619// TagFavorite provides a mock function for the type MockHomepageFavorites
6620func (_mock *MockHomepageFavorites) TagFavorite(ctx context.Context, favID entity.FavoriteID, tagID entity.TagID) error {
6621 ret := _mock.Called(ctx, favID, tagID)
6622
6623 if len(ret) == 0 {
6624 panic("no return value specified for TagFavorite")
6625 }
6626
6627 var r0 error
6628 if returnFunc, ok := ret.Get(0).(func(context.Context, entity.FavoriteID, entity.TagID) error); ok {
6629 r0 = returnFunc(ctx, favID, tagID)
6630 } else {
6631 r0 = ret.Error(0)
6632 }
6633 return r0
6634}
6635
6636// MockHomepageFavorites_TagFavorite_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TagFavorite'
6637type MockHomepageFavorites_TagFavorite_Call struct {
6638 *mock.Call
6639}
6640
6641// TagFavorite is a helper method to define mock.On call
6642// - ctx context.Context
6643// - favID entity.FavoriteID
6644// - tagID entity.TagID
6645func (_e *MockHomepageFavorites_Expecter) TagFavorite(ctx interface{}, favID interface{}, tagID interface{}) *MockHomepageFavorites_TagFavorite_Call {
6646 return &MockHomepageFavorites_TagFavorite_Call{Call: _e.mock.On("TagFavorite", ctx, favID, tagID)}
6647}
6648
6649func (_c *MockHomepageFavorites_TagFavorite_Call) Run(run func(ctx context.Context, favID entity.FavoriteID, tagID entity.TagID)) *MockHomepageFavorites_TagFavorite_Call {
6650 _c.Call.Run(func(args mock.Arguments) {
6651 var arg0 context.Context
6652 if args[0] != nil {
6653 arg0 = args[0].(context.Context)
6654 }
6655 var arg1 entity.FavoriteID
6656 if args[1] != nil {
6657 arg1 = args[1].(entity.FavoriteID)
6658 }
6659 var arg2 entity.TagID
6660 if args[2] != nil {
6661 arg2 = args[2].(entity.TagID)
6662 }
6663 run(
6664 arg0,
6665 arg1,
6666 arg2,
6667 )
6668 })
6669 return _c
6670}
6671
6672func (_c *MockHomepageFavorites_TagFavorite_Call) Return(err error) *MockHomepageFavorites_TagFavorite_Call {
6673 _c.Call.Return(err)
6674 return _c
6675}
6676
6677func (_c *MockHomepageFavorites_TagFavorite_Call) RunAndReturn(run func(ctx context.Context, favID entity.FavoriteID, tagID entity.TagID) error) *MockHomepageFavorites_TagFavorite_Call {
6678 _c.Call.Return(run)
6679 return _c
6680}
6681
6682// UntagFavorite provides a mock function for the type MockHomepageFavorites
6683func (_mock *MockHomepageFavorites) UntagFavorite(ctx context.Context, favID entity.FavoriteID, tagID entity.TagID) error {
6684 ret := _mock.Called(ctx, favID, tagID)
6685
6686 if len(ret) == 0 {
6687 panic("no return value specified for UntagFavorite")
6688 }
6689
6690 var r0 error
6691 if returnFunc, ok := ret.Get(0).(func(context.Context, entity.FavoriteID, entity.TagID) error); ok {
6692 r0 = returnFunc(ctx, favID, tagID)
6693 } else {
6694 r0 = ret.Error(0)
6695 }
6696 return r0
6697}
6698
6699// MockHomepageFavorites_UntagFavorite_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UntagFavorite'
6700type MockHomepageFavorites_UntagFavorite_Call struct {
6701 *mock.Call
6702}
6703
6704// UntagFavorite is a helper method to define mock.On call
6705// - ctx context.Context
6706// - favID entity.FavoriteID
6707// - tagID entity.TagID
6708func (_e *MockHomepageFavorites_Expecter) UntagFavorite(ctx interface{}, favID interface{}, tagID interface{}) *MockHomepageFavorites_UntagFavorite_Call {
6709 return &MockHomepageFavorites_UntagFavorite_Call{Call: _e.mock.On("UntagFavorite", ctx, favID, tagID)}
6710}
6711
6712func (_c *MockHomepageFavorites_UntagFavorite_Call) Run(run func(ctx context.Context, favID entity.FavoriteID, tagID entity.TagID)) *MockHomepageFavorites_UntagFavorite_Call {
6713 _c.Call.Run(func(args mock.Arguments) {
6714 var arg0 context.Context
6715 if args[0] != nil {
6716 arg0 = args[0].(context.Context)
6717 }
6718 var arg1 entity.FavoriteID
6719 if args[1] != nil {
6720 arg1 = args[1].(entity.FavoriteID)
6721 }
6722 var arg2 entity.TagID
6723 if args[2] != nil {
6724 arg2 = args[2].(entity.TagID)
6725 }
6726 run(
6727 arg0,
6728 arg1,
6729 arg2,
6730 )
6731 })
6732 return _c
6733}
6734
6735func (_c *MockHomepageFavorites_UntagFavorite_Call) Return(err error) *MockHomepageFavorites_UntagFavorite_Call {
6736 _c.Call.Return(err)
6737 return _c
6738}
6739
6740func (_c *MockHomepageFavorites_UntagFavorite_Call) RunAndReturn(run func(ctx context.Context, favID entity.FavoriteID, tagID entity.TagID) error) *MockHomepageFavorites_UntagFavorite_Call {
6741 _c.Call.Return(run)
6742 return _c
6743}
6744
6745// UpdateFolder provides a mock function for the type MockHomepageFavorites
6746func (_mock *MockHomepageFavorites) UpdateFolder(ctx context.Context, id entity.FolderID, name string, icon string) error {
6747 ret := _mock.Called(ctx, id, name, icon)
6748
6749 if len(ret) == 0 {
6750 panic("no return value specified for UpdateFolder")
6751 }
6752
6753 var r0 error
6754 if returnFunc, ok := ret.Get(0).(func(context.Context, entity.FolderID, string, string) error); ok {
6755 r0 = returnFunc(ctx, id, name, icon)
6756 } else {
6757 r0 = ret.Error(0)
6758 }
6759 return r0
6760}
6761
6762// MockHomepageFavorites_UpdateFolder_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateFolder'
6763type MockHomepageFavorites_UpdateFolder_Call struct {
6764 *mock.Call
6765}
6766
6767// UpdateFolder is a helper method to define mock.On call
6768// - ctx context.Context
6769// - id entity.FolderID
6770// - name string
6771// - icon string
6772func (_e *MockHomepageFavorites_Expecter) UpdateFolder(ctx interface{}, id interface{}, name interface{}, icon interface{}) *MockHomepageFavorites_UpdateFolder_Call {
6773 return &MockHomepageFavorites_UpdateFolder_Call{Call: _e.mock.On("UpdateFolder", ctx, id, name, icon)}
6774}
6775
6776func (_c *MockHomepageFavorites_UpdateFolder_Call) Run(run func(ctx context.Context, id entity.FolderID, name string, icon string)) *MockHomepageFavorites_UpdateFolder_Call {
6777 _c.Call.Run(func(args mock.Arguments) {
6778 var arg0 context.Context
6779 if args[0] != nil {
6780 arg0 = args[0].(context.Context)
6781 }
6782 var arg1 entity.FolderID
6783 if args[1] != nil {
6784 arg1 = args[1].(entity.FolderID)
6785 }
6786 var arg2 string
6787 if args[2] != nil {
6788 arg2 = args[2].(string)
6789 }
6790 var arg3 string
6791 if args[3] != nil {
6792 arg3 = args[3].(string)
6793 }
6794 run(
6795 arg0,
6796 arg1,
6797 arg2,
6798 arg3,
6799 )
6800 })
6801 return _c
6802}
6803
6804func (_c *MockHomepageFavorites_UpdateFolder_Call) Return(err error) *MockHomepageFavorites_UpdateFolder_Call {
6805 _c.Call.Return(err)
6806 return _c
6807}
6808
6809func (_c *MockHomepageFavorites_UpdateFolder_Call) RunAndReturn(run func(ctx context.Context, id entity.FolderID, name string, icon string) error) *MockHomepageFavorites_UpdateFolder_Call {
6810 _c.Call.Return(run)
6811 return _c
6812}
6813
6814// UpdateTag provides a mock function for the type MockHomepageFavorites
6815func (_mock *MockHomepageFavorites) UpdateTag(ctx context.Context, id entity.TagID, name string, color string) error {
6816 ret := _mock.Called(ctx, id, name, color)
6817
6818 if len(ret) == 0 {
6819 panic("no return value specified for UpdateTag")
6820 }
6821
6822 var r0 error
6823 if returnFunc, ok := ret.Get(0).(func(context.Context, entity.TagID, string, string) error); ok {
6824 r0 = returnFunc(ctx, id, name, color)
6825 } else {
6826 r0 = ret.Error(0)
6827 }
6828 return r0
6829}
6830
6831// MockHomepageFavorites_UpdateTag_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateTag'
6832type MockHomepageFavorites_UpdateTag_Call struct {
6833 *mock.Call
6834}
6835
6836// UpdateTag is a helper method to define mock.On call
6837// - ctx context.Context
6838// - id entity.TagID
6839// - name string
6840// - color string
6841func (_e *MockHomepageFavorites_Expecter) UpdateTag(ctx interface{}, id interface{}, name interface{}, color interface{}) *MockHomepageFavorites_UpdateTag_Call {
6842 return &MockHomepageFavorites_UpdateTag_Call{Call: _e.mock.On("UpdateTag", ctx, id, name, color)}
6843}
6844
6845func (_c *MockHomepageFavorites_UpdateTag_Call) Run(run func(ctx context.Context, id entity.TagID, name string, color string)) *MockHomepageFavorites_UpdateTag_Call {
6846 _c.Call.Run(func(args mock.Arguments) {
6847 var arg0 context.Context
6848 if args[0] != nil {
6849 arg0 = args[0].(context.Context)
6850 }
6851 var arg1 entity.TagID
6852 if args[1] != nil {
6853 arg1 = args[1].(entity.TagID)
6854 }
6855 var arg2 string
6856 if args[2] != nil {
6857 arg2 = args[2].(string)
6858 }
6859 var arg3 string
6860 if args[3] != nil {
6861 arg3 = args[3].(string)
6862 }
6863 run(
6864 arg0,
6865 arg1,
6866 arg2,
6867 arg3,
6868 )
6869 })
6870 return _c
6871}
6872
6873func (_c *MockHomepageFavorites_UpdateTag_Call) Return(err error) *MockHomepageFavorites_UpdateTag_Call {
6874 _c.Call.Return(err)
6875 return _c
6876}
6877
6878func (_c *MockHomepageFavorites_UpdateTag_Call) RunAndReturn(run func(ctx context.Context, id entity.TagID, name string, color string) error) *MockHomepageFavorites_UpdateTag_Call {
6879 _c.Call.Return(run)
6880 return _c
6881}
6882
6883// NewMockIdleInhibitor creates a new instance of MockIdleInhibitor. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
6884// The first argument is typically a *testing.T value.
6885func NewMockIdleInhibitor(t interface {
6886 mock.TestingT
6887 Cleanup(func())
6888}) *MockIdleInhibitor {
6889 mock := &MockIdleInhibitor{}
6890 mock.Mock.Test(t)
6891
6892 t.Cleanup(func() { mock.AssertExpectations(t) })
6893
6894 return mock
6895}
6896
6897// MockIdleInhibitor is an autogenerated mock type for the IdleInhibitor type
6898type MockIdleInhibitor struct {
6899 mock.Mock
6900}
6901
6902type MockIdleInhibitor_Expecter struct {
6903 mock *mock.Mock
6904}
6905
6906func (_m *MockIdleInhibitor) EXPECT() *MockIdleInhibitor_Expecter {
6907 return &MockIdleInhibitor_Expecter{mock: &_m.Mock}
6908}
6909
6910// Close provides a mock function for the type MockIdleInhibitor
6911func (_mock *MockIdleInhibitor) Close() error {
6912 ret := _mock.Called()
6913
6914 if len(ret) == 0 {
6915 panic("no return value specified for Close")
6916 }
6917
6918 var r0 error
6919 if returnFunc, ok := ret.Get(0).(func() error); ok {
6920 r0 = returnFunc()
6921 } else {
6922 r0 = ret.Error(0)
6923 }
6924 return r0
6925}
6926
6927// MockIdleInhibitor_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
6928type MockIdleInhibitor_Close_Call struct {
6929 *mock.Call
6930}
6931
6932// Close is a helper method to define mock.On call
6933func (_e *MockIdleInhibitor_Expecter) Close() *MockIdleInhibitor_Close_Call {
6934 return &MockIdleInhibitor_Close_Call{Call: _e.mock.On("Close")}
6935}
6936
6937func (_c *MockIdleInhibitor_Close_Call) Run(run func()) *MockIdleInhibitor_Close_Call {
6938 _c.Call.Run(func(args mock.Arguments) {
6939 run()
6940 })
6941 return _c
6942}
6943
6944func (_c *MockIdleInhibitor_Close_Call) Return(err error) *MockIdleInhibitor_Close_Call {
6945 _c.Call.Return(err)
6946 return _c
6947}
6948
6949func (_c *MockIdleInhibitor_Close_Call) RunAndReturn(run func() error) *MockIdleInhibitor_Close_Call {
6950 _c.Call.Return(run)
6951 return _c
6952}
6953
6954// Inhibit provides a mock function for the type MockIdleInhibitor
6955func (_mock *MockIdleInhibitor) Inhibit(ctx context.Context, reason string) error {
6956 ret := _mock.Called(ctx, reason)
6957
6958 if len(ret) == 0 {
6959 panic("no return value specified for Inhibit")
6960 }
6961
6962 var r0 error
6963 if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
6964 r0 = returnFunc(ctx, reason)
6965 } else {
6966 r0 = ret.Error(0)
6967 }
6968 return r0
6969}
6970
6971// MockIdleInhibitor_Inhibit_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Inhibit'
6972type MockIdleInhibitor_Inhibit_Call struct {
6973 *mock.Call
6974}
6975
6976// Inhibit is a helper method to define mock.On call
6977// - ctx context.Context
6978// - reason string
6979func (_e *MockIdleInhibitor_Expecter) Inhibit(ctx interface{}, reason interface{}) *MockIdleInhibitor_Inhibit_Call {
6980 return &MockIdleInhibitor_Inhibit_Call{Call: _e.mock.On("Inhibit", ctx, reason)}
6981}
6982
6983func (_c *MockIdleInhibitor_Inhibit_Call) Run(run func(ctx context.Context, reason string)) *MockIdleInhibitor_Inhibit_Call {
6984 _c.Call.Run(func(args mock.Arguments) {
6985 var arg0 context.Context
6986 if args[0] != nil {
6987 arg0 = args[0].(context.Context)
6988 }
6989 var arg1 string
6990 if args[1] != nil {
6991 arg1 = args[1].(string)
6992 }
6993 run(
6994 arg0,
6995 arg1,
6996 )
6997 })
6998 return _c
6999}
7000
7001func (_c *MockIdleInhibitor_Inhibit_Call) Return(err error) *MockIdleInhibitor_Inhibit_Call {
7002 _c.Call.Return(err)
7003 return _c
7004}
7005
7006func (_c *MockIdleInhibitor_Inhibit_Call) RunAndReturn(run func(ctx context.Context, reason string) error) *MockIdleInhibitor_Inhibit_Call {
7007 _c.Call.Return(run)
7008 return _c
7009}
7010
7011// IsInhibited provides a mock function for the type MockIdleInhibitor
7012func (_mock *MockIdleInhibitor) IsInhibited() bool {
7013 ret := _mock.Called()
7014
7015 if len(ret) == 0 {
7016 panic("no return value specified for IsInhibited")
7017 }
7018
7019 var r0 bool
7020 if returnFunc, ok := ret.Get(0).(func() bool); ok {
7021 r0 = returnFunc()
7022 } else {
7023 r0 = ret.Get(0).(bool)
7024 }
7025 return r0
7026}
7027
7028// MockIdleInhibitor_IsInhibited_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsInhibited'
7029type MockIdleInhibitor_IsInhibited_Call struct {
7030 *mock.Call
7031}
7032
7033// IsInhibited is a helper method to define mock.On call
7034func (_e *MockIdleInhibitor_Expecter) IsInhibited() *MockIdleInhibitor_IsInhibited_Call {
7035 return &MockIdleInhibitor_IsInhibited_Call{Call: _e.mock.On("IsInhibited")}
7036}
7037
7038func (_c *MockIdleInhibitor_IsInhibited_Call) Run(run func()) *MockIdleInhibitor_IsInhibited_Call {
7039 _c.Call.Run(func(args mock.Arguments) {
7040 run()
7041 })
7042 return _c
7043}
7044
7045func (_c *MockIdleInhibitor_IsInhibited_Call) Return(b bool) *MockIdleInhibitor_IsInhibited_Call {
7046 _c.Call.Return(b)
7047 return _c
7048}
7049
7050func (_c *MockIdleInhibitor_IsInhibited_Call) RunAndReturn(run func() bool) *MockIdleInhibitor_IsInhibited_Call {
7051 _c.Call.Return(run)
7052 return _c
7053}
7054
7055// Uninhibit provides a mock function for the type MockIdleInhibitor
7056func (_mock *MockIdleInhibitor) Uninhibit(ctx context.Context) error {
7057 ret := _mock.Called(ctx)
7058
7059 if len(ret) == 0 {
7060 panic("no return value specified for Uninhibit")
7061 }
7062
7063 var r0 error
7064 if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
7065 r0 = returnFunc(ctx)
7066 } else {
7067 r0 = ret.Error(0)
7068 }
7069 return r0
7070}
7071
7072// MockIdleInhibitor_Uninhibit_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Uninhibit'
7073type MockIdleInhibitor_Uninhibit_Call struct {
7074 *mock.Call
7075}
7076
7077// Uninhibit is a helper method to define mock.On call
7078// - ctx context.Context
7079func (_e *MockIdleInhibitor_Expecter) Uninhibit(ctx interface{}) *MockIdleInhibitor_Uninhibit_Call {
7080 return &MockIdleInhibitor_Uninhibit_Call{Call: _e.mock.On("Uninhibit", ctx)}
7081}
7082
7083func (_c *MockIdleInhibitor_Uninhibit_Call) Run(run func(ctx context.Context)) *MockIdleInhibitor_Uninhibit_Call {
7084 _c.Call.Run(func(args mock.Arguments) {
7085 var arg0 context.Context
7086 if args[0] != nil {
7087 arg0 = args[0].(context.Context)
7088 }
7089 run(
7090 arg0,
7091 )
7092 })
7093 return _c
7094}
7095
7096func (_c *MockIdleInhibitor_Uninhibit_Call) Return(err error) *MockIdleInhibitor_Uninhibit_Call {
7097 _c.Call.Return(err)
7098 return _c
7099}
7100
7101func (_c *MockIdleInhibitor_Uninhibit_Call) RunAndReturn(run func(ctx context.Context) error) *MockIdleInhibitor_Uninhibit_Call {
7102 _c.Call.Return(run)
7103 return _c
7104}
7105
7106// NewMockKeybindingsProvider creates a new instance of MockKeybindingsProvider. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
7107// The first argument is typically a *testing.T value.
7108func NewMockKeybindingsProvider(t interface {
7109 mock.TestingT
7110 Cleanup(func())
7111}) *MockKeybindingsProvider {
7112 mock := &MockKeybindingsProvider{}
7113 mock.Mock.Test(t)
7114
7115 t.Cleanup(func() { mock.AssertExpectations(t) })
7116
7117 return mock
7118}
7119
7120// MockKeybindingsProvider is an autogenerated mock type for the KeybindingsProvider type
7121type MockKeybindingsProvider struct {
7122 mock.Mock
7123}
7124
7125type MockKeybindingsProvider_Expecter struct {
7126 mock *mock.Mock
7127}
7128
7129func (_m *MockKeybindingsProvider) EXPECT() *MockKeybindingsProvider_Expecter {
7130 return &MockKeybindingsProvider_Expecter{mock: &_m.Mock}
7131}
7132
7133// CheckConflicts provides a mock function for the type MockKeybindingsProvider
7134func (_mock *MockKeybindingsProvider) CheckConflicts(ctx context.Context, mode string, action string, keys []string) ([]port.KeybindingConflict, error) {
7135 ret := _mock.Called(ctx, mode, action, keys)
7136
7137 if len(ret) == 0 {
7138 panic("no return value specified for CheckConflicts")
7139 }
7140
7141 var r0 []port.KeybindingConflict
7142 var r1 error
7143 if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, []string) ([]port.KeybindingConflict, error)); ok {
7144 return returnFunc(ctx, mode, action, keys)
7145 }
7146 if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, []string) []port.KeybindingConflict); ok {
7147 r0 = returnFunc(ctx, mode, action, keys)
7148 } else {
7149 if ret.Get(0) != nil {
7150 r0 = ret.Get(0).([]port.KeybindingConflict)
7151 }
7152 }
7153 if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, []string) error); ok {
7154 r1 = returnFunc(ctx, mode, action, keys)
7155 } else {
7156 r1 = ret.Error(1)
7157 }
7158 return r0, r1
7159}
7160
7161// MockKeybindingsProvider_CheckConflicts_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CheckConflicts'
7162type MockKeybindingsProvider_CheckConflicts_Call struct {
7163 *mock.Call
7164}
7165
7166// CheckConflicts is a helper method to define mock.On call
7167// - ctx context.Context
7168// - mode string
7169// - action string
7170// - keys []string
7171func (_e *MockKeybindingsProvider_Expecter) CheckConflicts(ctx interface{}, mode interface{}, action interface{}, keys interface{}) *MockKeybindingsProvider_CheckConflicts_Call {
7172 return &MockKeybindingsProvider_CheckConflicts_Call{Call: _e.mock.On("CheckConflicts", ctx, mode, action, keys)}
7173}
7174
7175func (_c *MockKeybindingsProvider_CheckConflicts_Call) Run(run func(ctx context.Context, mode string, action string, keys []string)) *MockKeybindingsProvider_CheckConflicts_Call {
7176 _c.Call.Run(func(args mock.Arguments) {
7177 var arg0 context.Context
7178 if args[0] != nil {
7179 arg0 = args[0].(context.Context)
7180 }
7181 var arg1 string
7182 if args[1] != nil {
7183 arg1 = args[1].(string)
7184 }
7185 var arg2 string
7186 if args[2] != nil {
7187 arg2 = args[2].(string)
7188 }
7189 var arg3 []string
7190 if args[3] != nil {
7191 arg3 = args[3].([]string)
7192 }
7193 run(
7194 arg0,
7195 arg1,
7196 arg2,
7197 arg3,
7198 )
7199 })
7200 return _c
7201}
7202
7203func (_c *MockKeybindingsProvider_CheckConflicts_Call) Return(keybindingConflicts []port.KeybindingConflict, err error) *MockKeybindingsProvider_CheckConflicts_Call {
7204 _c.Call.Return(keybindingConflicts, err)
7205 return _c
7206}
7207
7208func (_c *MockKeybindingsProvider_CheckConflicts_Call) RunAndReturn(run func(ctx context.Context, mode string, action string, keys []string) ([]port.KeybindingConflict, error)) *MockKeybindingsProvider_CheckConflicts_Call {
7209 _c.Call.Return(run)
7210 return _c
7211}
7212
7213// GetDefaultKeybindings provides a mock function for the type MockKeybindingsProvider
7214func (_mock *MockKeybindingsProvider) GetDefaultKeybindings(ctx context.Context) (port.KeybindingsConfig, error) {
7215 ret := _mock.Called(ctx)
7216
7217 if len(ret) == 0 {
7218 panic("no return value specified for GetDefaultKeybindings")
7219 }
7220
7221 var r0 port.KeybindingsConfig
7222 var r1 error
7223 if returnFunc, ok := ret.Get(0).(func(context.Context) (port.KeybindingsConfig, error)); ok {
7224 return returnFunc(ctx)
7225 }
7226 if returnFunc, ok := ret.Get(0).(func(context.Context) port.KeybindingsConfig); ok {
7227 r0 = returnFunc(ctx)
7228 } else {
7229 r0 = ret.Get(0).(port.KeybindingsConfig)
7230 }
7231 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
7232 r1 = returnFunc(ctx)
7233 } else {
7234 r1 = ret.Error(1)
7235 }
7236 return r0, r1
7237}
7238
7239// MockKeybindingsProvider_GetDefaultKeybindings_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetDefaultKeybindings'
7240type MockKeybindingsProvider_GetDefaultKeybindings_Call struct {
7241 *mock.Call
7242}
7243
7244// GetDefaultKeybindings is a helper method to define mock.On call
7245// - ctx context.Context
7246func (_e *MockKeybindingsProvider_Expecter) GetDefaultKeybindings(ctx interface{}) *MockKeybindingsProvider_GetDefaultKeybindings_Call {
7247 return &MockKeybindingsProvider_GetDefaultKeybindings_Call{Call: _e.mock.On("GetDefaultKeybindings", ctx)}
7248}
7249
7250func (_c *MockKeybindingsProvider_GetDefaultKeybindings_Call) Run(run func(ctx context.Context)) *MockKeybindingsProvider_GetDefaultKeybindings_Call {
7251 _c.Call.Run(func(args mock.Arguments) {
7252 var arg0 context.Context
7253 if args[0] != nil {
7254 arg0 = args[0].(context.Context)
7255 }
7256 run(
7257 arg0,
7258 )
7259 })
7260 return _c
7261}
7262
7263func (_c *MockKeybindingsProvider_GetDefaultKeybindings_Call) Return(keybindingsConfig port.KeybindingsConfig, err error) *MockKeybindingsProvider_GetDefaultKeybindings_Call {
7264 _c.Call.Return(keybindingsConfig, err)
7265 return _c
7266}
7267
7268func (_c *MockKeybindingsProvider_GetDefaultKeybindings_Call) RunAndReturn(run func(ctx context.Context) (port.KeybindingsConfig, error)) *MockKeybindingsProvider_GetDefaultKeybindings_Call {
7269 _c.Call.Return(run)
7270 return _c
7271}
7272
7273// GetKeybindings provides a mock function for the type MockKeybindingsProvider
7274func (_mock *MockKeybindingsProvider) GetKeybindings(ctx context.Context) (port.KeybindingsConfig, error) {
7275 ret := _mock.Called(ctx)
7276
7277 if len(ret) == 0 {
7278 panic("no return value specified for GetKeybindings")
7279 }
7280
7281 var r0 port.KeybindingsConfig
7282 var r1 error
7283 if returnFunc, ok := ret.Get(0).(func(context.Context) (port.KeybindingsConfig, error)); ok {
7284 return returnFunc(ctx)
7285 }
7286 if returnFunc, ok := ret.Get(0).(func(context.Context) port.KeybindingsConfig); ok {
7287 r0 = returnFunc(ctx)
7288 } else {
7289 r0 = ret.Get(0).(port.KeybindingsConfig)
7290 }
7291 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
7292 r1 = returnFunc(ctx)
7293 } else {
7294 r1 = ret.Error(1)
7295 }
7296 return r0, r1
7297}
7298
7299// MockKeybindingsProvider_GetKeybindings_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetKeybindings'
7300type MockKeybindingsProvider_GetKeybindings_Call struct {
7301 *mock.Call
7302}
7303
7304// GetKeybindings is a helper method to define mock.On call
7305// - ctx context.Context
7306func (_e *MockKeybindingsProvider_Expecter) GetKeybindings(ctx interface{}) *MockKeybindingsProvider_GetKeybindings_Call {
7307 return &MockKeybindingsProvider_GetKeybindings_Call{Call: _e.mock.On("GetKeybindings", ctx)}
7308}
7309
7310func (_c *MockKeybindingsProvider_GetKeybindings_Call) Run(run func(ctx context.Context)) *MockKeybindingsProvider_GetKeybindings_Call {
7311 _c.Call.Run(func(args mock.Arguments) {
7312 var arg0 context.Context
7313 if args[0] != nil {
7314 arg0 = args[0].(context.Context)
7315 }
7316 run(
7317 arg0,
7318 )
7319 })
7320 return _c
7321}
7322
7323func (_c *MockKeybindingsProvider_GetKeybindings_Call) Return(keybindingsConfig port.KeybindingsConfig, err error) *MockKeybindingsProvider_GetKeybindings_Call {
7324 _c.Call.Return(keybindingsConfig, err)
7325 return _c
7326}
7327
7328func (_c *MockKeybindingsProvider_GetKeybindings_Call) RunAndReturn(run func(ctx context.Context) (port.KeybindingsConfig, error)) *MockKeybindingsProvider_GetKeybindings_Call {
7329 _c.Call.Return(run)
7330 return _c
7331}
7332
7333// NewMockKeybindingsSaver creates a new instance of MockKeybindingsSaver. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
7334// The first argument is typically a *testing.T value.
7335func NewMockKeybindingsSaver(t interface {
7336 mock.TestingT
7337 Cleanup(func())
7338}) *MockKeybindingsSaver {
7339 mock := &MockKeybindingsSaver{}
7340 mock.Mock.Test(t)
7341
7342 t.Cleanup(func() { mock.AssertExpectations(t) })
7343
7344 return mock
7345}
7346
7347// MockKeybindingsSaver is an autogenerated mock type for the KeybindingsSaver type
7348type MockKeybindingsSaver struct {
7349 mock.Mock
7350}
7351
7352type MockKeybindingsSaver_Expecter struct {
7353 mock *mock.Mock
7354}
7355
7356func (_m *MockKeybindingsSaver) EXPECT() *MockKeybindingsSaver_Expecter {
7357 return &MockKeybindingsSaver_Expecter{mock: &_m.Mock}
7358}
7359
7360// ResetAllKeybindings provides a mock function for the type MockKeybindingsSaver
7361func (_mock *MockKeybindingsSaver) ResetAllKeybindings(ctx context.Context) error {
7362 ret := _mock.Called(ctx)
7363
7364 if len(ret) == 0 {
7365 panic("no return value specified for ResetAllKeybindings")
7366 }
7367
7368 var r0 error
7369 if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
7370 r0 = returnFunc(ctx)
7371 } else {
7372 r0 = ret.Error(0)
7373 }
7374 return r0
7375}
7376
7377// MockKeybindingsSaver_ResetAllKeybindings_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResetAllKeybindings'
7378type MockKeybindingsSaver_ResetAllKeybindings_Call struct {
7379 *mock.Call
7380}
7381
7382// ResetAllKeybindings is a helper method to define mock.On call
7383// - ctx context.Context
7384func (_e *MockKeybindingsSaver_Expecter) ResetAllKeybindings(ctx interface{}) *MockKeybindingsSaver_ResetAllKeybindings_Call {
7385 return &MockKeybindingsSaver_ResetAllKeybindings_Call{Call: _e.mock.On("ResetAllKeybindings", ctx)}
7386}
7387
7388func (_c *MockKeybindingsSaver_ResetAllKeybindings_Call) Run(run func(ctx context.Context)) *MockKeybindingsSaver_ResetAllKeybindings_Call {
7389 _c.Call.Run(func(args mock.Arguments) {
7390 var arg0 context.Context
7391 if args[0] != nil {
7392 arg0 = args[0].(context.Context)
7393 }
7394 run(
7395 arg0,
7396 )
7397 })
7398 return _c
7399}
7400
7401func (_c *MockKeybindingsSaver_ResetAllKeybindings_Call) Return(err error) *MockKeybindingsSaver_ResetAllKeybindings_Call {
7402 _c.Call.Return(err)
7403 return _c
7404}
7405
7406func (_c *MockKeybindingsSaver_ResetAllKeybindings_Call) RunAndReturn(run func(ctx context.Context) error) *MockKeybindingsSaver_ResetAllKeybindings_Call {
7407 _c.Call.Return(run)
7408 return _c
7409}
7410
7411// ResetKeybinding provides a mock function for the type MockKeybindingsSaver
7412func (_mock *MockKeybindingsSaver) ResetKeybinding(ctx context.Context, req port.ResetKeybindingRequest) error {
7413 ret := _mock.Called(ctx, req)
7414
7415 if len(ret) == 0 {
7416 panic("no return value specified for ResetKeybinding")
7417 }
7418
7419 var r0 error
7420 if returnFunc, ok := ret.Get(0).(func(context.Context, port.ResetKeybindingRequest) error); ok {
7421 r0 = returnFunc(ctx, req)
7422 } else {
7423 r0 = ret.Error(0)
7424 }
7425 return r0
7426}
7427
7428// MockKeybindingsSaver_ResetKeybinding_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResetKeybinding'
7429type MockKeybindingsSaver_ResetKeybinding_Call struct {
7430 *mock.Call
7431}
7432
7433// ResetKeybinding is a helper method to define mock.On call
7434// - ctx context.Context
7435// - req port.ResetKeybindingRequest
7436func (_e *MockKeybindingsSaver_Expecter) ResetKeybinding(ctx interface{}, req interface{}) *MockKeybindingsSaver_ResetKeybinding_Call {
7437 return &MockKeybindingsSaver_ResetKeybinding_Call{Call: _e.mock.On("ResetKeybinding", ctx, req)}
7438}
7439
7440func (_c *MockKeybindingsSaver_ResetKeybinding_Call) Run(run func(ctx context.Context, req port.ResetKeybindingRequest)) *MockKeybindingsSaver_ResetKeybinding_Call {
7441 _c.Call.Run(func(args mock.Arguments) {
7442 var arg0 context.Context
7443 if args[0] != nil {
7444 arg0 = args[0].(context.Context)
7445 }
7446 var arg1 port.ResetKeybindingRequest
7447 if args[1] != nil {
7448 arg1 = args[1].(port.ResetKeybindingRequest)
7449 }
7450 run(
7451 arg0,
7452 arg1,
7453 )
7454 })
7455 return _c
7456}
7457
7458func (_c *MockKeybindingsSaver_ResetKeybinding_Call) Return(err error) *MockKeybindingsSaver_ResetKeybinding_Call {
7459 _c.Call.Return(err)
7460 return _c
7461}
7462
7463func (_c *MockKeybindingsSaver_ResetKeybinding_Call) RunAndReturn(run func(ctx context.Context, req port.ResetKeybindingRequest) error) *MockKeybindingsSaver_ResetKeybinding_Call {
7464 _c.Call.Return(run)
7465 return _c
7466}
7467
7468// SetKeybinding provides a mock function for the type MockKeybindingsSaver
7469func (_mock *MockKeybindingsSaver) SetKeybinding(ctx context.Context, req port.SetKeybindingRequest) error {
7470 ret := _mock.Called(ctx, req)
7471
7472 if len(ret) == 0 {
7473 panic("no return value specified for SetKeybinding")
7474 }
7475
7476 var r0 error
7477 if returnFunc, ok := ret.Get(0).(func(context.Context, port.SetKeybindingRequest) error); ok {
7478 r0 = returnFunc(ctx, req)
7479 } else {
7480 r0 = ret.Error(0)
7481 }
7482 return r0
7483}
7484
7485// MockKeybindingsSaver_SetKeybinding_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetKeybinding'
7486type MockKeybindingsSaver_SetKeybinding_Call struct {
7487 *mock.Call
7488}
7489
7490// SetKeybinding is a helper method to define mock.On call
7491// - ctx context.Context
7492// - req port.SetKeybindingRequest
7493func (_e *MockKeybindingsSaver_Expecter) SetKeybinding(ctx interface{}, req interface{}) *MockKeybindingsSaver_SetKeybinding_Call {
7494 return &MockKeybindingsSaver_SetKeybinding_Call{Call: _e.mock.On("SetKeybinding", ctx, req)}
7495}
7496
7497func (_c *MockKeybindingsSaver_SetKeybinding_Call) Run(run func(ctx context.Context, req port.SetKeybindingRequest)) *MockKeybindingsSaver_SetKeybinding_Call {
7498 _c.Call.Run(func(args mock.Arguments) {
7499 var arg0 context.Context
7500 if args[0] != nil {
7501 arg0 = args[0].(context.Context)
7502 }
7503 var arg1 port.SetKeybindingRequest
7504 if args[1] != nil {
7505 arg1 = args[1].(port.SetKeybindingRequest)
7506 }
7507 run(
7508 arg0,
7509 arg1,
7510 )
7511 })
7512 return _c
7513}
7514
7515func (_c *MockKeybindingsSaver_SetKeybinding_Call) Return(err error) *MockKeybindingsSaver_SetKeybinding_Call {
7516 _c.Call.Return(err)
7517 return _c
7518}
7519
7520func (_c *MockKeybindingsSaver_SetKeybinding_Call) RunAndReturn(run func(ctx context.Context, req port.SetKeybindingRequest) error) *MockKeybindingsSaver_SetKeybinding_Call {
7521 _c.Call.Return(run)
7522 return _c
7523}
7524
7525// NewMockKeybindingsGetter creates a new instance of MockKeybindingsGetter. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
7526// The first argument is typically a *testing.T value.
7527func NewMockKeybindingsGetter(t interface {
7528 mock.TestingT
7529 Cleanup(func())
7530}) *MockKeybindingsGetter {
7531 mock := &MockKeybindingsGetter{}
7532 mock.Mock.Test(t)
7533
7534 t.Cleanup(func() { mock.AssertExpectations(t) })
7535
7536 return mock
7537}
7538
7539// MockKeybindingsGetter is an autogenerated mock type for the KeybindingsGetter type
7540type MockKeybindingsGetter struct {
7541 mock.Mock
7542}
7543
7544type MockKeybindingsGetter_Expecter struct {
7545 mock *mock.Mock
7546}
7547
7548func (_m *MockKeybindingsGetter) EXPECT() *MockKeybindingsGetter_Expecter {
7549 return &MockKeybindingsGetter_Expecter{mock: &_m.Mock}
7550}
7551
7552// Execute provides a mock function for the type MockKeybindingsGetter
7553func (_mock *MockKeybindingsGetter) Execute(ctx context.Context) (port.KeybindingsConfig, error) {
7554 ret := _mock.Called(ctx)
7555
7556 if len(ret) == 0 {
7557 panic("no return value specified for Execute")
7558 }
7559
7560 var r0 port.KeybindingsConfig
7561 var r1 error
7562 if returnFunc, ok := ret.Get(0).(func(context.Context) (port.KeybindingsConfig, error)); ok {
7563 return returnFunc(ctx)
7564 }
7565 if returnFunc, ok := ret.Get(0).(func(context.Context) port.KeybindingsConfig); ok {
7566 r0 = returnFunc(ctx)
7567 } else {
7568 r0 = ret.Get(0).(port.KeybindingsConfig)
7569 }
7570 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
7571 r1 = returnFunc(ctx)
7572 } else {
7573 r1 = ret.Error(1)
7574 }
7575 return r0, r1
7576}
7577
7578// MockKeybindingsGetter_Execute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Execute'
7579type MockKeybindingsGetter_Execute_Call struct {
7580 *mock.Call
7581}
7582
7583// Execute is a helper method to define mock.On call
7584// - ctx context.Context
7585func (_e *MockKeybindingsGetter_Expecter) Execute(ctx interface{}) *MockKeybindingsGetter_Execute_Call {
7586 return &MockKeybindingsGetter_Execute_Call{Call: _e.mock.On("Execute", ctx)}
7587}
7588
7589func (_c *MockKeybindingsGetter_Execute_Call) Run(run func(ctx context.Context)) *MockKeybindingsGetter_Execute_Call {
7590 _c.Call.Run(func(args mock.Arguments) {
7591 var arg0 context.Context
7592 if args[0] != nil {
7593 arg0 = args[0].(context.Context)
7594 }
7595 run(
7596 arg0,
7597 )
7598 })
7599 return _c
7600}
7601
7602func (_c *MockKeybindingsGetter_Execute_Call) Return(keybindingsConfig port.KeybindingsConfig, err error) *MockKeybindingsGetter_Execute_Call {
7603 _c.Call.Return(keybindingsConfig, err)
7604 return _c
7605}
7606
7607func (_c *MockKeybindingsGetter_Execute_Call) RunAndReturn(run func(ctx context.Context) (port.KeybindingsConfig, error)) *MockKeybindingsGetter_Execute_Call {
7608 _c.Call.Return(run)
7609 return _c
7610}
7611
7612// NewMockKeybindingSetter creates a new instance of MockKeybindingSetter. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
7613// The first argument is typically a *testing.T value.
7614func NewMockKeybindingSetter(t interface {
7615 mock.TestingT
7616 Cleanup(func())
7617}) *MockKeybindingSetter {
7618 mock := &MockKeybindingSetter{}
7619 mock.Mock.Test(t)
7620
7621 t.Cleanup(func() { mock.AssertExpectations(t) })
7622
7623 return mock
7624}
7625
7626// MockKeybindingSetter is an autogenerated mock type for the KeybindingSetter type
7627type MockKeybindingSetter struct {
7628 mock.Mock
7629}
7630
7631type MockKeybindingSetter_Expecter struct {
7632 mock *mock.Mock
7633}
7634
7635func (_m *MockKeybindingSetter) EXPECT() *MockKeybindingSetter_Expecter {
7636 return &MockKeybindingSetter_Expecter{mock: &_m.Mock}
7637}
7638
7639// Execute provides a mock function for the type MockKeybindingSetter
7640func (_mock *MockKeybindingSetter) Execute(ctx context.Context, req port.SetKeybindingRequest) (port.SetKeybindingResponse, error) {
7641 ret := _mock.Called(ctx, req)
7642
7643 if len(ret) == 0 {
7644 panic("no return value specified for Execute")
7645 }
7646
7647 var r0 port.SetKeybindingResponse
7648 var r1 error
7649 if returnFunc, ok := ret.Get(0).(func(context.Context, port.SetKeybindingRequest) (port.SetKeybindingResponse, error)); ok {
7650 return returnFunc(ctx, req)
7651 }
7652 if returnFunc, ok := ret.Get(0).(func(context.Context, port.SetKeybindingRequest) port.SetKeybindingResponse); ok {
7653 r0 = returnFunc(ctx, req)
7654 } else {
7655 r0 = ret.Get(0).(port.SetKeybindingResponse)
7656 }
7657 if returnFunc, ok := ret.Get(1).(func(context.Context, port.SetKeybindingRequest) error); ok {
7658 r1 = returnFunc(ctx, req)
7659 } else {
7660 r1 = ret.Error(1)
7661 }
7662 return r0, r1
7663}
7664
7665// MockKeybindingSetter_Execute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Execute'
7666type MockKeybindingSetter_Execute_Call struct {
7667 *mock.Call
7668}
7669
7670// Execute is a helper method to define mock.On call
7671// - ctx context.Context
7672// - req port.SetKeybindingRequest
7673func (_e *MockKeybindingSetter_Expecter) Execute(ctx interface{}, req interface{}) *MockKeybindingSetter_Execute_Call {
7674 return &MockKeybindingSetter_Execute_Call{Call: _e.mock.On("Execute", ctx, req)}
7675}
7676
7677func (_c *MockKeybindingSetter_Execute_Call) Run(run func(ctx context.Context, req port.SetKeybindingRequest)) *MockKeybindingSetter_Execute_Call {
7678 _c.Call.Run(func(args mock.Arguments) {
7679 var arg0 context.Context
7680 if args[0] != nil {
7681 arg0 = args[0].(context.Context)
7682 }
7683 var arg1 port.SetKeybindingRequest
7684 if args[1] != nil {
7685 arg1 = args[1].(port.SetKeybindingRequest)
7686 }
7687 run(
7688 arg0,
7689 arg1,
7690 )
7691 })
7692 return _c
7693}
7694
7695func (_c *MockKeybindingSetter_Execute_Call) Return(setKeybindingResponse port.SetKeybindingResponse, err error) *MockKeybindingSetter_Execute_Call {
7696 _c.Call.Return(setKeybindingResponse, err)
7697 return _c
7698}
7699
7700func (_c *MockKeybindingSetter_Execute_Call) RunAndReturn(run func(ctx context.Context, req port.SetKeybindingRequest) (port.SetKeybindingResponse, error)) *MockKeybindingSetter_Execute_Call {
7701 _c.Call.Return(run)
7702 return _c
7703}
7704
7705// NewMockKeybindingResetter creates a new instance of MockKeybindingResetter. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
7706// The first argument is typically a *testing.T value.
7707func NewMockKeybindingResetter(t interface {
7708 mock.TestingT
7709 Cleanup(func())
7710}) *MockKeybindingResetter {
7711 mock := &MockKeybindingResetter{}
7712 mock.Mock.Test(t)
7713
7714 t.Cleanup(func() { mock.AssertExpectations(t) })
7715
7716 return mock
7717}
7718
7719// MockKeybindingResetter is an autogenerated mock type for the KeybindingResetter type
7720type MockKeybindingResetter struct {
7721 mock.Mock
7722}
7723
7724type MockKeybindingResetter_Expecter struct {
7725 mock *mock.Mock
7726}
7727
7728func (_m *MockKeybindingResetter) EXPECT() *MockKeybindingResetter_Expecter {
7729 return &MockKeybindingResetter_Expecter{mock: &_m.Mock}
7730}
7731
7732// Execute provides a mock function for the type MockKeybindingResetter
7733func (_mock *MockKeybindingResetter) Execute(ctx context.Context, req port.ResetKeybindingRequest) error {
7734 ret := _mock.Called(ctx, req)
7735
7736 if len(ret) == 0 {
7737 panic("no return value specified for Execute")
7738 }
7739
7740 var r0 error
7741 if returnFunc, ok := ret.Get(0).(func(context.Context, port.ResetKeybindingRequest) error); ok {
7742 r0 = returnFunc(ctx, req)
7743 } else {
7744 r0 = ret.Error(0)
7745 }
7746 return r0
7747}
7748
7749// MockKeybindingResetter_Execute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Execute'
7750type MockKeybindingResetter_Execute_Call struct {
7751 *mock.Call
7752}
7753
7754// Execute is a helper method to define mock.On call
7755// - ctx context.Context
7756// - req port.ResetKeybindingRequest
7757func (_e *MockKeybindingResetter_Expecter) Execute(ctx interface{}, req interface{}) *MockKeybindingResetter_Execute_Call {
7758 return &MockKeybindingResetter_Execute_Call{Call: _e.mock.On("Execute", ctx, req)}
7759}
7760
7761func (_c *MockKeybindingResetter_Execute_Call) Run(run func(ctx context.Context, req port.ResetKeybindingRequest)) *MockKeybindingResetter_Execute_Call {
7762 _c.Call.Run(func(args mock.Arguments) {
7763 var arg0 context.Context
7764 if args[0] != nil {
7765 arg0 = args[0].(context.Context)
7766 }
7767 var arg1 port.ResetKeybindingRequest
7768 if args[1] != nil {
7769 arg1 = args[1].(port.ResetKeybindingRequest)
7770 }
7771 run(
7772 arg0,
7773 arg1,
7774 )
7775 })
7776 return _c
7777}
7778
7779func (_c *MockKeybindingResetter_Execute_Call) Return(err error) *MockKeybindingResetter_Execute_Call {
7780 _c.Call.Return(err)
7781 return _c
7782}
7783
7784func (_c *MockKeybindingResetter_Execute_Call) RunAndReturn(run func(ctx context.Context, req port.ResetKeybindingRequest) error) *MockKeybindingResetter_Execute_Call {
7785 _c.Call.Return(run)
7786 return _c
7787}
7788
7789// NewMockAllKeybindingsResetter creates a new instance of MockAllKeybindingsResetter. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
7790// The first argument is typically a *testing.T value.
7791func NewMockAllKeybindingsResetter(t interface {
7792 mock.TestingT
7793 Cleanup(func())
7794}) *MockAllKeybindingsResetter {
7795 mock := &MockAllKeybindingsResetter{}
7796 mock.Mock.Test(t)
7797
7798 t.Cleanup(func() { mock.AssertExpectations(t) })
7799
7800 return mock
7801}
7802
7803// MockAllKeybindingsResetter is an autogenerated mock type for the AllKeybindingsResetter type
7804type MockAllKeybindingsResetter struct {
7805 mock.Mock
7806}
7807
7808type MockAllKeybindingsResetter_Expecter struct {
7809 mock *mock.Mock
7810}
7811
7812func (_m *MockAllKeybindingsResetter) EXPECT() *MockAllKeybindingsResetter_Expecter {
7813 return &MockAllKeybindingsResetter_Expecter{mock: &_m.Mock}
7814}
7815
7816// Execute provides a mock function for the type MockAllKeybindingsResetter
7817func (_mock *MockAllKeybindingsResetter) Execute(ctx context.Context) error {
7818 ret := _mock.Called(ctx)
7819
7820 if len(ret) == 0 {
7821 panic("no return value specified for Execute")
7822 }
7823
7824 var r0 error
7825 if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
7826 r0 = returnFunc(ctx)
7827 } else {
7828 r0 = ret.Error(0)
7829 }
7830 return r0
7831}
7832
7833// MockAllKeybindingsResetter_Execute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Execute'
7834type MockAllKeybindingsResetter_Execute_Call struct {
7835 *mock.Call
7836}
7837
7838// Execute is a helper method to define mock.On call
7839// - ctx context.Context
7840func (_e *MockAllKeybindingsResetter_Expecter) Execute(ctx interface{}) *MockAllKeybindingsResetter_Execute_Call {
7841 return &MockAllKeybindingsResetter_Execute_Call{Call: _e.mock.On("Execute", ctx)}
7842}
7843
7844func (_c *MockAllKeybindingsResetter_Execute_Call) Run(run func(ctx context.Context)) *MockAllKeybindingsResetter_Execute_Call {
7845 _c.Call.Run(func(args mock.Arguments) {
7846 var arg0 context.Context
7847 if args[0] != nil {
7848 arg0 = args[0].(context.Context)
7849 }
7850 run(
7851 arg0,
7852 )
7853 })
7854 return _c
7855}
7856
7857func (_c *MockAllKeybindingsResetter_Execute_Call) Return(err error) *MockAllKeybindingsResetter_Execute_Call {
7858 _c.Call.Return(err)
7859 return _c
7860}
7861
7862func (_c *MockAllKeybindingsResetter_Execute_Call) RunAndReturn(run func(ctx context.Context) error) *MockAllKeybindingsResetter_Execute_Call {
7863 _c.Call.Return(run)
7864 return _c
7865}
7866
7867// NewMockMediaDiagnostics creates a new instance of MockMediaDiagnostics. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
7868// The first argument is typically a *testing.T value.
7869func NewMockMediaDiagnostics(t interface {
7870 mock.TestingT
7871 Cleanup(func())
7872}) *MockMediaDiagnostics {
7873 mock := &MockMediaDiagnostics{}
7874 mock.Mock.Test(t)
7875
7876 t.Cleanup(func() { mock.AssertExpectations(t) })
7877
7878 return mock
7879}
7880
7881// MockMediaDiagnostics is an autogenerated mock type for the MediaDiagnostics type
7882type MockMediaDiagnostics struct {
7883 mock.Mock
7884}
7885
7886type MockMediaDiagnostics_Expecter struct {
7887 mock *mock.Mock
7888}
7889
7890func (_m *MockMediaDiagnostics) EXPECT() *MockMediaDiagnostics_Expecter {
7891 return &MockMediaDiagnostics_Expecter{mock: &_m.Mock}
7892}
7893
7894// RunDiagnostics provides a mock function for the type MockMediaDiagnostics
7895func (_mock *MockMediaDiagnostics) RunDiagnostics(ctx context.Context) *port.MediaDiagnosticsResult {
7896 ret := _mock.Called(ctx)
7897
7898 if len(ret) == 0 {
7899 panic("no return value specified for RunDiagnostics")
7900 }
7901
7902 var r0 *port.MediaDiagnosticsResult
7903 if returnFunc, ok := ret.Get(0).(func(context.Context) *port.MediaDiagnosticsResult); ok {
7904 r0 = returnFunc(ctx)
7905 } else {
7906 if ret.Get(0) != nil {
7907 r0 = ret.Get(0).(*port.MediaDiagnosticsResult)
7908 }
7909 }
7910 return r0
7911}
7912
7913// MockMediaDiagnostics_RunDiagnostics_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RunDiagnostics'
7914type MockMediaDiagnostics_RunDiagnostics_Call struct {
7915 *mock.Call
7916}
7917
7918// RunDiagnostics is a helper method to define mock.On call
7919// - ctx context.Context
7920func (_e *MockMediaDiagnostics_Expecter) RunDiagnostics(ctx interface{}) *MockMediaDiagnostics_RunDiagnostics_Call {
7921 return &MockMediaDiagnostics_RunDiagnostics_Call{Call: _e.mock.On("RunDiagnostics", ctx)}
7922}
7923
7924func (_c *MockMediaDiagnostics_RunDiagnostics_Call) Run(run func(ctx context.Context)) *MockMediaDiagnostics_RunDiagnostics_Call {
7925 _c.Call.Run(func(args mock.Arguments) {
7926 var arg0 context.Context
7927 if args[0] != nil {
7928 arg0 = args[0].(context.Context)
7929 }
7930 run(
7931 arg0,
7932 )
7933 })
7934 return _c
7935}
7936
7937func (_c *MockMediaDiagnostics_RunDiagnostics_Call) Return(mediaDiagnosticsResult *port.MediaDiagnosticsResult) *MockMediaDiagnostics_RunDiagnostics_Call {
7938 _c.Call.Return(mediaDiagnosticsResult)
7939 return _c
7940}
7941
7942func (_c *MockMediaDiagnostics_RunDiagnostics_Call) RunAndReturn(run func(ctx context.Context) *port.MediaDiagnosticsResult) *MockMediaDiagnostics_RunDiagnostics_Call {
7943 _c.Call.Return(run)
7944 return _c
7945}
7946
7947// NewMockNotification creates a new instance of MockNotification. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
7948// The first argument is typically a *testing.T value.
7949func NewMockNotification(t interface {
7950 mock.TestingT
7951 Cleanup(func())
7952}) *MockNotification {
7953 mock := &MockNotification{}
7954 mock.Mock.Test(t)
7955
7956 t.Cleanup(func() { mock.AssertExpectations(t) })
7957
7958 return mock
7959}
7960
7961// MockNotification is an autogenerated mock type for the Notification type
7962type MockNotification struct {
7963 mock.Mock
7964}
7965
7966type MockNotification_Expecter struct {
7967 mock *mock.Mock
7968}
7969
7970func (_m *MockNotification) EXPECT() *MockNotification_Expecter {
7971 return &MockNotification_Expecter{mock: &_m.Mock}
7972}
7973
7974// Clear provides a mock function for the type MockNotification
7975func (_mock *MockNotification) Clear(ctx context.Context) {
7976 _mock.Called(ctx)
7977 return
7978}
7979
7980// MockNotification_Clear_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Clear'
7981type MockNotification_Clear_Call struct {
7982 *mock.Call
7983}
7984
7985// Clear is a helper method to define mock.On call
7986// - ctx context.Context
7987func (_e *MockNotification_Expecter) Clear(ctx interface{}) *MockNotification_Clear_Call {
7988 return &MockNotification_Clear_Call{Call: _e.mock.On("Clear", ctx)}
7989}
7990
7991func (_c *MockNotification_Clear_Call) Run(run func(ctx context.Context)) *MockNotification_Clear_Call {
7992 _c.Call.Run(func(args mock.Arguments) {
7993 var arg0 context.Context
7994 if args[0] != nil {
7995 arg0 = args[0].(context.Context)
7996 }
7997 run(
7998 arg0,
7999 )
8000 })
8001 return _c
8002}
8003
8004func (_c *MockNotification_Clear_Call) Return() *MockNotification_Clear_Call {
8005 _c.Call.Return()
8006 return _c
8007}
8008
8009func (_c *MockNotification_Clear_Call) RunAndReturn(run func(ctx context.Context)) *MockNotification_Clear_Call {
8010 _c.Run(run)
8011 return _c
8012}
8013
8014// Dismiss provides a mock function for the type MockNotification
8015func (_mock *MockNotification) Dismiss(ctx context.Context, id port.NotificationID) {
8016 _mock.Called(ctx, id)
8017 return
8018}
8019
8020// MockNotification_Dismiss_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Dismiss'
8021type MockNotification_Dismiss_Call struct {
8022 *mock.Call
8023}
8024
8025// Dismiss is a helper method to define mock.On call
8026// - ctx context.Context
8027// - id port.NotificationID
8028func (_e *MockNotification_Expecter) Dismiss(ctx interface{}, id interface{}) *MockNotification_Dismiss_Call {
8029 return &MockNotification_Dismiss_Call{Call: _e.mock.On("Dismiss", ctx, id)}
8030}
8031
8032func (_c *MockNotification_Dismiss_Call) Run(run func(ctx context.Context, id port.NotificationID)) *MockNotification_Dismiss_Call {
8033 _c.Call.Run(func(args mock.Arguments) {
8034 var arg0 context.Context
8035 if args[0] != nil {
8036 arg0 = args[0].(context.Context)
8037 }
8038 var arg1 port.NotificationID
8039 if args[1] != nil {
8040 arg1 = args[1].(port.NotificationID)
8041 }
8042 run(
8043 arg0,
8044 arg1,
8045 )
8046 })
8047 return _c
8048}
8049
8050func (_c *MockNotification_Dismiss_Call) Return() *MockNotification_Dismiss_Call {
8051 _c.Call.Return()
8052 return _c
8053}
8054
8055func (_c *MockNotification_Dismiss_Call) RunAndReturn(run func(ctx context.Context, id port.NotificationID)) *MockNotification_Dismiss_Call {
8056 _c.Run(run)
8057 return _c
8058}
8059
8060// Show provides a mock function for the type MockNotification
8061func (_mock *MockNotification) Show(ctx context.Context, message string, notifType port.NotificationType, durationMs int) port.NotificationID {
8062 ret := _mock.Called(ctx, message, notifType, durationMs)
8063
8064 if len(ret) == 0 {
8065 panic("no return value specified for Show")
8066 }
8067
8068 var r0 port.NotificationID
8069 if returnFunc, ok := ret.Get(0).(func(context.Context, string, port.NotificationType, int) port.NotificationID); ok {
8070 r0 = returnFunc(ctx, message, notifType, durationMs)
8071 } else {
8072 r0 = ret.Get(0).(port.NotificationID)
8073 }
8074 return r0
8075}
8076
8077// MockNotification_Show_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Show'
8078type MockNotification_Show_Call struct {
8079 *mock.Call
8080}
8081
8082// Show is a helper method to define mock.On call
8083// - ctx context.Context
8084// - message string
8085// - notifType port.NotificationType
8086// - durationMs int
8087func (_e *MockNotification_Expecter) Show(ctx interface{}, message interface{}, notifType interface{}, durationMs interface{}) *MockNotification_Show_Call {
8088 return &MockNotification_Show_Call{Call: _e.mock.On("Show", ctx, message, notifType, durationMs)}
8089}
8090
8091func (_c *MockNotification_Show_Call) Run(run func(ctx context.Context, message string, notifType port.NotificationType, durationMs int)) *MockNotification_Show_Call {
8092 _c.Call.Run(func(args mock.Arguments) {
8093 var arg0 context.Context
8094 if args[0] != nil {
8095 arg0 = args[0].(context.Context)
8096 }
8097 var arg1 string
8098 if args[1] != nil {
8099 arg1 = args[1].(string)
8100 }
8101 var arg2 port.NotificationType
8102 if args[2] != nil {
8103 arg2 = args[2].(port.NotificationType)
8104 }
8105 var arg3 int
8106 if args[3] != nil {
8107 arg3 = args[3].(int)
8108 }
8109 run(
8110 arg0,
8111 arg1,
8112 arg2,
8113 arg3,
8114 )
8115 })
8116 return _c
8117}
8118
8119func (_c *MockNotification_Show_Call) Return(notificationID port.NotificationID) *MockNotification_Show_Call {
8120 _c.Call.Return(notificationID)
8121 return _c
8122}
8123
8124func (_c *MockNotification_Show_Call) RunAndReturn(run func(ctx context.Context, message string, notifType port.NotificationType, durationMs int) port.NotificationID) *MockNotification_Show_Call {
8125 _c.Call.Return(run)
8126 return _c
8127}
8128
8129// ShowZoom provides a mock function for the type MockNotification
8130func (_mock *MockNotification) ShowZoom(ctx context.Context, zoomPercent int) port.NotificationID {
8131 ret := _mock.Called(ctx, zoomPercent)
8132
8133 if len(ret) == 0 {
8134 panic("no return value specified for ShowZoom")
8135 }
8136
8137 var r0 port.NotificationID
8138 if returnFunc, ok := ret.Get(0).(func(context.Context, int) port.NotificationID); ok {
8139 r0 = returnFunc(ctx, zoomPercent)
8140 } else {
8141 r0 = ret.Get(0).(port.NotificationID)
8142 }
8143 return r0
8144}
8145
8146// MockNotification_ShowZoom_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ShowZoom'
8147type MockNotification_ShowZoom_Call struct {
8148 *mock.Call
8149}
8150
8151// ShowZoom is a helper method to define mock.On call
8152// - ctx context.Context
8153// - zoomPercent int
8154func (_e *MockNotification_Expecter) ShowZoom(ctx interface{}, zoomPercent interface{}) *MockNotification_ShowZoom_Call {
8155 return &MockNotification_ShowZoom_Call{Call: _e.mock.On("ShowZoom", ctx, zoomPercent)}
8156}
8157
8158func (_c *MockNotification_ShowZoom_Call) Run(run func(ctx context.Context, zoomPercent int)) *MockNotification_ShowZoom_Call {
8159 _c.Call.Run(func(args mock.Arguments) {
8160 var arg0 context.Context
8161 if args[0] != nil {
8162 arg0 = args[0].(context.Context)
8163 }
8164 var arg1 int
8165 if args[1] != nil {
8166 arg1 = args[1].(int)
8167 }
8168 run(
8169 arg0,
8170 arg1,
8171 )
8172 })
8173 return _c
8174}
8175
8176func (_c *MockNotification_ShowZoom_Call) Return(notificationID port.NotificationID) *MockNotification_ShowZoom_Call {
8177 _c.Call.Return(notificationID)
8178 return _c
8179}
8180
8181func (_c *MockNotification_ShowZoom_Call) RunAndReturn(run func(ctx context.Context, zoomPercent int) port.NotificationID) *MockNotification_ShowZoom_Call {
8182 _c.Call.Return(run)
8183 return _c
8184}
8185
8186// NewMockPermissionDialogPresenter creates a new instance of MockPermissionDialogPresenter. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
8187// The first argument is typically a *testing.T value.
8188func NewMockPermissionDialogPresenter(t interface {
8189 mock.TestingT
8190 Cleanup(func())
8191}) *MockPermissionDialogPresenter {
8192 mock := &MockPermissionDialogPresenter{}
8193 mock.Mock.Test(t)
8194
8195 t.Cleanup(func() { mock.AssertExpectations(t) })
8196
8197 return mock
8198}
8199
8200// MockPermissionDialogPresenter is an autogenerated mock type for the PermissionDialogPresenter type
8201type MockPermissionDialogPresenter struct {
8202 mock.Mock
8203}
8204
8205type MockPermissionDialogPresenter_Expecter struct {
8206 mock *mock.Mock
8207}
8208
8209func (_m *MockPermissionDialogPresenter) EXPECT() *MockPermissionDialogPresenter_Expecter {
8210 return &MockPermissionDialogPresenter_Expecter{mock: &_m.Mock}
8211}
8212
8213// ShowPermissionDialog provides a mock function for the type MockPermissionDialogPresenter
8214func (_mock *MockPermissionDialogPresenter) ShowPermissionDialog(ctx context.Context, origin string, permTypes []entity.PermissionType, metadata entity.PermissionMetadata, callback func(result port.PermissionDialogResult)) {
8215 _mock.Called(ctx, origin, permTypes, metadata, callback)
8216 return
8217}
8218
8219// MockPermissionDialogPresenter_ShowPermissionDialog_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ShowPermissionDialog'
8220type MockPermissionDialogPresenter_ShowPermissionDialog_Call struct {
8221 *mock.Call
8222}
8223
8224// ShowPermissionDialog is a helper method to define mock.On call
8225// - ctx context.Context
8226// - origin string
8227// - permTypes []entity.PermissionType
8228// - metadata entity.PermissionMetadata
8229// - callback func(result port.PermissionDialogResult)
8230func (_e *MockPermissionDialogPresenter_Expecter) ShowPermissionDialog(ctx interface{}, origin interface{}, permTypes interface{}, metadata interface{}, callback interface{}) *MockPermissionDialogPresenter_ShowPermissionDialog_Call {
8231 return &MockPermissionDialogPresenter_ShowPermissionDialog_Call{Call: _e.mock.On("ShowPermissionDialog", ctx, origin, permTypes, metadata, callback)}
8232}
8233
8234func (_c *MockPermissionDialogPresenter_ShowPermissionDialog_Call) Run(run func(ctx context.Context, origin string, permTypes []entity.PermissionType, metadata entity.PermissionMetadata, callback func(result port.PermissionDialogResult))) *MockPermissionDialogPresenter_ShowPermissionDialog_Call {
8235 _c.Call.Run(func(args mock.Arguments) {
8236 var arg0 context.Context
8237 if args[0] != nil {
8238 arg0 = args[0].(context.Context)
8239 }
8240 var arg1 string
8241 if args[1] != nil {
8242 arg1 = args[1].(string)
8243 }
8244 var arg2 []entity.PermissionType
8245 if args[2] != nil {
8246 arg2 = args[2].([]entity.PermissionType)
8247 }
8248 var arg3 entity.PermissionMetadata
8249 if args[3] != nil {
8250 arg3 = args[3].(entity.PermissionMetadata)
8251 }
8252 var arg4 func(result port.PermissionDialogResult)
8253 if args[4] != nil {
8254 arg4 = args[4].(func(result port.PermissionDialogResult))
8255 }
8256 run(
8257 arg0,
8258 arg1,
8259 arg2,
8260 arg3,
8261 arg4,
8262 )
8263 })
8264 return _c
8265}
8266
8267func (_c *MockPermissionDialogPresenter_ShowPermissionDialog_Call) Return() *MockPermissionDialogPresenter_ShowPermissionDialog_Call {
8268 _c.Call.Return()
8269 return _c
8270}
8271
8272func (_c *MockPermissionDialogPresenter_ShowPermissionDialog_Call) RunAndReturn(run func(ctx context.Context, origin string, permTypes []entity.PermissionType, metadata entity.PermissionMetadata, callback func(result port.PermissionDialogResult))) *MockPermissionDialogPresenter_ShowPermissionDialog_Call {
8273 _c.Run(run)
8274 return _c
8275}
8276
8277// NewMockPermissionRepository creates a new instance of MockPermissionRepository. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
8278// The first argument is typically a *testing.T value.
8279func NewMockPermissionRepository(t interface {
8280 mock.TestingT
8281 Cleanup(func())
8282}) *MockPermissionRepository {
8283 mock := &MockPermissionRepository{}
8284 mock.Mock.Test(t)
8285
8286 t.Cleanup(func() { mock.AssertExpectations(t) })
8287
8288 return mock
8289}
8290
8291// MockPermissionRepository is an autogenerated mock type for the PermissionRepository type
8292type MockPermissionRepository struct {
8293 mock.Mock
8294}
8295
8296type MockPermissionRepository_Expecter struct {
8297 mock *mock.Mock
8298}
8299
8300func (_m *MockPermissionRepository) EXPECT() *MockPermissionRepository_Expecter {
8301 return &MockPermissionRepository_Expecter{mock: &_m.Mock}
8302}
8303
8304// Delete provides a mock function for the type MockPermissionRepository
8305func (_mock *MockPermissionRepository) Delete(ctx context.Context, origin string, permType entity.PermissionType) error {
8306 ret := _mock.Called(ctx, origin, permType)
8307
8308 if len(ret) == 0 {
8309 panic("no return value specified for Delete")
8310 }
8311
8312 var r0 error
8313 if returnFunc, ok := ret.Get(0).(func(context.Context, string, entity.PermissionType) error); ok {
8314 r0 = returnFunc(ctx, origin, permType)
8315 } else {
8316 r0 = ret.Error(0)
8317 }
8318 return r0
8319}
8320
8321// MockPermissionRepository_Delete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Delete'
8322type MockPermissionRepository_Delete_Call struct {
8323 *mock.Call
8324}
8325
8326// Delete is a helper method to define mock.On call
8327// - ctx context.Context
8328// - origin string
8329// - permType entity.PermissionType
8330func (_e *MockPermissionRepository_Expecter) Delete(ctx interface{}, origin interface{}, permType interface{}) *MockPermissionRepository_Delete_Call {
8331 return &MockPermissionRepository_Delete_Call{Call: _e.mock.On("Delete", ctx, origin, permType)}
8332}
8333
8334func (_c *MockPermissionRepository_Delete_Call) Run(run func(ctx context.Context, origin string, permType entity.PermissionType)) *MockPermissionRepository_Delete_Call {
8335 _c.Call.Run(func(args mock.Arguments) {
8336 var arg0 context.Context
8337 if args[0] != nil {
8338 arg0 = args[0].(context.Context)
8339 }
8340 var arg1 string
8341 if args[1] != nil {
8342 arg1 = args[1].(string)
8343 }
8344 var arg2 entity.PermissionType
8345 if args[2] != nil {
8346 arg2 = args[2].(entity.PermissionType)
8347 }
8348 run(
8349 arg0,
8350 arg1,
8351 arg2,
8352 )
8353 })
8354 return _c
8355}
8356
8357func (_c *MockPermissionRepository_Delete_Call) Return(err error) *MockPermissionRepository_Delete_Call {
8358 _c.Call.Return(err)
8359 return _c
8360}
8361
8362func (_c *MockPermissionRepository_Delete_Call) RunAndReturn(run func(ctx context.Context, origin string, permType entity.PermissionType) error) *MockPermissionRepository_Delete_Call {
8363 _c.Call.Return(run)
8364 return _c
8365}
8366
8367// Get provides a mock function for the type MockPermissionRepository
8368func (_mock *MockPermissionRepository) Get(ctx context.Context, origin string, permType entity.PermissionType) (*entity.PermissionRecord, error) {
8369 ret := _mock.Called(ctx, origin, permType)
8370
8371 if len(ret) == 0 {
8372 panic("no return value specified for Get")
8373 }
8374
8375 var r0 *entity.PermissionRecord
8376 var r1 error
8377 if returnFunc, ok := ret.Get(0).(func(context.Context, string, entity.PermissionType) (*entity.PermissionRecord, error)); ok {
8378 return returnFunc(ctx, origin, permType)
8379 }
8380 if returnFunc, ok := ret.Get(0).(func(context.Context, string, entity.PermissionType) *entity.PermissionRecord); ok {
8381 r0 = returnFunc(ctx, origin, permType)
8382 } else {
8383 if ret.Get(0) != nil {
8384 r0 = ret.Get(0).(*entity.PermissionRecord)
8385 }
8386 }
8387 if returnFunc, ok := ret.Get(1).(func(context.Context, string, entity.PermissionType) error); ok {
8388 r1 = returnFunc(ctx, origin, permType)
8389 } else {
8390 r1 = ret.Error(1)
8391 }
8392 return r0, r1
8393}
8394
8395// MockPermissionRepository_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get'
8396type MockPermissionRepository_Get_Call struct {
8397 *mock.Call
8398}
8399
8400// Get is a helper method to define mock.On call
8401// - ctx context.Context
8402// - origin string
8403// - permType entity.PermissionType
8404func (_e *MockPermissionRepository_Expecter) Get(ctx interface{}, origin interface{}, permType interface{}) *MockPermissionRepository_Get_Call {
8405 return &MockPermissionRepository_Get_Call{Call: _e.mock.On("Get", ctx, origin, permType)}
8406}
8407
8408func (_c *MockPermissionRepository_Get_Call) Run(run func(ctx context.Context, origin string, permType entity.PermissionType)) *MockPermissionRepository_Get_Call {
8409 _c.Call.Run(func(args mock.Arguments) {
8410 var arg0 context.Context
8411 if args[0] != nil {
8412 arg0 = args[0].(context.Context)
8413 }
8414 var arg1 string
8415 if args[1] != nil {
8416 arg1 = args[1].(string)
8417 }
8418 var arg2 entity.PermissionType
8419 if args[2] != nil {
8420 arg2 = args[2].(entity.PermissionType)
8421 }
8422 run(
8423 arg0,
8424 arg1,
8425 arg2,
8426 )
8427 })
8428 return _c
8429}
8430
8431func (_c *MockPermissionRepository_Get_Call) Return(permissionRecord *entity.PermissionRecord, err error) *MockPermissionRepository_Get_Call {
8432 _c.Call.Return(permissionRecord, err)
8433 return _c
8434}
8435
8436func (_c *MockPermissionRepository_Get_Call) RunAndReturn(run func(ctx context.Context, origin string, permType entity.PermissionType) (*entity.PermissionRecord, error)) *MockPermissionRepository_Get_Call {
8437 _c.Call.Return(run)
8438 return _c
8439}
8440
8441// GetAll provides a mock function for the type MockPermissionRepository
8442func (_mock *MockPermissionRepository) GetAll(ctx context.Context, origin string) ([]*entity.PermissionRecord, error) {
8443 ret := _mock.Called(ctx, origin)
8444
8445 if len(ret) == 0 {
8446 panic("no return value specified for GetAll")
8447 }
8448
8449 var r0 []*entity.PermissionRecord
8450 var r1 error
8451 if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]*entity.PermissionRecord, error)); ok {
8452 return returnFunc(ctx, origin)
8453 }
8454 if returnFunc, ok := ret.Get(0).(func(context.Context, string) []*entity.PermissionRecord); ok {
8455 r0 = returnFunc(ctx, origin)
8456 } else {
8457 if ret.Get(0) != nil {
8458 r0 = ret.Get(0).([]*entity.PermissionRecord)
8459 }
8460 }
8461 if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
8462 r1 = returnFunc(ctx, origin)
8463 } else {
8464 r1 = ret.Error(1)
8465 }
8466 return r0, r1
8467}
8468
8469// MockPermissionRepository_GetAll_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAll'
8470type MockPermissionRepository_GetAll_Call struct {
8471 *mock.Call
8472}
8473
8474// GetAll is a helper method to define mock.On call
8475// - ctx context.Context
8476// - origin string
8477func (_e *MockPermissionRepository_Expecter) GetAll(ctx interface{}, origin interface{}) *MockPermissionRepository_GetAll_Call {
8478 return &MockPermissionRepository_GetAll_Call{Call: _e.mock.On("GetAll", ctx, origin)}
8479}
8480
8481func (_c *MockPermissionRepository_GetAll_Call) Run(run func(ctx context.Context, origin string)) *MockPermissionRepository_GetAll_Call {
8482 _c.Call.Run(func(args mock.Arguments) {
8483 var arg0 context.Context
8484 if args[0] != nil {
8485 arg0 = args[0].(context.Context)
8486 }
8487 var arg1 string
8488 if args[1] != nil {
8489 arg1 = args[1].(string)
8490 }
8491 run(
8492 arg0,
8493 arg1,
8494 )
8495 })
8496 return _c
8497}
8498
8499func (_c *MockPermissionRepository_GetAll_Call) Return(permissionRecords []*entity.PermissionRecord, err error) *MockPermissionRepository_GetAll_Call {
8500 _c.Call.Return(permissionRecords, err)
8501 return _c
8502}
8503
8504func (_c *MockPermissionRepository_GetAll_Call) RunAndReturn(run func(ctx context.Context, origin string) ([]*entity.PermissionRecord, error)) *MockPermissionRepository_GetAll_Call {
8505 _c.Call.Return(run)
8506 return _c
8507}
8508
8509// Set provides a mock function for the type MockPermissionRepository
8510func (_mock *MockPermissionRepository) Set(ctx context.Context, record *entity.PermissionRecord) error {
8511 ret := _mock.Called(ctx, record)
8512
8513 if len(ret) == 0 {
8514 panic("no return value specified for Set")
8515 }
8516
8517 var r0 error
8518 if returnFunc, ok := ret.Get(0).(func(context.Context, *entity.PermissionRecord) error); ok {
8519 r0 = returnFunc(ctx, record)
8520 } else {
8521 r0 = ret.Error(0)
8522 }
8523 return r0
8524}
8525
8526// MockPermissionRepository_Set_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Set'
8527type MockPermissionRepository_Set_Call struct {
8528 *mock.Call
8529}
8530
8531// Set is a helper method to define mock.On call
8532// - ctx context.Context
8533// - record *entity.PermissionRecord
8534func (_e *MockPermissionRepository_Expecter) Set(ctx interface{}, record interface{}) *MockPermissionRepository_Set_Call {
8535 return &MockPermissionRepository_Set_Call{Call: _e.mock.On("Set", ctx, record)}
8536}
8537
8538func (_c *MockPermissionRepository_Set_Call) Run(run func(ctx context.Context, record *entity.PermissionRecord)) *MockPermissionRepository_Set_Call {
8539 _c.Call.Run(func(args mock.Arguments) {
8540 var arg0 context.Context
8541 if args[0] != nil {
8542 arg0 = args[0].(context.Context)
8543 }
8544 var arg1 *entity.PermissionRecord
8545 if args[1] != nil {
8546 arg1 = args[1].(*entity.PermissionRecord)
8547 }
8548 run(
8549 arg0,
8550 arg1,
8551 )
8552 })
8553 return _c
8554}
8555
8556func (_c *MockPermissionRepository_Set_Call) Return(err error) *MockPermissionRepository_Set_Call {
8557 _c.Call.Return(err)
8558 return _c
8559}
8560
8561func (_c *MockPermissionRepository_Set_Call) RunAndReturn(run func(ctx context.Context, record *entity.PermissionRecord) error) *MockPermissionRepository_Set_Call {
8562 _c.Call.Return(run)
8563 return _c
8564}
8565
8566// NewMockRenderingEnvManager creates a new instance of MockRenderingEnvManager. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
8567// The first argument is typically a *testing.T value.
8568func NewMockRenderingEnvManager(t interface {
8569 mock.TestingT
8570 Cleanup(func())
8571}) *MockRenderingEnvManager {
8572 mock := &MockRenderingEnvManager{}
8573 mock.Mock.Test(t)
8574
8575 t.Cleanup(func() { mock.AssertExpectations(t) })
8576
8577 return mock
8578}
8579
8580// MockRenderingEnvManager is an autogenerated mock type for the RenderingEnvManager type
8581type MockRenderingEnvManager struct {
8582 mock.Mock
8583}
8584
8585type MockRenderingEnvManager_Expecter struct {
8586 mock *mock.Mock
8587}
8588
8589func (_m *MockRenderingEnvManager) EXPECT() *MockRenderingEnvManager_Expecter {
8590 return &MockRenderingEnvManager_Expecter{mock: &_m.Mock}
8591}
8592
8593// DetectGPUVendor provides a mock function for the type MockRenderingEnvManager
8594func (_mock *MockRenderingEnvManager) DetectGPUVendor(ctx context.Context) port.GPUVendor {
8595 ret := _mock.Called(ctx)
8596
8597 if len(ret) == 0 {
8598 panic("no return value specified for DetectGPUVendor")
8599 }
8600
8601 var r0 port.GPUVendor
8602 if returnFunc, ok := ret.Get(0).(func(context.Context) port.GPUVendor); ok {
8603 r0 = returnFunc(ctx)
8604 } else {
8605 r0 = ret.Get(0).(port.GPUVendor)
8606 }
8607 return r0
8608}
8609
8610// MockRenderingEnvManager_DetectGPUVendor_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DetectGPUVendor'
8611type MockRenderingEnvManager_DetectGPUVendor_Call struct {
8612 *mock.Call
8613}
8614
8615// DetectGPUVendor is a helper method to define mock.On call
8616// - ctx context.Context
8617func (_e *MockRenderingEnvManager_Expecter) DetectGPUVendor(ctx interface{}) *MockRenderingEnvManager_DetectGPUVendor_Call {
8618 return &MockRenderingEnvManager_DetectGPUVendor_Call{Call: _e.mock.On("DetectGPUVendor", ctx)}
8619}
8620
8621func (_c *MockRenderingEnvManager_DetectGPUVendor_Call) Run(run func(ctx context.Context)) *MockRenderingEnvManager_DetectGPUVendor_Call {
8622 _c.Call.Run(func(args mock.Arguments) {
8623 var arg0 context.Context
8624 if args[0] != nil {
8625 arg0 = args[0].(context.Context)
8626 }
8627 run(
8628 arg0,
8629 )
8630 })
8631 return _c
8632}
8633
8634func (_c *MockRenderingEnvManager_DetectGPUVendor_Call) Return(gPUVendor port.GPUVendor) *MockRenderingEnvManager_DetectGPUVendor_Call {
8635 _c.Call.Return(gPUVendor)
8636 return _c
8637}
8638
8639func (_c *MockRenderingEnvManager_DetectGPUVendor_Call) RunAndReturn(run func(ctx context.Context) port.GPUVendor) *MockRenderingEnvManager_DetectGPUVendor_Call {
8640 _c.Call.Return(run)
8641 return _c
8642}
8643
8644// GetAppliedVars provides a mock function for the type MockRenderingEnvManager
8645func (_mock *MockRenderingEnvManager) GetAppliedVars() map[string]string {
8646 ret := _mock.Called()
8647
8648 if len(ret) == 0 {
8649 panic("no return value specified for GetAppliedVars")
8650 }
8651
8652 var r0 map[string]string
8653 if returnFunc, ok := ret.Get(0).(func() map[string]string); ok {
8654 r0 = returnFunc()
8655 } else {
8656 if ret.Get(0) != nil {
8657 r0 = ret.Get(0).(map[string]string)
8658 }
8659 }
8660 return r0
8661}
8662
8663// MockRenderingEnvManager_GetAppliedVars_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAppliedVars'
8664type MockRenderingEnvManager_GetAppliedVars_Call struct {
8665 *mock.Call
8666}
8667
8668// GetAppliedVars is a helper method to define mock.On call
8669func (_e *MockRenderingEnvManager_Expecter) GetAppliedVars() *MockRenderingEnvManager_GetAppliedVars_Call {
8670 return &MockRenderingEnvManager_GetAppliedVars_Call{Call: _e.mock.On("GetAppliedVars")}
8671}
8672
8673func (_c *MockRenderingEnvManager_GetAppliedVars_Call) Run(run func()) *MockRenderingEnvManager_GetAppliedVars_Call {
8674 _c.Call.Run(func(args mock.Arguments) {
8675 run()
8676 })
8677 return _c
8678}
8679
8680func (_c *MockRenderingEnvManager_GetAppliedVars_Call) Return(stringToString map[string]string) *MockRenderingEnvManager_GetAppliedVars_Call {
8681 _c.Call.Return(stringToString)
8682 return _c
8683}
8684
8685func (_c *MockRenderingEnvManager_GetAppliedVars_Call) RunAndReturn(run func() map[string]string) *MockRenderingEnvManager_GetAppliedVars_Call {
8686 _c.Call.Return(run)
8687 return _c
8688}
8689
8690// NewMockRuntimeVersionProbe creates a new instance of MockRuntimeVersionProbe. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
8691// The first argument is typically a *testing.T value.
8692func NewMockRuntimeVersionProbe(t interface {
8693 mock.TestingT
8694 Cleanup(func())
8695}) *MockRuntimeVersionProbe {
8696 mock := &MockRuntimeVersionProbe{}
8697 mock.Mock.Test(t)
8698
8699 t.Cleanup(func() { mock.AssertExpectations(t) })
8700
8701 return mock
8702}
8703
8704// MockRuntimeVersionProbe is an autogenerated mock type for the RuntimeVersionProbe type
8705type MockRuntimeVersionProbe struct {
8706 mock.Mock
8707}
8708
8709type MockRuntimeVersionProbe_Expecter struct {
8710 mock *mock.Mock
8711}
8712
8713func (_m *MockRuntimeVersionProbe) EXPECT() *MockRuntimeVersionProbe_Expecter {
8714 return &MockRuntimeVersionProbe_Expecter{mock: &_m.Mock}
8715}
8716
8717// PkgConfigModVersion provides a mock function for the type MockRuntimeVersionProbe
8718func (_mock *MockRuntimeVersionProbe) PkgConfigModVersion(ctx context.Context, pkgName string, prefix string) (string, error) {
8719 ret := _mock.Called(ctx, pkgName, prefix)
8720
8721 if len(ret) == 0 {
8722 panic("no return value specified for PkgConfigModVersion")
8723 }
8724
8725 var r0 string
8726 var r1 error
8727 if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (string, error)); ok {
8728 return returnFunc(ctx, pkgName, prefix)
8729 }
8730 if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) string); ok {
8731 r0 = returnFunc(ctx, pkgName, prefix)
8732 } else {
8733 r0 = ret.Get(0).(string)
8734 }
8735 if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
8736 r1 = returnFunc(ctx, pkgName, prefix)
8737 } else {
8738 r1 = ret.Error(1)
8739 }
8740 return r0, r1
8741}
8742
8743// MockRuntimeVersionProbe_PkgConfigModVersion_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PkgConfigModVersion'
8744type MockRuntimeVersionProbe_PkgConfigModVersion_Call struct {
8745 *mock.Call
8746}
8747
8748// PkgConfigModVersion is a helper method to define mock.On call
8749// - ctx context.Context
8750// - pkgName string
8751// - prefix string
8752func (_e *MockRuntimeVersionProbe_Expecter) PkgConfigModVersion(ctx interface{}, pkgName interface{}, prefix interface{}) *MockRuntimeVersionProbe_PkgConfigModVersion_Call {
8753 return &MockRuntimeVersionProbe_PkgConfigModVersion_Call{Call: _e.mock.On("PkgConfigModVersion", ctx, pkgName, prefix)}
8754}
8755
8756func (_c *MockRuntimeVersionProbe_PkgConfigModVersion_Call) Run(run func(ctx context.Context, pkgName string, prefix string)) *MockRuntimeVersionProbe_PkgConfigModVersion_Call {
8757 _c.Call.Run(func(args mock.Arguments) {
8758 var arg0 context.Context
8759 if args[0] != nil {
8760 arg0 = args[0].(context.Context)
8761 }
8762 var arg1 string
8763 if args[1] != nil {
8764 arg1 = args[1].(string)
8765 }
8766 var arg2 string
8767 if args[2] != nil {
8768 arg2 = args[2].(string)
8769 }
8770 run(
8771 arg0,
8772 arg1,
8773 arg2,
8774 )
8775 })
8776 return _c
8777}
8778
8779func (_c *MockRuntimeVersionProbe_PkgConfigModVersion_Call) Return(s string, err error) *MockRuntimeVersionProbe_PkgConfigModVersion_Call {
8780 _c.Call.Return(s, err)
8781 return _c
8782}
8783
8784func (_c *MockRuntimeVersionProbe_PkgConfigModVersion_Call) RunAndReturn(run func(ctx context.Context, pkgName string, prefix string) (string, error)) *MockRuntimeVersionProbe_PkgConfigModVersion_Call {
8785 _c.Call.Return(run)
8786 return _c
8787}
8788
8789// NewMockSessionLogger creates a new instance of MockSessionLogger. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
8790// The first argument is typically a *testing.T value.
8791func NewMockSessionLogger(t interface {
8792 mock.TestingT
8793 Cleanup(func())
8794}) *MockSessionLogger {
8795 mock := &MockSessionLogger{}
8796 mock.Mock.Test(t)
8797
8798 t.Cleanup(func() { mock.AssertExpectations(t) })
8799
8800 return mock
8801}
8802
8803// MockSessionLogger is an autogenerated mock type for the SessionLogger type
8804type MockSessionLogger struct {
8805 mock.Mock
8806}
8807
8808type MockSessionLogger_Expecter struct {
8809 mock *mock.Mock
8810}
8811
8812func (_m *MockSessionLogger) EXPECT() *MockSessionLogger_Expecter {
8813 return &MockSessionLogger_Expecter{mock: &_m.Mock}
8814}
8815
8816// CreateLogger provides a mock function for the type MockSessionLogger
8817func (_mock *MockSessionLogger) CreateLogger(ctx context.Context, sessionID entity.SessionID, cfg port.SessionLogConfig) (zerolog.Logger, func(), error) {
8818 ret := _mock.Called(ctx, sessionID, cfg)
8819
8820 if len(ret) == 0 {
8821 panic("no return value specified for CreateLogger")
8822 }
8823
8824 var r0 zerolog.Logger
8825 var r1 func()
8826 var r2 error
8827 if returnFunc, ok := ret.Get(0).(func(context.Context, entity.SessionID, port.SessionLogConfig) (zerolog.Logger, func(), error)); ok {
8828 return returnFunc(ctx, sessionID, cfg)
8829 }
8830 if returnFunc, ok := ret.Get(0).(func(context.Context, entity.SessionID, port.SessionLogConfig) zerolog.Logger); ok {
8831 r0 = returnFunc(ctx, sessionID, cfg)
8832 } else {
8833 r0 = ret.Get(0).(zerolog.Logger)
8834 }
8835 if returnFunc, ok := ret.Get(1).(func(context.Context, entity.SessionID, port.SessionLogConfig) func()); ok {
8836 r1 = returnFunc(ctx, sessionID, cfg)
8837 } else {
8838 if ret.Get(1) != nil {
8839 r1 = ret.Get(1).(func())
8840 }
8841 }
8842 if returnFunc, ok := ret.Get(2).(func(context.Context, entity.SessionID, port.SessionLogConfig) error); ok {
8843 r2 = returnFunc(ctx, sessionID, cfg)
8844 } else {
8845 r2 = ret.Error(2)
8846 }
8847 return r0, r1, r2
8848}
8849
8850// MockSessionLogger_CreateLogger_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateLogger'
8851type MockSessionLogger_CreateLogger_Call struct {
8852 *mock.Call
8853}
8854
8855// CreateLogger is a helper method to define mock.On call
8856// - ctx context.Context
8857// - sessionID entity.SessionID
8858// - cfg port.SessionLogConfig
8859func (_e *MockSessionLogger_Expecter) CreateLogger(ctx interface{}, sessionID interface{}, cfg interface{}) *MockSessionLogger_CreateLogger_Call {
8860 return &MockSessionLogger_CreateLogger_Call{Call: _e.mock.On("CreateLogger", ctx, sessionID, cfg)}
8861}
8862
8863func (_c *MockSessionLogger_CreateLogger_Call) Run(run func(ctx context.Context, sessionID entity.SessionID, cfg port.SessionLogConfig)) *MockSessionLogger_CreateLogger_Call {
8864 _c.Call.Run(func(args mock.Arguments) {
8865 var arg0 context.Context
8866 if args[0] != nil {
8867 arg0 = args[0].(context.Context)
8868 }
8869 var arg1 entity.SessionID
8870 if args[1] != nil {
8871 arg1 = args[1].(entity.SessionID)
8872 }
8873 var arg2 port.SessionLogConfig
8874 if args[2] != nil {
8875 arg2 = args[2].(port.SessionLogConfig)
8876 }
8877 run(
8878 arg0,
8879 arg1,
8880 arg2,
8881 )
8882 })
8883 return _c
8884}
8885
8886func (_c *MockSessionLogger_CreateLogger_Call) Return(logger zerolog.Logger, fn func(), err error) *MockSessionLogger_CreateLogger_Call {
8887 _c.Call.Return(logger, fn, err)
8888 return _c
8889}
8890
8891func (_c *MockSessionLogger_CreateLogger_Call) RunAndReturn(run func(ctx context.Context, sessionID entity.SessionID, cfg port.SessionLogConfig) (zerolog.Logger, func(), error)) *MockSessionLogger_CreateLogger_Call {
8892 _c.Call.Return(run)
8893 return _c
8894}
8895
8896// NewMockTabListProvider creates a new instance of MockTabListProvider. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
8897// The first argument is typically a *testing.T value.
8898func NewMockTabListProvider(t interface {
8899 mock.TestingT
8900 Cleanup(func())
8901}) *MockTabListProvider {
8902 mock := &MockTabListProvider{}
8903 mock.Mock.Test(t)
8904
8905 t.Cleanup(func() { mock.AssertExpectations(t) })
8906
8907 return mock
8908}
8909
8910// MockTabListProvider is an autogenerated mock type for the TabListProvider type
8911type MockTabListProvider struct {
8912 mock.Mock
8913}
8914
8915type MockTabListProvider_Expecter struct {
8916 mock *mock.Mock
8917}
8918
8919func (_m *MockTabListProvider) EXPECT() *MockTabListProvider_Expecter {
8920 return &MockTabListProvider_Expecter{mock: &_m.Mock}
8921}
8922
8923// GetSessionID provides a mock function for the type MockTabListProvider
8924func (_mock *MockTabListProvider) GetSessionID() entity.SessionID {
8925 ret := _mock.Called()
8926
8927 if len(ret) == 0 {
8928 panic("no return value specified for GetSessionID")
8929 }
8930
8931 var r0 entity.SessionID
8932 if returnFunc, ok := ret.Get(0).(func() entity.SessionID); ok {
8933 r0 = returnFunc()
8934 } else {
8935 r0 = ret.Get(0).(entity.SessionID)
8936 }
8937 return r0
8938}
8939
8940// MockTabListProvider_GetSessionID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSessionID'
8941type MockTabListProvider_GetSessionID_Call struct {
8942 *mock.Call
8943}
8944
8945// GetSessionID is a helper method to define mock.On call
8946func (_e *MockTabListProvider_Expecter) GetSessionID() *MockTabListProvider_GetSessionID_Call {
8947 return &MockTabListProvider_GetSessionID_Call{Call: _e.mock.On("GetSessionID")}
8948}
8949
8950func (_c *MockTabListProvider_GetSessionID_Call) Run(run func()) *MockTabListProvider_GetSessionID_Call {
8951 _c.Call.Run(func(args mock.Arguments) {
8952 run()
8953 })
8954 return _c
8955}
8956
8957func (_c *MockTabListProvider_GetSessionID_Call) Return(sessionID entity.SessionID) *MockTabListProvider_GetSessionID_Call {
8958 _c.Call.Return(sessionID)
8959 return _c
8960}
8961
8962func (_c *MockTabListProvider_GetSessionID_Call) RunAndReturn(run func() entity.SessionID) *MockTabListProvider_GetSessionID_Call {
8963 _c.Call.Return(run)
8964 return _c
8965}
8966
8967// GetTabList provides a mock function for the type MockTabListProvider
8968func (_mock *MockTabListProvider) GetTabList() *entity.TabList {
8969 ret := _mock.Called()
8970
8971 if len(ret) == 0 {
8972 panic("no return value specified for GetTabList")
8973 }
8974
8975 var r0 *entity.TabList
8976 if returnFunc, ok := ret.Get(0).(func() *entity.TabList); ok {
8977 r0 = returnFunc()
8978 } else {
8979 if ret.Get(0) != nil {
8980 r0 = ret.Get(0).(*entity.TabList)
8981 }
8982 }
8983 return r0
8984}
8985
8986// MockTabListProvider_GetTabList_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTabList'
8987type MockTabListProvider_GetTabList_Call struct {
8988 *mock.Call
8989}
8990
8991// GetTabList is a helper method to define mock.On call
8992func (_e *MockTabListProvider_Expecter) GetTabList() *MockTabListProvider_GetTabList_Call {
8993 return &MockTabListProvider_GetTabList_Call{Call: _e.mock.On("GetTabList")}
8994}
8995
8996func (_c *MockTabListProvider_GetTabList_Call) Run(run func()) *MockTabListProvider_GetTabList_Call {
8997 _c.Call.Run(func(args mock.Arguments) {
8998 run()
8999 })
9000 return _c
9001}
9002
9003func (_c *MockTabListProvider_GetTabList_Call) Return(tabList *entity.TabList) *MockTabListProvider_GetTabList_Call {
9004 _c.Call.Return(tabList)
9005 return _c
9006}
9007
9008func (_c *MockTabListProvider_GetTabList_Call) RunAndReturn(run func() *entity.TabList) *MockTabListProvider_GetTabList_Call {
9009 _c.Call.Return(run)
9010 return _c
9011}
9012
9013// NewMockSessionSpawner creates a new instance of MockSessionSpawner. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
9014// The first argument is typically a *testing.T value.
9015func NewMockSessionSpawner(t interface {
9016 mock.TestingT
9017 Cleanup(func())
9018}) *MockSessionSpawner {
9019 mock := &MockSessionSpawner{}
9020 mock.Mock.Test(t)
9021
9022 t.Cleanup(func() { mock.AssertExpectations(t) })
9023
9024 return mock
9025}
9026
9027// MockSessionSpawner is an autogenerated mock type for the SessionSpawner type
9028type MockSessionSpawner struct {
9029 mock.Mock
9030}
9031
9032type MockSessionSpawner_Expecter struct {
9033 mock *mock.Mock
9034}
9035
9036func (_m *MockSessionSpawner) EXPECT() *MockSessionSpawner_Expecter {
9037 return &MockSessionSpawner_Expecter{mock: &_m.Mock}
9038}
9039
9040// SpawnWithSession provides a mock function for the type MockSessionSpawner
9041func (_mock *MockSessionSpawner) SpawnWithSession(sessionID entity.SessionID) error {
9042 ret := _mock.Called(sessionID)
9043
9044 if len(ret) == 0 {
9045 panic("no return value specified for SpawnWithSession")
9046 }
9047
9048 var r0 error
9049 if returnFunc, ok := ret.Get(0).(func(entity.SessionID) error); ok {
9050 r0 = returnFunc(sessionID)
9051 } else {
9052 r0 = ret.Error(0)
9053 }
9054 return r0
9055}
9056
9057// MockSessionSpawner_SpawnWithSession_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SpawnWithSession'
9058type MockSessionSpawner_SpawnWithSession_Call struct {
9059 *mock.Call
9060}
9061
9062// SpawnWithSession is a helper method to define mock.On call
9063// - sessionID entity.SessionID
9064func (_e *MockSessionSpawner_Expecter) SpawnWithSession(sessionID interface{}) *MockSessionSpawner_SpawnWithSession_Call {
9065 return &MockSessionSpawner_SpawnWithSession_Call{Call: _e.mock.On("SpawnWithSession", sessionID)}
9066}
9067
9068func (_c *MockSessionSpawner_SpawnWithSession_Call) Run(run func(sessionID entity.SessionID)) *MockSessionSpawner_SpawnWithSession_Call {
9069 _c.Call.Run(func(args mock.Arguments) {
9070 var arg0 entity.SessionID
9071 if args[0] != nil {
9072 arg0 = args[0].(entity.SessionID)
9073 }
9074 run(
9075 arg0,
9076 )
9077 })
9078 return _c
9079}
9080
9081func (_c *MockSessionSpawner_SpawnWithSession_Call) Return(err error) *MockSessionSpawner_SpawnWithSession_Call {
9082 _c.Call.Return(err)
9083 return _c
9084}
9085
9086func (_c *MockSessionSpawner_SpawnWithSession_Call) RunAndReturn(run func(sessionID entity.SessionID) error) *MockSessionSpawner_SpawnWithSession_Call {
9087 _c.Call.Return(run)
9088 return _c
9089}
9090
9091// NewMockSnapshotService creates a new instance of MockSnapshotService. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
9092// The first argument is typically a *testing.T value.
9093func NewMockSnapshotService(t interface {
9094 mock.TestingT
9095 Cleanup(func())
9096}) *MockSnapshotService {
9097 mock := &MockSnapshotService{}
9098 mock.Mock.Test(t)
9099
9100 t.Cleanup(func() { mock.AssertExpectations(t) })
9101
9102 return mock
9103}
9104
9105// MockSnapshotService is an autogenerated mock type for the SnapshotService type
9106type MockSnapshotService struct {
9107 mock.Mock
9108}
9109
9110type MockSnapshotService_Expecter struct {
9111 mock *mock.Mock
9112}
9113
9114func (_m *MockSnapshotService) EXPECT() *MockSnapshotService_Expecter {
9115 return &MockSnapshotService_Expecter{mock: &_m.Mock}
9116}
9117
9118// MarkDirty provides a mock function for the type MockSnapshotService
9119func (_mock *MockSnapshotService) MarkDirty() {
9120 _mock.Called()
9121 return
9122}
9123
9124// MockSnapshotService_MarkDirty_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MarkDirty'
9125type MockSnapshotService_MarkDirty_Call struct {
9126 *mock.Call
9127}
9128
9129// MarkDirty is a helper method to define mock.On call
9130func (_e *MockSnapshotService_Expecter) MarkDirty() *MockSnapshotService_MarkDirty_Call {
9131 return &MockSnapshotService_MarkDirty_Call{Call: _e.mock.On("MarkDirty")}
9132}
9133
9134func (_c *MockSnapshotService_MarkDirty_Call) Run(run func()) *MockSnapshotService_MarkDirty_Call {
9135 _c.Call.Run(func(args mock.Arguments) {
9136 run()
9137 })
9138 return _c
9139}
9140
9141func (_c *MockSnapshotService_MarkDirty_Call) Return() *MockSnapshotService_MarkDirty_Call {
9142 _c.Call.Return()
9143 return _c
9144}
9145
9146func (_c *MockSnapshotService_MarkDirty_Call) RunAndReturn(run func()) *MockSnapshotService_MarkDirty_Call {
9147 _c.Run(run)
9148 return _c
9149}
9150
9151// SaveNow provides a mock function for the type MockSnapshotService
9152func (_mock *MockSnapshotService) SaveNow(ctx context.Context) error {
9153 ret := _mock.Called(ctx)
9154
9155 if len(ret) == 0 {
9156 panic("no return value specified for SaveNow")
9157 }
9158
9159 var r0 error
9160 if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
9161 r0 = returnFunc(ctx)
9162 } else {
9163 r0 = ret.Error(0)
9164 }
9165 return r0
9166}
9167
9168// MockSnapshotService_SaveNow_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SaveNow'
9169type MockSnapshotService_SaveNow_Call struct {
9170 *mock.Call
9171}
9172
9173// SaveNow is a helper method to define mock.On call
9174// - ctx context.Context
9175func (_e *MockSnapshotService_Expecter) SaveNow(ctx interface{}) *MockSnapshotService_SaveNow_Call {
9176 return &MockSnapshotService_SaveNow_Call{Call: _e.mock.On("SaveNow", ctx)}
9177}
9178
9179func (_c *MockSnapshotService_SaveNow_Call) Run(run func(ctx context.Context)) *MockSnapshotService_SaveNow_Call {
9180 _c.Call.Run(func(args mock.Arguments) {
9181 var arg0 context.Context
9182 if args[0] != nil {
9183 arg0 = args[0].(context.Context)
9184 }
9185 run(
9186 arg0,
9187 )
9188 })
9189 return _c
9190}
9191
9192func (_c *MockSnapshotService_SaveNow_Call) Return(err error) *MockSnapshotService_SaveNow_Call {
9193 _c.Call.Return(err)
9194 return _c
9195}
9196
9197func (_c *MockSnapshotService_SaveNow_Call) RunAndReturn(run func(ctx context.Context) error) *MockSnapshotService_SaveNow_Call {
9198 _c.Call.Return(run)
9199 return _c
9200}
9201
9202// SetReady provides a mock function for the type MockSnapshotService
9203func (_mock *MockSnapshotService) SetReady() {
9204 _mock.Called()
9205 return
9206}
9207
9208// MockSnapshotService_SetReady_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetReady'
9209type MockSnapshotService_SetReady_Call struct {
9210 *mock.Call
9211}
9212
9213// SetReady is a helper method to define mock.On call
9214func (_e *MockSnapshotService_Expecter) SetReady() *MockSnapshotService_SetReady_Call {
9215 return &MockSnapshotService_SetReady_Call{Call: _e.mock.On("SetReady")}
9216}
9217
9218func (_c *MockSnapshotService_SetReady_Call) Run(run func()) *MockSnapshotService_SetReady_Call {
9219 _c.Call.Run(func(args mock.Arguments) {
9220 run()
9221 })
9222 return _c
9223}
9224
9225func (_c *MockSnapshotService_SetReady_Call) Return() *MockSnapshotService_SetReady_Call {
9226 _c.Call.Return()
9227 return _c
9228}
9229
9230func (_c *MockSnapshotService_SetReady_Call) RunAndReturn(run func()) *MockSnapshotService_SetReady_Call {
9231 _c.Run(run)
9232 return _c
9233}
9234
9235// Start provides a mock function for the type MockSnapshotService
9236func (_mock *MockSnapshotService) Start(ctx context.Context) {
9237 _mock.Called(ctx)
9238 return
9239}
9240
9241// MockSnapshotService_Start_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Start'
9242type MockSnapshotService_Start_Call struct {
9243 *mock.Call
9244}
9245
9246// Start is a helper method to define mock.On call
9247// - ctx context.Context
9248func (_e *MockSnapshotService_Expecter) Start(ctx interface{}) *MockSnapshotService_Start_Call {
9249 return &MockSnapshotService_Start_Call{Call: _e.mock.On("Start", ctx)}
9250}
9251
9252func (_c *MockSnapshotService_Start_Call) Run(run func(ctx context.Context)) *MockSnapshotService_Start_Call {
9253 _c.Call.Run(func(args mock.Arguments) {
9254 var arg0 context.Context
9255 if args[0] != nil {
9256 arg0 = args[0].(context.Context)
9257 }
9258 run(
9259 arg0,
9260 )
9261 })
9262 return _c
9263}
9264
9265func (_c *MockSnapshotService_Start_Call) Return() *MockSnapshotService_Start_Call {
9266 _c.Call.Return()
9267 return _c
9268}
9269
9270func (_c *MockSnapshotService_Start_Call) RunAndReturn(run func(ctx context.Context)) *MockSnapshotService_Start_Call {
9271 _c.Run(run)
9272 return _c
9273}
9274
9275// Stop provides a mock function for the type MockSnapshotService
9276func (_mock *MockSnapshotService) Stop(ctx context.Context) error {
9277 ret := _mock.Called(ctx)
9278
9279 if len(ret) == 0 {
9280 panic("no return value specified for Stop")
9281 }
9282
9283 var r0 error
9284 if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
9285 r0 = returnFunc(ctx)
9286 } else {
9287 r0 = ret.Error(0)
9288 }
9289 return r0
9290}
9291
9292// MockSnapshotService_Stop_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Stop'
9293type MockSnapshotService_Stop_Call struct {
9294 *mock.Call
9295}
9296
9297// Stop is a helper method to define mock.On call
9298// - ctx context.Context
9299func (_e *MockSnapshotService_Expecter) Stop(ctx interface{}) *MockSnapshotService_Stop_Call {
9300 return &MockSnapshotService_Stop_Call{Call: _e.mock.On("Stop", ctx)}
9301}
9302
9303func (_c *MockSnapshotService_Stop_Call) Run(run func(ctx context.Context)) *MockSnapshotService_Stop_Call {
9304 _c.Call.Run(func(args mock.Arguments) {
9305 var arg0 context.Context
9306 if args[0] != nil {
9307 arg0 = args[0].(context.Context)
9308 }
9309 run(
9310 arg0,
9311 )
9312 })
9313 return _c
9314}
9315
9316func (_c *MockSnapshotService_Stop_Call) Return(err error) *MockSnapshotService_Stop_Call {
9317 _c.Call.Return(err)
9318 return _c
9319}
9320
9321func (_c *MockSnapshotService_Stop_Call) RunAndReturn(run func(ctx context.Context) error) *MockSnapshotService_Stop_Call {
9322 _c.Call.Return(run)
9323 return _c
9324}
9325
9326// NewMockTextInputTarget creates a new instance of MockTextInputTarget. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
9327// The first argument is typically a *testing.T value.
9328func NewMockTextInputTarget(t interface {
9329 mock.TestingT
9330 Cleanup(func())
9331}) *MockTextInputTarget {
9332 mock := &MockTextInputTarget{}
9333 mock.Mock.Test(t)
9334
9335 t.Cleanup(func() { mock.AssertExpectations(t) })
9336
9337 return mock
9338}
9339
9340// MockTextInputTarget is an autogenerated mock type for the TextInputTarget type
9341type MockTextInputTarget struct {
9342 mock.Mock
9343}
9344
9345type MockTextInputTarget_Expecter struct {
9346 mock *mock.Mock
9347}
9348
9349func (_m *MockTextInputTarget) EXPECT() *MockTextInputTarget_Expecter {
9350 return &MockTextInputTarget_Expecter{mock: &_m.Mock}
9351}
9352
9353// DeleteBeforeCursor provides a mock function for the type MockTextInputTarget
9354func (_mock *MockTextInputTarget) DeleteBeforeCursor(ctx context.Context, n int) error {
9355 ret := _mock.Called(ctx, n)
9356
9357 if len(ret) == 0 {
9358 panic("no return value specified for DeleteBeforeCursor")
9359 }
9360
9361 var r0 error
9362 if returnFunc, ok := ret.Get(0).(func(context.Context, int) error); ok {
9363 r0 = returnFunc(ctx, n)
9364 } else {
9365 r0 = ret.Error(0)
9366 }
9367 return r0
9368}
9369
9370// MockTextInputTarget_DeleteBeforeCursor_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteBeforeCursor'
9371type MockTextInputTarget_DeleteBeforeCursor_Call struct {
9372 *mock.Call
9373}
9374
9375// DeleteBeforeCursor is a helper method to define mock.On call
9376// - ctx context.Context
9377// - n int
9378func (_e *MockTextInputTarget_Expecter) DeleteBeforeCursor(ctx interface{}, n interface{}) *MockTextInputTarget_DeleteBeforeCursor_Call {
9379 return &MockTextInputTarget_DeleteBeforeCursor_Call{Call: _e.mock.On("DeleteBeforeCursor", ctx, n)}
9380}
9381
9382func (_c *MockTextInputTarget_DeleteBeforeCursor_Call) Run(run func(ctx context.Context, n int)) *MockTextInputTarget_DeleteBeforeCursor_Call {
9383 _c.Call.Run(func(args mock.Arguments) {
9384 var arg0 context.Context
9385 if args[0] != nil {
9386 arg0 = args[0].(context.Context)
9387 }
9388 var arg1 int
9389 if args[1] != nil {
9390 arg1 = args[1].(int)
9391 }
9392 run(
9393 arg0,
9394 arg1,
9395 )
9396 })
9397 return _c
9398}
9399
9400func (_c *MockTextInputTarget_DeleteBeforeCursor_Call) Return(err error) *MockTextInputTarget_DeleteBeforeCursor_Call {
9401 _c.Call.Return(err)
9402 return _c
9403}
9404
9405func (_c *MockTextInputTarget_DeleteBeforeCursor_Call) RunAndReturn(run func(ctx context.Context, n int) error) *MockTextInputTarget_DeleteBeforeCursor_Call {
9406 _c.Call.Return(run)
9407 return _c
9408}
9409
9410// InsertText provides a mock function for the type MockTextInputTarget
9411func (_mock *MockTextInputTarget) InsertText(ctx context.Context, text string) error {
9412 ret := _mock.Called(ctx, text)
9413
9414 if len(ret) == 0 {
9415 panic("no return value specified for InsertText")
9416 }
9417
9418 var r0 error
9419 if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
9420 r0 = returnFunc(ctx, text)
9421 } else {
9422 r0 = ret.Error(0)
9423 }
9424 return r0
9425}
9426
9427// MockTextInputTarget_InsertText_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'InsertText'
9428type MockTextInputTarget_InsertText_Call struct {
9429 *mock.Call
9430}
9431
9432// InsertText is a helper method to define mock.On call
9433// - ctx context.Context
9434// - text string
9435func (_e *MockTextInputTarget_Expecter) InsertText(ctx interface{}, text interface{}) *MockTextInputTarget_InsertText_Call {
9436 return &MockTextInputTarget_InsertText_Call{Call: _e.mock.On("InsertText", ctx, text)}
9437}
9438
9439func (_c *MockTextInputTarget_InsertText_Call) Run(run func(ctx context.Context, text string)) *MockTextInputTarget_InsertText_Call {
9440 _c.Call.Run(func(args mock.Arguments) {
9441 var arg0 context.Context
9442 if args[0] != nil {
9443 arg0 = args[0].(context.Context)
9444 }
9445 var arg1 string
9446 if args[1] != nil {
9447 arg1 = args[1].(string)
9448 }
9449 run(
9450 arg0,
9451 arg1,
9452 )
9453 })
9454 return _c
9455}
9456
9457func (_c *MockTextInputTarget_InsertText_Call) Return(err error) *MockTextInputTarget_InsertText_Call {
9458 _c.Call.Return(err)
9459 return _c
9460}
9461
9462func (_c *MockTextInputTarget_InsertText_Call) RunAndReturn(run func(ctx context.Context, text string) error) *MockTextInputTarget_InsertText_Call {
9463 _c.Call.Return(run)
9464 return _c
9465}
9466
9467// NewMockFocusable creates a new instance of MockFocusable. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
9468// The first argument is typically a *testing.T value.
9469func NewMockFocusable(t interface {
9470 mock.TestingT
9471 Cleanup(func())
9472}) *MockFocusable {
9473 mock := &MockFocusable{}
9474 mock.Mock.Test(t)
9475
9476 t.Cleanup(func() { mock.AssertExpectations(t) })
9477
9478 return mock
9479}
9480
9481// MockFocusable is an autogenerated mock type for the Focusable type
9482type MockFocusable struct {
9483 mock.Mock
9484}
9485
9486type MockFocusable_Expecter struct {
9487 mock *mock.Mock
9488}
9489
9490func (_m *MockFocusable) EXPECT() *MockFocusable_Expecter {
9491 return &MockFocusable_Expecter{mock: &_m.Mock}
9492}
9493
9494// Focus provides a mock function for the type MockFocusable
9495func (_mock *MockFocusable) Focus(ctx context.Context) {
9496 _mock.Called(ctx)
9497 return
9498}
9499
9500// MockFocusable_Focus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Focus'
9501type MockFocusable_Focus_Call struct {
9502 *mock.Call
9503}
9504
9505// Focus is a helper method to define mock.On call
9506// - ctx context.Context
9507func (_e *MockFocusable_Expecter) Focus(ctx interface{}) *MockFocusable_Focus_Call {
9508 return &MockFocusable_Focus_Call{Call: _e.mock.On("Focus", ctx)}
9509}
9510
9511func (_c *MockFocusable_Focus_Call) Run(run func(ctx context.Context)) *MockFocusable_Focus_Call {
9512 _c.Call.Run(func(args mock.Arguments) {
9513 var arg0 context.Context
9514 if args[0] != nil {
9515 arg0 = args[0].(context.Context)
9516 }
9517 run(
9518 arg0,
9519 )
9520 })
9521 return _c
9522}
9523
9524func (_c *MockFocusable_Focus_Call) Return() *MockFocusable_Focus_Call {
9525 _c.Call.Return()
9526 return _c
9527}
9528
9529func (_c *MockFocusable_Focus_Call) RunAndReturn(run func(ctx context.Context)) *MockFocusable_Focus_Call {
9530 _c.Run(run)
9531 return _c
9532}
9533
9534// NewMockEntryInputTarget creates a new instance of MockEntryInputTarget. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
9535// The first argument is typically a *testing.T value.
9536func NewMockEntryInputTarget(t interface {
9537 mock.TestingT
9538 Cleanup(func())
9539}) *MockEntryInputTarget {
9540 mock := &MockEntryInputTarget{}
9541 mock.Mock.Test(t)
9542
9543 t.Cleanup(func() { mock.AssertExpectations(t) })
9544
9545 return mock
9546}
9547
9548// MockEntryInputTarget is an autogenerated mock type for the EntryInputTarget type
9549type MockEntryInputTarget struct {
9550 mock.Mock
9551}
9552
9553type MockEntryInputTarget_Expecter struct {
9554 mock *mock.Mock
9555}
9556
9557func (_m *MockEntryInputTarget) EXPECT() *MockEntryInputTarget_Expecter {
9558 return &MockEntryInputTarget_Expecter{mock: &_m.Mock}
9559}
9560
9561// DeleteBeforeCursor provides a mock function for the type MockEntryInputTarget
9562func (_mock *MockEntryInputTarget) DeleteBeforeCursor(ctx context.Context, n int) error {
9563 ret := _mock.Called(ctx, n)
9564
9565 if len(ret) == 0 {
9566 panic("no return value specified for DeleteBeforeCursor")
9567 }
9568
9569 var r0 error
9570 if returnFunc, ok := ret.Get(0).(func(context.Context, int) error); ok {
9571 r0 = returnFunc(ctx, n)
9572 } else {
9573 r0 = ret.Error(0)
9574 }
9575 return r0
9576}
9577
9578// MockEntryInputTarget_DeleteBeforeCursor_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteBeforeCursor'
9579type MockEntryInputTarget_DeleteBeforeCursor_Call struct {
9580 *mock.Call
9581}
9582
9583// DeleteBeforeCursor is a helper method to define mock.On call
9584// - ctx context.Context
9585// - n int
9586func (_e *MockEntryInputTarget_Expecter) DeleteBeforeCursor(ctx interface{}, n interface{}) *MockEntryInputTarget_DeleteBeforeCursor_Call {
9587 return &MockEntryInputTarget_DeleteBeforeCursor_Call{Call: _e.mock.On("DeleteBeforeCursor", ctx, n)}
9588}
9589
9590func (_c *MockEntryInputTarget_DeleteBeforeCursor_Call) Run(run func(ctx context.Context, n int)) *MockEntryInputTarget_DeleteBeforeCursor_Call {
9591 _c.Call.Run(func(args mock.Arguments) {
9592 var arg0 context.Context
9593 if args[0] != nil {
9594 arg0 = args[0].(context.Context)
9595 }
9596 var arg1 int
9597 if args[1] != nil {
9598 arg1 = args[1].(int)
9599 }
9600 run(
9601 arg0,
9602 arg1,
9603 )
9604 })
9605 return _c
9606}
9607
9608func (_c *MockEntryInputTarget_DeleteBeforeCursor_Call) Return(err error) *MockEntryInputTarget_DeleteBeforeCursor_Call {
9609 _c.Call.Return(err)
9610 return _c
9611}
9612
9613func (_c *MockEntryInputTarget_DeleteBeforeCursor_Call) RunAndReturn(run func(ctx context.Context, n int) error) *MockEntryInputTarget_DeleteBeforeCursor_Call {
9614 _c.Call.Return(run)
9615 return _c
9616}
9617
9618// InsertText provides a mock function for the type MockEntryInputTarget
9619func (_mock *MockEntryInputTarget) InsertText(ctx context.Context, text string) error {
9620 ret := _mock.Called(ctx, text)
9621
9622 if len(ret) == 0 {
9623 panic("no return value specified for InsertText")
9624 }
9625
9626 var r0 error
9627 if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
9628 r0 = returnFunc(ctx, text)
9629 } else {
9630 r0 = ret.Error(0)
9631 }
9632 return r0
9633}
9634
9635// MockEntryInputTarget_InsertText_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'InsertText'
9636type MockEntryInputTarget_InsertText_Call struct {
9637 *mock.Call
9638}
9639
9640// InsertText is a helper method to define mock.On call
9641// - ctx context.Context
9642// - text string
9643func (_e *MockEntryInputTarget_Expecter) InsertText(ctx interface{}, text interface{}) *MockEntryInputTarget_InsertText_Call {
9644 return &MockEntryInputTarget_InsertText_Call{Call: _e.mock.On("InsertText", ctx, text)}
9645}
9646
9647func (_c *MockEntryInputTarget_InsertText_Call) Run(run func(ctx context.Context, text string)) *MockEntryInputTarget_InsertText_Call {
9648 _c.Call.Run(func(args mock.Arguments) {
9649 var arg0 context.Context
9650 if args[0] != nil {
9651 arg0 = args[0].(context.Context)
9652 }
9653 var arg1 string
9654 if args[1] != nil {
9655 arg1 = args[1].(string)
9656 }
9657 run(
9658 arg0,
9659 arg1,
9660 )
9661 })
9662 return _c
9663}
9664
9665func (_c *MockEntryInputTarget_InsertText_Call) Return(err error) *MockEntryInputTarget_InsertText_Call {
9666 _c.Call.Return(err)
9667 return _c
9668}
9669
9670func (_c *MockEntryInputTarget_InsertText_Call) RunAndReturn(run func(ctx context.Context, text string) error) *MockEntryInputTarget_InsertText_Call {
9671 _c.Call.Return(run)
9672 return _c
9673}
9674
9675// IsGTKEntryTarget provides a mock function for the type MockEntryInputTarget
9676func (_mock *MockEntryInputTarget) IsGTKEntryTarget() bool {
9677 ret := _mock.Called()
9678
9679 if len(ret) == 0 {
9680 panic("no return value specified for IsGTKEntryTarget")
9681 }
9682
9683 var r0 bool
9684 if returnFunc, ok := ret.Get(0).(func() bool); ok {
9685 r0 = returnFunc()
9686 } else {
9687 r0 = ret.Get(0).(bool)
9688 }
9689 return r0
9690}
9691
9692// MockEntryInputTarget_IsGTKEntryTarget_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsGTKEntryTarget'
9693type MockEntryInputTarget_IsGTKEntryTarget_Call struct {
9694 *mock.Call
9695}
9696
9697// IsGTKEntryTarget is a helper method to define mock.On call
9698func (_e *MockEntryInputTarget_Expecter) IsGTKEntryTarget() *MockEntryInputTarget_IsGTKEntryTarget_Call {
9699 return &MockEntryInputTarget_IsGTKEntryTarget_Call{Call: _e.mock.On("IsGTKEntryTarget")}
9700}
9701
9702func (_c *MockEntryInputTarget_IsGTKEntryTarget_Call) Run(run func()) *MockEntryInputTarget_IsGTKEntryTarget_Call {
9703 _c.Call.Run(func(args mock.Arguments) {
9704 run()
9705 })
9706 return _c
9707}
9708
9709func (_c *MockEntryInputTarget_IsGTKEntryTarget_Call) Return(b bool) *MockEntryInputTarget_IsGTKEntryTarget_Call {
9710 _c.Call.Return(b)
9711 return _c
9712}
9713
9714func (_c *MockEntryInputTarget_IsGTKEntryTarget_Call) RunAndReturn(run func() bool) *MockEntryInputTarget_IsGTKEntryTarget_Call {
9715 _c.Call.Return(run)
9716 return _c
9717}
9718
9719// NewMockFocusedInputProvider creates a new instance of MockFocusedInputProvider. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
9720// The first argument is typically a *testing.T value.
9721func NewMockFocusedInputProvider(t interface {
9722 mock.TestingT
9723 Cleanup(func())
9724}) *MockFocusedInputProvider {
9725 mock := &MockFocusedInputProvider{}
9726 mock.Mock.Test(t)
9727
9728 t.Cleanup(func() { mock.AssertExpectations(t) })
9729
9730 return mock
9731}
9732
9733// MockFocusedInputProvider is an autogenerated mock type for the FocusedInputProvider type
9734type MockFocusedInputProvider struct {
9735 mock.Mock
9736}
9737
9738type MockFocusedInputProvider_Expecter struct {
9739 mock *mock.Mock
9740}
9741
9742func (_m *MockFocusedInputProvider) EXPECT() *MockFocusedInputProvider_Expecter {
9743 return &MockFocusedInputProvider_Expecter{mock: &_m.Mock}
9744}
9745
9746// GetFocusedInput provides a mock function for the type MockFocusedInputProvider
9747func (_mock *MockFocusedInputProvider) GetFocusedInput() port.TextInputTarget {
9748 ret := _mock.Called()
9749
9750 if len(ret) == 0 {
9751 panic("no return value specified for GetFocusedInput")
9752 }
9753
9754 var r0 port.TextInputTarget
9755 if returnFunc, ok := ret.Get(0).(func() port.TextInputTarget); ok {
9756 r0 = returnFunc()
9757 } else {
9758 if ret.Get(0) != nil {
9759 r0 = ret.Get(0).(port.TextInputTarget)
9760 }
9761 }
9762 return r0
9763}
9764
9765// MockFocusedInputProvider_GetFocusedInput_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetFocusedInput'
9766type MockFocusedInputProvider_GetFocusedInput_Call struct {
9767 *mock.Call
9768}
9769
9770// GetFocusedInput is a helper method to define mock.On call
9771func (_e *MockFocusedInputProvider_Expecter) GetFocusedInput() *MockFocusedInputProvider_GetFocusedInput_Call {
9772 return &MockFocusedInputProvider_GetFocusedInput_Call{Call: _e.mock.On("GetFocusedInput")}
9773}
9774
9775func (_c *MockFocusedInputProvider_GetFocusedInput_Call) Run(run func()) *MockFocusedInputProvider_GetFocusedInput_Call {
9776 _c.Call.Run(func(args mock.Arguments) {
9777 run()
9778 })
9779 return _c
9780}
9781
9782func (_c *MockFocusedInputProvider_GetFocusedInput_Call) Return(textInputTarget port.TextInputTarget) *MockFocusedInputProvider_GetFocusedInput_Call {
9783 _c.Call.Return(textInputTarget)
9784 return _c
9785}
9786
9787func (_c *MockFocusedInputProvider_GetFocusedInput_Call) RunAndReturn(run func() port.TextInputTarget) *MockFocusedInputProvider_GetFocusedInput_Call {
9788 _c.Call.Return(run)
9789 return _c
9790}
9791
9792// SetFocusedInput provides a mock function for the type MockFocusedInputProvider
9793func (_mock *MockFocusedInputProvider) SetFocusedInput(target port.TextInputTarget) {
9794 _mock.Called(target)
9795 return
9796}
9797
9798// MockFocusedInputProvider_SetFocusedInput_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetFocusedInput'
9799type MockFocusedInputProvider_SetFocusedInput_Call struct {
9800 *mock.Call
9801}
9802
9803// SetFocusedInput is a helper method to define mock.On call
9804// - target port.TextInputTarget
9805func (_e *MockFocusedInputProvider_Expecter) SetFocusedInput(target interface{}) *MockFocusedInputProvider_SetFocusedInput_Call {
9806 return &MockFocusedInputProvider_SetFocusedInput_Call{Call: _e.mock.On("SetFocusedInput", target)}
9807}
9808
9809func (_c *MockFocusedInputProvider_SetFocusedInput_Call) Run(run func(target port.TextInputTarget)) *MockFocusedInputProvider_SetFocusedInput_Call {
9810 _c.Call.Run(func(args mock.Arguments) {
9811 var arg0 port.TextInputTarget
9812 if args[0] != nil {
9813 arg0 = args[0].(port.TextInputTarget)
9814 }
9815 run(
9816 arg0,
9817 )
9818 })
9819 return _c
9820}
9821
9822func (_c *MockFocusedInputProvider_SetFocusedInput_Call) Return() *MockFocusedInputProvider_SetFocusedInput_Call {
9823 _c.Call.Return()
9824 return _c
9825}
9826
9827func (_c *MockFocusedInputProvider_SetFocusedInput_Call) RunAndReturn(run func(target port.TextInputTarget)) *MockFocusedInputProvider_SetFocusedInput_Call {
9828 _c.Run(run)
9829 return _c
9830}
9831
9832// NewMockUpdateChecker creates a new instance of MockUpdateChecker. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
9833// The first argument is typically a *testing.T value.
9834func NewMockUpdateChecker(t interface {
9835 mock.TestingT
9836 Cleanup(func())
9837}) *MockUpdateChecker {
9838 mock := &MockUpdateChecker{}
9839 mock.Mock.Test(t)
9840
9841 t.Cleanup(func() { mock.AssertExpectations(t) })
9842
9843 return mock
9844}
9845
9846// MockUpdateChecker is an autogenerated mock type for the UpdateChecker type
9847type MockUpdateChecker struct {
9848 mock.Mock
9849}
9850
9851type MockUpdateChecker_Expecter struct {
9852 mock *mock.Mock
9853}
9854
9855func (_m *MockUpdateChecker) EXPECT() *MockUpdateChecker_Expecter {
9856 return &MockUpdateChecker_Expecter{mock: &_m.Mock}
9857}
9858
9859// CheckForUpdate provides a mock function for the type MockUpdateChecker
9860func (_mock *MockUpdateChecker) CheckForUpdate(ctx context.Context, currentVersion string) (*entity.UpdateInfo, error) {
9861 ret := _mock.Called(ctx, currentVersion)
9862
9863 if len(ret) == 0 {
9864 panic("no return value specified for CheckForUpdate")
9865 }
9866
9867 var r0 *entity.UpdateInfo
9868 var r1 error
9869 if returnFunc, ok := ret.Get(0).(func(context.Context, string) (*entity.UpdateInfo, error)); ok {
9870 return returnFunc(ctx, currentVersion)
9871 }
9872 if returnFunc, ok := ret.Get(0).(func(context.Context, string) *entity.UpdateInfo); ok {
9873 r0 = returnFunc(ctx, currentVersion)
9874 } else {
9875 if ret.Get(0) != nil {
9876 r0 = ret.Get(0).(*entity.UpdateInfo)
9877 }
9878 }
9879 if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
9880 r1 = returnFunc(ctx, currentVersion)
9881 } else {
9882 r1 = ret.Error(1)
9883 }
9884 return r0, r1
9885}
9886
9887// MockUpdateChecker_CheckForUpdate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CheckForUpdate'
9888type MockUpdateChecker_CheckForUpdate_Call struct {
9889 *mock.Call
9890}
9891
9892// CheckForUpdate is a helper method to define mock.On call
9893// - ctx context.Context
9894// - currentVersion string
9895func (_e *MockUpdateChecker_Expecter) CheckForUpdate(ctx interface{}, currentVersion interface{}) *MockUpdateChecker_CheckForUpdate_Call {
9896 return &MockUpdateChecker_CheckForUpdate_Call{Call: _e.mock.On("CheckForUpdate", ctx, currentVersion)}
9897}
9898
9899func (_c *MockUpdateChecker_CheckForUpdate_Call) Run(run func(ctx context.Context, currentVersion string)) *MockUpdateChecker_CheckForUpdate_Call {
9900 _c.Call.Run(func(args mock.Arguments) {
9901 var arg0 context.Context
9902 if args[0] != nil {
9903 arg0 = args[0].(context.Context)
9904 }
9905 var arg1 string
9906 if args[1] != nil {
9907 arg1 = args[1].(string)
9908 }
9909 run(
9910 arg0,
9911 arg1,
9912 )
9913 })
9914 return _c
9915}
9916
9917func (_c *MockUpdateChecker_CheckForUpdate_Call) Return(updateInfo *entity.UpdateInfo, err error) *MockUpdateChecker_CheckForUpdate_Call {
9918 _c.Call.Return(updateInfo, err)
9919 return _c
9920}
9921
9922func (_c *MockUpdateChecker_CheckForUpdate_Call) RunAndReturn(run func(ctx context.Context, currentVersion string) (*entity.UpdateInfo, error)) *MockUpdateChecker_CheckForUpdate_Call {
9923 _c.Call.Return(run)
9924 return _c
9925}
9926
9927// NewMockUpdateDownloader creates a new instance of MockUpdateDownloader. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
9928// The first argument is typically a *testing.T value.
9929func NewMockUpdateDownloader(t interface {
9930 mock.TestingT
9931 Cleanup(func())
9932}) *MockUpdateDownloader {
9933 mock := &MockUpdateDownloader{}
9934 mock.Mock.Test(t)
9935
9936 t.Cleanup(func() { mock.AssertExpectations(t) })
9937
9938 return mock
9939}
9940
9941// MockUpdateDownloader is an autogenerated mock type for the UpdateDownloader type
9942type MockUpdateDownloader struct {
9943 mock.Mock
9944}
9945
9946type MockUpdateDownloader_Expecter struct {
9947 mock *mock.Mock
9948}
9949
9950func (_m *MockUpdateDownloader) EXPECT() *MockUpdateDownloader_Expecter {
9951 return &MockUpdateDownloader_Expecter{mock: &_m.Mock}
9952}
9953
9954// Download provides a mock function for the type MockUpdateDownloader
9955func (_mock *MockUpdateDownloader) Download(ctx context.Context, downloadURL string, destDir string) (string, error) {
9956 ret := _mock.Called(ctx, downloadURL, destDir)
9957
9958 if len(ret) == 0 {
9959 panic("no return value specified for Download")
9960 }
9961
9962 var r0 string
9963 var r1 error
9964 if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (string, error)); ok {
9965 return returnFunc(ctx, downloadURL, destDir)
9966 }
9967 if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) string); ok {
9968 r0 = returnFunc(ctx, downloadURL, destDir)
9969 } else {
9970 r0 = ret.Get(0).(string)
9971 }
9972 if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
9973 r1 = returnFunc(ctx, downloadURL, destDir)
9974 } else {
9975 r1 = ret.Error(1)
9976 }
9977 return r0, r1
9978}
9979
9980// MockUpdateDownloader_Download_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Download'
9981type MockUpdateDownloader_Download_Call struct {
9982 *mock.Call
9983}
9984
9985// Download is a helper method to define mock.On call
9986// - ctx context.Context
9987// - downloadURL string
9988// - destDir string
9989func (_e *MockUpdateDownloader_Expecter) Download(ctx interface{}, downloadURL interface{}, destDir interface{}) *MockUpdateDownloader_Download_Call {
9990 return &MockUpdateDownloader_Download_Call{Call: _e.mock.On("Download", ctx, downloadURL, destDir)}
9991}
9992
9993func (_c *MockUpdateDownloader_Download_Call) Run(run func(ctx context.Context, downloadURL string, destDir string)) *MockUpdateDownloader_Download_Call {
9994 _c.Call.Run(func(args mock.Arguments) {
9995 var arg0 context.Context
9996 if args[0] != nil {
9997 arg0 = args[0].(context.Context)
9998 }
9999 var arg1 string
10000 if args[1] != nil {
10001 arg1 = args[1].(string)
10002 }
10003 var arg2 string
10004 if args[2] != nil {
10005 arg2 = args[2].(string)
10006 }
10007 run(
10008 arg0,
10009 arg1,
10010 arg2,
10011 )
10012 })
10013 return _c
10014}
10015
10016func (_c *MockUpdateDownloader_Download_Call) Return(archivePath string, err error) *MockUpdateDownloader_Download_Call {
10017 _c.Call.Return(archivePath, err)
10018 return _c
10019}
10020
10021func (_c *MockUpdateDownloader_Download_Call) RunAndReturn(run func(ctx context.Context, downloadURL string, destDir string) (string, error)) *MockUpdateDownloader_Download_Call {
10022 _c.Call.Return(run)
10023 return _c
10024}
10025
10026// Extract provides a mock function for the type MockUpdateDownloader
10027func (_mock *MockUpdateDownloader) Extract(ctx context.Context, archivePath string, destDir string) (string, error) {
10028 ret := _mock.Called(ctx, archivePath, destDir)
10029
10030 if len(ret) == 0 {
10031 panic("no return value specified for Extract")
10032 }
10033
10034 var r0 string
10035 var r1 error
10036 if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (string, error)); ok {
10037 return returnFunc(ctx, archivePath, destDir)
10038 }
10039 if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) string); ok {
10040 r0 = returnFunc(ctx, archivePath, destDir)
10041 } else {
10042 r0 = ret.Get(0).(string)
10043 }
10044 if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
10045 r1 = returnFunc(ctx, archivePath, destDir)
10046 } else {
10047 r1 = ret.Error(1)
10048 }
10049 return r0, r1
10050}
10051
10052// MockUpdateDownloader_Extract_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Extract'
10053type MockUpdateDownloader_Extract_Call struct {
10054 *mock.Call
10055}
10056
10057// Extract is a helper method to define mock.On call
10058// - ctx context.Context
10059// - archivePath string
10060// - destDir string
10061func (_e *MockUpdateDownloader_Expecter) Extract(ctx interface{}, archivePath interface{}, destDir interface{}) *MockUpdateDownloader_Extract_Call {
10062 return &MockUpdateDownloader_Extract_Call{Call: _e.mock.On("Extract", ctx, archivePath, destDir)}
10063}
10064
10065func (_c *MockUpdateDownloader_Extract_Call) Run(run func(ctx context.Context, archivePath string, destDir string)) *MockUpdateDownloader_Extract_Call {
10066 _c.Call.Run(func(args mock.Arguments) {
10067 var arg0 context.Context
10068 if args[0] != nil {
10069 arg0 = args[0].(context.Context)
10070 }
10071 var arg1 string
10072 if args[1] != nil {
10073 arg1 = args[1].(string)
10074 }
10075 var arg2 string
10076 if args[2] != nil {
10077 arg2 = args[2].(string)
10078 }
10079 run(
10080 arg0,
10081 arg1,
10082 arg2,
10083 )
10084 })
10085 return _c
10086}
10087
10088func (_c *MockUpdateDownloader_Extract_Call) Return(binaryPath string, err error) *MockUpdateDownloader_Extract_Call {
10089 _c.Call.Return(binaryPath, err)
10090 return _c
10091}
10092
10093func (_c *MockUpdateDownloader_Extract_Call) RunAndReturn(run func(ctx context.Context, archivePath string, destDir string) (string, error)) *MockUpdateDownloader_Extract_Call {
10094 _c.Call.Return(run)
10095 return _c
10096}
10097
10098// NewMockUpdateApplier creates a new instance of MockUpdateApplier. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
10099// The first argument is typically a *testing.T value.
10100func NewMockUpdateApplier(t interface {
10101 mock.TestingT
10102 Cleanup(func())
10103}) *MockUpdateApplier {
10104 mock := &MockUpdateApplier{}
10105 mock.Mock.Test(t)
10106
10107 t.Cleanup(func() { mock.AssertExpectations(t) })
10108
10109 return mock
10110}
10111
10112// MockUpdateApplier is an autogenerated mock type for the UpdateApplier type
10113type MockUpdateApplier struct {
10114 mock.Mock
10115}
10116
10117type MockUpdateApplier_Expecter struct {
10118 mock *mock.Mock
10119}
10120
10121func (_m *MockUpdateApplier) EXPECT() *MockUpdateApplier_Expecter {
10122 return &MockUpdateApplier_Expecter{mock: &_m.Mock}
10123}
10124
10125// ApplyOnExit provides a mock function for the type MockUpdateApplier
10126func (_mock *MockUpdateApplier) ApplyOnExit(ctx context.Context) (string, error) {
10127 ret := _mock.Called(ctx)
10128
10129 if len(ret) == 0 {
10130 panic("no return value specified for ApplyOnExit")
10131 }
10132
10133 var r0 string
10134 var r1 error
10135 if returnFunc, ok := ret.Get(0).(func(context.Context) (string, error)); ok {
10136 return returnFunc(ctx)
10137 }
10138 if returnFunc, ok := ret.Get(0).(func(context.Context) string); ok {
10139 r0 = returnFunc(ctx)
10140 } else {
10141 r0 = ret.Get(0).(string)
10142 }
10143 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
10144 r1 = returnFunc(ctx)
10145 } else {
10146 r1 = ret.Error(1)
10147 }
10148 return r0, r1
10149}
10150
10151// MockUpdateApplier_ApplyOnExit_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ApplyOnExit'
10152type MockUpdateApplier_ApplyOnExit_Call struct {
10153 *mock.Call
10154}
10155
10156// ApplyOnExit is a helper method to define mock.On call
10157// - ctx context.Context
10158func (_e *MockUpdateApplier_Expecter) ApplyOnExit(ctx interface{}) *MockUpdateApplier_ApplyOnExit_Call {
10159 return &MockUpdateApplier_ApplyOnExit_Call{Call: _e.mock.On("ApplyOnExit", ctx)}
10160}
10161
10162func (_c *MockUpdateApplier_ApplyOnExit_Call) Run(run func(ctx context.Context)) *MockUpdateApplier_ApplyOnExit_Call {
10163 _c.Call.Run(func(args mock.Arguments) {
10164 var arg0 context.Context
10165 if args[0] != nil {
10166 arg0 = args[0].(context.Context)
10167 }
10168 run(
10169 arg0,
10170 )
10171 })
10172 return _c
10173}
10174
10175func (_c *MockUpdateApplier_ApplyOnExit_Call) Return(backupPath string, err error) *MockUpdateApplier_ApplyOnExit_Call {
10176 _c.Call.Return(backupPath, err)
10177 return _c
10178}
10179
10180func (_c *MockUpdateApplier_ApplyOnExit_Call) RunAndReturn(run func(ctx context.Context) (string, error)) *MockUpdateApplier_ApplyOnExit_Call {
10181 _c.Call.Return(run)
10182 return _c
10183}
10184
10185// CanSelfUpdate provides a mock function for the type MockUpdateApplier
10186func (_mock *MockUpdateApplier) CanSelfUpdate(ctx context.Context) bool {
10187 ret := _mock.Called(ctx)
10188
10189 if len(ret) == 0 {
10190 panic("no return value specified for CanSelfUpdate")
10191 }
10192
10193 var r0 bool
10194 if returnFunc, ok := ret.Get(0).(func(context.Context) bool); ok {
10195 r0 = returnFunc(ctx)
10196 } else {
10197 r0 = ret.Get(0).(bool)
10198 }
10199 return r0
10200}
10201
10202// MockUpdateApplier_CanSelfUpdate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CanSelfUpdate'
10203type MockUpdateApplier_CanSelfUpdate_Call struct {
10204 *mock.Call
10205}
10206
10207// CanSelfUpdate is a helper method to define mock.On call
10208// - ctx context.Context
10209func (_e *MockUpdateApplier_Expecter) CanSelfUpdate(ctx interface{}) *MockUpdateApplier_CanSelfUpdate_Call {
10210 return &MockUpdateApplier_CanSelfUpdate_Call{Call: _e.mock.On("CanSelfUpdate", ctx)}
10211}
10212
10213func (_c *MockUpdateApplier_CanSelfUpdate_Call) Run(run func(ctx context.Context)) *MockUpdateApplier_CanSelfUpdate_Call {
10214 _c.Call.Run(func(args mock.Arguments) {
10215 var arg0 context.Context
10216 if args[0] != nil {
10217 arg0 = args[0].(context.Context)
10218 }
10219 run(
10220 arg0,
10221 )
10222 })
10223 return _c
10224}
10225
10226func (_c *MockUpdateApplier_CanSelfUpdate_Call) Return(b bool) *MockUpdateApplier_CanSelfUpdate_Call {
10227 _c.Call.Return(b)
10228 return _c
10229}
10230
10231func (_c *MockUpdateApplier_CanSelfUpdate_Call) RunAndReturn(run func(ctx context.Context) bool) *MockUpdateApplier_CanSelfUpdate_Call {
10232 _c.Call.Return(run)
10233 return _c
10234}
10235
10236// ClearStagedUpdate provides a mock function for the type MockUpdateApplier
10237func (_mock *MockUpdateApplier) ClearStagedUpdate(ctx context.Context) error {
10238 ret := _mock.Called(ctx)
10239
10240 if len(ret) == 0 {
10241 panic("no return value specified for ClearStagedUpdate")
10242 }
10243
10244 var r0 error
10245 if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
10246 r0 = returnFunc(ctx)
10247 } else {
10248 r0 = ret.Error(0)
10249 }
10250 return r0
10251}
10252
10253// MockUpdateApplier_ClearStagedUpdate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClearStagedUpdate'
10254type MockUpdateApplier_ClearStagedUpdate_Call struct {
10255 *mock.Call
10256}
10257
10258// ClearStagedUpdate is a helper method to define mock.On call
10259// - ctx context.Context
10260func (_e *MockUpdateApplier_Expecter) ClearStagedUpdate(ctx interface{}) *MockUpdateApplier_ClearStagedUpdate_Call {
10261 return &MockUpdateApplier_ClearStagedUpdate_Call{Call: _e.mock.On("ClearStagedUpdate", ctx)}
10262}
10263
10264func (_c *MockUpdateApplier_ClearStagedUpdate_Call) Run(run func(ctx context.Context)) *MockUpdateApplier_ClearStagedUpdate_Call {
10265 _c.Call.Run(func(args mock.Arguments) {
10266 var arg0 context.Context
10267 if args[0] != nil {
10268 arg0 = args[0].(context.Context)
10269 }
10270 run(
10271 arg0,
10272 )
10273 })
10274 return _c
10275}
10276
10277func (_c *MockUpdateApplier_ClearStagedUpdate_Call) Return(err error) *MockUpdateApplier_ClearStagedUpdate_Call {
10278 _c.Call.Return(err)
10279 return _c
10280}
10281
10282func (_c *MockUpdateApplier_ClearStagedUpdate_Call) RunAndReturn(run func(ctx context.Context) error) *MockUpdateApplier_ClearStagedUpdate_Call {
10283 _c.Call.Return(run)
10284 return _c
10285}
10286
10287// GetBinaryPath provides a mock function for the type MockUpdateApplier
10288func (_mock *MockUpdateApplier) GetBinaryPath() (string, error) {
10289 ret := _mock.Called()
10290
10291 if len(ret) == 0 {
10292 panic("no return value specified for GetBinaryPath")
10293 }
10294
10295 var r0 string
10296 var r1 error
10297 if returnFunc, ok := ret.Get(0).(func() (string, error)); ok {
10298 return returnFunc()
10299 }
10300 if returnFunc, ok := ret.Get(0).(func() string); ok {
10301 r0 = returnFunc()
10302 } else {
10303 r0 = ret.Get(0).(string)
10304 }
10305 if returnFunc, ok := ret.Get(1).(func() error); ok {
10306 r1 = returnFunc()
10307 } else {
10308 r1 = ret.Error(1)
10309 }
10310 return r0, r1
10311}
10312
10313// MockUpdateApplier_GetBinaryPath_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBinaryPath'
10314type MockUpdateApplier_GetBinaryPath_Call struct {
10315 *mock.Call
10316}
10317
10318// GetBinaryPath is a helper method to define mock.On call
10319func (_e *MockUpdateApplier_Expecter) GetBinaryPath() *MockUpdateApplier_GetBinaryPath_Call {
10320 return &MockUpdateApplier_GetBinaryPath_Call{Call: _e.mock.On("GetBinaryPath")}
10321}
10322
10323func (_c *MockUpdateApplier_GetBinaryPath_Call) Run(run func()) *MockUpdateApplier_GetBinaryPath_Call {
10324 _c.Call.Run(func(args mock.Arguments) {
10325 run()
10326 })
10327 return _c
10328}
10329
10330func (_c *MockUpdateApplier_GetBinaryPath_Call) Return(s string, err error) *MockUpdateApplier_GetBinaryPath_Call {
10331 _c.Call.Return(s, err)
10332 return _c
10333}
10334
10335func (_c *MockUpdateApplier_GetBinaryPath_Call) RunAndReturn(run func() (string, error)) *MockUpdateApplier_GetBinaryPath_Call {
10336 _c.Call.Return(run)
10337 return _c
10338}
10339
10340// HasStagedUpdate provides a mock function for the type MockUpdateApplier
10341func (_mock *MockUpdateApplier) HasStagedUpdate(ctx context.Context) bool {
10342 ret := _mock.Called(ctx)
10343
10344 if len(ret) == 0 {
10345 panic("no return value specified for HasStagedUpdate")
10346 }
10347
10348 var r0 bool
10349 if returnFunc, ok := ret.Get(0).(func(context.Context) bool); ok {
10350 r0 = returnFunc(ctx)
10351 } else {
10352 r0 = ret.Get(0).(bool)
10353 }
10354 return r0
10355}
10356
10357// MockUpdateApplier_HasStagedUpdate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasStagedUpdate'
10358type MockUpdateApplier_HasStagedUpdate_Call struct {
10359 *mock.Call
10360}
10361
10362// HasStagedUpdate is a helper method to define mock.On call
10363// - ctx context.Context
10364func (_e *MockUpdateApplier_Expecter) HasStagedUpdate(ctx interface{}) *MockUpdateApplier_HasStagedUpdate_Call {
10365 return &MockUpdateApplier_HasStagedUpdate_Call{Call: _e.mock.On("HasStagedUpdate", ctx)}
10366}
10367
10368func (_c *MockUpdateApplier_HasStagedUpdate_Call) Run(run func(ctx context.Context)) *MockUpdateApplier_HasStagedUpdate_Call {
10369 _c.Call.Run(func(args mock.Arguments) {
10370 var arg0 context.Context
10371 if args[0] != nil {
10372 arg0 = args[0].(context.Context)
10373 }
10374 run(
10375 arg0,
10376 )
10377 })
10378 return _c
10379}
10380
10381func (_c *MockUpdateApplier_HasStagedUpdate_Call) Return(b bool) *MockUpdateApplier_HasStagedUpdate_Call {
10382 _c.Call.Return(b)
10383 return _c
10384}
10385
10386func (_c *MockUpdateApplier_HasStagedUpdate_Call) RunAndReturn(run func(ctx context.Context) bool) *MockUpdateApplier_HasStagedUpdate_Call {
10387 _c.Call.Return(run)
10388 return _c
10389}
10390
10391// SelfUpdateBlockedReason provides a mock function for the type MockUpdateApplier
10392func (_mock *MockUpdateApplier) SelfUpdateBlockedReason(ctx context.Context) port.SelfUpdateBlockedReason {
10393 ret := _mock.Called(ctx)
10394
10395 if len(ret) == 0 {
10396 panic("no return value specified for SelfUpdateBlockedReason")
10397 }
10398
10399 var r0 port.SelfUpdateBlockedReason
10400 if returnFunc, ok := ret.Get(0).(func(context.Context) port.SelfUpdateBlockedReason); ok {
10401 r0 = returnFunc(ctx)
10402 } else {
10403 r0 = ret.Get(0).(port.SelfUpdateBlockedReason)
10404 }
10405 return r0
10406}
10407
10408// MockUpdateApplier_SelfUpdateBlockedReason_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SelfUpdateBlockedReason'
10409type MockUpdateApplier_SelfUpdateBlockedReason_Call struct {
10410 *mock.Call
10411}
10412
10413// SelfUpdateBlockedReason is a helper method to define mock.On call
10414// - ctx context.Context
10415func (_e *MockUpdateApplier_Expecter) SelfUpdateBlockedReason(ctx interface{}) *MockUpdateApplier_SelfUpdateBlockedReason_Call {
10416 return &MockUpdateApplier_SelfUpdateBlockedReason_Call{Call: _e.mock.On("SelfUpdateBlockedReason", ctx)}
10417}
10418
10419func (_c *MockUpdateApplier_SelfUpdateBlockedReason_Call) Run(run func(ctx context.Context)) *MockUpdateApplier_SelfUpdateBlockedReason_Call {
10420 _c.Call.Run(func(args mock.Arguments) {
10421 var arg0 context.Context
10422 if args[0] != nil {
10423 arg0 = args[0].(context.Context)
10424 }
10425 run(
10426 arg0,
10427 )
10428 })
10429 return _c
10430}
10431
10432func (_c *MockUpdateApplier_SelfUpdateBlockedReason_Call) Return(selfUpdateBlockedReason port.SelfUpdateBlockedReason) *MockUpdateApplier_SelfUpdateBlockedReason_Call {
10433 _c.Call.Return(selfUpdateBlockedReason)
10434 return _c
10435}
10436
10437func (_c *MockUpdateApplier_SelfUpdateBlockedReason_Call) RunAndReturn(run func(ctx context.Context) port.SelfUpdateBlockedReason) *MockUpdateApplier_SelfUpdateBlockedReason_Call {
10438 _c.Call.Return(run)
10439 return _c
10440}
10441
10442// StageUpdate provides a mock function for the type MockUpdateApplier
10443func (_mock *MockUpdateApplier) StageUpdate(ctx context.Context, newBinaryPath string) error {
10444 ret := _mock.Called(ctx, newBinaryPath)
10445
10446 if len(ret) == 0 {
10447 panic("no return value specified for StageUpdate")
10448 }
10449
10450 var r0 error
10451 if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
10452 r0 = returnFunc(ctx, newBinaryPath)
10453 } else {
10454 r0 = ret.Error(0)
10455 }
10456 return r0
10457}
10458
10459// MockUpdateApplier_StageUpdate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StageUpdate'
10460type MockUpdateApplier_StageUpdate_Call struct {
10461 *mock.Call
10462}
10463
10464// StageUpdate is a helper method to define mock.On call
10465// - ctx context.Context
10466// - newBinaryPath string
10467func (_e *MockUpdateApplier_Expecter) StageUpdate(ctx interface{}, newBinaryPath interface{}) *MockUpdateApplier_StageUpdate_Call {
10468 return &MockUpdateApplier_StageUpdate_Call{Call: _e.mock.On("StageUpdate", ctx, newBinaryPath)}
10469}
10470
10471func (_c *MockUpdateApplier_StageUpdate_Call) Run(run func(ctx context.Context, newBinaryPath string)) *MockUpdateApplier_StageUpdate_Call {
10472 _c.Call.Run(func(args mock.Arguments) {
10473 var arg0 context.Context
10474 if args[0] != nil {
10475 arg0 = args[0].(context.Context)
10476 }
10477 var arg1 string
10478 if args[1] != nil {
10479 arg1 = args[1].(string)
10480 }
10481 run(
10482 arg0,
10483 arg1,
10484 )
10485 })
10486 return _c
10487}
10488
10489func (_c *MockUpdateApplier_StageUpdate_Call) Return(err error) *MockUpdateApplier_StageUpdate_Call {
10490 _c.Call.Return(err)
10491 return _c
10492}
10493
10494func (_c *MockUpdateApplier_StageUpdate_Call) RunAndReturn(run func(ctx context.Context, newBinaryPath string) error) *MockUpdateApplier_StageUpdate_Call {
10495 _c.Call.Return(run)
10496 return _c
10497}
10498
10499// NewMockWebUIConfigSaver creates a new instance of MockWebUIConfigSaver. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
10500// The first argument is typically a *testing.T value.
10501func NewMockWebUIConfigSaver(t interface {
10502 mock.TestingT
10503 Cleanup(func())
10504}) *MockWebUIConfigSaver {
10505 mock := &MockWebUIConfigSaver{}
10506 mock.Mock.Test(t)
10507
10508 t.Cleanup(func() { mock.AssertExpectations(t) })
10509
10510 return mock
10511}
10512
10513// MockWebUIConfigSaver is an autogenerated mock type for the WebUIConfigSaver type
10514type MockWebUIConfigSaver struct {
10515 mock.Mock
10516}
10517
10518type MockWebUIConfigSaver_Expecter struct {
10519 mock *mock.Mock
10520}
10521
10522func (_m *MockWebUIConfigSaver) EXPECT() *MockWebUIConfigSaver_Expecter {
10523 return &MockWebUIConfigSaver_Expecter{mock: &_m.Mock}
10524}
10525
10526// SaveWebUIConfig provides a mock function for the type MockWebUIConfigSaver
10527func (_mock *MockWebUIConfigSaver) SaveWebUIConfig(ctx context.Context, cfg port.WebUIConfig) error {
10528 ret := _mock.Called(ctx, cfg)
10529
10530 if len(ret) == 0 {
10531 panic("no return value specified for SaveWebUIConfig")
10532 }
10533
10534 var r0 error
10535 if returnFunc, ok := ret.Get(0).(func(context.Context, port.WebUIConfig) error); ok {
10536 r0 = returnFunc(ctx, cfg)
10537 } else {
10538 r0 = ret.Error(0)
10539 }
10540 return r0
10541}
10542
10543// MockWebUIConfigSaver_SaveWebUIConfig_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SaveWebUIConfig'
10544type MockWebUIConfigSaver_SaveWebUIConfig_Call struct {
10545 *mock.Call
10546}
10547
10548// SaveWebUIConfig is a helper method to define mock.On call
10549// - ctx context.Context
10550// - cfg port.WebUIConfig
10551func (_e *MockWebUIConfigSaver_Expecter) SaveWebUIConfig(ctx interface{}, cfg interface{}) *MockWebUIConfigSaver_SaveWebUIConfig_Call {
10552 return &MockWebUIConfigSaver_SaveWebUIConfig_Call{Call: _e.mock.On("SaveWebUIConfig", ctx, cfg)}
10553}
10554
10555func (_c *MockWebUIConfigSaver_SaveWebUIConfig_Call) Run(run func(ctx context.Context, cfg port.WebUIConfig)) *MockWebUIConfigSaver_SaveWebUIConfig_Call {
10556 _c.Call.Run(func(args mock.Arguments) {
10557 var arg0 context.Context
10558 if args[0] != nil {
10559 arg0 = args[0].(context.Context)
10560 }
10561 var arg1 port.WebUIConfig
10562 if args[1] != nil {
10563 arg1 = args[1].(port.WebUIConfig)
10564 }
10565 run(
10566 arg0,
10567 arg1,
10568 )
10569 })
10570 return _c
10571}
10572
10573func (_c *MockWebUIConfigSaver_SaveWebUIConfig_Call) Return(err error) *MockWebUIConfigSaver_SaveWebUIConfig_Call {
10574 _c.Call.Return(err)
10575 return _c
10576}
10577
10578func (_c *MockWebUIConfigSaver_SaveWebUIConfig_Call) RunAndReturn(run func(ctx context.Context, cfg port.WebUIConfig) error) *MockWebUIConfigSaver_SaveWebUIConfig_Call {
10579 _c.Call.Return(run)
10580 return _c
10581}
10582
10583// NewMockTexture creates a new instance of MockTexture. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
10584// The first argument is typically a *testing.T value.
10585func NewMockTexture(t interface {
10586 mock.TestingT
10587 Cleanup(func())
10588}) *MockTexture {
10589 mock := &MockTexture{}
10590 mock.Mock.Test(t)
10591
10592 t.Cleanup(func() { mock.AssertExpectations(t) })
10593
10594 return mock
10595}
10596
10597// MockTexture is an autogenerated mock type for the Texture type
10598type MockTexture struct {
10599 mock.Mock
10600}
10601
10602type MockTexture_Expecter struct {
10603 mock *mock.Mock
10604}
10605
10606func (_m *MockTexture) EXPECT() *MockTexture_Expecter {
10607 return &MockTexture_Expecter{mock: &_m.Mock}
10608}
10609
10610// GoPointer provides a mock function for the type MockTexture
10611func (_mock *MockTexture) GoPointer() uintptr {
10612 ret := _mock.Called()
10613
10614 if len(ret) == 0 {
10615 panic("no return value specified for GoPointer")
10616 }
10617
10618 var r0 uintptr
10619 if returnFunc, ok := ret.Get(0).(func() uintptr); ok {
10620 r0 = returnFunc()
10621 } else {
10622 r0 = ret.Get(0).(uintptr)
10623 }
10624 return r0
10625}
10626
10627// MockTexture_GoPointer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GoPointer'
10628type MockTexture_GoPointer_Call struct {
10629 *mock.Call
10630}
10631
10632// GoPointer is a helper method to define mock.On call
10633func (_e *MockTexture_Expecter) GoPointer() *MockTexture_GoPointer_Call {
10634 return &MockTexture_GoPointer_Call{Call: _e.mock.On("GoPointer")}
10635}
10636
10637func (_c *MockTexture_GoPointer_Call) Run(run func()) *MockTexture_GoPointer_Call {
10638 _c.Call.Run(func(args mock.Arguments) {
10639 run()
10640 })
10641 return _c
10642}
10643
10644func (_c *MockTexture_GoPointer_Call) Return(v uintptr) *MockTexture_GoPointer_Call {
10645 _c.Call.Return(v)
10646 return _c
10647}
10648
10649func (_c *MockTexture_GoPointer_Call) RunAndReturn(run func() uintptr) *MockTexture_GoPointer_Call {
10650 _c.Call.Return(run)
10651 return _c
10652}
10653
10654// NewMockFindController creates a new instance of MockFindController. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
10655// The first argument is typically a *testing.T value.
10656func NewMockFindController(t interface {
10657 mock.TestingT
10658 Cleanup(func())
10659}) *MockFindController {
10660 mock := &MockFindController{}
10661 mock.Mock.Test(t)
10662
10663 t.Cleanup(func() { mock.AssertExpectations(t) })
10664
10665 return mock
10666}
10667
10668// MockFindController is an autogenerated mock type for the FindController type
10669type MockFindController struct {
10670 mock.Mock
10671}
10672
10673type MockFindController_Expecter struct {
10674 mock *mock.Mock
10675}
10676
10677func (_m *MockFindController) EXPECT() *MockFindController_Expecter {
10678 return &MockFindController_Expecter{mock: &_m.Mock}
10679}
10680
10681// CountMatches provides a mock function for the type MockFindController
10682func (_mock *MockFindController) CountMatches(text string, options port.FindOptions, maxMatches uint) {
10683 _mock.Called(text, options, maxMatches)
10684 return
10685}
10686
10687// MockFindController_CountMatches_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CountMatches'
10688type MockFindController_CountMatches_Call struct {
10689 *mock.Call
10690}
10691
10692// CountMatches is a helper method to define mock.On call
10693// - text string
10694// - options port.FindOptions
10695// - maxMatches uint
10696func (_e *MockFindController_Expecter) CountMatches(text interface{}, options interface{}, maxMatches interface{}) *MockFindController_CountMatches_Call {
10697 return &MockFindController_CountMatches_Call{Call: _e.mock.On("CountMatches", text, options, maxMatches)}
10698}
10699
10700func (_c *MockFindController_CountMatches_Call) Run(run func(text string, options port.FindOptions, maxMatches uint)) *MockFindController_CountMatches_Call {
10701 _c.Call.Run(func(args mock.Arguments) {
10702 var arg0 string
10703 if args[0] != nil {
10704 arg0 = args[0].(string)
10705 }
10706 var arg1 port.FindOptions
10707 if args[1] != nil {
10708 arg1 = args[1].(port.FindOptions)
10709 }
10710 var arg2 uint
10711 if args[2] != nil {
10712 arg2 = args[2].(uint)
10713 }
10714 run(
10715 arg0,
10716 arg1,
10717 arg2,
10718 )
10719 })
10720 return _c
10721}
10722
10723func (_c *MockFindController_CountMatches_Call) Return() *MockFindController_CountMatches_Call {
10724 _c.Call.Return()
10725 return _c
10726}
10727
10728func (_c *MockFindController_CountMatches_Call) RunAndReturn(run func(text string, options port.FindOptions, maxMatches uint)) *MockFindController_CountMatches_Call {
10729 _c.Run(run)
10730 return _c
10731}
10732
10733// DisconnectSignal provides a mock function for the type MockFindController
10734func (_mock *MockFindController) DisconnectSignal(id uint) {
10735 _mock.Called(id)
10736 return
10737}
10738
10739// MockFindController_DisconnectSignal_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DisconnectSignal'
10740type MockFindController_DisconnectSignal_Call struct {
10741 *mock.Call
10742}
10743
10744// DisconnectSignal is a helper method to define mock.On call
10745// - id uint
10746func (_e *MockFindController_Expecter) DisconnectSignal(id interface{}) *MockFindController_DisconnectSignal_Call {
10747 return &MockFindController_DisconnectSignal_Call{Call: _e.mock.On("DisconnectSignal", id)}
10748}
10749
10750func (_c *MockFindController_DisconnectSignal_Call) Run(run func(id uint)) *MockFindController_DisconnectSignal_Call {
10751 _c.Call.Run(func(args mock.Arguments) {
10752 var arg0 uint
10753 if args[0] != nil {
10754 arg0 = args[0].(uint)
10755 }
10756 run(
10757 arg0,
10758 )
10759 })
10760 return _c
10761}
10762
10763func (_c *MockFindController_DisconnectSignal_Call) Return() *MockFindController_DisconnectSignal_Call {
10764 _c.Call.Return()
10765 return _c
10766}
10767
10768func (_c *MockFindController_DisconnectSignal_Call) RunAndReturn(run func(id uint)) *MockFindController_DisconnectSignal_Call {
10769 _c.Run(run)
10770 return _c
10771}
10772
10773// GetSearchText provides a mock function for the type MockFindController
10774func (_mock *MockFindController) GetSearchText() string {
10775 ret := _mock.Called()
10776
10777 if len(ret) == 0 {
10778 panic("no return value specified for GetSearchText")
10779 }
10780
10781 var r0 string
10782 if returnFunc, ok := ret.Get(0).(func() string); ok {
10783 r0 = returnFunc()
10784 } else {
10785 r0 = ret.Get(0).(string)
10786 }
10787 return r0
10788}
10789
10790// MockFindController_GetSearchText_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSearchText'
10791type MockFindController_GetSearchText_Call struct {
10792 *mock.Call
10793}
10794
10795// GetSearchText is a helper method to define mock.On call
10796func (_e *MockFindController_Expecter) GetSearchText() *MockFindController_GetSearchText_Call {
10797 return &MockFindController_GetSearchText_Call{Call: _e.mock.On("GetSearchText")}
10798}
10799
10800func (_c *MockFindController_GetSearchText_Call) Run(run func()) *MockFindController_GetSearchText_Call {
10801 _c.Call.Run(func(args mock.Arguments) {
10802 run()
10803 })
10804 return _c
10805}
10806
10807func (_c *MockFindController_GetSearchText_Call) Return(s string) *MockFindController_GetSearchText_Call {
10808 _c.Call.Return(s)
10809 return _c
10810}
10811
10812func (_c *MockFindController_GetSearchText_Call) RunAndReturn(run func() string) *MockFindController_GetSearchText_Call {
10813 _c.Call.Return(run)
10814 return _c
10815}
10816
10817// OnCountedMatches provides a mock function for the type MockFindController
10818func (_mock *MockFindController) OnCountedMatches(callback func(matchCount uint)) uint {
10819 ret := _mock.Called(callback)
10820
10821 if len(ret) == 0 {
10822 panic("no return value specified for OnCountedMatches")
10823 }
10824
10825 var r0 uint
10826 if returnFunc, ok := ret.Get(0).(func(func(matchCount uint)) uint); ok {
10827 r0 = returnFunc(callback)
10828 } else {
10829 r0 = ret.Get(0).(uint)
10830 }
10831 return r0
10832}
10833
10834// MockFindController_OnCountedMatches_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OnCountedMatches'
10835type MockFindController_OnCountedMatches_Call struct {
10836 *mock.Call
10837}
10838
10839// OnCountedMatches is a helper method to define mock.On call
10840// - callback func(matchCount uint)
10841func (_e *MockFindController_Expecter) OnCountedMatches(callback interface{}) *MockFindController_OnCountedMatches_Call {
10842 return &MockFindController_OnCountedMatches_Call{Call: _e.mock.On("OnCountedMatches", callback)}
10843}
10844
10845func (_c *MockFindController_OnCountedMatches_Call) Run(run func(callback func(matchCount uint))) *MockFindController_OnCountedMatches_Call {
10846 _c.Call.Run(func(args mock.Arguments) {
10847 var arg0 func(matchCount uint)
10848 if args[0] != nil {
10849 arg0 = args[0].(func(matchCount uint))
10850 }
10851 run(
10852 arg0,
10853 )
10854 })
10855 return _c
10856}
10857
10858func (_c *MockFindController_OnCountedMatches_Call) Return(v uint) *MockFindController_OnCountedMatches_Call {
10859 _c.Call.Return(v)
10860 return _c
10861}
10862
10863func (_c *MockFindController_OnCountedMatches_Call) RunAndReturn(run func(callback func(matchCount uint)) uint) *MockFindController_OnCountedMatches_Call {
10864 _c.Call.Return(run)
10865 return _c
10866}
10867
10868// OnFailedToFindText provides a mock function for the type MockFindController
10869func (_mock *MockFindController) OnFailedToFindText(callback func()) uint {
10870 ret := _mock.Called(callback)
10871
10872 if len(ret) == 0 {
10873 panic("no return value specified for OnFailedToFindText")
10874 }
10875
10876 var r0 uint
10877 if returnFunc, ok := ret.Get(0).(func(func()) uint); ok {
10878 r0 = returnFunc(callback)
10879 } else {
10880 r0 = ret.Get(0).(uint)
10881 }
10882 return r0
10883}
10884
10885// MockFindController_OnFailedToFindText_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OnFailedToFindText'
10886type MockFindController_OnFailedToFindText_Call struct {
10887 *mock.Call
10888}
10889
10890// OnFailedToFindText is a helper method to define mock.On call
10891// - callback func()
10892func (_e *MockFindController_Expecter) OnFailedToFindText(callback interface{}) *MockFindController_OnFailedToFindText_Call {
10893 return &MockFindController_OnFailedToFindText_Call{Call: _e.mock.On("OnFailedToFindText", callback)}
10894}
10895
10896func (_c *MockFindController_OnFailedToFindText_Call) Run(run func(callback func())) *MockFindController_OnFailedToFindText_Call {
10897 _c.Call.Run(func(args mock.Arguments) {
10898 var arg0 func()
10899 if args[0] != nil {
10900 arg0 = args[0].(func())
10901 }
10902 run(
10903 arg0,
10904 )
10905 })
10906 return _c
10907}
10908
10909func (_c *MockFindController_OnFailedToFindText_Call) Return(v uint) *MockFindController_OnFailedToFindText_Call {
10910 _c.Call.Return(v)
10911 return _c
10912}
10913
10914func (_c *MockFindController_OnFailedToFindText_Call) RunAndReturn(run func(callback func()) uint) *MockFindController_OnFailedToFindText_Call {
10915 _c.Call.Return(run)
10916 return _c
10917}
10918
10919// OnFoundText provides a mock function for the type MockFindController
10920func (_mock *MockFindController) OnFoundText(callback func(matchCount uint)) uint {
10921 ret := _mock.Called(callback)
10922
10923 if len(ret) == 0 {
10924 panic("no return value specified for OnFoundText")
10925 }
10926
10927 var r0 uint
10928 if returnFunc, ok := ret.Get(0).(func(func(matchCount uint)) uint); ok {
10929 r0 = returnFunc(callback)
10930 } else {
10931 r0 = ret.Get(0).(uint)
10932 }
10933 return r0
10934}
10935
10936// MockFindController_OnFoundText_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OnFoundText'
10937type MockFindController_OnFoundText_Call struct {
10938 *mock.Call
10939}
10940
10941// OnFoundText is a helper method to define mock.On call
10942// - callback func(matchCount uint)
10943func (_e *MockFindController_Expecter) OnFoundText(callback interface{}) *MockFindController_OnFoundText_Call {
10944 return &MockFindController_OnFoundText_Call{Call: _e.mock.On("OnFoundText", callback)}
10945}
10946
10947func (_c *MockFindController_OnFoundText_Call) Run(run func(callback func(matchCount uint))) *MockFindController_OnFoundText_Call {
10948 _c.Call.Run(func(args mock.Arguments) {
10949 var arg0 func(matchCount uint)
10950 if args[0] != nil {
10951 arg0 = args[0].(func(matchCount uint))
10952 }
10953 run(
10954 arg0,
10955 )
10956 })
10957 return _c
10958}
10959
10960func (_c *MockFindController_OnFoundText_Call) Return(v uint) *MockFindController_OnFoundText_Call {
10961 _c.Call.Return(v)
10962 return _c
10963}
10964
10965func (_c *MockFindController_OnFoundText_Call) RunAndReturn(run func(callback func(matchCount uint)) uint) *MockFindController_OnFoundText_Call {
10966 _c.Call.Return(run)
10967 return _c
10968}
10969
10970// Search provides a mock function for the type MockFindController
10971func (_mock *MockFindController) Search(text string, options port.FindOptions, maxMatches uint) {
10972 _mock.Called(text, options, maxMatches)
10973 return
10974}
10975
10976// MockFindController_Search_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Search'
10977type MockFindController_Search_Call struct {
10978 *mock.Call
10979}
10980
10981// Search is a helper method to define mock.On call
10982// - text string
10983// - options port.FindOptions
10984// - maxMatches uint
10985func (_e *MockFindController_Expecter) Search(text interface{}, options interface{}, maxMatches interface{}) *MockFindController_Search_Call {
10986 return &MockFindController_Search_Call{Call: _e.mock.On("Search", text, options, maxMatches)}
10987}
10988
10989func (_c *MockFindController_Search_Call) Run(run func(text string, options port.FindOptions, maxMatches uint)) *MockFindController_Search_Call {
10990 _c.Call.Run(func(args mock.Arguments) {
10991 var arg0 string
10992 if args[0] != nil {
10993 arg0 = args[0].(string)
10994 }
10995 var arg1 port.FindOptions
10996 if args[1] != nil {
10997 arg1 = args[1].(port.FindOptions)
10998 }
10999 var arg2 uint
11000 if args[2] != nil {
11001 arg2 = args[2].(uint)
11002 }
11003 run(
11004 arg0,
11005 arg1,
11006 arg2,
11007 )
11008 })
11009 return _c
11010}
11011
11012func (_c *MockFindController_Search_Call) Return() *MockFindController_Search_Call {
11013 _c.Call.Return()
11014 return _c
11015}
11016
11017func (_c *MockFindController_Search_Call) RunAndReturn(run func(text string, options port.FindOptions, maxMatches uint)) *MockFindController_Search_Call {
11018 _c.Run(run)
11019 return _c
11020}
11021
11022// SearchFinish provides a mock function for the type MockFindController
11023func (_mock *MockFindController) SearchFinish() {
11024 _mock.Called()
11025 return
11026}
11027
11028// MockFindController_SearchFinish_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SearchFinish'
11029type MockFindController_SearchFinish_Call struct {
11030 *mock.Call
11031}
11032
11033// SearchFinish is a helper method to define mock.On call
11034func (_e *MockFindController_Expecter) SearchFinish() *MockFindController_SearchFinish_Call {
11035 return &MockFindController_SearchFinish_Call{Call: _e.mock.On("SearchFinish")}
11036}
11037
11038func (_c *MockFindController_SearchFinish_Call) Run(run func()) *MockFindController_SearchFinish_Call {
11039 _c.Call.Run(func(args mock.Arguments) {
11040 run()
11041 })
11042 return _c
11043}
11044
11045func (_c *MockFindController_SearchFinish_Call) Return() *MockFindController_SearchFinish_Call {
11046 _c.Call.Return()
11047 return _c
11048}
11049
11050func (_c *MockFindController_SearchFinish_Call) RunAndReturn(run func()) *MockFindController_SearchFinish_Call {
11051 _c.Run(run)
11052 return _c
11053}
11054
11055// SearchNext provides a mock function for the type MockFindController
11056func (_mock *MockFindController) SearchNext() {
11057 _mock.Called()
11058 return
11059}
11060
11061// MockFindController_SearchNext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SearchNext'
11062type MockFindController_SearchNext_Call struct {
11063 *mock.Call
11064}
11065
11066// SearchNext is a helper method to define mock.On call
11067func (_e *MockFindController_Expecter) SearchNext() *MockFindController_SearchNext_Call {
11068 return &MockFindController_SearchNext_Call{Call: _e.mock.On("SearchNext")}
11069}
11070
11071func (_c *MockFindController_SearchNext_Call) Run(run func()) *MockFindController_SearchNext_Call {
11072 _c.Call.Run(func(args mock.Arguments) {
11073 run()
11074 })
11075 return _c
11076}
11077
11078func (_c *MockFindController_SearchNext_Call) Return() *MockFindController_SearchNext_Call {
11079 _c.Call.Return()
11080 return _c
11081}
11082
11083func (_c *MockFindController_SearchNext_Call) RunAndReturn(run func()) *MockFindController_SearchNext_Call {
11084 _c.Run(run)
11085 return _c
11086}
11087
11088// SearchPrevious provides a mock function for the type MockFindController
11089func (_mock *MockFindController) SearchPrevious() {
11090 _mock.Called()
11091 return
11092}
11093
11094// MockFindController_SearchPrevious_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SearchPrevious'
11095type MockFindController_SearchPrevious_Call struct {
11096 *mock.Call
11097}
11098
11099// SearchPrevious is a helper method to define mock.On call
11100func (_e *MockFindController_Expecter) SearchPrevious() *MockFindController_SearchPrevious_Call {
11101 return &MockFindController_SearchPrevious_Call{Call: _e.mock.On("SearchPrevious")}
11102}
11103
11104func (_c *MockFindController_SearchPrevious_Call) Run(run func()) *MockFindController_SearchPrevious_Call {
11105 _c.Call.Run(func(args mock.Arguments) {
11106 run()
11107 })
11108 return _c
11109}
11110
11111func (_c *MockFindController_SearchPrevious_Call) Return() *MockFindController_SearchPrevious_Call {
11112 _c.Call.Return()
11113 return _c
11114}
11115
11116func (_c *MockFindController_SearchPrevious_Call) RunAndReturn(run func()) *MockFindController_SearchPrevious_Call {
11117 _c.Run(run)
11118 return _c
11119}
11120
11121// NewMockWebView creates a new instance of MockWebView. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
11122// The first argument is typically a *testing.T value.
11123func NewMockWebView(t interface {
11124 mock.TestingT
11125 Cleanup(func())
11126}) *MockWebView {
11127 mock := &MockWebView{}
11128 mock.Mock.Test(t)
11129
11130 t.Cleanup(func() { mock.AssertExpectations(t) })
11131
11132 return mock
11133}
11134
11135// MockWebView is an autogenerated mock type for the WebView type
11136type MockWebView struct {
11137 mock.Mock
11138}
11139
11140type MockWebView_Expecter struct {
11141 mock *mock.Mock
11142}
11143
11144func (_m *MockWebView) EXPECT() *MockWebView_Expecter {
11145 return &MockWebView_Expecter{mock: &_m.Mock}
11146}
11147
11148// CanGoBack provides a mock function for the type MockWebView
11149func (_mock *MockWebView) CanGoBack() bool {
11150 ret := _mock.Called()
11151
11152 if len(ret) == 0 {
11153 panic("no return value specified for CanGoBack")
11154 }
11155
11156 var r0 bool
11157 if returnFunc, ok := ret.Get(0).(func() bool); ok {
11158 r0 = returnFunc()
11159 } else {
11160 r0 = ret.Get(0).(bool)
11161 }
11162 return r0
11163}
11164
11165// MockWebView_CanGoBack_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CanGoBack'
11166type MockWebView_CanGoBack_Call struct {
11167 *mock.Call
11168}
11169
11170// CanGoBack is a helper method to define mock.On call
11171func (_e *MockWebView_Expecter) CanGoBack() *MockWebView_CanGoBack_Call {
11172 return &MockWebView_CanGoBack_Call{Call: _e.mock.On("CanGoBack")}
11173}
11174
11175func (_c *MockWebView_CanGoBack_Call) Run(run func()) *MockWebView_CanGoBack_Call {
11176 _c.Call.Run(func(args mock.Arguments) {
11177 run()
11178 })
11179 return _c
11180}
11181
11182func (_c *MockWebView_CanGoBack_Call) Return(b bool) *MockWebView_CanGoBack_Call {
11183 _c.Call.Return(b)
11184 return _c
11185}
11186
11187func (_c *MockWebView_CanGoBack_Call) RunAndReturn(run func() bool) *MockWebView_CanGoBack_Call {
11188 _c.Call.Return(run)
11189 return _c
11190}
11191
11192// CanGoForward provides a mock function for the type MockWebView
11193func (_mock *MockWebView) CanGoForward() bool {
11194 ret := _mock.Called()
11195
11196 if len(ret) == 0 {
11197 panic("no return value specified for CanGoForward")
11198 }
11199
11200 var r0 bool
11201 if returnFunc, ok := ret.Get(0).(func() bool); ok {
11202 r0 = returnFunc()
11203 } else {
11204 r0 = ret.Get(0).(bool)
11205 }
11206 return r0
11207}
11208
11209// MockWebView_CanGoForward_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CanGoForward'
11210type MockWebView_CanGoForward_Call struct {
11211 *mock.Call
11212}
11213
11214// CanGoForward is a helper method to define mock.On call
11215func (_e *MockWebView_Expecter) CanGoForward() *MockWebView_CanGoForward_Call {
11216 return &MockWebView_CanGoForward_Call{Call: _e.mock.On("CanGoForward")}
11217}
11218
11219func (_c *MockWebView_CanGoForward_Call) Run(run func()) *MockWebView_CanGoForward_Call {
11220 _c.Call.Run(func(args mock.Arguments) {
11221 run()
11222 })
11223 return _c
11224}
11225
11226func (_c *MockWebView_CanGoForward_Call) Return(b bool) *MockWebView_CanGoForward_Call {
11227 _c.Call.Return(b)
11228 return _c
11229}
11230
11231func (_c *MockWebView_CanGoForward_Call) RunAndReturn(run func() bool) *MockWebView_CanGoForward_Call {
11232 _c.Call.Return(run)
11233 return _c
11234}
11235
11236// Destroy provides a mock function for the type MockWebView
11237func (_mock *MockWebView) Destroy() {
11238 _mock.Called()
11239 return
11240}
11241
11242// MockWebView_Destroy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Destroy'
11243type MockWebView_Destroy_Call struct {
11244 *mock.Call
11245}
11246
11247// Destroy is a helper method to define mock.On call
11248func (_e *MockWebView_Expecter) Destroy() *MockWebView_Destroy_Call {
11249 return &MockWebView_Destroy_Call{Call: _e.mock.On("Destroy")}
11250}
11251
11252func (_c *MockWebView_Destroy_Call) Run(run func()) *MockWebView_Destroy_Call {
11253 _c.Call.Run(func(args mock.Arguments) {
11254 run()
11255 })
11256 return _c
11257}
11258
11259func (_c *MockWebView_Destroy_Call) Return() *MockWebView_Destroy_Call {
11260 _c.Call.Return()
11261 return _c
11262}
11263
11264func (_c *MockWebView_Destroy_Call) RunAndReturn(run func()) *MockWebView_Destroy_Call {
11265 _c.Run(run)
11266 return _c
11267}
11268
11269// EstimatedProgress provides a mock function for the type MockWebView
11270func (_mock *MockWebView) EstimatedProgress() float64 {
11271 ret := _mock.Called()
11272
11273 if len(ret) == 0 {
11274 panic("no return value specified for EstimatedProgress")
11275 }
11276
11277 var r0 float64
11278 if returnFunc, ok := ret.Get(0).(func() float64); ok {
11279 r0 = returnFunc()
11280 } else {
11281 r0 = ret.Get(0).(float64)
11282 }
11283 return r0
11284}
11285
11286// MockWebView_EstimatedProgress_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EstimatedProgress'
11287type MockWebView_EstimatedProgress_Call struct {
11288 *mock.Call
11289}
11290
11291// EstimatedProgress is a helper method to define mock.On call
11292func (_e *MockWebView_Expecter) EstimatedProgress() *MockWebView_EstimatedProgress_Call {
11293 return &MockWebView_EstimatedProgress_Call{Call: _e.mock.On("EstimatedProgress")}
11294}
11295
11296func (_c *MockWebView_EstimatedProgress_Call) Run(run func()) *MockWebView_EstimatedProgress_Call {
11297 _c.Call.Run(func(args mock.Arguments) {
11298 run()
11299 })
11300 return _c
11301}
11302
11303func (_c *MockWebView_EstimatedProgress_Call) Return(f float64) *MockWebView_EstimatedProgress_Call {
11304 _c.Call.Return(f)
11305 return _c
11306}
11307
11308func (_c *MockWebView_EstimatedProgress_Call) RunAndReturn(run func() float64) *MockWebView_EstimatedProgress_Call {
11309 _c.Call.Return(run)
11310 return _c
11311}
11312
11313// Favicon provides a mock function for the type MockWebView
11314func (_mock *MockWebView) Favicon() port.Texture {
11315 ret := _mock.Called()
11316
11317 if len(ret) == 0 {
11318 panic("no return value specified for Favicon")
11319 }
11320
11321 var r0 port.Texture
11322 if returnFunc, ok := ret.Get(0).(func() port.Texture); ok {
11323 r0 = returnFunc()
11324 } else {
11325 if ret.Get(0) != nil {
11326 r0 = ret.Get(0).(port.Texture)
11327 }
11328 }
11329 return r0
11330}
11331
11332// MockWebView_Favicon_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Favicon'
11333type MockWebView_Favicon_Call struct {
11334 *mock.Call
11335}
11336
11337// Favicon is a helper method to define mock.On call
11338func (_e *MockWebView_Expecter) Favicon() *MockWebView_Favicon_Call {
11339 return &MockWebView_Favicon_Call{Call: _e.mock.On("Favicon")}
11340}
11341
11342func (_c *MockWebView_Favicon_Call) Run(run func()) *MockWebView_Favicon_Call {
11343 _c.Call.Run(func(args mock.Arguments) {
11344 run()
11345 })
11346 return _c
11347}
11348
11349func (_c *MockWebView_Favicon_Call) Return(texture port.Texture) *MockWebView_Favicon_Call {
11350 _c.Call.Return(texture)
11351 return _c
11352}
11353
11354func (_c *MockWebView_Favicon_Call) RunAndReturn(run func() port.Texture) *MockWebView_Favicon_Call {
11355 _c.Call.Return(run)
11356 return _c
11357}
11358
11359// Generation provides a mock function for the type MockWebView
11360func (_mock *MockWebView) Generation() uint64 {
11361 ret := _mock.Called()
11362
11363 if len(ret) == 0 {
11364 panic("no return value specified for Generation")
11365 }
11366
11367 var r0 uint64
11368 if returnFunc, ok := ret.Get(0).(func() uint64); ok {
11369 r0 = returnFunc()
11370 } else {
11371 r0 = ret.Get(0).(uint64)
11372 }
11373 return r0
11374}
11375
11376// MockWebView_Generation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Generation'
11377type MockWebView_Generation_Call struct {
11378 *mock.Call
11379}
11380
11381// Generation is a helper method to define mock.On call
11382func (_e *MockWebView_Expecter) Generation() *MockWebView_Generation_Call {
11383 return &MockWebView_Generation_Call{Call: _e.mock.On("Generation")}
11384}
11385
11386func (_c *MockWebView_Generation_Call) Run(run func()) *MockWebView_Generation_Call {
11387 _c.Call.Run(func(args mock.Arguments) {
11388 run()
11389 })
11390 return _c
11391}
11392
11393func (_c *MockWebView_Generation_Call) Return(v uint64) *MockWebView_Generation_Call {
11394 _c.Call.Return(v)
11395 return _c
11396}
11397
11398func (_c *MockWebView_Generation_Call) RunAndReturn(run func() uint64) *MockWebView_Generation_Call {
11399 _c.Call.Return(run)
11400 return _c
11401}
11402
11403// GetFindController provides a mock function for the type MockWebView
11404func (_mock *MockWebView) GetFindController() port.FindController {
11405 ret := _mock.Called()
11406
11407 if len(ret) == 0 {
11408 panic("no return value specified for GetFindController")
11409 }
11410
11411 var r0 port.FindController
11412 if returnFunc, ok := ret.Get(0).(func() port.FindController); ok {
11413 r0 = returnFunc()
11414 } else {
11415 if ret.Get(0) != nil {
11416 r0 = ret.Get(0).(port.FindController)
11417 }
11418 }
11419 return r0
11420}
11421
11422// MockWebView_GetFindController_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetFindController'
11423type MockWebView_GetFindController_Call struct {
11424 *mock.Call
11425}
11426
11427// GetFindController is a helper method to define mock.On call
11428func (_e *MockWebView_Expecter) GetFindController() *MockWebView_GetFindController_Call {
11429 return &MockWebView_GetFindController_Call{Call: _e.mock.On("GetFindController")}
11430}
11431
11432func (_c *MockWebView_GetFindController_Call) Run(run func()) *MockWebView_GetFindController_Call {
11433 _c.Call.Run(func(args mock.Arguments) {
11434 run()
11435 })
11436 return _c
11437}
11438
11439func (_c *MockWebView_GetFindController_Call) Return(findController port.FindController) *MockWebView_GetFindController_Call {
11440 _c.Call.Return(findController)
11441 return _c
11442}
11443
11444func (_c *MockWebView_GetFindController_Call) RunAndReturn(run func() port.FindController) *MockWebView_GetFindController_Call {
11445 _c.Call.Return(run)
11446 return _c
11447}
11448
11449// GetZoomLevel provides a mock function for the type MockWebView
11450func (_mock *MockWebView) GetZoomLevel() float64 {
11451 ret := _mock.Called()
11452
11453 if len(ret) == 0 {
11454 panic("no return value specified for GetZoomLevel")
11455 }
11456
11457 var r0 float64
11458 if returnFunc, ok := ret.Get(0).(func() float64); ok {
11459 r0 = returnFunc()
11460 } else {
11461 r0 = ret.Get(0).(float64)
11462 }
11463 return r0
11464}
11465
11466// MockWebView_GetZoomLevel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetZoomLevel'
11467type MockWebView_GetZoomLevel_Call struct {
11468 *mock.Call
11469}
11470
11471// GetZoomLevel is a helper method to define mock.On call
11472func (_e *MockWebView_Expecter) GetZoomLevel() *MockWebView_GetZoomLevel_Call {
11473 return &MockWebView_GetZoomLevel_Call{Call: _e.mock.On("GetZoomLevel")}
11474}
11475
11476func (_c *MockWebView_GetZoomLevel_Call) Run(run func()) *MockWebView_GetZoomLevel_Call {
11477 _c.Call.Run(func(args mock.Arguments) {
11478 run()
11479 })
11480 return _c
11481}
11482
11483func (_c *MockWebView_GetZoomLevel_Call) Return(f float64) *MockWebView_GetZoomLevel_Call {
11484 _c.Call.Return(f)
11485 return _c
11486}
11487
11488func (_c *MockWebView_GetZoomLevel_Call) RunAndReturn(run func() float64) *MockWebView_GetZoomLevel_Call {
11489 _c.Call.Return(run)
11490 return _c
11491}
11492
11493// GoBack provides a mock function for the type MockWebView
11494func (_mock *MockWebView) GoBack(ctx context.Context) error {
11495 ret := _mock.Called(ctx)
11496
11497 if len(ret) == 0 {
11498 panic("no return value specified for GoBack")
11499 }
11500
11501 var r0 error
11502 if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
11503 r0 = returnFunc(ctx)
11504 } else {
11505 r0 = ret.Error(0)
11506 }
11507 return r0
11508}
11509
11510// MockWebView_GoBack_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GoBack'
11511type MockWebView_GoBack_Call struct {
11512 *mock.Call
11513}
11514
11515// GoBack is a helper method to define mock.On call
11516// - ctx context.Context
11517func (_e *MockWebView_Expecter) GoBack(ctx interface{}) *MockWebView_GoBack_Call {
11518 return &MockWebView_GoBack_Call{Call: _e.mock.On("GoBack", ctx)}
11519}
11520
11521func (_c *MockWebView_GoBack_Call) Run(run func(ctx context.Context)) *MockWebView_GoBack_Call {
11522 _c.Call.Run(func(args mock.Arguments) {
11523 var arg0 context.Context
11524 if args[0] != nil {
11525 arg0 = args[0].(context.Context)
11526 }
11527 run(
11528 arg0,
11529 )
11530 })
11531 return _c
11532}
11533
11534func (_c *MockWebView_GoBack_Call) Return(err error) *MockWebView_GoBack_Call {
11535 _c.Call.Return(err)
11536 return _c
11537}
11538
11539func (_c *MockWebView_GoBack_Call) RunAndReturn(run func(ctx context.Context) error) *MockWebView_GoBack_Call {
11540 _c.Call.Return(run)
11541 return _c
11542}
11543
11544// GoForward provides a mock function for the type MockWebView
11545func (_mock *MockWebView) GoForward(ctx context.Context) error {
11546 ret := _mock.Called(ctx)
11547
11548 if len(ret) == 0 {
11549 panic("no return value specified for GoForward")
11550 }
11551
11552 var r0 error
11553 if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
11554 r0 = returnFunc(ctx)
11555 } else {
11556 r0 = ret.Error(0)
11557 }
11558 return r0
11559}
11560
11561// MockWebView_GoForward_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GoForward'
11562type MockWebView_GoForward_Call struct {
11563 *mock.Call
11564}
11565
11566// GoForward is a helper method to define mock.On call
11567// - ctx context.Context
11568func (_e *MockWebView_Expecter) GoForward(ctx interface{}) *MockWebView_GoForward_Call {
11569 return &MockWebView_GoForward_Call{Call: _e.mock.On("GoForward", ctx)}
11570}
11571
11572func (_c *MockWebView_GoForward_Call) Run(run func(ctx context.Context)) *MockWebView_GoForward_Call {
11573 _c.Call.Run(func(args mock.Arguments) {
11574 var arg0 context.Context
11575 if args[0] != nil {
11576 arg0 = args[0].(context.Context)
11577 }
11578 run(
11579 arg0,
11580 )
11581 })
11582 return _c
11583}
11584
11585func (_c *MockWebView_GoForward_Call) Return(err error) *MockWebView_GoForward_Call {
11586 _c.Call.Return(err)
11587 return _c
11588}
11589
11590func (_c *MockWebView_GoForward_Call) RunAndReturn(run func(ctx context.Context) error) *MockWebView_GoForward_Call {
11591 _c.Call.Return(run)
11592 return _c
11593}
11594
11595// ID provides a mock function for the type MockWebView
11596func (_mock *MockWebView) ID() port.WebViewID {
11597 ret := _mock.Called()
11598
11599 if len(ret) == 0 {
11600 panic("no return value specified for ID")
11601 }
11602
11603 var r0 port.WebViewID
11604 if returnFunc, ok := ret.Get(0).(func() port.WebViewID); ok {
11605 r0 = returnFunc()
11606 } else {
11607 r0 = ret.Get(0).(port.WebViewID)
11608 }
11609 return r0
11610}
11611
11612// MockWebView_ID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ID'
11613type MockWebView_ID_Call struct {
11614 *mock.Call
11615}
11616
11617// ID is a helper method to define mock.On call
11618func (_e *MockWebView_Expecter) ID() *MockWebView_ID_Call {
11619 return &MockWebView_ID_Call{Call: _e.mock.On("ID")}
11620}
11621
11622func (_c *MockWebView_ID_Call) Run(run func()) *MockWebView_ID_Call {
11623 _c.Call.Run(func(args mock.Arguments) {
11624 run()
11625 })
11626 return _c
11627}
11628
11629func (_c *MockWebView_ID_Call) Return(webViewID port.WebViewID) *MockWebView_ID_Call {
11630 _c.Call.Return(webViewID)
11631 return _c
11632}
11633
11634func (_c *MockWebView_ID_Call) RunAndReturn(run func() port.WebViewID) *MockWebView_ID_Call {
11635 _c.Call.Return(run)
11636 return _c
11637}
11638
11639// IsDestroyed provides a mock function for the type MockWebView
11640func (_mock *MockWebView) IsDestroyed() bool {
11641 ret := _mock.Called()
11642
11643 if len(ret) == 0 {
11644 panic("no return value specified for IsDestroyed")
11645 }
11646
11647 var r0 bool
11648 if returnFunc, ok := ret.Get(0).(func() bool); ok {
11649 r0 = returnFunc()
11650 } else {
11651 r0 = ret.Get(0).(bool)
11652 }
11653 return r0
11654}
11655
11656// MockWebView_IsDestroyed_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsDestroyed'
11657type MockWebView_IsDestroyed_Call struct {
11658 *mock.Call
11659}
11660
11661// IsDestroyed is a helper method to define mock.On call
11662func (_e *MockWebView_Expecter) IsDestroyed() *MockWebView_IsDestroyed_Call {
11663 return &MockWebView_IsDestroyed_Call{Call: _e.mock.On("IsDestroyed")}
11664}
11665
11666func (_c *MockWebView_IsDestroyed_Call) Run(run func()) *MockWebView_IsDestroyed_Call {
11667 _c.Call.Run(func(args mock.Arguments) {
11668 run()
11669 })
11670 return _c
11671}
11672
11673func (_c *MockWebView_IsDestroyed_Call) Return(b bool) *MockWebView_IsDestroyed_Call {
11674 _c.Call.Return(b)
11675 return _c
11676}
11677
11678func (_c *MockWebView_IsDestroyed_Call) RunAndReturn(run func() bool) *MockWebView_IsDestroyed_Call {
11679 _c.Call.Return(run)
11680 return _c
11681}
11682
11683// IsFullscreen provides a mock function for the type MockWebView
11684func (_mock *MockWebView) IsFullscreen() bool {
11685 ret := _mock.Called()
11686
11687 if len(ret) == 0 {
11688 panic("no return value specified for IsFullscreen")
11689 }
11690
11691 var r0 bool
11692 if returnFunc, ok := ret.Get(0).(func() bool); ok {
11693 r0 = returnFunc()
11694 } else {
11695 r0 = ret.Get(0).(bool)
11696 }
11697 return r0
11698}
11699
11700// MockWebView_IsFullscreen_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsFullscreen'
11701type MockWebView_IsFullscreen_Call struct {
11702 *mock.Call
11703}
11704
11705// IsFullscreen is a helper method to define mock.On call
11706func (_e *MockWebView_Expecter) IsFullscreen() *MockWebView_IsFullscreen_Call {
11707 return &MockWebView_IsFullscreen_Call{Call: _e.mock.On("IsFullscreen")}
11708}
11709
11710func (_c *MockWebView_IsFullscreen_Call) Run(run func()) *MockWebView_IsFullscreen_Call {
11711 _c.Call.Run(func(args mock.Arguments) {
11712 run()
11713 })
11714 return _c
11715}
11716
11717func (_c *MockWebView_IsFullscreen_Call) Return(b bool) *MockWebView_IsFullscreen_Call {
11718 _c.Call.Return(b)
11719 return _c
11720}
11721
11722func (_c *MockWebView_IsFullscreen_Call) RunAndReturn(run func() bool) *MockWebView_IsFullscreen_Call {
11723 _c.Call.Return(run)
11724 return _c
11725}
11726
11727// IsLoading provides a mock function for the type MockWebView
11728func (_mock *MockWebView) IsLoading() bool {
11729 ret := _mock.Called()
11730
11731 if len(ret) == 0 {
11732 panic("no return value specified for IsLoading")
11733 }
11734
11735 var r0 bool
11736 if returnFunc, ok := ret.Get(0).(func() bool); ok {
11737 r0 = returnFunc()
11738 } else {
11739 r0 = ret.Get(0).(bool)
11740 }
11741 return r0
11742}
11743
11744// MockWebView_IsLoading_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsLoading'
11745type MockWebView_IsLoading_Call struct {
11746 *mock.Call
11747}
11748
11749// IsLoading is a helper method to define mock.On call
11750func (_e *MockWebView_Expecter) IsLoading() *MockWebView_IsLoading_Call {
11751 return &MockWebView_IsLoading_Call{Call: _e.mock.On("IsLoading")}
11752}
11753
11754func (_c *MockWebView_IsLoading_Call) Run(run func()) *MockWebView_IsLoading_Call {
11755 _c.Call.Run(func(args mock.Arguments) {
11756 run()
11757 })
11758 return _c
11759}
11760
11761func (_c *MockWebView_IsLoading_Call) Return(b bool) *MockWebView_IsLoading_Call {
11762 _c.Call.Return(b)
11763 return _c
11764}
11765
11766func (_c *MockWebView_IsLoading_Call) RunAndReturn(run func() bool) *MockWebView_IsLoading_Call {
11767 _c.Call.Return(run)
11768 return _c
11769}
11770
11771// IsPlayingAudio provides a mock function for the type MockWebView
11772func (_mock *MockWebView) IsPlayingAudio() bool {
11773 ret := _mock.Called()
11774
11775 if len(ret) == 0 {
11776 panic("no return value specified for IsPlayingAudio")
11777 }
11778
11779 var r0 bool
11780 if returnFunc, ok := ret.Get(0).(func() bool); ok {
11781 r0 = returnFunc()
11782 } else {
11783 r0 = ret.Get(0).(bool)
11784 }
11785 return r0
11786}
11787
11788// MockWebView_IsPlayingAudio_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsPlayingAudio'
11789type MockWebView_IsPlayingAudio_Call struct {
11790 *mock.Call
11791}
11792
11793// IsPlayingAudio is a helper method to define mock.On call
11794func (_e *MockWebView_Expecter) IsPlayingAudio() *MockWebView_IsPlayingAudio_Call {
11795 return &MockWebView_IsPlayingAudio_Call{Call: _e.mock.On("IsPlayingAudio")}
11796}
11797
11798func (_c *MockWebView_IsPlayingAudio_Call) Run(run func()) *MockWebView_IsPlayingAudio_Call {
11799 _c.Call.Run(func(args mock.Arguments) {
11800 run()
11801 })
11802 return _c
11803}
11804
11805func (_c *MockWebView_IsPlayingAudio_Call) Return(b bool) *MockWebView_IsPlayingAudio_Call {
11806 _c.Call.Return(b)
11807 return _c
11808}
11809
11810func (_c *MockWebView_IsPlayingAudio_Call) RunAndReturn(run func() bool) *MockWebView_IsPlayingAudio_Call {
11811 _c.Call.Return(run)
11812 return _c
11813}
11814
11815// LoadHTML provides a mock function for the type MockWebView
11816func (_mock *MockWebView) LoadHTML(ctx context.Context, content string, baseURI string) error {
11817 ret := _mock.Called(ctx, content, baseURI)
11818
11819 if len(ret) == 0 {
11820 panic("no return value specified for LoadHTML")
11821 }
11822
11823 var r0 error
11824 if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) error); ok {
11825 r0 = returnFunc(ctx, content, baseURI)
11826 } else {
11827 r0 = ret.Error(0)
11828 }
11829 return r0
11830}
11831
11832// MockWebView_LoadHTML_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LoadHTML'
11833type MockWebView_LoadHTML_Call struct {
11834 *mock.Call
11835}
11836
11837// LoadHTML is a helper method to define mock.On call
11838// - ctx context.Context
11839// - content string
11840// - baseURI string
11841func (_e *MockWebView_Expecter) LoadHTML(ctx interface{}, content interface{}, baseURI interface{}) *MockWebView_LoadHTML_Call {
11842 return &MockWebView_LoadHTML_Call{Call: _e.mock.On("LoadHTML", ctx, content, baseURI)}
11843}
11844
11845func (_c *MockWebView_LoadHTML_Call) Run(run func(ctx context.Context, content string, baseURI string)) *MockWebView_LoadHTML_Call {
11846 _c.Call.Run(func(args mock.Arguments) {
11847 var arg0 context.Context
11848 if args[0] != nil {
11849 arg0 = args[0].(context.Context)
11850 }
11851 var arg1 string
11852 if args[1] != nil {
11853 arg1 = args[1].(string)
11854 }
11855 var arg2 string
11856 if args[2] != nil {
11857 arg2 = args[2].(string)
11858 }
11859 run(
11860 arg0,
11861 arg1,
11862 arg2,
11863 )
11864 })
11865 return _c
11866}
11867
11868func (_c *MockWebView_LoadHTML_Call) Return(err error) *MockWebView_LoadHTML_Call {
11869 _c.Call.Return(err)
11870 return _c
11871}
11872
11873func (_c *MockWebView_LoadHTML_Call) RunAndReturn(run func(ctx context.Context, content string, baseURI string) error) *MockWebView_LoadHTML_Call {
11874 _c.Call.Return(run)
11875 return _c
11876}
11877
11878// LoadURI provides a mock function for the type MockWebView
11879func (_mock *MockWebView) LoadURI(ctx context.Context, uri string) error {
11880 ret := _mock.Called(ctx, uri)
11881
11882 if len(ret) == 0 {
11883 panic("no return value specified for LoadURI")
11884 }
11885
11886 var r0 error
11887 if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
11888 r0 = returnFunc(ctx, uri)
11889 } else {
11890 r0 = ret.Error(0)
11891 }
11892 return r0
11893}
11894
11895// MockWebView_LoadURI_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LoadURI'
11896type MockWebView_LoadURI_Call struct {
11897 *mock.Call
11898}
11899
11900// LoadURI is a helper method to define mock.On call
11901// - ctx context.Context
11902// - uri string
11903func (_e *MockWebView_Expecter) LoadURI(ctx interface{}, uri interface{}) *MockWebView_LoadURI_Call {
11904 return &MockWebView_LoadURI_Call{Call: _e.mock.On("LoadURI", ctx, uri)}
11905}
11906
11907func (_c *MockWebView_LoadURI_Call) Run(run func(ctx context.Context, uri string)) *MockWebView_LoadURI_Call {
11908 _c.Call.Run(func(args mock.Arguments) {
11909 var arg0 context.Context
11910 if args[0] != nil {
11911 arg0 = args[0].(context.Context)
11912 }
11913 var arg1 string
11914 if args[1] != nil {
11915 arg1 = args[1].(string)
11916 }
11917 run(
11918 arg0,
11919 arg1,
11920 )
11921 })
11922 return _c
11923}
11924
11925func (_c *MockWebView_LoadURI_Call) Return(err error) *MockWebView_LoadURI_Call {
11926 _c.Call.Return(err)
11927 return _c
11928}
11929
11930func (_c *MockWebView_LoadURI_Call) RunAndReturn(run func(ctx context.Context, uri string) error) *MockWebView_LoadURI_Call {
11931 _c.Call.Return(run)
11932 return _c
11933}
11934
11935// Reload provides a mock function for the type MockWebView
11936func (_mock *MockWebView) Reload(ctx context.Context) error {
11937 ret := _mock.Called(ctx)
11938
11939 if len(ret) == 0 {
11940 panic("no return value specified for Reload")
11941 }
11942
11943 var r0 error
11944 if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
11945 r0 = returnFunc(ctx)
11946 } else {
11947 r0 = ret.Error(0)
11948 }
11949 return r0
11950}
11951
11952// MockWebView_Reload_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Reload'
11953type MockWebView_Reload_Call struct {
11954 *mock.Call
11955}
11956
11957// Reload is a helper method to define mock.On call
11958// - ctx context.Context
11959func (_e *MockWebView_Expecter) Reload(ctx interface{}) *MockWebView_Reload_Call {
11960 return &MockWebView_Reload_Call{Call: _e.mock.On("Reload", ctx)}
11961}
11962
11963func (_c *MockWebView_Reload_Call) Run(run func(ctx context.Context)) *MockWebView_Reload_Call {
11964 _c.Call.Run(func(args mock.Arguments) {
11965 var arg0 context.Context
11966 if args[0] != nil {
11967 arg0 = args[0].(context.Context)
11968 }
11969 run(
11970 arg0,
11971 )
11972 })
11973 return _c
11974}
11975
11976func (_c *MockWebView_Reload_Call) Return(err error) *MockWebView_Reload_Call {
11977 _c.Call.Return(err)
11978 return _c
11979}
11980
11981func (_c *MockWebView_Reload_Call) RunAndReturn(run func(ctx context.Context) error) *MockWebView_Reload_Call {
11982 _c.Call.Return(run)
11983 return _c
11984}
11985
11986// ReloadBypassCache provides a mock function for the type MockWebView
11987func (_mock *MockWebView) ReloadBypassCache(ctx context.Context) error {
11988 ret := _mock.Called(ctx)
11989
11990 if len(ret) == 0 {
11991 panic("no return value specified for ReloadBypassCache")
11992 }
11993
11994 var r0 error
11995 if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
11996 r0 = returnFunc(ctx)
11997 } else {
11998 r0 = ret.Error(0)
11999 }
12000 return r0
12001}
12002
12003// MockWebView_ReloadBypassCache_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReloadBypassCache'
12004type MockWebView_ReloadBypassCache_Call struct {
12005 *mock.Call
12006}
12007
12008// ReloadBypassCache is a helper method to define mock.On call
12009// - ctx context.Context
12010func (_e *MockWebView_Expecter) ReloadBypassCache(ctx interface{}) *MockWebView_ReloadBypassCache_Call {
12011 return &MockWebView_ReloadBypassCache_Call{Call: _e.mock.On("ReloadBypassCache", ctx)}
12012}
12013
12014func (_c *MockWebView_ReloadBypassCache_Call) Run(run func(ctx context.Context)) *MockWebView_ReloadBypassCache_Call {
12015 _c.Call.Run(func(args mock.Arguments) {
12016 var arg0 context.Context
12017 if args[0] != nil {
12018 arg0 = args[0].(context.Context)
12019 }
12020 run(
12021 arg0,
12022 )
12023 })
12024 return _c
12025}
12026
12027func (_c *MockWebView_ReloadBypassCache_Call) Return(err error) *MockWebView_ReloadBypassCache_Call {
12028 _c.Call.Return(err)
12029 return _c
12030}
12031
12032func (_c *MockWebView_ReloadBypassCache_Call) RunAndReturn(run func(ctx context.Context) error) *MockWebView_ReloadBypassCache_Call {
12033 _c.Call.Return(run)
12034 return _c
12035}
12036
12037// ResetBackgroundToDefault provides a mock function for the type MockWebView
12038func (_mock *MockWebView) ResetBackgroundToDefault() {
12039 _mock.Called()
12040 return
12041}
12042
12043// MockWebView_ResetBackgroundToDefault_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResetBackgroundToDefault'
12044type MockWebView_ResetBackgroundToDefault_Call struct {
12045 *mock.Call
12046}
12047
12048// ResetBackgroundToDefault is a helper method to define mock.On call
12049func (_e *MockWebView_Expecter) ResetBackgroundToDefault() *MockWebView_ResetBackgroundToDefault_Call {
12050 return &MockWebView_ResetBackgroundToDefault_Call{Call: _e.mock.On("ResetBackgroundToDefault")}
12051}
12052
12053func (_c *MockWebView_ResetBackgroundToDefault_Call) Run(run func()) *MockWebView_ResetBackgroundToDefault_Call {
12054 _c.Call.Run(func(args mock.Arguments) {
12055 run()
12056 })
12057 return _c
12058}
12059
12060func (_c *MockWebView_ResetBackgroundToDefault_Call) Return() *MockWebView_ResetBackgroundToDefault_Call {
12061 _c.Call.Return()
12062 return _c
12063}
12064
12065func (_c *MockWebView_ResetBackgroundToDefault_Call) RunAndReturn(run func()) *MockWebView_ResetBackgroundToDefault_Call {
12066 _c.Run(run)
12067 return _c
12068}
12069
12070// RunJavaScript provides a mock function for the type MockWebView
12071func (_mock *MockWebView) RunJavaScript(ctx context.Context, script string) {
12072 _mock.Called(ctx, script)
12073 return
12074}
12075
12076// MockWebView_RunJavaScript_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RunJavaScript'
12077type MockWebView_RunJavaScript_Call struct {
12078 *mock.Call
12079}
12080
12081// RunJavaScript is a helper method to define mock.On call
12082// - ctx context.Context
12083// - script string
12084func (_e *MockWebView_Expecter) RunJavaScript(ctx interface{}, script interface{}) *MockWebView_RunJavaScript_Call {
12085 return &MockWebView_RunJavaScript_Call{Call: _e.mock.On("RunJavaScript", ctx, script)}
12086}
12087
12088func (_c *MockWebView_RunJavaScript_Call) Run(run func(ctx context.Context, script string)) *MockWebView_RunJavaScript_Call {
12089 _c.Call.Run(func(args mock.Arguments) {
12090 var arg0 context.Context
12091 if args[0] != nil {
12092 arg0 = args[0].(context.Context)
12093 }
12094 var arg1 string
12095 if args[1] != nil {
12096 arg1 = args[1].(string)
12097 }
12098 run(
12099 arg0,
12100 arg1,
12101 )
12102 })
12103 return _c
12104}
12105
12106func (_c *MockWebView_RunJavaScript_Call) Return() *MockWebView_RunJavaScript_Call {
12107 _c.Call.Return()
12108 return _c
12109}
12110
12111func (_c *MockWebView_RunJavaScript_Call) RunAndReturn(run func(ctx context.Context, script string)) *MockWebView_RunJavaScript_Call {
12112 _c.Run(run)
12113 return _c
12114}
12115
12116// SetBackgroundColor provides a mock function for the type MockWebView
12117func (_mock *MockWebView) SetBackgroundColor(r float64, g float64, b float64, a float64) {
12118 _mock.Called(r, g, b, a)
12119 return
12120}
12121
12122// MockWebView_SetBackgroundColor_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetBackgroundColor'
12123type MockWebView_SetBackgroundColor_Call struct {
12124 *mock.Call
12125}
12126
12127// SetBackgroundColor is a helper method to define mock.On call
12128// - r float64
12129// - g float64
12130// - b float64
12131// - a float64
12132func (_e *MockWebView_Expecter) SetBackgroundColor(r interface{}, g interface{}, b interface{}, a interface{}) *MockWebView_SetBackgroundColor_Call {
12133 return &MockWebView_SetBackgroundColor_Call{Call: _e.mock.On("SetBackgroundColor", r, g, b, a)}
12134}
12135
12136func (_c *MockWebView_SetBackgroundColor_Call) Run(run func(r float64, g float64, b float64, a float64)) *MockWebView_SetBackgroundColor_Call {
12137 _c.Call.Run(func(args mock.Arguments) {
12138 var arg0 float64
12139 if args[0] != nil {
12140 arg0 = args[0].(float64)
12141 }
12142 var arg1 float64
12143 if args[1] != nil {
12144 arg1 = args[1].(float64)
12145 }
12146 var arg2 float64
12147 if args[2] != nil {
12148 arg2 = args[2].(float64)
12149 }
12150 var arg3 float64
12151 if args[3] != nil {
12152 arg3 = args[3].(float64)
12153 }
12154 run(
12155 arg0,
12156 arg1,
12157 arg2,
12158 arg3,
12159 )
12160 })
12161 return _c
12162}
12163
12164func (_c *MockWebView_SetBackgroundColor_Call) Return() *MockWebView_SetBackgroundColor_Call {
12165 _c.Call.Return()
12166 return _c
12167}
12168
12169func (_c *MockWebView_SetBackgroundColor_Call) RunAndReturn(run func(r float64, g float64, b float64, a float64)) *MockWebView_SetBackgroundColor_Call {
12170 _c.Run(run)
12171 return _c
12172}
12173
12174// SetCallbacks provides a mock function for the type MockWebView
12175func (_mock *MockWebView) SetCallbacks(callbacks *port.WebViewCallbacks) {
12176 _mock.Called(callbacks)
12177 return
12178}
12179
12180// MockWebView_SetCallbacks_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetCallbacks'
12181type MockWebView_SetCallbacks_Call struct {
12182 *mock.Call
12183}
12184
12185// SetCallbacks is a helper method to define mock.On call
12186// - callbacks *port.WebViewCallbacks
12187func (_e *MockWebView_Expecter) SetCallbacks(callbacks interface{}) *MockWebView_SetCallbacks_Call {
12188 return &MockWebView_SetCallbacks_Call{Call: _e.mock.On("SetCallbacks", callbacks)}
12189}
12190
12191func (_c *MockWebView_SetCallbacks_Call) Run(run func(callbacks *port.WebViewCallbacks)) *MockWebView_SetCallbacks_Call {
12192 _c.Call.Run(func(args mock.Arguments) {
12193 var arg0 *port.WebViewCallbacks
12194 if args[0] != nil {
12195 arg0 = args[0].(*port.WebViewCallbacks)
12196 }
12197 run(
12198 arg0,
12199 )
12200 })
12201 return _c
12202}
12203
12204func (_c *MockWebView_SetCallbacks_Call) Return() *MockWebView_SetCallbacks_Call {
12205 _c.Call.Return()
12206 return _c
12207}
12208
12209func (_c *MockWebView_SetCallbacks_Call) RunAndReturn(run func(callbacks *port.WebViewCallbacks)) *MockWebView_SetCallbacks_Call {
12210 _c.Run(run)
12211 return _c
12212}
12213
12214// SetZoomLevel provides a mock function for the type MockWebView
12215func (_mock *MockWebView) SetZoomLevel(ctx context.Context, level float64) error {
12216 ret := _mock.Called(ctx, level)
12217
12218 if len(ret) == 0 {
12219 panic("no return value specified for SetZoomLevel")
12220 }
12221
12222 var r0 error
12223 if returnFunc, ok := ret.Get(0).(func(context.Context, float64) error); ok {
12224 r0 = returnFunc(ctx, level)
12225 } else {
12226 r0 = ret.Error(0)
12227 }
12228 return r0
12229}
12230
12231// MockWebView_SetZoomLevel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetZoomLevel'
12232type MockWebView_SetZoomLevel_Call struct {
12233 *mock.Call
12234}
12235
12236// SetZoomLevel is a helper method to define mock.On call
12237// - ctx context.Context
12238// - level float64
12239func (_e *MockWebView_Expecter) SetZoomLevel(ctx interface{}, level interface{}) *MockWebView_SetZoomLevel_Call {
12240 return &MockWebView_SetZoomLevel_Call{Call: _e.mock.On("SetZoomLevel", ctx, level)}
12241}
12242
12243func (_c *MockWebView_SetZoomLevel_Call) Run(run func(ctx context.Context, level float64)) *MockWebView_SetZoomLevel_Call {
12244 _c.Call.Run(func(args mock.Arguments) {
12245 var arg0 context.Context
12246 if args[0] != nil {
12247 arg0 = args[0].(context.Context)
12248 }
12249 var arg1 float64
12250 if args[1] != nil {
12251 arg1 = args[1].(float64)
12252 }
12253 run(
12254 arg0,
12255 arg1,
12256 )
12257 })
12258 return _c
12259}
12260
12261func (_c *MockWebView_SetZoomLevel_Call) Return(err error) *MockWebView_SetZoomLevel_Call {
12262 _c.Call.Return(err)
12263 return _c
12264}
12265
12266func (_c *MockWebView_SetZoomLevel_Call) RunAndReturn(run func(ctx context.Context, level float64) error) *MockWebView_SetZoomLevel_Call {
12267 _c.Call.Return(run)
12268 return _c
12269}
12270
12271// State provides a mock function for the type MockWebView
12272func (_mock *MockWebView) State() port.WebViewState {
12273 ret := _mock.Called()
12274
12275 if len(ret) == 0 {
12276 panic("no return value specified for State")
12277 }
12278
12279 var r0 port.WebViewState
12280 if returnFunc, ok := ret.Get(0).(func() port.WebViewState); ok {
12281 r0 = returnFunc()
12282 } else {
12283 r0 = ret.Get(0).(port.WebViewState)
12284 }
12285 return r0
12286}
12287
12288// MockWebView_State_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'State'
12289type MockWebView_State_Call struct {
12290 *mock.Call
12291}
12292
12293// State is a helper method to define mock.On call
12294func (_e *MockWebView_Expecter) State() *MockWebView_State_Call {
12295 return &MockWebView_State_Call{Call: _e.mock.On("State")}
12296}
12297
12298func (_c *MockWebView_State_Call) Run(run func()) *MockWebView_State_Call {
12299 _c.Call.Run(func(args mock.Arguments) {
12300 run()
12301 })
12302 return _c
12303}
12304
12305func (_c *MockWebView_State_Call) Return(webViewState port.WebViewState) *MockWebView_State_Call {
12306 _c.Call.Return(webViewState)
12307 return _c
12308}
12309
12310func (_c *MockWebView_State_Call) RunAndReturn(run func() port.WebViewState) *MockWebView_State_Call {
12311 _c.Call.Return(run)
12312 return _c
12313}
12314
12315// Stop provides a mock function for the type MockWebView
12316func (_mock *MockWebView) Stop(ctx context.Context) error {
12317 ret := _mock.Called(ctx)
12318
12319 if len(ret) == 0 {
12320 panic("no return value specified for Stop")
12321 }
12322
12323 var r0 error
12324 if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
12325 r0 = returnFunc(ctx)
12326 } else {
12327 r0 = ret.Error(0)
12328 }
12329 return r0
12330}
12331
12332// MockWebView_Stop_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Stop'
12333type MockWebView_Stop_Call struct {
12334 *mock.Call
12335}
12336
12337// Stop is a helper method to define mock.On call
12338// - ctx context.Context
12339func (_e *MockWebView_Expecter) Stop(ctx interface{}) *MockWebView_Stop_Call {
12340 return &MockWebView_Stop_Call{Call: _e.mock.On("Stop", ctx)}
12341}
12342
12343func (_c *MockWebView_Stop_Call) Run(run func(ctx context.Context)) *MockWebView_Stop_Call {
12344 _c.Call.Run(func(args mock.Arguments) {
12345 var arg0 context.Context
12346 if args[0] != nil {
12347 arg0 = args[0].(context.Context)
12348 }
12349 run(
12350 arg0,
12351 )
12352 })
12353 return _c
12354}
12355
12356func (_c *MockWebView_Stop_Call) Return(err error) *MockWebView_Stop_Call {
12357 _c.Call.Return(err)
12358 return _c
12359}
12360
12361func (_c *MockWebView_Stop_Call) RunAndReturn(run func(ctx context.Context) error) *MockWebView_Stop_Call {
12362 _c.Call.Return(run)
12363 return _c
12364}
12365
12366// Title provides a mock function for the type MockWebView
12367func (_mock *MockWebView) Title() string {
12368 ret := _mock.Called()
12369
12370 if len(ret) == 0 {
12371 panic("no return value specified for Title")
12372 }
12373
12374 var r0 string
12375 if returnFunc, ok := ret.Get(0).(func() string); ok {
12376 r0 = returnFunc()
12377 } else {
12378 r0 = ret.Get(0).(string)
12379 }
12380 return r0
12381}
12382
12383// MockWebView_Title_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Title'
12384type MockWebView_Title_Call struct {
12385 *mock.Call
12386}
12387
12388// Title is a helper method to define mock.On call
12389func (_e *MockWebView_Expecter) Title() *MockWebView_Title_Call {
12390 return &MockWebView_Title_Call{Call: _e.mock.On("Title")}
12391}
12392
12393func (_c *MockWebView_Title_Call) Run(run func()) *MockWebView_Title_Call {
12394 _c.Call.Run(func(args mock.Arguments) {
12395 run()
12396 })
12397 return _c
12398}
12399
12400func (_c *MockWebView_Title_Call) Return(s string) *MockWebView_Title_Call {
12401 _c.Call.Return(s)
12402 return _c
12403}
12404
12405func (_c *MockWebView_Title_Call) RunAndReturn(run func() string) *MockWebView_Title_Call {
12406 _c.Call.Return(run)
12407 return _c
12408}
12409
12410// URI provides a mock function for the type MockWebView
12411func (_mock *MockWebView) URI() string {
12412 ret := _mock.Called()
12413
12414 if len(ret) == 0 {
12415 panic("no return value specified for URI")
12416 }
12417
12418 var r0 string
12419 if returnFunc, ok := ret.Get(0).(func() string); ok {
12420 r0 = returnFunc()
12421 } else {
12422 r0 = ret.Get(0).(string)
12423 }
12424 return r0
12425}
12426
12427// MockWebView_URI_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'URI'
12428type MockWebView_URI_Call struct {
12429 *mock.Call
12430}
12431
12432// URI is a helper method to define mock.On call
12433func (_e *MockWebView_Expecter) URI() *MockWebView_URI_Call {
12434 return &MockWebView_URI_Call{Call: _e.mock.On("URI")}
12435}
12436
12437func (_c *MockWebView_URI_Call) Run(run func()) *MockWebView_URI_Call {
12438 _c.Call.Run(func(args mock.Arguments) {
12439 run()
12440 })
12441 return _c
12442}
12443
12444func (_c *MockWebView_URI_Call) Return(s string) *MockWebView_URI_Call {
12445 _c.Call.Return(s)
12446 return _c
12447}
12448
12449func (_c *MockWebView_URI_Call) RunAndReturn(run func() string) *MockWebView_URI_Call {
12450 _c.Call.Return(run)
12451 return _c
12452}
12453
12454// NewMockWebViewPool creates a new instance of MockWebViewPool. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
12455// The first argument is typically a *testing.T value.
12456func NewMockWebViewPool(t interface {
12457 mock.TestingT
12458 Cleanup(func())
12459}) *MockWebViewPool {
12460 mock := &MockWebViewPool{}
12461 mock.Mock.Test(t)
12462
12463 t.Cleanup(func() { mock.AssertExpectations(t) })
12464
12465 return mock
12466}
12467
12468// MockWebViewPool is an autogenerated mock type for the WebViewPool type
12469type MockWebViewPool struct {
12470 mock.Mock
12471}
12472
12473type MockWebViewPool_Expecter struct {
12474 mock *mock.Mock
12475}
12476
12477func (_m *MockWebViewPool) EXPECT() *MockWebViewPool_Expecter {
12478 return &MockWebViewPool_Expecter{mock: &_m.Mock}
12479}
12480
12481// Acquire provides a mock function for the type MockWebViewPool
12482func (_mock *MockWebViewPool) Acquire(ctx context.Context) (port.WebView, error) {
12483 ret := _mock.Called(ctx)
12484
12485 if len(ret) == 0 {
12486 panic("no return value specified for Acquire")
12487 }
12488
12489 var r0 port.WebView
12490 var r1 error
12491 if returnFunc, ok := ret.Get(0).(func(context.Context) (port.WebView, error)); ok {
12492 return returnFunc(ctx)
12493 }
12494 if returnFunc, ok := ret.Get(0).(func(context.Context) port.WebView); ok {
12495 r0 = returnFunc(ctx)
12496 } else {
12497 if ret.Get(0) != nil {
12498 r0 = ret.Get(0).(port.WebView)
12499 }
12500 }
12501 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
12502 r1 = returnFunc(ctx)
12503 } else {
12504 r1 = ret.Error(1)
12505 }
12506 return r0, r1
12507}
12508
12509// MockWebViewPool_Acquire_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Acquire'
12510type MockWebViewPool_Acquire_Call struct {
12511 *mock.Call
12512}
12513
12514// Acquire is a helper method to define mock.On call
12515// - ctx context.Context
12516func (_e *MockWebViewPool_Expecter) Acquire(ctx interface{}) *MockWebViewPool_Acquire_Call {
12517 return &MockWebViewPool_Acquire_Call{Call: _e.mock.On("Acquire", ctx)}
12518}
12519
12520func (_c *MockWebViewPool_Acquire_Call) Run(run func(ctx context.Context)) *MockWebViewPool_Acquire_Call {
12521 _c.Call.Run(func(args mock.Arguments) {
12522 var arg0 context.Context
12523 if args[0] != nil {
12524 arg0 = args[0].(context.Context)
12525 }
12526 run(
12527 arg0,
12528 )
12529 })
12530 return _c
12531}
12532
12533func (_c *MockWebViewPool_Acquire_Call) Return(webView port.WebView, err error) *MockWebViewPool_Acquire_Call {
12534 _c.Call.Return(webView, err)
12535 return _c
12536}
12537
12538func (_c *MockWebViewPool_Acquire_Call) RunAndReturn(run func(ctx context.Context) (port.WebView, error)) *MockWebViewPool_Acquire_Call {
12539 _c.Call.Return(run)
12540 return _c
12541}
12542
12543// Close provides a mock function for the type MockWebViewPool
12544func (_mock *MockWebViewPool) Close() {
12545 _mock.Called()
12546 return
12547}
12548
12549// MockWebViewPool_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
12550type MockWebViewPool_Close_Call struct {
12551 *mock.Call
12552}
12553
12554// Close is a helper method to define mock.On call
12555func (_e *MockWebViewPool_Expecter) Close() *MockWebViewPool_Close_Call {
12556 return &MockWebViewPool_Close_Call{Call: _e.mock.On("Close")}
12557}
12558
12559func (_c *MockWebViewPool_Close_Call) Run(run func()) *MockWebViewPool_Close_Call {
12560 _c.Call.Run(func(args mock.Arguments) {
12561 run()
12562 })
12563 return _c
12564}
12565
12566func (_c *MockWebViewPool_Close_Call) Return() *MockWebViewPool_Close_Call {
12567 _c.Call.Return()
12568 return _c
12569}
12570
12571func (_c *MockWebViewPool_Close_Call) RunAndReturn(run func()) *MockWebViewPool_Close_Call {
12572 _c.Run(run)
12573 return _c
12574}
12575
12576// Prewarm provides a mock function for the type MockWebViewPool
12577func (_mock *MockWebViewPool) Prewarm(count int) {
12578 _mock.Called(count)
12579 return
12580}
12581
12582// MockWebViewPool_Prewarm_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Prewarm'
12583type MockWebViewPool_Prewarm_Call struct {
12584 *mock.Call
12585}
12586
12587// Prewarm is a helper method to define mock.On call
12588// - count int
12589func (_e *MockWebViewPool_Expecter) Prewarm(count interface{}) *MockWebViewPool_Prewarm_Call {
12590 return &MockWebViewPool_Prewarm_Call{Call: _e.mock.On("Prewarm", count)}
12591}
12592
12593func (_c *MockWebViewPool_Prewarm_Call) Run(run func(count int)) *MockWebViewPool_Prewarm_Call {
12594 _c.Call.Run(func(args mock.Arguments) {
12595 var arg0 int
12596 if args[0] != nil {
12597 arg0 = args[0].(int)
12598 }
12599 run(
12600 arg0,
12601 )
12602 })
12603 return _c
12604}
12605
12606func (_c *MockWebViewPool_Prewarm_Call) Return() *MockWebViewPool_Prewarm_Call {
12607 _c.Call.Return()
12608 return _c
12609}
12610
12611func (_c *MockWebViewPool_Prewarm_Call) RunAndReturn(run func(count int)) *MockWebViewPool_Prewarm_Call {
12612 _c.Run(run)
12613 return _c
12614}
12615
12616// PrewarmAsync provides a mock function for the type MockWebViewPool
12617func (_mock *MockWebViewPool) PrewarmAsync(ctx context.Context, count int) {
12618 _mock.Called(ctx, count)
12619 return
12620}
12621
12622// MockWebViewPool_PrewarmAsync_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PrewarmAsync'
12623type MockWebViewPool_PrewarmAsync_Call struct {
12624 *mock.Call
12625}
12626
12627// PrewarmAsync is a helper method to define mock.On call
12628// - ctx context.Context
12629// - count int
12630func (_e *MockWebViewPool_Expecter) PrewarmAsync(ctx interface{}, count interface{}) *MockWebViewPool_PrewarmAsync_Call {
12631 return &MockWebViewPool_PrewarmAsync_Call{Call: _e.mock.On("PrewarmAsync", ctx, count)}
12632}
12633
12634func (_c *MockWebViewPool_PrewarmAsync_Call) Run(run func(ctx context.Context, count int)) *MockWebViewPool_PrewarmAsync_Call {
12635 _c.Call.Run(func(args mock.Arguments) {
12636 var arg0 context.Context
12637 if args[0] != nil {
12638 arg0 = args[0].(context.Context)
12639 }
12640 var arg1 int
12641 if args[1] != nil {
12642 arg1 = args[1].(int)
12643 }
12644 run(
12645 arg0,
12646 arg1,
12647 )
12648 })
12649 return _c
12650}
12651
12652func (_c *MockWebViewPool_PrewarmAsync_Call) Return() *MockWebViewPool_PrewarmAsync_Call {
12653 _c.Call.Return()
12654 return _c
12655}
12656
12657func (_c *MockWebViewPool_PrewarmAsync_Call) RunAndReturn(run func(ctx context.Context, count int)) *MockWebViewPool_PrewarmAsync_Call {
12658 _c.Run(run)
12659 return _c
12660}
12661
12662// Release provides a mock function for the type MockWebViewPool
12663func (_mock *MockWebViewPool) Release(wv port.WebView) {
12664 _mock.Called(wv)
12665 return
12666}
12667
12668// MockWebViewPool_Release_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Release'
12669type MockWebViewPool_Release_Call struct {
12670 *mock.Call
12671}
12672
12673// Release is a helper method to define mock.On call
12674// - wv port.WebView
12675func (_e *MockWebViewPool_Expecter) Release(wv interface{}) *MockWebViewPool_Release_Call {
12676 return &MockWebViewPool_Release_Call{Call: _e.mock.On("Release", wv)}
12677}
12678
12679func (_c *MockWebViewPool_Release_Call) Run(run func(wv port.WebView)) *MockWebViewPool_Release_Call {
12680 _c.Call.Run(func(args mock.Arguments) {
12681 var arg0 port.WebView
12682 if args[0] != nil {
12683 arg0 = args[0].(port.WebView)
12684 }
12685 run(
12686 arg0,
12687 )
12688 })
12689 return _c
12690}
12691
12692func (_c *MockWebViewPool_Release_Call) Return() *MockWebViewPool_Release_Call {
12693 _c.Call.Return()
12694 return _c
12695}
12696
12697func (_c *MockWebViewPool_Release_Call) RunAndReturn(run func(wv port.WebView)) *MockWebViewPool_Release_Call {
12698 _c.Run(run)
12699 return _c
12700}
12701
12702// Size provides a mock function for the type MockWebViewPool
12703func (_mock *MockWebViewPool) Size() int {
12704 ret := _mock.Called()
12705
12706 if len(ret) == 0 {
12707 panic("no return value specified for Size")
12708 }
12709
12710 var r0 int
12711 if returnFunc, ok := ret.Get(0).(func() int); ok {
12712 r0 = returnFunc()
12713 } else {
12714 r0 = ret.Get(0).(int)
12715 }
12716 return r0
12717}
12718
12719// MockWebViewPool_Size_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Size'
12720type MockWebViewPool_Size_Call struct {
12721 *mock.Call
12722}
12723
12724// Size is a helper method to define mock.On call
12725func (_e *MockWebViewPool_Expecter) Size() *MockWebViewPool_Size_Call {
12726 return &MockWebViewPool_Size_Call{Call: _e.mock.On("Size")}
12727}
12728
12729func (_c *MockWebViewPool_Size_Call) Run(run func()) *MockWebViewPool_Size_Call {
12730 _c.Call.Run(func(args mock.Arguments) {
12731 run()
12732 })
12733 return _c
12734}
12735
12736func (_c *MockWebViewPool_Size_Call) Return(n int) *MockWebViewPool_Size_Call {
12737 _c.Call.Return(n)
12738 return _c
12739}
12740
12741func (_c *MockWebViewPool_Size_Call) RunAndReturn(run func() int) *MockWebViewPool_Size_Call {
12742 _c.Call.Return(run)
12743 return _c
12744}
12745
12746// NewMockWebViewFactory creates a new instance of MockWebViewFactory. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
12747// The first argument is typically a *testing.T value.
12748func NewMockWebViewFactory(t interface {
12749 mock.TestingT
12750 Cleanup(func())
12751}) *MockWebViewFactory {
12752 mock := &MockWebViewFactory{}
12753 mock.Mock.Test(t)
12754
12755 t.Cleanup(func() { mock.AssertExpectations(t) })
12756
12757 return mock
12758}
12759
12760// MockWebViewFactory is an autogenerated mock type for the WebViewFactory type
12761type MockWebViewFactory struct {
12762 mock.Mock
12763}
12764
12765type MockWebViewFactory_Expecter struct {
12766 mock *mock.Mock
12767}
12768
12769func (_m *MockWebViewFactory) EXPECT() *MockWebViewFactory_Expecter {
12770 return &MockWebViewFactory_Expecter{mock: &_m.Mock}
12771}
12772
12773// Create provides a mock function for the type MockWebViewFactory
12774func (_mock *MockWebViewFactory) Create(ctx context.Context) (port.WebView, error) {
12775 ret := _mock.Called(ctx)
12776
12777 if len(ret) == 0 {
12778 panic("no return value specified for Create")
12779 }
12780
12781 var r0 port.WebView
12782 var r1 error
12783 if returnFunc, ok := ret.Get(0).(func(context.Context) (port.WebView, error)); ok {
12784 return returnFunc(ctx)
12785 }
12786 if returnFunc, ok := ret.Get(0).(func(context.Context) port.WebView); ok {
12787 r0 = returnFunc(ctx)
12788 } else {
12789 if ret.Get(0) != nil {
12790 r0 = ret.Get(0).(port.WebView)
12791 }
12792 }
12793 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
12794 r1 = returnFunc(ctx)
12795 } else {
12796 r1 = ret.Error(1)
12797 }
12798 return r0, r1
12799}
12800
12801// MockWebViewFactory_Create_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Create'
12802type MockWebViewFactory_Create_Call struct {
12803 *mock.Call
12804}
12805
12806// Create is a helper method to define mock.On call
12807// - ctx context.Context
12808func (_e *MockWebViewFactory_Expecter) Create(ctx interface{}) *MockWebViewFactory_Create_Call {
12809 return &MockWebViewFactory_Create_Call{Call: _e.mock.On("Create", ctx)}
12810}
12811
12812func (_c *MockWebViewFactory_Create_Call) Run(run func(ctx context.Context)) *MockWebViewFactory_Create_Call {
12813 _c.Call.Run(func(args mock.Arguments) {
12814 var arg0 context.Context
12815 if args[0] != nil {
12816 arg0 = args[0].(context.Context)
12817 }
12818 run(
12819 arg0,
12820 )
12821 })
12822 return _c
12823}
12824
12825func (_c *MockWebViewFactory_Create_Call) Return(webView port.WebView, err error) *MockWebViewFactory_Create_Call {
12826 _c.Call.Return(webView, err)
12827 return _c
12828}
12829
12830func (_c *MockWebViewFactory_Create_Call) RunAndReturn(run func(ctx context.Context) (port.WebView, error)) *MockWebViewFactory_Create_Call {
12831 _c.Call.Return(run)
12832 return _c
12833}
12834
12835// CreateRelated provides a mock function for the type MockWebViewFactory
12836func (_mock *MockWebViewFactory) CreateRelated(ctx context.Context, parentID port.WebViewID) (port.WebView, error) {
12837 ret := _mock.Called(ctx, parentID)
12838
12839 if len(ret) == 0 {
12840 panic("no return value specified for CreateRelated")
12841 }
12842
12843 var r0 port.WebView
12844 var r1 error
12845 if returnFunc, ok := ret.Get(0).(func(context.Context, port.WebViewID) (port.WebView, error)); ok {
12846 return returnFunc(ctx, parentID)
12847 }
12848 if returnFunc, ok := ret.Get(0).(func(context.Context, port.WebViewID) port.WebView); ok {
12849 r0 = returnFunc(ctx, parentID)
12850 } else {
12851 if ret.Get(0) != nil {
12852 r0 = ret.Get(0).(port.WebView)
12853 }
12854 }
12855 if returnFunc, ok := ret.Get(1).(func(context.Context, port.WebViewID) error); ok {
12856 r1 = returnFunc(ctx, parentID)
12857 } else {
12858 r1 = ret.Error(1)
12859 }
12860 return r0, r1
12861}
12862
12863// MockWebViewFactory_CreateRelated_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateRelated'
12864type MockWebViewFactory_CreateRelated_Call struct {
12865 *mock.Call
12866}
12867
12868// CreateRelated is a helper method to define mock.On call
12869// - ctx context.Context
12870// - parentID port.WebViewID
12871func (_e *MockWebViewFactory_Expecter) CreateRelated(ctx interface{}, parentID interface{}) *MockWebViewFactory_CreateRelated_Call {
12872 return &MockWebViewFactory_CreateRelated_Call{Call: _e.mock.On("CreateRelated", ctx, parentID)}
12873}
12874
12875func (_c *MockWebViewFactory_CreateRelated_Call) Run(run func(ctx context.Context, parentID port.WebViewID)) *MockWebViewFactory_CreateRelated_Call {
12876 _c.Call.Run(func(args mock.Arguments) {
12877 var arg0 context.Context
12878 if args[0] != nil {
12879 arg0 = args[0].(context.Context)
12880 }
12881 var arg1 port.WebViewID
12882 if args[1] != nil {
12883 arg1 = args[1].(port.WebViewID)
12884 }
12885 run(
12886 arg0,
12887 arg1,
12888 )
12889 })
12890 return _c
12891}
12892
12893func (_c *MockWebViewFactory_CreateRelated_Call) Return(webView port.WebView, err error) *MockWebViewFactory_CreateRelated_Call {
12894 _c.Call.Return(webView, err)
12895 return _c
12896}
12897
12898func (_c *MockWebViewFactory_CreateRelated_Call) RunAndReturn(run func(ctx context.Context, parentID port.WebViewID) (port.WebView, error)) *MockWebViewFactory_CreateRelated_Call {
12899 _c.Call.Return(run)
12900 return _c
12901}
12902
12903// NewMockDevToolsOpener creates a new instance of MockDevToolsOpener. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
12904// The first argument is typically a *testing.T value.
12905func NewMockDevToolsOpener(t interface {
12906 mock.TestingT
12907 Cleanup(func())
12908}) *MockDevToolsOpener {
12909 mock := &MockDevToolsOpener{}
12910 mock.Mock.Test(t)
12911
12912 t.Cleanup(func() { mock.AssertExpectations(t) })
12913
12914 return mock
12915}
12916
12917// MockDevToolsOpener is an autogenerated mock type for the DevToolsOpener type
12918type MockDevToolsOpener struct {
12919 mock.Mock
12920}
12921
12922type MockDevToolsOpener_Expecter struct {
12923 mock *mock.Mock
12924}
12925
12926func (_m *MockDevToolsOpener) EXPECT() *MockDevToolsOpener_Expecter {
12927 return &MockDevToolsOpener_Expecter{mock: &_m.Mock}
12928}
12929
12930// OpenDevTools provides a mock function for the type MockDevToolsOpener
12931func (_mock *MockDevToolsOpener) OpenDevTools() {
12932 _mock.Called()
12933 return
12934}
12935
12936// MockDevToolsOpener_OpenDevTools_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OpenDevTools'
12937type MockDevToolsOpener_OpenDevTools_Call struct {
12938 *mock.Call
12939}
12940
12941// OpenDevTools is a helper method to define mock.On call
12942func (_e *MockDevToolsOpener_Expecter) OpenDevTools() *MockDevToolsOpener_OpenDevTools_Call {
12943 return &MockDevToolsOpener_OpenDevTools_Call{Call: _e.mock.On("OpenDevTools")}
12944}
12945
12946func (_c *MockDevToolsOpener_OpenDevTools_Call) Run(run func()) *MockDevToolsOpener_OpenDevTools_Call {
12947 _c.Call.Run(func(args mock.Arguments) {
12948 run()
12949 })
12950 return _c
12951}
12952
12953func (_c *MockDevToolsOpener_OpenDevTools_Call) Return() *MockDevToolsOpener_OpenDevTools_Call {
12954 _c.Call.Return()
12955 return _c
12956}
12957
12958func (_c *MockDevToolsOpener_OpenDevTools_Call) RunAndReturn(run func()) *MockDevToolsOpener_OpenDevTools_Call {
12959 _c.Run(run)
12960 return _c
12961}
12962
12963// NewMockPrinter creates a new instance of MockPrinter. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
12964// The first argument is typically a *testing.T value.
12965func NewMockPrinter(t interface {
12966 mock.TestingT
12967 Cleanup(func())
12968}) *MockPrinter {
12969 mock := &MockPrinter{}
12970 mock.Mock.Test(t)
12971
12972 t.Cleanup(func() { mock.AssertExpectations(t) })
12973
12974 return mock
12975}
12976
12977// MockPrinter is an autogenerated mock type for the Printer type
12978type MockPrinter struct {
12979 mock.Mock
12980}
12981
12982type MockPrinter_Expecter struct {
12983 mock *mock.Mock
12984}
12985
12986func (_m *MockPrinter) EXPECT() *MockPrinter_Expecter {
12987 return &MockPrinter_Expecter{mock: &_m.Mock}
12988}
12989
12990// PrintPage provides a mock function for the type MockPrinter
12991func (_mock *MockPrinter) PrintPage() {
12992 _mock.Called()
12993 return
12994}
12995
12996// MockPrinter_PrintPage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PrintPage'
12997type MockPrinter_PrintPage_Call struct {
12998 *mock.Call
12999}
13000
13001// PrintPage is a helper method to define mock.On call
13002func (_e *MockPrinter_Expecter) PrintPage() *MockPrinter_PrintPage_Call {
13003 return &MockPrinter_PrintPage_Call{Call: _e.mock.On("PrintPage")}
13004}
13005
13006func (_c *MockPrinter_PrintPage_Call) Run(run func()) *MockPrinter_PrintPage_Call {
13007 _c.Call.Run(func(args mock.Arguments) {
13008 run()
13009 })
13010 return _c
13011}
13012
13013func (_c *MockPrinter_PrintPage_Call) Return() *MockPrinter_PrintPage_Call {
13014 _c.Call.Return()
13015 return _c
13016}
13017
13018func (_c *MockPrinter_PrintPage_Call) RunAndReturn(run func()) *MockPrinter_PrintPage_Call {
13019 _c.Run(run)
13020 return _c
13021}
13022
13023// NewMockPopupCapable creates a new instance of MockPopupCapable. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
13024// The first argument is typically a *testing.T value.
13025func NewMockPopupCapable(t interface {
13026 mock.TestingT
13027 Cleanup(func())
13028}) *MockPopupCapable {
13029 mock := &MockPopupCapable{}
13030 mock.Mock.Test(t)
13031
13032 t.Cleanup(func() { mock.AssertExpectations(t) })
13033
13034 return mock
13035}
13036
13037// MockPopupCapable is an autogenerated mock type for the PopupCapable type
13038type MockPopupCapable struct {
13039 mock.Mock
13040}
13041
13042type MockPopupCapable_Expecter struct {
13043 mock *mock.Mock
13044}
13045
13046func (_m *MockPopupCapable) EXPECT() *MockPopupCapable_Expecter {
13047 return &MockPopupCapable_Expecter{mock: &_m.Mock}
13048}
13049
13050// SetOnClose provides a mock function for the type MockPopupCapable
13051func (_mock *MockPopupCapable) SetOnClose(fn func()) {
13052 _mock.Called(fn)
13053 return
13054}
13055
13056// MockPopupCapable_SetOnClose_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetOnClose'
13057type MockPopupCapable_SetOnClose_Call struct {
13058 *mock.Call
13059}
13060
13061// SetOnClose is a helper method to define mock.On call
13062// - fn func()
13063func (_e *MockPopupCapable_Expecter) SetOnClose(fn interface{}) *MockPopupCapable_SetOnClose_Call {
13064 return &MockPopupCapable_SetOnClose_Call{Call: _e.mock.On("SetOnClose", fn)}
13065}
13066
13067func (_c *MockPopupCapable_SetOnClose_Call) Run(run func(fn func())) *MockPopupCapable_SetOnClose_Call {
13068 _c.Call.Run(func(args mock.Arguments) {
13069 var arg0 func()
13070 if args[0] != nil {
13071 arg0 = args[0].(func())
13072 }
13073 run(
13074 arg0,
13075 )
13076 })
13077 return _c
13078}
13079
13080func (_c *MockPopupCapable_SetOnClose_Call) Return() *MockPopupCapable_SetOnClose_Call {
13081 _c.Call.Return()
13082 return _c
13083}
13084
13085func (_c *MockPopupCapable_SetOnClose_Call) RunAndReturn(run func(fn func())) *MockPopupCapable_SetOnClose_Call {
13086 _c.Run(run)
13087 return _c
13088}
13089
13090// SetOnReadyToShow provides a mock function for the type MockPopupCapable
13091func (_mock *MockPopupCapable) SetOnReadyToShow(fn func()) {
13092 _mock.Called(fn)
13093 return
13094}
13095
13096// MockPopupCapable_SetOnReadyToShow_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetOnReadyToShow'
13097type MockPopupCapable_SetOnReadyToShow_Call struct {
13098 *mock.Call
13099}
13100
13101// SetOnReadyToShow is a helper method to define mock.On call
13102// - fn func()
13103func (_e *MockPopupCapable_Expecter) SetOnReadyToShow(fn interface{}) *MockPopupCapable_SetOnReadyToShow_Call {
13104 return &MockPopupCapable_SetOnReadyToShow_Call{Call: _e.mock.On("SetOnReadyToShow", fn)}
13105}
13106
13107func (_c *MockPopupCapable_SetOnReadyToShow_Call) Run(run func(fn func())) *MockPopupCapable_SetOnReadyToShow_Call {
13108 _c.Call.Run(func(args mock.Arguments) {
13109 var arg0 func()
13110 if args[0] != nil {
13111 arg0 = args[0].(func())
13112 }
13113 run(
13114 arg0,
13115 )
13116 })
13117 return _c
13118}
13119
13120func (_c *MockPopupCapable_SetOnReadyToShow_Call) Return() *MockPopupCapable_SetOnReadyToShow_Call {
13121 _c.Call.Return()
13122 return _c
13123}
13124
13125func (_c *MockPopupCapable_SetOnReadyToShow_Call) RunAndReturn(run func(fn func())) *MockPopupCapable_SetOnReadyToShow_Call {
13126 _c.Run(run)
13127 return _c
13128}
13129
13130// Show provides a mock function for the type MockPopupCapable
13131func (_mock *MockPopupCapable) Show() {
13132 _mock.Called()
13133 return
13134}
13135
13136// MockPopupCapable_Show_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Show'
13137type MockPopupCapable_Show_Call struct {
13138 *mock.Call
13139}
13140
13141// Show is a helper method to define mock.On call
13142func (_e *MockPopupCapable_Expecter) Show() *MockPopupCapable_Show_Call {
13143 return &MockPopupCapable_Show_Call{Call: _e.mock.On("Show")}
13144}
13145
13146func (_c *MockPopupCapable_Show_Call) Run(run func()) *MockPopupCapable_Show_Call {
13147 _c.Call.Run(func(args mock.Arguments) {
13148 run()
13149 })
13150 return _c
13151}
13152
13153func (_c *MockPopupCapable_Show_Call) Return() *MockPopupCapable_Show_Call {
13154 _c.Call.Return()
13155 return _c
13156}
13157
13158func (_c *MockPopupCapable_Show_Call) RunAndReturn(run func()) *MockPopupCapable_Show_Call {
13159 _c.Run(run)
13160 return _c
13161}
13162
13163// NewMockOAuthCallbackCapable creates a new instance of MockOAuthCallbackCapable. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
13164// The first argument is typically a *testing.T value.
13165func NewMockOAuthCallbackCapable(t interface {
13166 mock.TestingT
13167 Cleanup(func())
13168}) *MockOAuthCallbackCapable {
13169 mock := &MockOAuthCallbackCapable{}
13170 mock.Mock.Test(t)
13171
13172 t.Cleanup(func() { mock.AssertExpectations(t) })
13173
13174 return mock
13175}
13176
13177// MockOAuthCallbackCapable is an autogenerated mock type for the OAuthCallbackCapable type
13178type MockOAuthCallbackCapable struct {
13179 mock.Mock
13180}
13181
13182type MockOAuthCallbackCapable_Expecter struct {
13183 mock *mock.Mock
13184}
13185
13186func (_m *MockOAuthCallbackCapable) EXPECT() *MockOAuthCallbackCapable_Expecter {
13187 return &MockOAuthCallbackCapable_Expecter{mock: &_m.Mock}
13188}
13189
13190// AddCloseCallback provides a mock function for the type MockOAuthCallbackCapable
13191func (_mock *MockOAuthCallbackCapable) AddCloseCallback(fn func()) {
13192 _mock.Called(fn)
13193 return
13194}
13195
13196// MockOAuthCallbackCapable_AddCloseCallback_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddCloseCallback'
13197type MockOAuthCallbackCapable_AddCloseCallback_Call struct {
13198 *mock.Call
13199}
13200
13201// AddCloseCallback is a helper method to define mock.On call
13202// - fn func()
13203func (_e *MockOAuthCallbackCapable_Expecter) AddCloseCallback(fn interface{}) *MockOAuthCallbackCapable_AddCloseCallback_Call {
13204 return &MockOAuthCallbackCapable_AddCloseCallback_Call{Call: _e.mock.On("AddCloseCallback", fn)}
13205}
13206
13207func (_c *MockOAuthCallbackCapable_AddCloseCallback_Call) Run(run func(fn func())) *MockOAuthCallbackCapable_AddCloseCallback_Call {
13208 _c.Call.Run(func(args mock.Arguments) {
13209 var arg0 func()
13210 if args[0] != nil {
13211 arg0 = args[0].(func())
13212 }
13213 run(
13214 arg0,
13215 )
13216 })
13217 return _c
13218}
13219
13220func (_c *MockOAuthCallbackCapable_AddCloseCallback_Call) Return() *MockOAuthCallbackCapable_AddCloseCallback_Call {
13221 _c.Call.Return()
13222 return _c
13223}
13224
13225func (_c *MockOAuthCallbackCapable_AddCloseCallback_Call) RunAndReturn(run func(fn func())) *MockOAuthCallbackCapable_AddCloseCallback_Call {
13226 _c.Run(run)
13227 return _c
13228}
13229
13230// AddNavigationCallback provides a mock function for the type MockOAuthCallbackCapable
13231func (_mock *MockOAuthCallbackCapable) AddNavigationCallback(fn func(uri string)) {
13232 _mock.Called(fn)
13233 return
13234}
13235
13236// MockOAuthCallbackCapable_AddNavigationCallback_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddNavigationCallback'
13237type MockOAuthCallbackCapable_AddNavigationCallback_Call struct {
13238 *mock.Call
13239}
13240
13241// AddNavigationCallback is a helper method to define mock.On call
13242// - fn func(uri string)
13243func (_e *MockOAuthCallbackCapable_Expecter) AddNavigationCallback(fn interface{}) *MockOAuthCallbackCapable_AddNavigationCallback_Call {
13244 return &MockOAuthCallbackCapable_AddNavigationCallback_Call{Call: _e.mock.On("AddNavigationCallback", fn)}
13245}
13246
13247func (_c *MockOAuthCallbackCapable_AddNavigationCallback_Call) Run(run func(fn func(uri string))) *MockOAuthCallbackCapable_AddNavigationCallback_Call {
13248 _c.Call.Run(func(args mock.Arguments) {
13249 var arg0 func(uri string)
13250 if args[0] != nil {
13251 arg0 = args[0].(func(uri string))
13252 }
13253 run(
13254 arg0,
13255 )
13256 })
13257 return _c
13258}
13259
13260func (_c *MockOAuthCallbackCapable_AddNavigationCallback_Call) Return() *MockOAuthCallbackCapable_AddNavigationCallback_Call {
13261 _c.Call.Return()
13262 return _c
13263}
13264
13265func (_c *MockOAuthCallbackCapable_AddNavigationCallback_Call) RunAndReturn(run func(fn func(uri string))) *MockOAuthCallbackCapable_AddNavigationCallback_Call {
13266 _c.Run(run)
13267 return _c
13268}
13269
13270// Close provides a mock function for the type MockOAuthCallbackCapable
13271func (_mock *MockOAuthCallbackCapable) Close() {
13272 _mock.Called()
13273 return
13274}
13275
13276// MockOAuthCallbackCapable_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
13277type MockOAuthCallbackCapable_Close_Call struct {
13278 *mock.Call
13279}
13280
13281// Close is a helper method to define mock.On call
13282func (_e *MockOAuthCallbackCapable_Expecter) Close() *MockOAuthCallbackCapable_Close_Call {
13283 return &MockOAuthCallbackCapable_Close_Call{Call: _e.mock.On("Close")}
13284}
13285
13286func (_c *MockOAuthCallbackCapable_Close_Call) Run(run func()) *MockOAuthCallbackCapable_Close_Call {
13287 _c.Call.Run(func(args mock.Arguments) {
13288 run()
13289 })
13290 return _c
13291}
13292
13293func (_c *MockOAuthCallbackCapable_Close_Call) Return() *MockOAuthCallbackCapable_Close_Call {
13294 _c.Call.Return()
13295 return _c
13296}
13297
13298func (_c *MockOAuthCallbackCapable_Close_Call) RunAndReturn(run func()) *MockOAuthCallbackCapable_Close_Call {
13299 _c.Run(run)
13300 return _c
13301}
13302
13303// NewMockTextInputTargetProvider creates a new instance of MockTextInputTargetProvider. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
13304// The first argument is typically a *testing.T value.
13305func NewMockTextInputTargetProvider(t interface {
13306 mock.TestingT
13307 Cleanup(func())
13308}) *MockTextInputTargetProvider {
13309 mock := &MockTextInputTargetProvider{}
13310 mock.Mock.Test(t)
13311
13312 t.Cleanup(func() { mock.AssertExpectations(t) })
13313
13314 return mock
13315}
13316
13317// MockTextInputTargetProvider is an autogenerated mock type for the TextInputTargetProvider type
13318type MockTextInputTargetProvider struct {
13319 mock.Mock
13320}
13321
13322type MockTextInputTargetProvider_Expecter struct {
13323 mock *mock.Mock
13324}
13325
13326func (_m *MockTextInputTargetProvider) EXPECT() *MockTextInputTargetProvider_Expecter {
13327 return &MockTextInputTargetProvider_Expecter{mock: &_m.Mock}
13328}
13329
13330// TextInputTarget provides a mock function for the type MockTextInputTargetProvider
13331func (_mock *MockTextInputTargetProvider) TextInputTarget() port.TextInputTarget {
13332 ret := _mock.Called()
13333
13334 if len(ret) == 0 {
13335 panic("no return value specified for TextInputTarget")
13336 }
13337
13338 var r0 port.TextInputTarget
13339 if returnFunc, ok := ret.Get(0).(func() port.TextInputTarget); ok {
13340 r0 = returnFunc()
13341 } else {
13342 if ret.Get(0) != nil {
13343 r0 = ret.Get(0).(port.TextInputTarget)
13344 }
13345 }
13346 return r0
13347}
13348
13349// MockTextInputTargetProvider_TextInputTarget_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TextInputTarget'
13350type MockTextInputTargetProvider_TextInputTarget_Call struct {
13351 *mock.Call
13352}
13353
13354// TextInputTarget is a helper method to define mock.On call
13355func (_e *MockTextInputTargetProvider_Expecter) TextInputTarget() *MockTextInputTargetProvider_TextInputTarget_Call {
13356 return &MockTextInputTargetProvider_TextInputTarget_Call{Call: _e.mock.On("TextInputTarget")}
13357}
13358
13359func (_c *MockTextInputTargetProvider_TextInputTarget_Call) Run(run func()) *MockTextInputTargetProvider_TextInputTarget_Call {
13360 _c.Call.Run(func(args mock.Arguments) {
13361 run()
13362 })
13363 return _c
13364}
13365
13366func (_c *MockTextInputTargetProvider_TextInputTarget_Call) Return(textInputTarget port.TextInputTarget) *MockTextInputTargetProvider_TextInputTarget_Call {
13367 _c.Call.Return(textInputTarget)
13368 return _c
13369}
13370
13371func (_c *MockTextInputTargetProvider_TextInputTarget_Call) RunAndReturn(run func() port.TextInputTarget) *MockTextInputTargetProvider_TextInputTarget_Call {
13372 _c.Call.Return(run)
13373 return _c
13374}
13375
13376// NewMockXDGPaths creates a new instance of MockXDGPaths. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
13377// The first argument is typically a *testing.T value.
13378func NewMockXDGPaths(t interface {
13379 mock.TestingT
13380 Cleanup(func())
13381}) *MockXDGPaths {
13382 mock := &MockXDGPaths{}
13383 mock.Mock.Test(t)
13384
13385 t.Cleanup(func() { mock.AssertExpectations(t) })
13386
13387 return mock
13388}
13389
13390// MockXDGPaths is an autogenerated mock type for the XDGPaths type
13391type MockXDGPaths struct {
13392 mock.Mock
13393}
13394
13395type MockXDGPaths_Expecter struct {
13396 mock *mock.Mock
13397}
13398
13399func (_m *MockXDGPaths) EXPECT() *MockXDGPaths_Expecter {
13400 return &MockXDGPaths_Expecter{mock: &_m.Mock}
13401}
13402
13403// CacheDir provides a mock function for the type MockXDGPaths
13404func (_mock *MockXDGPaths) CacheDir() (string, error) {
13405 ret := _mock.Called()
13406
13407 if len(ret) == 0 {
13408 panic("no return value specified for CacheDir")
13409 }
13410
13411 var r0 string
13412 var r1 error
13413 if returnFunc, ok := ret.Get(0).(func() (string, error)); ok {
13414 return returnFunc()
13415 }
13416 if returnFunc, ok := ret.Get(0).(func() string); ok {
13417 r0 = returnFunc()
13418 } else {
13419 r0 = ret.Get(0).(string)
13420 }
13421 if returnFunc, ok := ret.Get(1).(func() error); ok {
13422 r1 = returnFunc()
13423 } else {
13424 r1 = ret.Error(1)
13425 }
13426 return r0, r1
13427}
13428
13429// MockXDGPaths_CacheDir_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CacheDir'
13430type MockXDGPaths_CacheDir_Call struct {
13431 *mock.Call
13432}
13433
13434// CacheDir is a helper method to define mock.On call
13435func (_e *MockXDGPaths_Expecter) CacheDir() *MockXDGPaths_CacheDir_Call {
13436 return &MockXDGPaths_CacheDir_Call{Call: _e.mock.On("CacheDir")}
13437}
13438
13439func (_c *MockXDGPaths_CacheDir_Call) Run(run func()) *MockXDGPaths_CacheDir_Call {
13440 _c.Call.Run(func(args mock.Arguments) {
13441 run()
13442 })
13443 return _c
13444}
13445
13446func (_c *MockXDGPaths_CacheDir_Call) Return(s string, err error) *MockXDGPaths_CacheDir_Call {
13447 _c.Call.Return(s, err)
13448 return _c
13449}
13450
13451func (_c *MockXDGPaths_CacheDir_Call) RunAndReturn(run func() (string, error)) *MockXDGPaths_CacheDir_Call {
13452 _c.Call.Return(run)
13453 return _c
13454}
13455
13456// ConfigDir provides a mock function for the type MockXDGPaths
13457func (_mock *MockXDGPaths) ConfigDir() (string, error) {
13458 ret := _mock.Called()
13459
13460 if len(ret) == 0 {
13461 panic("no return value specified for ConfigDir")
13462 }
13463
13464 var r0 string
13465 var r1 error
13466 if returnFunc, ok := ret.Get(0).(func() (string, error)); ok {
13467 return returnFunc()
13468 }
13469 if returnFunc, ok := ret.Get(0).(func() string); ok {
13470 r0 = returnFunc()
13471 } else {
13472 r0 = ret.Get(0).(string)
13473 }
13474 if returnFunc, ok := ret.Get(1).(func() error); ok {
13475 r1 = returnFunc()
13476 } else {
13477 r1 = ret.Error(1)
13478 }
13479 return r0, r1
13480}
13481
13482// MockXDGPaths_ConfigDir_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ConfigDir'
13483type MockXDGPaths_ConfigDir_Call struct {
13484 *mock.Call
13485}
13486
13487// ConfigDir is a helper method to define mock.On call
13488func (_e *MockXDGPaths_Expecter) ConfigDir() *MockXDGPaths_ConfigDir_Call {
13489 return &MockXDGPaths_ConfigDir_Call{Call: _e.mock.On("ConfigDir")}
13490}
13491
13492func (_c *MockXDGPaths_ConfigDir_Call) Run(run func()) *MockXDGPaths_ConfigDir_Call {
13493 _c.Call.Run(func(args mock.Arguments) {
13494 run()
13495 })
13496 return _c
13497}
13498
13499func (_c *MockXDGPaths_ConfigDir_Call) Return(s string, err error) *MockXDGPaths_ConfigDir_Call {
13500 _c.Call.Return(s, err)
13501 return _c
13502}
13503
13504func (_c *MockXDGPaths_ConfigDir_Call) RunAndReturn(run func() (string, error)) *MockXDGPaths_ConfigDir_Call {
13505 _c.Call.Return(run)
13506 return _c
13507}
13508
13509// DataDir provides a mock function for the type MockXDGPaths
13510func (_mock *MockXDGPaths) DataDir() (string, error) {
13511 ret := _mock.Called()
13512
13513 if len(ret) == 0 {
13514 panic("no return value specified for DataDir")
13515 }
13516
13517 var r0 string
13518 var r1 error
13519 if returnFunc, ok := ret.Get(0).(func() (string, error)); ok {
13520 return returnFunc()
13521 }
13522 if returnFunc, ok := ret.Get(0).(func() string); ok {
13523 r0 = returnFunc()
13524 } else {
13525 r0 = ret.Get(0).(string)
13526 }
13527 if returnFunc, ok := ret.Get(1).(func() error); ok {
13528 r1 = returnFunc()
13529 } else {
13530 r1 = ret.Error(1)
13531 }
13532 return r0, r1
13533}
13534
13535// MockXDGPaths_DataDir_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DataDir'
13536type MockXDGPaths_DataDir_Call struct {
13537 *mock.Call
13538}
13539
13540// DataDir is a helper method to define mock.On call
13541func (_e *MockXDGPaths_Expecter) DataDir() *MockXDGPaths_DataDir_Call {
13542 return &MockXDGPaths_DataDir_Call{Call: _e.mock.On("DataDir")}
13543}
13544
13545func (_c *MockXDGPaths_DataDir_Call) Run(run func()) *MockXDGPaths_DataDir_Call {
13546 _c.Call.Run(func(args mock.Arguments) {
13547 run()
13548 })
13549 return _c
13550}
13551
13552func (_c *MockXDGPaths_DataDir_Call) Return(s string, err error) *MockXDGPaths_DataDir_Call {
13553 _c.Call.Return(s, err)
13554 return _c
13555}
13556
13557func (_c *MockXDGPaths_DataDir_Call) RunAndReturn(run func() (string, error)) *MockXDGPaths_DataDir_Call {
13558 _c.Call.Return(run)
13559 return _c
13560}
13561
13562// DownloadDir provides a mock function for the type MockXDGPaths
13563func (_mock *MockXDGPaths) DownloadDir() (string, error) {
13564 ret := _mock.Called()
13565
13566 if len(ret) == 0 {
13567 panic("no return value specified for DownloadDir")
13568 }
13569
13570 var r0 string
13571 var r1 error
13572 if returnFunc, ok := ret.Get(0).(func() (string, error)); ok {
13573 return returnFunc()
13574 }
13575 if returnFunc, ok := ret.Get(0).(func() string); ok {
13576 r0 = returnFunc()
13577 } else {
13578 r0 = ret.Get(0).(string)
13579 }
13580 if returnFunc, ok := ret.Get(1).(func() error); ok {
13581 r1 = returnFunc()
13582 } else {
13583 r1 = ret.Error(1)
13584 }
13585 return r0, r1
13586}
13587
13588// MockXDGPaths_DownloadDir_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DownloadDir'
13589type MockXDGPaths_DownloadDir_Call struct {
13590 *mock.Call
13591}
13592
13593// DownloadDir is a helper method to define mock.On call
13594func (_e *MockXDGPaths_Expecter) DownloadDir() *MockXDGPaths_DownloadDir_Call {
13595 return &MockXDGPaths_DownloadDir_Call{Call: _e.mock.On("DownloadDir")}
13596}
13597
13598func (_c *MockXDGPaths_DownloadDir_Call) Run(run func()) *MockXDGPaths_DownloadDir_Call {
13599 _c.Call.Run(func(args mock.Arguments) {
13600 run()
13601 })
13602 return _c
13603}
13604
13605func (_c *MockXDGPaths_DownloadDir_Call) Return(s string, err error) *MockXDGPaths_DownloadDir_Call {
13606 _c.Call.Return(s, err)
13607 return _c
13608}
13609
13610func (_c *MockXDGPaths_DownloadDir_Call) RunAndReturn(run func() (string, error)) *MockXDGPaths_DownloadDir_Call {
13611 _c.Call.Return(run)
13612 return _c
13613}
13614
13615// FilterCacheDir provides a mock function for the type MockXDGPaths
13616func (_mock *MockXDGPaths) FilterCacheDir() (string, error) {
13617 ret := _mock.Called()
13618
13619 if len(ret) == 0 {
13620 panic("no return value specified for FilterCacheDir")
13621 }
13622
13623 var r0 string
13624 var r1 error
13625 if returnFunc, ok := ret.Get(0).(func() (string, error)); ok {
13626 return returnFunc()
13627 }
13628 if returnFunc, ok := ret.Get(0).(func() string); ok {
13629 r0 = returnFunc()
13630 } else {
13631 r0 = ret.Get(0).(string)
13632 }
13633 if returnFunc, ok := ret.Get(1).(func() error); ok {
13634 r1 = returnFunc()
13635 } else {
13636 r1 = ret.Error(1)
13637 }
13638 return r0, r1
13639}
13640
13641// MockXDGPaths_FilterCacheDir_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FilterCacheDir'
13642type MockXDGPaths_FilterCacheDir_Call struct {
13643 *mock.Call
13644}
13645
13646// FilterCacheDir is a helper method to define mock.On call
13647func (_e *MockXDGPaths_Expecter) FilterCacheDir() *MockXDGPaths_FilterCacheDir_Call {
13648 return &MockXDGPaths_FilterCacheDir_Call{Call: _e.mock.On("FilterCacheDir")}
13649}
13650
13651func (_c *MockXDGPaths_FilterCacheDir_Call) Run(run func()) *MockXDGPaths_FilterCacheDir_Call {
13652 _c.Call.Run(func(args mock.Arguments) {
13653 run()
13654 })
13655 return _c
13656}
13657
13658func (_c *MockXDGPaths_FilterCacheDir_Call) Return(s string, err error) *MockXDGPaths_FilterCacheDir_Call {
13659 _c.Call.Return(s, err)
13660 return _c
13661}
13662
13663func (_c *MockXDGPaths_FilterCacheDir_Call) RunAndReturn(run func() (string, error)) *MockXDGPaths_FilterCacheDir_Call {
13664 _c.Call.Return(run)
13665 return _c
13666}
13667
13668// FilterJSONDir provides a mock function for the type MockXDGPaths
13669func (_mock *MockXDGPaths) FilterJSONDir() (string, error) {
13670 ret := _mock.Called()
13671
13672 if len(ret) == 0 {
13673 panic("no return value specified for FilterJSONDir")
13674 }
13675
13676 var r0 string
13677 var r1 error
13678 if returnFunc, ok := ret.Get(0).(func() (string, error)); ok {
13679 return returnFunc()
13680 }
13681 if returnFunc, ok := ret.Get(0).(func() string); ok {
13682 r0 = returnFunc()
13683 } else {
13684 r0 = ret.Get(0).(string)
13685 }
13686 if returnFunc, ok := ret.Get(1).(func() error); ok {
13687 r1 = returnFunc()
13688 } else {
13689 r1 = ret.Error(1)
13690 }
13691 return r0, r1
13692}
13693
13694// MockXDGPaths_FilterJSONDir_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FilterJSONDir'
13695type MockXDGPaths_FilterJSONDir_Call struct {
13696 *mock.Call
13697}
13698
13699// FilterJSONDir is a helper method to define mock.On call
13700func (_e *MockXDGPaths_Expecter) FilterJSONDir() *MockXDGPaths_FilterJSONDir_Call {
13701 return &MockXDGPaths_FilterJSONDir_Call{Call: _e.mock.On("FilterJSONDir")}
13702}
13703
13704func (_c *MockXDGPaths_FilterJSONDir_Call) Run(run func()) *MockXDGPaths_FilterJSONDir_Call {
13705 _c.Call.Run(func(args mock.Arguments) {
13706 run()
13707 })
13708 return _c
13709}
13710
13711func (_c *MockXDGPaths_FilterJSONDir_Call) Return(s string, err error) *MockXDGPaths_FilterJSONDir_Call {
13712 _c.Call.Return(s, err)
13713 return _c
13714}
13715
13716func (_c *MockXDGPaths_FilterJSONDir_Call) RunAndReturn(run func() (string, error)) *MockXDGPaths_FilterJSONDir_Call {
13717 _c.Call.Return(run)
13718 return _c
13719}
13720
13721// FilterStoreDir provides a mock function for the type MockXDGPaths
13722func (_mock *MockXDGPaths) FilterStoreDir() (string, error) {
13723 ret := _mock.Called()
13724
13725 if len(ret) == 0 {
13726 panic("no return value specified for FilterStoreDir")
13727 }
13728
13729 var r0 string
13730 var r1 error
13731 if returnFunc, ok := ret.Get(0).(func() (string, error)); ok {
13732 return returnFunc()
13733 }
13734 if returnFunc, ok := ret.Get(0).(func() string); ok {
13735 r0 = returnFunc()
13736 } else {
13737 r0 = ret.Get(0).(string)
13738 }
13739 if returnFunc, ok := ret.Get(1).(func() error); ok {
13740 r1 = returnFunc()
13741 } else {
13742 r1 = ret.Error(1)
13743 }
13744 return r0, r1
13745}
13746
13747// MockXDGPaths_FilterStoreDir_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FilterStoreDir'
13748type MockXDGPaths_FilterStoreDir_Call struct {
13749 *mock.Call
13750}
13751
13752// FilterStoreDir is a helper method to define mock.On call
13753func (_e *MockXDGPaths_Expecter) FilterStoreDir() *MockXDGPaths_FilterStoreDir_Call {
13754 return &MockXDGPaths_FilterStoreDir_Call{Call: _e.mock.On("FilterStoreDir")}
13755}
13756
13757func (_c *MockXDGPaths_FilterStoreDir_Call) Run(run func()) *MockXDGPaths_FilterStoreDir_Call {
13758 _c.Call.Run(func(args mock.Arguments) {
13759 run()
13760 })
13761 return _c
13762}
13763
13764func (_c *MockXDGPaths_FilterStoreDir_Call) Return(s string, err error) *MockXDGPaths_FilterStoreDir_Call {
13765 _c.Call.Return(s, err)
13766 return _c
13767}
13768
13769func (_c *MockXDGPaths_FilterStoreDir_Call) RunAndReturn(run func() (string, error)) *MockXDGPaths_FilterStoreDir_Call {
13770 _c.Call.Return(run)
13771 return _c
13772}
13773
13774// ManDir provides a mock function for the type MockXDGPaths
13775func (_mock *MockXDGPaths) ManDir() (string, error) {
13776 ret := _mock.Called()
13777
13778 if len(ret) == 0 {
13779 panic("no return value specified for ManDir")
13780 }
13781
13782 var r0 string
13783 var r1 error
13784 if returnFunc, ok := ret.Get(0).(func() (string, error)); ok {
13785 return returnFunc()
13786 }
13787 if returnFunc, ok := ret.Get(0).(func() string); ok {
13788 r0 = returnFunc()
13789 } else {
13790 r0 = ret.Get(0).(string)
13791 }
13792 if returnFunc, ok := ret.Get(1).(func() error); ok {
13793 r1 = returnFunc()
13794 } else {
13795 r1 = ret.Error(1)
13796 }
13797 return r0, r1
13798}
13799
13800// MockXDGPaths_ManDir_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ManDir'
13801type MockXDGPaths_ManDir_Call struct {
13802 *mock.Call
13803}
13804
13805// ManDir is a helper method to define mock.On call
13806func (_e *MockXDGPaths_Expecter) ManDir() *MockXDGPaths_ManDir_Call {
13807 return &MockXDGPaths_ManDir_Call{Call: _e.mock.On("ManDir")}
13808}
13809
13810func (_c *MockXDGPaths_ManDir_Call) Run(run func()) *MockXDGPaths_ManDir_Call {
13811 _c.Call.Run(func(args mock.Arguments) {
13812 run()
13813 })
13814 return _c
13815}
13816
13817func (_c *MockXDGPaths_ManDir_Call) Return(s string, err error) *MockXDGPaths_ManDir_Call {
13818 _c.Call.Return(s, err)
13819 return _c
13820}
13821
13822func (_c *MockXDGPaths_ManDir_Call) RunAndReturn(run func() (string, error)) *MockXDGPaths_ManDir_Call {
13823 _c.Call.Return(run)
13824 return _c
13825}
13826
13827// StateDir provides a mock function for the type MockXDGPaths
13828func (_mock *MockXDGPaths) StateDir() (string, error) {
13829 ret := _mock.Called()
13830
13831 if len(ret) == 0 {
13832 panic("no return value specified for StateDir")
13833 }
13834
13835 var r0 string
13836 var r1 error
13837 if returnFunc, ok := ret.Get(0).(func() (string, error)); ok {
13838 return returnFunc()
13839 }
13840 if returnFunc, ok := ret.Get(0).(func() string); ok {
13841 r0 = returnFunc()
13842 } else {
13843 r0 = ret.Get(0).(string)
13844 }
13845 if returnFunc, ok := ret.Get(1).(func() error); ok {
13846 r1 = returnFunc()
13847 } else {
13848 r1 = ret.Error(1)
13849 }
13850 return r0, r1
13851}
13852
13853// MockXDGPaths_StateDir_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StateDir'
13854type MockXDGPaths_StateDir_Call struct {
13855 *mock.Call
13856}
13857
13858// StateDir is a helper method to define mock.On call
13859func (_e *MockXDGPaths_Expecter) StateDir() *MockXDGPaths_StateDir_Call {
13860 return &MockXDGPaths_StateDir_Call{Call: _e.mock.On("StateDir")}
13861}
13862
13863func (_c *MockXDGPaths_StateDir_Call) Run(run func()) *MockXDGPaths_StateDir_Call {
13864 _c.Call.Run(func(args mock.Arguments) {
13865 run()
13866 })
13867 return _c
13868}
13869
13870func (_c *MockXDGPaths_StateDir_Call) Return(s string, err error) *MockXDGPaths_StateDir_Call {
13871 _c.Call.Return(s, err)
13872 return _c
13873}
13874
13875func (_c *MockXDGPaths_StateDir_Call) RunAndReturn(run func() (string, error)) *MockXDGPaths_StateDir_Call {
13876 _c.Call.Return(run)
13877 return _c
13878}