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
11 "github.com/bnema/dumber/internal/application/port"
12 "github.com/bnema/dumber/internal/domain/entity"
13 "github.com/rs/zerolog"
14 mock "github.com/stretchr/testify/mock"
15)
16
17// 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.
18// The first argument is typically a *testing.T value.
19func NewMockAccentPickerUI(t interface {
20 mock.TestingT
21 Cleanup(func())
22}) *MockAccentPickerUI {
23 mock := &MockAccentPickerUI{}
24 mock.Mock.Test(t)
25
26 t.Cleanup(func() { mock.AssertExpectations(t) })
27
28 return mock
29}
30
31// MockAccentPickerUI is an autogenerated mock type for the AccentPickerUI type
32type MockAccentPickerUI struct {
33 mock.Mock
34}
35
36type MockAccentPickerUI_Expecter struct {
37 mock *mock.Mock
38}
39
40func (_m *MockAccentPickerUI) EXPECT() *MockAccentPickerUI_Expecter {
41 return &MockAccentPickerUI_Expecter{mock: &_m.Mock}
42}
43
44// Hide provides a mock function for the type MockAccentPickerUI
45func (_mock *MockAccentPickerUI) Hide() {
46 _mock.Called()
47 return
48}
49
50// MockAccentPickerUI_Hide_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Hide'
51type MockAccentPickerUI_Hide_Call struct {
52 *mock.Call
53}
54
55// Hide is a helper method to define mock.On call
56func (_e *MockAccentPickerUI_Expecter) Hide() *MockAccentPickerUI_Hide_Call {
57 return &MockAccentPickerUI_Hide_Call{Call: _e.mock.On("Hide")}
58}
59
60func (_c *MockAccentPickerUI_Hide_Call) Run(run func()) *MockAccentPickerUI_Hide_Call {
61 _c.Call.Run(func(args mock.Arguments) {
62 run()
63 })
64 return _c
65}
66
67func (_c *MockAccentPickerUI_Hide_Call) Return() *MockAccentPickerUI_Hide_Call {
68 _c.Call.Return()
69 return _c
70}
71
72func (_c *MockAccentPickerUI_Hide_Call) RunAndReturn(run func()) *MockAccentPickerUI_Hide_Call {
73 _c.Run(run)
74 return _c
75}
76
77// IsVisible provides a mock function for the type MockAccentPickerUI
78func (_mock *MockAccentPickerUI) IsVisible() bool {
79 ret := _mock.Called()
80
81 if len(ret) == 0 {
82 panic("no return value specified for IsVisible")
83 }
84
85 var r0 bool
86 if returnFunc, ok := ret.Get(0).(func() bool); ok {
87 r0 = returnFunc()
88 } else {
89 r0 = ret.Get(0).(bool)
90 }
91 return r0
92}
93
94// MockAccentPickerUI_IsVisible_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsVisible'
95type MockAccentPickerUI_IsVisible_Call struct {
96 *mock.Call
97}
98
99// IsVisible is a helper method to define mock.On call
100func (_e *MockAccentPickerUI_Expecter) IsVisible() *MockAccentPickerUI_IsVisible_Call {
101 return &MockAccentPickerUI_IsVisible_Call{Call: _e.mock.On("IsVisible")}
102}
103
104func (_c *MockAccentPickerUI_IsVisible_Call) Run(run func()) *MockAccentPickerUI_IsVisible_Call {
105 _c.Call.Run(func(args mock.Arguments) {
106 run()
107 })
108 return _c
109}
110
111func (_c *MockAccentPickerUI_IsVisible_Call) Return(b bool) *MockAccentPickerUI_IsVisible_Call {
112 _c.Call.Return(b)
113 return _c
114}
115
116func (_c *MockAccentPickerUI_IsVisible_Call) RunAndReturn(run func() bool) *MockAccentPickerUI_IsVisible_Call {
117 _c.Call.Return(run)
118 return _c
119}
120
121// Show provides a mock function for the type MockAccentPickerUI
122func (_mock *MockAccentPickerUI) Show(accents []rune, selectedCallback func(accent rune), cancelCallback func()) {
123 _mock.Called(accents, selectedCallback, cancelCallback)
124 return
125}
126
127// MockAccentPickerUI_Show_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Show'
128type MockAccentPickerUI_Show_Call struct {
129 *mock.Call
130}
131
132// Show is a helper method to define mock.On call
133// - accents []rune
134// - selectedCallback func(accent rune)
135// - cancelCallback func()
136func (_e *MockAccentPickerUI_Expecter) Show(accents interface{}, selectedCallback interface{}, cancelCallback interface{}) *MockAccentPickerUI_Show_Call {
137 return &MockAccentPickerUI_Show_Call{Call: _e.mock.On("Show", accents, selectedCallback, cancelCallback)}
138}
139
140func (_c *MockAccentPickerUI_Show_Call) Run(run func(accents []rune, selectedCallback func(accent rune), cancelCallback func())) *MockAccentPickerUI_Show_Call {
141 _c.Call.Run(func(args mock.Arguments) {
142 var arg0 []rune
143 if args[0] != nil {
144 arg0 = args[0].([]rune)
145 }
146 var arg1 func(accent rune)
147 if args[1] != nil {
148 arg1 = args[1].(func(accent rune))
149 }
150 var arg2 func()
151 if args[2] != nil {
152 arg2 = args[2].(func())
153 }
154 run(
155 arg0,
156 arg1,
157 arg2,
158 )
159 })
160 return _c
161}
162
163func (_c *MockAccentPickerUI_Show_Call) Return() *MockAccentPickerUI_Show_Call {
164 _c.Call.Return()
165 return _c
166}
167
168func (_c *MockAccentPickerUI_Show_Call) RunAndReturn(run func(accents []rune, selectedCallback func(accent rune), cancelCallback func())) *MockAccentPickerUI_Show_Call {
169 _c.Run(run)
170 return _c
171}
172
173// 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.
174// The first argument is typically a *testing.T value.
175func NewMockColorSchemeDetector(t interface {
176 mock.TestingT
177 Cleanup(func())
178}) *MockColorSchemeDetector {
179 mock := &MockColorSchemeDetector{}
180 mock.Mock.Test(t)
181
182 t.Cleanup(func() { mock.AssertExpectations(t) })
183
184 return mock
185}
186
187// MockColorSchemeDetector is an autogenerated mock type for the ColorSchemeDetector type
188type MockColorSchemeDetector struct {
189 mock.Mock
190}
191
192type MockColorSchemeDetector_Expecter struct {
193 mock *mock.Mock
194}
195
196func (_m *MockColorSchemeDetector) EXPECT() *MockColorSchemeDetector_Expecter {
197 return &MockColorSchemeDetector_Expecter{mock: &_m.Mock}
198}
199
200// Available provides a mock function for the type MockColorSchemeDetector
201func (_mock *MockColorSchemeDetector) Available() bool {
202 ret := _mock.Called()
203
204 if len(ret) == 0 {
205 panic("no return value specified for Available")
206 }
207
208 var r0 bool
209 if returnFunc, ok := ret.Get(0).(func() bool); ok {
210 r0 = returnFunc()
211 } else {
212 r0 = ret.Get(0).(bool)
213 }
214 return r0
215}
216
217// MockColorSchemeDetector_Available_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Available'
218type MockColorSchemeDetector_Available_Call struct {
219 *mock.Call
220}
221
222// Available is a helper method to define mock.On call
223func (_e *MockColorSchemeDetector_Expecter) Available() *MockColorSchemeDetector_Available_Call {
224 return &MockColorSchemeDetector_Available_Call{Call: _e.mock.On("Available")}
225}
226
227func (_c *MockColorSchemeDetector_Available_Call) Run(run func()) *MockColorSchemeDetector_Available_Call {
228 _c.Call.Run(func(args mock.Arguments) {
229 run()
230 })
231 return _c
232}
233
234func (_c *MockColorSchemeDetector_Available_Call) Return(b bool) *MockColorSchemeDetector_Available_Call {
235 _c.Call.Return(b)
236 return _c
237}
238
239func (_c *MockColorSchemeDetector_Available_Call) RunAndReturn(run func() bool) *MockColorSchemeDetector_Available_Call {
240 _c.Call.Return(run)
241 return _c
242}
243
244// Detect provides a mock function for the type MockColorSchemeDetector
245func (_mock *MockColorSchemeDetector) Detect() (bool, bool) {
246 ret := _mock.Called()
247
248 if len(ret) == 0 {
249 panic("no return value specified for Detect")
250 }
251
252 var r0 bool
253 var r1 bool
254 if returnFunc, ok := ret.Get(0).(func() (bool, bool)); ok {
255 return returnFunc()
256 }
257 if returnFunc, ok := ret.Get(0).(func() bool); ok {
258 r0 = returnFunc()
259 } else {
260 r0 = ret.Get(0).(bool)
261 }
262 if returnFunc, ok := ret.Get(1).(func() bool); ok {
263 r1 = returnFunc()
264 } else {
265 r1 = ret.Get(1).(bool)
266 }
267 return r0, r1
268}
269
270// MockColorSchemeDetector_Detect_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Detect'
271type MockColorSchemeDetector_Detect_Call struct {
272 *mock.Call
273}
274
275// Detect is a helper method to define mock.On call
276func (_e *MockColorSchemeDetector_Expecter) Detect() *MockColorSchemeDetector_Detect_Call {
277 return &MockColorSchemeDetector_Detect_Call{Call: _e.mock.On("Detect")}
278}
279
280func (_c *MockColorSchemeDetector_Detect_Call) Run(run func()) *MockColorSchemeDetector_Detect_Call {
281 _c.Call.Run(func(args mock.Arguments) {
282 run()
283 })
284 return _c
285}
286
287func (_c *MockColorSchemeDetector_Detect_Call) Return(prefersDark bool, ok bool) *MockColorSchemeDetector_Detect_Call {
288 _c.Call.Return(prefersDark, ok)
289 return _c
290}
291
292func (_c *MockColorSchemeDetector_Detect_Call) RunAndReturn(run func() (bool, bool)) *MockColorSchemeDetector_Detect_Call {
293 _c.Call.Return(run)
294 return _c
295}
296
297// Name provides a mock function for the type MockColorSchemeDetector
298func (_mock *MockColorSchemeDetector) Name() string {
299 ret := _mock.Called()
300
301 if len(ret) == 0 {
302 panic("no return value specified for Name")
303 }
304
305 var r0 string
306 if returnFunc, ok := ret.Get(0).(func() string); ok {
307 r0 = returnFunc()
308 } else {
309 r0 = ret.Get(0).(string)
310 }
311 return r0
312}
313
314// MockColorSchemeDetector_Name_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Name'
315type MockColorSchemeDetector_Name_Call struct {
316 *mock.Call
317}
318
319// Name is a helper method to define mock.On call
320func (_e *MockColorSchemeDetector_Expecter) Name() *MockColorSchemeDetector_Name_Call {
321 return &MockColorSchemeDetector_Name_Call{Call: _e.mock.On("Name")}
322}
323
324func (_c *MockColorSchemeDetector_Name_Call) Run(run func()) *MockColorSchemeDetector_Name_Call {
325 _c.Call.Run(func(args mock.Arguments) {
326 run()
327 })
328 return _c
329}
330
331func (_c *MockColorSchemeDetector_Name_Call) Return(s string) *MockColorSchemeDetector_Name_Call {
332 _c.Call.Return(s)
333 return _c
334}
335
336func (_c *MockColorSchemeDetector_Name_Call) RunAndReturn(run func() string) *MockColorSchemeDetector_Name_Call {
337 _c.Call.Return(run)
338 return _c
339}
340
341// Priority provides a mock function for the type MockColorSchemeDetector
342func (_mock *MockColorSchemeDetector) Priority() int {
343 ret := _mock.Called()
344
345 if len(ret) == 0 {
346 panic("no return value specified for Priority")
347 }
348
349 var r0 int
350 if returnFunc, ok := ret.Get(0).(func() int); ok {
351 r0 = returnFunc()
352 } else {
353 r0 = ret.Get(0).(int)
354 }
355 return r0
356}
357
358// MockColorSchemeDetector_Priority_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Priority'
359type MockColorSchemeDetector_Priority_Call struct {
360 *mock.Call
361}
362
363// Priority is a helper method to define mock.On call
364func (_e *MockColorSchemeDetector_Expecter) Priority() *MockColorSchemeDetector_Priority_Call {
365 return &MockColorSchemeDetector_Priority_Call{Call: _e.mock.On("Priority")}
366}
367
368func (_c *MockColorSchemeDetector_Priority_Call) Run(run func()) *MockColorSchemeDetector_Priority_Call {
369 _c.Call.Run(func(args mock.Arguments) {
370 run()
371 })
372 return _c
373}
374
375func (_c *MockColorSchemeDetector_Priority_Call) Return(n int) *MockColorSchemeDetector_Priority_Call {
376 _c.Call.Return(n)
377 return _c
378}
379
380func (_c *MockColorSchemeDetector_Priority_Call) RunAndReturn(run func() int) *MockColorSchemeDetector_Priority_Call {
381 _c.Call.Return(run)
382 return _c
383}
384
385// 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.
386// The first argument is typically a *testing.T value.
387func NewMockColorSchemeResolver(t interface {
388 mock.TestingT
389 Cleanup(func())
390}) *MockColorSchemeResolver {
391 mock := &MockColorSchemeResolver{}
392 mock.Mock.Test(t)
393
394 t.Cleanup(func() { mock.AssertExpectations(t) })
395
396 return mock
397}
398
399// MockColorSchemeResolver is an autogenerated mock type for the ColorSchemeResolver type
400type MockColorSchemeResolver struct {
401 mock.Mock
402}
403
404type MockColorSchemeResolver_Expecter struct {
405 mock *mock.Mock
406}
407
408func (_m *MockColorSchemeResolver) EXPECT() *MockColorSchemeResolver_Expecter {
409 return &MockColorSchemeResolver_Expecter{mock: &_m.Mock}
410}
411
412// OnChange provides a mock function for the type MockColorSchemeResolver
413func (_mock *MockColorSchemeResolver) OnChange(callback func(port.ColorSchemePreference)) func() {
414 ret := _mock.Called(callback)
415
416 if len(ret) == 0 {
417 panic("no return value specified for OnChange")
418 }
419
420 var r0 func()
421 if returnFunc, ok := ret.Get(0).(func(func(port.ColorSchemePreference)) func()); ok {
422 r0 = returnFunc(callback)
423 } else {
424 if ret.Get(0) != nil {
425 r0 = ret.Get(0).(func())
426 }
427 }
428 return r0
429}
430
431// MockColorSchemeResolver_OnChange_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OnChange'
432type MockColorSchemeResolver_OnChange_Call struct {
433 *mock.Call
434}
435
436// OnChange is a helper method to define mock.On call
437// - callback func(port.ColorSchemePreference)
438func (_e *MockColorSchemeResolver_Expecter) OnChange(callback interface{}) *MockColorSchemeResolver_OnChange_Call {
439 return &MockColorSchemeResolver_OnChange_Call{Call: _e.mock.On("OnChange", callback)}
440}
441
442func (_c *MockColorSchemeResolver_OnChange_Call) Run(run func(callback func(port.ColorSchemePreference))) *MockColorSchemeResolver_OnChange_Call {
443 _c.Call.Run(func(args mock.Arguments) {
444 var arg0 func(port.ColorSchemePreference)
445 if args[0] != nil {
446 arg0 = args[0].(func(port.ColorSchemePreference))
447 }
448 run(
449 arg0,
450 )
451 })
452 return _c
453}
454
455func (_c *MockColorSchemeResolver_OnChange_Call) Return(fn func()) *MockColorSchemeResolver_OnChange_Call {
456 _c.Call.Return(fn)
457 return _c
458}
459
460func (_c *MockColorSchemeResolver_OnChange_Call) RunAndReturn(run func(callback func(port.ColorSchemePreference)) func()) *MockColorSchemeResolver_OnChange_Call {
461 _c.Call.Return(run)
462 return _c
463}
464
465// Refresh provides a mock function for the type MockColorSchemeResolver
466func (_mock *MockColorSchemeResolver) Refresh() port.ColorSchemePreference {
467 ret := _mock.Called()
468
469 if len(ret) == 0 {
470 panic("no return value specified for Refresh")
471 }
472
473 var r0 port.ColorSchemePreference
474 if returnFunc, ok := ret.Get(0).(func() port.ColorSchemePreference); ok {
475 r0 = returnFunc()
476 } else {
477 r0 = ret.Get(0).(port.ColorSchemePreference)
478 }
479 return r0
480}
481
482// MockColorSchemeResolver_Refresh_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Refresh'
483type MockColorSchemeResolver_Refresh_Call struct {
484 *mock.Call
485}
486
487// Refresh is a helper method to define mock.On call
488func (_e *MockColorSchemeResolver_Expecter) Refresh() *MockColorSchemeResolver_Refresh_Call {
489 return &MockColorSchemeResolver_Refresh_Call{Call: _e.mock.On("Refresh")}
490}
491
492func (_c *MockColorSchemeResolver_Refresh_Call) Run(run func()) *MockColorSchemeResolver_Refresh_Call {
493 _c.Call.Run(func(args mock.Arguments) {
494 run()
495 })
496 return _c
497}
498
499func (_c *MockColorSchemeResolver_Refresh_Call) Return(colorSchemePreference port.ColorSchemePreference) *MockColorSchemeResolver_Refresh_Call {
500 _c.Call.Return(colorSchemePreference)
501 return _c
502}
503
504func (_c *MockColorSchemeResolver_Refresh_Call) RunAndReturn(run func() port.ColorSchemePreference) *MockColorSchemeResolver_Refresh_Call {
505 _c.Call.Return(run)
506 return _c
507}
508
509// RegisterDetector provides a mock function for the type MockColorSchemeResolver
510func (_mock *MockColorSchemeResolver) RegisterDetector(detector port.ColorSchemeDetector) {
511 _mock.Called(detector)
512 return
513}
514
515// MockColorSchemeResolver_RegisterDetector_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterDetector'
516type MockColorSchemeResolver_RegisterDetector_Call struct {
517 *mock.Call
518}
519
520// RegisterDetector is a helper method to define mock.On call
521// - detector port.ColorSchemeDetector
522func (_e *MockColorSchemeResolver_Expecter) RegisterDetector(detector interface{}) *MockColorSchemeResolver_RegisterDetector_Call {
523 return &MockColorSchemeResolver_RegisterDetector_Call{Call: _e.mock.On("RegisterDetector", detector)}
524}
525
526func (_c *MockColorSchemeResolver_RegisterDetector_Call) Run(run func(detector port.ColorSchemeDetector)) *MockColorSchemeResolver_RegisterDetector_Call {
527 _c.Call.Run(func(args mock.Arguments) {
528 var arg0 port.ColorSchemeDetector
529 if args[0] != nil {
530 arg0 = args[0].(port.ColorSchemeDetector)
531 }
532 run(
533 arg0,
534 )
535 })
536 return _c
537}
538
539func (_c *MockColorSchemeResolver_RegisterDetector_Call) Return() *MockColorSchemeResolver_RegisterDetector_Call {
540 _c.Call.Return()
541 return _c
542}
543
544func (_c *MockColorSchemeResolver_RegisterDetector_Call) RunAndReturn(run func(detector port.ColorSchemeDetector)) *MockColorSchemeResolver_RegisterDetector_Call {
545 _c.Run(run)
546 return _c
547}
548
549// Resolve provides a mock function for the type MockColorSchemeResolver
550func (_mock *MockColorSchemeResolver) Resolve() port.ColorSchemePreference {
551 ret := _mock.Called()
552
553 if len(ret) == 0 {
554 panic("no return value specified for Resolve")
555 }
556
557 var r0 port.ColorSchemePreference
558 if returnFunc, ok := ret.Get(0).(func() port.ColorSchemePreference); ok {
559 r0 = returnFunc()
560 } else {
561 r0 = ret.Get(0).(port.ColorSchemePreference)
562 }
563 return r0
564}
565
566// MockColorSchemeResolver_Resolve_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Resolve'
567type MockColorSchemeResolver_Resolve_Call struct {
568 *mock.Call
569}
570
571// Resolve is a helper method to define mock.On call
572func (_e *MockColorSchemeResolver_Expecter) Resolve() *MockColorSchemeResolver_Resolve_Call {
573 return &MockColorSchemeResolver_Resolve_Call{Call: _e.mock.On("Resolve")}
574}
575
576func (_c *MockColorSchemeResolver_Resolve_Call) Run(run func()) *MockColorSchemeResolver_Resolve_Call {
577 _c.Call.Run(func(args mock.Arguments) {
578 run()
579 })
580 return _c
581}
582
583func (_c *MockColorSchemeResolver_Resolve_Call) Return(colorSchemePreference port.ColorSchemePreference) *MockColorSchemeResolver_Resolve_Call {
584 _c.Call.Return(colorSchemePreference)
585 return _c
586}
587
588func (_c *MockColorSchemeResolver_Resolve_Call) RunAndReturn(run func() port.ColorSchemePreference) *MockColorSchemeResolver_Resolve_Call {
589 _c.Call.Return(run)
590 return _c
591}
592
593// 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.
594// The first argument is typically a *testing.T value.
595func NewMockConfigMigrator(t interface {
596 mock.TestingT
597 Cleanup(func())
598}) *MockConfigMigrator {
599 mock := &MockConfigMigrator{}
600 mock.Mock.Test(t)
601
602 t.Cleanup(func() { mock.AssertExpectations(t) })
603
604 return mock
605}
606
607// MockConfigMigrator is an autogenerated mock type for the ConfigMigrator type
608type MockConfigMigrator struct {
609 mock.Mock
610}
611
612type MockConfigMigrator_Expecter struct {
613 mock *mock.Mock
614}
615
616func (_m *MockConfigMigrator) EXPECT() *MockConfigMigrator_Expecter {
617 return &MockConfigMigrator_Expecter{mock: &_m.Mock}
618}
619
620// CheckMigration provides a mock function for the type MockConfigMigrator
621func (_mock *MockConfigMigrator) CheckMigration() (*port.MigrationResult, error) {
622 ret := _mock.Called()
623
624 if len(ret) == 0 {
625 panic("no return value specified for CheckMigration")
626 }
627
628 var r0 *port.MigrationResult
629 var r1 error
630 if returnFunc, ok := ret.Get(0).(func() (*port.MigrationResult, error)); ok {
631 return returnFunc()
632 }
633 if returnFunc, ok := ret.Get(0).(func() *port.MigrationResult); ok {
634 r0 = returnFunc()
635 } else {
636 if ret.Get(0) != nil {
637 r0 = ret.Get(0).(*port.MigrationResult)
638 }
639 }
640 if returnFunc, ok := ret.Get(1).(func() error); ok {
641 r1 = returnFunc()
642 } else {
643 r1 = ret.Error(1)
644 }
645 return r0, r1
646}
647
648// MockConfigMigrator_CheckMigration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CheckMigration'
649type MockConfigMigrator_CheckMigration_Call struct {
650 *mock.Call
651}
652
653// CheckMigration is a helper method to define mock.On call
654func (_e *MockConfigMigrator_Expecter) CheckMigration() *MockConfigMigrator_CheckMigration_Call {
655 return &MockConfigMigrator_CheckMigration_Call{Call: _e.mock.On("CheckMigration")}
656}
657
658func (_c *MockConfigMigrator_CheckMigration_Call) Run(run func()) *MockConfigMigrator_CheckMigration_Call {
659 _c.Call.Run(func(args mock.Arguments) {
660 run()
661 })
662 return _c
663}
664
665func (_c *MockConfigMigrator_CheckMigration_Call) Return(migrationResult *port.MigrationResult, err error) *MockConfigMigrator_CheckMigration_Call {
666 _c.Call.Return(migrationResult, err)
667 return _c
668}
669
670func (_c *MockConfigMigrator_CheckMigration_Call) RunAndReturn(run func() (*port.MigrationResult, error)) *MockConfigMigrator_CheckMigration_Call {
671 _c.Call.Return(run)
672 return _c
673}
674
675// DetectChanges provides a mock function for the type MockConfigMigrator
676func (_mock *MockConfigMigrator) DetectChanges() ([]port.KeyChange, error) {
677 ret := _mock.Called()
678
679 if len(ret) == 0 {
680 panic("no return value specified for DetectChanges")
681 }
682
683 var r0 []port.KeyChange
684 var r1 error
685 if returnFunc, ok := ret.Get(0).(func() ([]port.KeyChange, error)); ok {
686 return returnFunc()
687 }
688 if returnFunc, ok := ret.Get(0).(func() []port.KeyChange); ok {
689 r0 = returnFunc()
690 } else {
691 if ret.Get(0) != nil {
692 r0 = ret.Get(0).([]port.KeyChange)
693 }
694 }
695 if returnFunc, ok := ret.Get(1).(func() error); ok {
696 r1 = returnFunc()
697 } else {
698 r1 = ret.Error(1)
699 }
700 return r0, r1
701}
702
703// MockConfigMigrator_DetectChanges_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DetectChanges'
704type MockConfigMigrator_DetectChanges_Call struct {
705 *mock.Call
706}
707
708// DetectChanges is a helper method to define mock.On call
709func (_e *MockConfigMigrator_Expecter) DetectChanges() *MockConfigMigrator_DetectChanges_Call {
710 return &MockConfigMigrator_DetectChanges_Call{Call: _e.mock.On("DetectChanges")}
711}
712
713func (_c *MockConfigMigrator_DetectChanges_Call) Run(run func()) *MockConfigMigrator_DetectChanges_Call {
714 _c.Call.Run(func(args mock.Arguments) {
715 run()
716 })
717 return _c
718}
719
720func (_c *MockConfigMigrator_DetectChanges_Call) Return(keyChanges []port.KeyChange, err error) *MockConfigMigrator_DetectChanges_Call {
721 _c.Call.Return(keyChanges, err)
722 return _c
723}
724
725func (_c *MockConfigMigrator_DetectChanges_Call) RunAndReturn(run func() ([]port.KeyChange, error)) *MockConfigMigrator_DetectChanges_Call {
726 _c.Call.Return(run)
727 return _c
728}
729
730// GetConfigFile provides a mock function for the type MockConfigMigrator
731func (_mock *MockConfigMigrator) GetConfigFile() (string, error) {
732 ret := _mock.Called()
733
734 if len(ret) == 0 {
735 panic("no return value specified for GetConfigFile")
736 }
737
738 var r0 string
739 var r1 error
740 if returnFunc, ok := ret.Get(0).(func() (string, error)); ok {
741 return returnFunc()
742 }
743 if returnFunc, ok := ret.Get(0).(func() string); ok {
744 r0 = returnFunc()
745 } else {
746 r0 = ret.Get(0).(string)
747 }
748 if returnFunc, ok := ret.Get(1).(func() error); ok {
749 r1 = returnFunc()
750 } else {
751 r1 = ret.Error(1)
752 }
753 return r0, r1
754}
755
756// MockConfigMigrator_GetConfigFile_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetConfigFile'
757type MockConfigMigrator_GetConfigFile_Call struct {
758 *mock.Call
759}
760
761// GetConfigFile is a helper method to define mock.On call
762func (_e *MockConfigMigrator_Expecter) GetConfigFile() *MockConfigMigrator_GetConfigFile_Call {
763 return &MockConfigMigrator_GetConfigFile_Call{Call: _e.mock.On("GetConfigFile")}
764}
765
766func (_c *MockConfigMigrator_GetConfigFile_Call) Run(run func()) *MockConfigMigrator_GetConfigFile_Call {
767 _c.Call.Run(func(args mock.Arguments) {
768 run()
769 })
770 return _c
771}
772
773func (_c *MockConfigMigrator_GetConfigFile_Call) Return(s string, err error) *MockConfigMigrator_GetConfigFile_Call {
774 _c.Call.Return(s, err)
775 return _c
776}
777
778func (_c *MockConfigMigrator_GetConfigFile_Call) RunAndReturn(run func() (string, error)) *MockConfigMigrator_GetConfigFile_Call {
779 _c.Call.Return(run)
780 return _c
781}
782
783// GetKeyInfo provides a mock function for the type MockConfigMigrator
784func (_mock *MockConfigMigrator) GetKeyInfo(key string) port.KeyInfo {
785 ret := _mock.Called(key)
786
787 if len(ret) == 0 {
788 panic("no return value specified for GetKeyInfo")
789 }
790
791 var r0 port.KeyInfo
792 if returnFunc, ok := ret.Get(0).(func(string) port.KeyInfo); ok {
793 r0 = returnFunc(key)
794 } else {
795 r0 = ret.Get(0).(port.KeyInfo)
796 }
797 return r0
798}
799
800// MockConfigMigrator_GetKeyInfo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetKeyInfo'
801type MockConfigMigrator_GetKeyInfo_Call struct {
802 *mock.Call
803}
804
805// GetKeyInfo is a helper method to define mock.On call
806// - key string
807func (_e *MockConfigMigrator_Expecter) GetKeyInfo(key interface{}) *MockConfigMigrator_GetKeyInfo_Call {
808 return &MockConfigMigrator_GetKeyInfo_Call{Call: _e.mock.On("GetKeyInfo", key)}
809}
810
811func (_c *MockConfigMigrator_GetKeyInfo_Call) Run(run func(key string)) *MockConfigMigrator_GetKeyInfo_Call {
812 _c.Call.Run(func(args mock.Arguments) {
813 var arg0 string
814 if args[0] != nil {
815 arg0 = args[0].(string)
816 }
817 run(
818 arg0,
819 )
820 })
821 return _c
822}
823
824func (_c *MockConfigMigrator_GetKeyInfo_Call) Return(keyInfo port.KeyInfo) *MockConfigMigrator_GetKeyInfo_Call {
825 _c.Call.Return(keyInfo)
826 return _c
827}
828
829func (_c *MockConfigMigrator_GetKeyInfo_Call) RunAndReturn(run func(key string) port.KeyInfo) *MockConfigMigrator_GetKeyInfo_Call {
830 _c.Call.Return(run)
831 return _c
832}
833
834// Migrate provides a mock function for the type MockConfigMigrator
835func (_mock *MockConfigMigrator) Migrate() ([]string, error) {
836 ret := _mock.Called()
837
838 if len(ret) == 0 {
839 panic("no return value specified for Migrate")
840 }
841
842 var r0 []string
843 var r1 error
844 if returnFunc, ok := ret.Get(0).(func() ([]string, error)); ok {
845 return returnFunc()
846 }
847 if returnFunc, ok := ret.Get(0).(func() []string); ok {
848 r0 = returnFunc()
849 } else {
850 if ret.Get(0) != nil {
851 r0 = ret.Get(0).([]string)
852 }
853 }
854 if returnFunc, ok := ret.Get(1).(func() error); ok {
855 r1 = returnFunc()
856 } else {
857 r1 = ret.Error(1)
858 }
859 return r0, r1
860}
861
862// MockConfigMigrator_Migrate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Migrate'
863type MockConfigMigrator_Migrate_Call struct {
864 *mock.Call
865}
866
867// Migrate is a helper method to define mock.On call
868func (_e *MockConfigMigrator_Expecter) Migrate() *MockConfigMigrator_Migrate_Call {
869 return &MockConfigMigrator_Migrate_Call{Call: _e.mock.On("Migrate")}
870}
871
872func (_c *MockConfigMigrator_Migrate_Call) Run(run func()) *MockConfigMigrator_Migrate_Call {
873 _c.Call.Run(func(args mock.Arguments) {
874 run()
875 })
876 return _c
877}
878
879func (_c *MockConfigMigrator_Migrate_Call) Return(strings []string, err error) *MockConfigMigrator_Migrate_Call {
880 _c.Call.Return(strings, err)
881 return _c
882}
883
884func (_c *MockConfigMigrator_Migrate_Call) RunAndReturn(run func() ([]string, error)) *MockConfigMigrator_Migrate_Call {
885 _c.Call.Return(run)
886 return _c
887}
888
889// 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.
890// The first argument is typically a *testing.T value.
891func NewMockDiffFormatter(t interface {
892 mock.TestingT
893 Cleanup(func())
894}) *MockDiffFormatter {
895 mock := &MockDiffFormatter{}
896 mock.Mock.Test(t)
897
898 t.Cleanup(func() { mock.AssertExpectations(t) })
899
900 return mock
901}
902
903// MockDiffFormatter is an autogenerated mock type for the DiffFormatter type
904type MockDiffFormatter struct {
905 mock.Mock
906}
907
908type MockDiffFormatter_Expecter struct {
909 mock *mock.Mock
910}
911
912func (_m *MockDiffFormatter) EXPECT() *MockDiffFormatter_Expecter {
913 return &MockDiffFormatter_Expecter{mock: &_m.Mock}
914}
915
916// FormatChangesAsDiff provides a mock function for the type MockDiffFormatter
917func (_mock *MockDiffFormatter) FormatChangesAsDiff(changes []port.KeyChange) string {
918 ret := _mock.Called(changes)
919
920 if len(ret) == 0 {
921 panic("no return value specified for FormatChangesAsDiff")
922 }
923
924 var r0 string
925 if returnFunc, ok := ret.Get(0).(func([]port.KeyChange) string); ok {
926 r0 = returnFunc(changes)
927 } else {
928 r0 = ret.Get(0).(string)
929 }
930 return r0
931}
932
933// MockDiffFormatter_FormatChangesAsDiff_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FormatChangesAsDiff'
934type MockDiffFormatter_FormatChangesAsDiff_Call struct {
935 *mock.Call
936}
937
938// FormatChangesAsDiff is a helper method to define mock.On call
939// - changes []port.KeyChange
940func (_e *MockDiffFormatter_Expecter) FormatChangesAsDiff(changes interface{}) *MockDiffFormatter_FormatChangesAsDiff_Call {
941 return &MockDiffFormatter_FormatChangesAsDiff_Call{Call: _e.mock.On("FormatChangesAsDiff", changes)}
942}
943
944func (_c *MockDiffFormatter_FormatChangesAsDiff_Call) Run(run func(changes []port.KeyChange)) *MockDiffFormatter_FormatChangesAsDiff_Call {
945 _c.Call.Run(func(args mock.Arguments) {
946 var arg0 []port.KeyChange
947 if args[0] != nil {
948 arg0 = args[0].([]port.KeyChange)
949 }
950 run(
951 arg0,
952 )
953 })
954 return _c
955}
956
957func (_c *MockDiffFormatter_FormatChangesAsDiff_Call) Return(s string) *MockDiffFormatter_FormatChangesAsDiff_Call {
958 _c.Call.Return(s)
959 return _c
960}
961
962func (_c *MockDiffFormatter_FormatChangesAsDiff_Call) RunAndReturn(run func(changes []port.KeyChange) string) *MockDiffFormatter_FormatChangesAsDiff_Call {
963 _c.Call.Return(run)
964 return _c
965}
966
967// 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.
968// The first argument is typically a *testing.T value.
969func NewMockConfigSchemaProvider(t interface {
970 mock.TestingT
971 Cleanup(func())
972}) *MockConfigSchemaProvider {
973 mock := &MockConfigSchemaProvider{}
974 mock.Mock.Test(t)
975
976 t.Cleanup(func() { mock.AssertExpectations(t) })
977
978 return mock
979}
980
981// MockConfigSchemaProvider is an autogenerated mock type for the ConfigSchemaProvider type
982type MockConfigSchemaProvider struct {
983 mock.Mock
984}
985
986type MockConfigSchemaProvider_Expecter struct {
987 mock *mock.Mock
988}
989
990func (_m *MockConfigSchemaProvider) EXPECT() *MockConfigSchemaProvider_Expecter {
991 return &MockConfigSchemaProvider_Expecter{mock: &_m.Mock}
992}
993
994// GetSchema provides a mock function for the type MockConfigSchemaProvider
995func (_mock *MockConfigSchemaProvider) GetSchema() []entity.ConfigKeyInfo {
996 ret := _mock.Called()
997
998 if len(ret) == 0 {
999 panic("no return value specified for GetSchema")
1000 }
1001
1002 var r0 []entity.ConfigKeyInfo
1003 if returnFunc, ok := ret.Get(0).(func() []entity.ConfigKeyInfo); ok {
1004 r0 = returnFunc()
1005 } else {
1006 if ret.Get(0) != nil {
1007 r0 = ret.Get(0).([]entity.ConfigKeyInfo)
1008 }
1009 }
1010 return r0
1011}
1012
1013// MockConfigSchemaProvider_GetSchema_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSchema'
1014type MockConfigSchemaProvider_GetSchema_Call struct {
1015 *mock.Call
1016}
1017
1018// GetSchema is a helper method to define mock.On call
1019func (_e *MockConfigSchemaProvider_Expecter) GetSchema() *MockConfigSchemaProvider_GetSchema_Call {
1020 return &MockConfigSchemaProvider_GetSchema_Call{Call: _e.mock.On("GetSchema")}
1021}
1022
1023func (_c *MockConfigSchemaProvider_GetSchema_Call) Run(run func()) *MockConfigSchemaProvider_GetSchema_Call {
1024 _c.Call.Run(func(args mock.Arguments) {
1025 run()
1026 })
1027 return _c
1028}
1029
1030func (_c *MockConfigSchemaProvider_GetSchema_Call) Return(configKeyInfos []entity.ConfigKeyInfo) *MockConfigSchemaProvider_GetSchema_Call {
1031 _c.Call.Return(configKeyInfos)
1032 return _c
1033}
1034
1035func (_c *MockConfigSchemaProvider_GetSchema_Call) RunAndReturn(run func() []entity.ConfigKeyInfo) *MockConfigSchemaProvider_GetSchema_Call {
1036 _c.Call.Return(run)
1037 return _c
1038}
1039
1040// 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.
1041// The first argument is typically a *testing.T value.
1042func NewMockConfigTransformer(t interface {
1043 mock.TestingT
1044 Cleanup(func())
1045}) *MockConfigTransformer {
1046 mock := &MockConfigTransformer{}
1047 mock.Mock.Test(t)
1048
1049 t.Cleanup(func() { mock.AssertExpectations(t) })
1050
1051 return mock
1052}
1053
1054// MockConfigTransformer is an autogenerated mock type for the ConfigTransformer type
1055type MockConfigTransformer struct {
1056 mock.Mock
1057}
1058
1059type MockConfigTransformer_Expecter struct {
1060 mock *mock.Mock
1061}
1062
1063func (_m *MockConfigTransformer) EXPECT() *MockConfigTransformer_Expecter {
1064 return &MockConfigTransformer_Expecter{mock: &_m.Mock}
1065}
1066
1067// TransformLegacyActions provides a mock function for the type MockConfigTransformer
1068func (_mock *MockConfigTransformer) TransformLegacyActions(rawConfig map[string]any) {
1069 _mock.Called(rawConfig)
1070 return
1071}
1072
1073// MockConfigTransformer_TransformLegacyActions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TransformLegacyActions'
1074type MockConfigTransformer_TransformLegacyActions_Call struct {
1075 *mock.Call
1076}
1077
1078// TransformLegacyActions is a helper method to define mock.On call
1079// - rawConfig map[string]any
1080func (_e *MockConfigTransformer_Expecter) TransformLegacyActions(rawConfig interface{}) *MockConfigTransformer_TransformLegacyActions_Call {
1081 return &MockConfigTransformer_TransformLegacyActions_Call{Call: _e.mock.On("TransformLegacyActions", rawConfig)}
1082}
1083
1084func (_c *MockConfigTransformer_TransformLegacyActions_Call) Run(run func(rawConfig map[string]any)) *MockConfigTransformer_TransformLegacyActions_Call {
1085 _c.Call.Run(func(args mock.Arguments) {
1086 var arg0 map[string]any
1087 if args[0] != nil {
1088 arg0 = args[0].(map[string]any)
1089 }
1090 run(
1091 arg0,
1092 )
1093 })
1094 return _c
1095}
1096
1097func (_c *MockConfigTransformer_TransformLegacyActions_Call) Return() *MockConfigTransformer_TransformLegacyActions_Call {
1098 _c.Call.Return()
1099 return _c
1100}
1101
1102func (_c *MockConfigTransformer_TransformLegacyActions_Call) RunAndReturn(run func(rawConfig map[string]any)) *MockConfigTransformer_TransformLegacyActions_Call {
1103 _c.Run(run)
1104 return _c
1105}
1106
1107// 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.
1108// The first argument is typically a *testing.T value.
1109func NewMockDatabaseProvider(t interface {
1110 mock.TestingT
1111 Cleanup(func())
1112}) *MockDatabaseProvider {
1113 mock := &MockDatabaseProvider{}
1114 mock.Mock.Test(t)
1115
1116 t.Cleanup(func() { mock.AssertExpectations(t) })
1117
1118 return mock
1119}
1120
1121// MockDatabaseProvider is an autogenerated mock type for the DatabaseProvider type
1122type MockDatabaseProvider struct {
1123 mock.Mock
1124}
1125
1126type MockDatabaseProvider_Expecter struct {
1127 mock *mock.Mock
1128}
1129
1130func (_m *MockDatabaseProvider) EXPECT() *MockDatabaseProvider_Expecter {
1131 return &MockDatabaseProvider_Expecter{mock: &_m.Mock}
1132}
1133
1134// Close provides a mock function for the type MockDatabaseProvider
1135func (_mock *MockDatabaseProvider) Close() error {
1136 ret := _mock.Called()
1137
1138 if len(ret) == 0 {
1139 panic("no return value specified for Close")
1140 }
1141
1142 var r0 error
1143 if returnFunc, ok := ret.Get(0).(func() error); ok {
1144 r0 = returnFunc()
1145 } else {
1146 r0 = ret.Error(0)
1147 }
1148 return r0
1149}
1150
1151// MockDatabaseProvider_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
1152type MockDatabaseProvider_Close_Call struct {
1153 *mock.Call
1154}
1155
1156// Close is a helper method to define mock.On call
1157func (_e *MockDatabaseProvider_Expecter) Close() *MockDatabaseProvider_Close_Call {
1158 return &MockDatabaseProvider_Close_Call{Call: _e.mock.On("Close")}
1159}
1160
1161func (_c *MockDatabaseProvider_Close_Call) Run(run func()) *MockDatabaseProvider_Close_Call {
1162 _c.Call.Run(func(args mock.Arguments) {
1163 run()
1164 })
1165 return _c
1166}
1167
1168func (_c *MockDatabaseProvider_Close_Call) Return(err error) *MockDatabaseProvider_Close_Call {
1169 _c.Call.Return(err)
1170 return _c
1171}
1172
1173func (_c *MockDatabaseProvider_Close_Call) RunAndReturn(run func() error) *MockDatabaseProvider_Close_Call {
1174 _c.Call.Return(run)
1175 return _c
1176}
1177
1178// DB provides a mock function for the type MockDatabaseProvider
1179func (_mock *MockDatabaseProvider) DB(ctx context.Context) (*sql.DB, error) {
1180 ret := _mock.Called(ctx)
1181
1182 if len(ret) == 0 {
1183 panic("no return value specified for DB")
1184 }
1185
1186 var r0 *sql.DB
1187 var r1 error
1188 if returnFunc, ok := ret.Get(0).(func(context.Context) (*sql.DB, error)); ok {
1189 return returnFunc(ctx)
1190 }
1191 if returnFunc, ok := ret.Get(0).(func(context.Context) *sql.DB); ok {
1192 r0 = returnFunc(ctx)
1193 } else {
1194 if ret.Get(0) != nil {
1195 r0 = ret.Get(0).(*sql.DB)
1196 }
1197 }
1198 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
1199 r1 = returnFunc(ctx)
1200 } else {
1201 r1 = ret.Error(1)
1202 }
1203 return r0, r1
1204}
1205
1206// MockDatabaseProvider_DB_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DB'
1207type MockDatabaseProvider_DB_Call struct {
1208 *mock.Call
1209}
1210
1211// DB is a helper method to define mock.On call
1212// - ctx context.Context
1213func (_e *MockDatabaseProvider_Expecter) DB(ctx interface{}) *MockDatabaseProvider_DB_Call {
1214 return &MockDatabaseProvider_DB_Call{Call: _e.mock.On("DB", ctx)}
1215}
1216
1217func (_c *MockDatabaseProvider_DB_Call) Run(run func(ctx context.Context)) *MockDatabaseProvider_DB_Call {
1218 _c.Call.Run(func(args mock.Arguments) {
1219 var arg0 context.Context
1220 if args[0] != nil {
1221 arg0 = args[0].(context.Context)
1222 }
1223 run(
1224 arg0,
1225 )
1226 })
1227 return _c
1228}
1229
1230func (_c *MockDatabaseProvider_DB_Call) Return(dB *sql.DB, err error) *MockDatabaseProvider_DB_Call {
1231 _c.Call.Return(dB, err)
1232 return _c
1233}
1234
1235func (_c *MockDatabaseProvider_DB_Call) RunAndReturn(run func(ctx context.Context) (*sql.DB, error)) *MockDatabaseProvider_DB_Call {
1236 _c.Call.Return(run)
1237 return _c
1238}
1239
1240// IsInitialized provides a mock function for the type MockDatabaseProvider
1241func (_mock *MockDatabaseProvider) IsInitialized() bool {
1242 ret := _mock.Called()
1243
1244 if len(ret) == 0 {
1245 panic("no return value specified for IsInitialized")
1246 }
1247
1248 var r0 bool
1249 if returnFunc, ok := ret.Get(0).(func() bool); ok {
1250 r0 = returnFunc()
1251 } else {
1252 r0 = ret.Get(0).(bool)
1253 }
1254 return r0
1255}
1256
1257// MockDatabaseProvider_IsInitialized_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsInitialized'
1258type MockDatabaseProvider_IsInitialized_Call struct {
1259 *mock.Call
1260}
1261
1262// IsInitialized is a helper method to define mock.On call
1263func (_e *MockDatabaseProvider_Expecter) IsInitialized() *MockDatabaseProvider_IsInitialized_Call {
1264 return &MockDatabaseProvider_IsInitialized_Call{Call: _e.mock.On("IsInitialized")}
1265}
1266
1267func (_c *MockDatabaseProvider_IsInitialized_Call) Run(run func()) *MockDatabaseProvider_IsInitialized_Call {
1268 _c.Call.Run(func(args mock.Arguments) {
1269 run()
1270 })
1271 return _c
1272}
1273
1274func (_c *MockDatabaseProvider_IsInitialized_Call) Return(b bool) *MockDatabaseProvider_IsInitialized_Call {
1275 _c.Call.Return(b)
1276 return _c
1277}
1278
1279func (_c *MockDatabaseProvider_IsInitialized_Call) RunAndReturn(run func() bool) *MockDatabaseProvider_IsInitialized_Call {
1280 _c.Call.Return(run)
1281 return _c
1282}
1283
1284// 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.
1285// The first argument is typically a *testing.T value.
1286func NewMockDownloadResponse(t interface {
1287 mock.TestingT
1288 Cleanup(func())
1289}) *MockDownloadResponse {
1290 mock := &MockDownloadResponse{}
1291 mock.Mock.Test(t)
1292
1293 t.Cleanup(func() { mock.AssertExpectations(t) })
1294
1295 return mock
1296}
1297
1298// MockDownloadResponse is an autogenerated mock type for the DownloadResponse type
1299type MockDownloadResponse struct {
1300 mock.Mock
1301}
1302
1303type MockDownloadResponse_Expecter struct {
1304 mock *mock.Mock
1305}
1306
1307func (_m *MockDownloadResponse) EXPECT() *MockDownloadResponse_Expecter {
1308 return &MockDownloadResponse_Expecter{mock: &_m.Mock}
1309}
1310
1311// GetMimeType provides a mock function for the type MockDownloadResponse
1312func (_mock *MockDownloadResponse) GetMimeType() string {
1313 ret := _mock.Called()
1314
1315 if len(ret) == 0 {
1316 panic("no return value specified for GetMimeType")
1317 }
1318
1319 var r0 string
1320 if returnFunc, ok := ret.Get(0).(func() string); ok {
1321 r0 = returnFunc()
1322 } else {
1323 r0 = ret.Get(0).(string)
1324 }
1325 return r0
1326}
1327
1328// MockDownloadResponse_GetMimeType_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetMimeType'
1329type MockDownloadResponse_GetMimeType_Call struct {
1330 *mock.Call
1331}
1332
1333// GetMimeType is a helper method to define mock.On call
1334func (_e *MockDownloadResponse_Expecter) GetMimeType() *MockDownloadResponse_GetMimeType_Call {
1335 return &MockDownloadResponse_GetMimeType_Call{Call: _e.mock.On("GetMimeType")}
1336}
1337
1338func (_c *MockDownloadResponse_GetMimeType_Call) Run(run func()) *MockDownloadResponse_GetMimeType_Call {
1339 _c.Call.Run(func(args mock.Arguments) {
1340 run()
1341 })
1342 return _c
1343}
1344
1345func (_c *MockDownloadResponse_GetMimeType_Call) Return(s string) *MockDownloadResponse_GetMimeType_Call {
1346 _c.Call.Return(s)
1347 return _c
1348}
1349
1350func (_c *MockDownloadResponse_GetMimeType_Call) RunAndReturn(run func() string) *MockDownloadResponse_GetMimeType_Call {
1351 _c.Call.Return(run)
1352 return _c
1353}
1354
1355// GetSuggestedFilename provides a mock function for the type MockDownloadResponse
1356func (_mock *MockDownloadResponse) GetSuggestedFilename() string {
1357 ret := _mock.Called()
1358
1359 if len(ret) == 0 {
1360 panic("no return value specified for GetSuggestedFilename")
1361 }
1362
1363 var r0 string
1364 if returnFunc, ok := ret.Get(0).(func() string); ok {
1365 r0 = returnFunc()
1366 } else {
1367 r0 = ret.Get(0).(string)
1368 }
1369 return r0
1370}
1371
1372// MockDownloadResponse_GetSuggestedFilename_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSuggestedFilename'
1373type MockDownloadResponse_GetSuggestedFilename_Call struct {
1374 *mock.Call
1375}
1376
1377// GetSuggestedFilename is a helper method to define mock.On call
1378func (_e *MockDownloadResponse_Expecter) GetSuggestedFilename() *MockDownloadResponse_GetSuggestedFilename_Call {
1379 return &MockDownloadResponse_GetSuggestedFilename_Call{Call: _e.mock.On("GetSuggestedFilename")}
1380}
1381
1382func (_c *MockDownloadResponse_GetSuggestedFilename_Call) Run(run func()) *MockDownloadResponse_GetSuggestedFilename_Call {
1383 _c.Call.Run(func(args mock.Arguments) {
1384 run()
1385 })
1386 return _c
1387}
1388
1389func (_c *MockDownloadResponse_GetSuggestedFilename_Call) Return(s string) *MockDownloadResponse_GetSuggestedFilename_Call {
1390 _c.Call.Return(s)
1391 return _c
1392}
1393
1394func (_c *MockDownloadResponse_GetSuggestedFilename_Call) RunAndReturn(run func() string) *MockDownloadResponse_GetSuggestedFilename_Call {
1395 _c.Call.Return(run)
1396 return _c
1397}
1398
1399// GetUri provides a mock function for the type MockDownloadResponse
1400func (_mock *MockDownloadResponse) GetUri() string {
1401 ret := _mock.Called()
1402
1403 if len(ret) == 0 {
1404 panic("no return value specified for GetUri")
1405 }
1406
1407 var r0 string
1408 if returnFunc, ok := ret.Get(0).(func() string); ok {
1409 r0 = returnFunc()
1410 } else {
1411 r0 = ret.Get(0).(string)
1412 }
1413 return r0
1414}
1415
1416// MockDownloadResponse_GetUri_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetUri'
1417type MockDownloadResponse_GetUri_Call struct {
1418 *mock.Call
1419}
1420
1421// GetUri is a helper method to define mock.On call
1422func (_e *MockDownloadResponse_Expecter) GetUri() *MockDownloadResponse_GetUri_Call {
1423 return &MockDownloadResponse_GetUri_Call{Call: _e.mock.On("GetUri")}
1424}
1425
1426func (_c *MockDownloadResponse_GetUri_Call) Run(run func()) *MockDownloadResponse_GetUri_Call {
1427 _c.Call.Run(func(args mock.Arguments) {
1428 run()
1429 })
1430 return _c
1431}
1432
1433func (_c *MockDownloadResponse_GetUri_Call) Return(s string) *MockDownloadResponse_GetUri_Call {
1434 _c.Call.Return(s)
1435 return _c
1436}
1437
1438func (_c *MockDownloadResponse_GetUri_Call) RunAndReturn(run func() string) *MockDownloadResponse_GetUri_Call {
1439 _c.Call.Return(run)
1440 return _c
1441}
1442
1443// 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.
1444// The first argument is typically a *testing.T value.
1445func NewMockFontDetector(t interface {
1446 mock.TestingT
1447 Cleanup(func())
1448}) *MockFontDetector {
1449 mock := &MockFontDetector{}
1450 mock.Mock.Test(t)
1451
1452 t.Cleanup(func() { mock.AssertExpectations(t) })
1453
1454 return mock
1455}
1456
1457// MockFontDetector is an autogenerated mock type for the FontDetector type
1458type MockFontDetector struct {
1459 mock.Mock
1460}
1461
1462type MockFontDetector_Expecter struct {
1463 mock *mock.Mock
1464}
1465
1466func (_m *MockFontDetector) EXPECT() *MockFontDetector_Expecter {
1467 return &MockFontDetector_Expecter{mock: &_m.Mock}
1468}
1469
1470// GetAvailableFonts provides a mock function for the type MockFontDetector
1471func (_mock *MockFontDetector) GetAvailableFonts(ctx context.Context) ([]string, error) {
1472 ret := _mock.Called(ctx)
1473
1474 if len(ret) == 0 {
1475 panic("no return value specified for GetAvailableFonts")
1476 }
1477
1478 var r0 []string
1479 var r1 error
1480 if returnFunc, ok := ret.Get(0).(func(context.Context) ([]string, error)); ok {
1481 return returnFunc(ctx)
1482 }
1483 if returnFunc, ok := ret.Get(0).(func(context.Context) []string); ok {
1484 r0 = returnFunc(ctx)
1485 } else {
1486 if ret.Get(0) != nil {
1487 r0 = ret.Get(0).([]string)
1488 }
1489 }
1490 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
1491 r1 = returnFunc(ctx)
1492 } else {
1493 r1 = ret.Error(1)
1494 }
1495 return r0, r1
1496}
1497
1498// MockFontDetector_GetAvailableFonts_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAvailableFonts'
1499type MockFontDetector_GetAvailableFonts_Call struct {
1500 *mock.Call
1501}
1502
1503// GetAvailableFonts is a helper method to define mock.On call
1504// - ctx context.Context
1505func (_e *MockFontDetector_Expecter) GetAvailableFonts(ctx interface{}) *MockFontDetector_GetAvailableFonts_Call {
1506 return &MockFontDetector_GetAvailableFonts_Call{Call: _e.mock.On("GetAvailableFonts", ctx)}
1507}
1508
1509func (_c *MockFontDetector_GetAvailableFonts_Call) Run(run func(ctx context.Context)) *MockFontDetector_GetAvailableFonts_Call {
1510 _c.Call.Run(func(args mock.Arguments) {
1511 var arg0 context.Context
1512 if args[0] != nil {
1513 arg0 = args[0].(context.Context)
1514 }
1515 run(
1516 arg0,
1517 )
1518 })
1519 return _c
1520}
1521
1522func (_c *MockFontDetector_GetAvailableFonts_Call) Return(strings []string, err error) *MockFontDetector_GetAvailableFonts_Call {
1523 _c.Call.Return(strings, err)
1524 return _c
1525}
1526
1527func (_c *MockFontDetector_GetAvailableFonts_Call) RunAndReturn(run func(ctx context.Context) ([]string, error)) *MockFontDetector_GetAvailableFonts_Call {
1528 _c.Call.Return(run)
1529 return _c
1530}
1531
1532// IsAvailable provides a mock function for the type MockFontDetector
1533func (_mock *MockFontDetector) IsAvailable(ctx context.Context) bool {
1534 ret := _mock.Called(ctx)
1535
1536 if len(ret) == 0 {
1537 panic("no return value specified for IsAvailable")
1538 }
1539
1540 var r0 bool
1541 if returnFunc, ok := ret.Get(0).(func(context.Context) bool); ok {
1542 r0 = returnFunc(ctx)
1543 } else {
1544 r0 = ret.Get(0).(bool)
1545 }
1546 return r0
1547}
1548
1549// MockFontDetector_IsAvailable_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsAvailable'
1550type MockFontDetector_IsAvailable_Call struct {
1551 *mock.Call
1552}
1553
1554// IsAvailable is a helper method to define mock.On call
1555// - ctx context.Context
1556func (_e *MockFontDetector_Expecter) IsAvailable(ctx interface{}) *MockFontDetector_IsAvailable_Call {
1557 return &MockFontDetector_IsAvailable_Call{Call: _e.mock.On("IsAvailable", ctx)}
1558}
1559
1560func (_c *MockFontDetector_IsAvailable_Call) Run(run func(ctx context.Context)) *MockFontDetector_IsAvailable_Call {
1561 _c.Call.Run(func(args mock.Arguments) {
1562 var arg0 context.Context
1563 if args[0] != nil {
1564 arg0 = args[0].(context.Context)
1565 }
1566 run(
1567 arg0,
1568 )
1569 })
1570 return _c
1571}
1572
1573func (_c *MockFontDetector_IsAvailable_Call) Return(b bool) *MockFontDetector_IsAvailable_Call {
1574 _c.Call.Return(b)
1575 return _c
1576}
1577
1578func (_c *MockFontDetector_IsAvailable_Call) RunAndReturn(run func(ctx context.Context) bool) *MockFontDetector_IsAvailable_Call {
1579 _c.Call.Return(run)
1580 return _c
1581}
1582
1583// SelectBestFont provides a mock function for the type MockFontDetector
1584func (_mock *MockFontDetector) SelectBestFont(ctx context.Context, category port.FontCategory, fallbackChain []string) string {
1585 ret := _mock.Called(ctx, category, fallbackChain)
1586
1587 if len(ret) == 0 {
1588 panic("no return value specified for SelectBestFont")
1589 }
1590
1591 var r0 string
1592 if returnFunc, ok := ret.Get(0).(func(context.Context, port.FontCategory, []string) string); ok {
1593 r0 = returnFunc(ctx, category, fallbackChain)
1594 } else {
1595 r0 = ret.Get(0).(string)
1596 }
1597 return r0
1598}
1599
1600// MockFontDetector_SelectBestFont_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SelectBestFont'
1601type MockFontDetector_SelectBestFont_Call struct {
1602 *mock.Call
1603}
1604
1605// SelectBestFont is a helper method to define mock.On call
1606// - ctx context.Context
1607// - category port.FontCategory
1608// - fallbackChain []string
1609func (_e *MockFontDetector_Expecter) SelectBestFont(ctx interface{}, category interface{}, fallbackChain interface{}) *MockFontDetector_SelectBestFont_Call {
1610 return &MockFontDetector_SelectBestFont_Call{Call: _e.mock.On("SelectBestFont", ctx, category, fallbackChain)}
1611}
1612
1613func (_c *MockFontDetector_SelectBestFont_Call) Run(run func(ctx context.Context, category port.FontCategory, fallbackChain []string)) *MockFontDetector_SelectBestFont_Call {
1614 _c.Call.Run(func(args mock.Arguments) {
1615 var arg0 context.Context
1616 if args[0] != nil {
1617 arg0 = args[0].(context.Context)
1618 }
1619 var arg1 port.FontCategory
1620 if args[1] != nil {
1621 arg1 = args[1].(port.FontCategory)
1622 }
1623 var arg2 []string
1624 if args[2] != nil {
1625 arg2 = args[2].([]string)
1626 }
1627 run(
1628 arg0,
1629 arg1,
1630 arg2,
1631 )
1632 })
1633 return _c
1634}
1635
1636func (_c *MockFontDetector_SelectBestFont_Call) Return(s string) *MockFontDetector_SelectBestFont_Call {
1637 _c.Call.Return(s)
1638 return _c
1639}
1640
1641func (_c *MockFontDetector_SelectBestFont_Call) RunAndReturn(run func(ctx context.Context, category port.FontCategory, fallbackChain []string) string) *MockFontDetector_SelectBestFont_Call {
1642 _c.Call.Return(run)
1643 return _c
1644}
1645
1646// 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.
1647// The first argument is typically a *testing.T value.
1648func NewMockHardwareSurveyor(t interface {
1649 mock.TestingT
1650 Cleanup(func())
1651}) *MockHardwareSurveyor {
1652 mock := &MockHardwareSurveyor{}
1653 mock.Mock.Test(t)
1654
1655 t.Cleanup(func() { mock.AssertExpectations(t) })
1656
1657 return mock
1658}
1659
1660// MockHardwareSurveyor is an autogenerated mock type for the HardwareSurveyor type
1661type MockHardwareSurveyor struct {
1662 mock.Mock
1663}
1664
1665type MockHardwareSurveyor_Expecter struct {
1666 mock *mock.Mock
1667}
1668
1669func (_m *MockHardwareSurveyor) EXPECT() *MockHardwareSurveyor_Expecter {
1670 return &MockHardwareSurveyor_Expecter{mock: &_m.Mock}
1671}
1672
1673// Survey provides a mock function for the type MockHardwareSurveyor
1674func (_mock *MockHardwareSurveyor) Survey(ctx context.Context) port.HardwareInfo {
1675 ret := _mock.Called(ctx)
1676
1677 if len(ret) == 0 {
1678 panic("no return value specified for Survey")
1679 }
1680
1681 var r0 port.HardwareInfo
1682 if returnFunc, ok := ret.Get(0).(func(context.Context) port.HardwareInfo); ok {
1683 r0 = returnFunc(ctx)
1684 } else {
1685 r0 = ret.Get(0).(port.HardwareInfo)
1686 }
1687 return r0
1688}
1689
1690// MockHardwareSurveyor_Survey_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Survey'
1691type MockHardwareSurveyor_Survey_Call struct {
1692 *mock.Call
1693}
1694
1695// Survey is a helper method to define mock.On call
1696// - ctx context.Context
1697func (_e *MockHardwareSurveyor_Expecter) Survey(ctx interface{}) *MockHardwareSurveyor_Survey_Call {
1698 return &MockHardwareSurveyor_Survey_Call{Call: _e.mock.On("Survey", ctx)}
1699}
1700
1701func (_c *MockHardwareSurveyor_Survey_Call) Run(run func(ctx context.Context)) *MockHardwareSurveyor_Survey_Call {
1702 _c.Call.Run(func(args mock.Arguments) {
1703 var arg0 context.Context
1704 if args[0] != nil {
1705 arg0 = args[0].(context.Context)
1706 }
1707 run(
1708 arg0,
1709 )
1710 })
1711 return _c
1712}
1713
1714func (_c *MockHardwareSurveyor_Survey_Call) Return(hardwareInfo port.HardwareInfo) *MockHardwareSurveyor_Survey_Call {
1715 _c.Call.Return(hardwareInfo)
1716 return _c
1717}
1718
1719func (_c *MockHardwareSurveyor_Survey_Call) RunAndReturn(run func(ctx context.Context) port.HardwareInfo) *MockHardwareSurveyor_Survey_Call {
1720 _c.Call.Return(run)
1721 return _c
1722}
1723
1724// 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.
1725// The first argument is typically a *testing.T value.
1726func NewMockKeybindingsProvider(t interface {
1727 mock.TestingT
1728 Cleanup(func())
1729}) *MockKeybindingsProvider {
1730 mock := &MockKeybindingsProvider{}
1731 mock.Mock.Test(t)
1732
1733 t.Cleanup(func() { mock.AssertExpectations(t) })
1734
1735 return mock
1736}
1737
1738// MockKeybindingsProvider is an autogenerated mock type for the KeybindingsProvider type
1739type MockKeybindingsProvider struct {
1740 mock.Mock
1741}
1742
1743type MockKeybindingsProvider_Expecter struct {
1744 mock *mock.Mock
1745}
1746
1747func (_m *MockKeybindingsProvider) EXPECT() *MockKeybindingsProvider_Expecter {
1748 return &MockKeybindingsProvider_Expecter{mock: &_m.Mock}
1749}
1750
1751// CheckConflicts provides a mock function for the type MockKeybindingsProvider
1752func (_mock *MockKeybindingsProvider) CheckConflicts(ctx context.Context, mode string, action string, keys []string) ([]port.KeybindingConflict, error) {
1753 ret := _mock.Called(ctx, mode, action, keys)
1754
1755 if len(ret) == 0 {
1756 panic("no return value specified for CheckConflicts")
1757 }
1758
1759 var r0 []port.KeybindingConflict
1760 var r1 error
1761 if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, []string) ([]port.KeybindingConflict, error)); ok {
1762 return returnFunc(ctx, mode, action, keys)
1763 }
1764 if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, []string) []port.KeybindingConflict); ok {
1765 r0 = returnFunc(ctx, mode, action, keys)
1766 } else {
1767 if ret.Get(0) != nil {
1768 r0 = ret.Get(0).([]port.KeybindingConflict)
1769 }
1770 }
1771 if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, []string) error); ok {
1772 r1 = returnFunc(ctx, mode, action, keys)
1773 } else {
1774 r1 = ret.Error(1)
1775 }
1776 return r0, r1
1777}
1778
1779// MockKeybindingsProvider_CheckConflicts_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CheckConflicts'
1780type MockKeybindingsProvider_CheckConflicts_Call struct {
1781 *mock.Call
1782}
1783
1784// CheckConflicts is a helper method to define mock.On call
1785// - ctx context.Context
1786// - mode string
1787// - action string
1788// - keys []string
1789func (_e *MockKeybindingsProvider_Expecter) CheckConflicts(ctx interface{}, mode interface{}, action interface{}, keys interface{}) *MockKeybindingsProvider_CheckConflicts_Call {
1790 return &MockKeybindingsProvider_CheckConflicts_Call{Call: _e.mock.On("CheckConflicts", ctx, mode, action, keys)}
1791}
1792
1793func (_c *MockKeybindingsProvider_CheckConflicts_Call) Run(run func(ctx context.Context, mode string, action string, keys []string)) *MockKeybindingsProvider_CheckConflicts_Call {
1794 _c.Call.Run(func(args mock.Arguments) {
1795 var arg0 context.Context
1796 if args[0] != nil {
1797 arg0 = args[0].(context.Context)
1798 }
1799 var arg1 string
1800 if args[1] != nil {
1801 arg1 = args[1].(string)
1802 }
1803 var arg2 string
1804 if args[2] != nil {
1805 arg2 = args[2].(string)
1806 }
1807 var arg3 []string
1808 if args[3] != nil {
1809 arg3 = args[3].([]string)
1810 }
1811 run(
1812 arg0,
1813 arg1,
1814 arg2,
1815 arg3,
1816 )
1817 })
1818 return _c
1819}
1820
1821func (_c *MockKeybindingsProvider_CheckConflicts_Call) Return(keybindingConflicts []port.KeybindingConflict, err error) *MockKeybindingsProvider_CheckConflicts_Call {
1822 _c.Call.Return(keybindingConflicts, err)
1823 return _c
1824}
1825
1826func (_c *MockKeybindingsProvider_CheckConflicts_Call) RunAndReturn(run func(ctx context.Context, mode string, action string, keys []string) ([]port.KeybindingConflict, error)) *MockKeybindingsProvider_CheckConflicts_Call {
1827 _c.Call.Return(run)
1828 return _c
1829}
1830
1831// GetDefaultKeybindings provides a mock function for the type MockKeybindingsProvider
1832func (_mock *MockKeybindingsProvider) GetDefaultKeybindings(ctx context.Context) (port.KeybindingsConfig, error) {
1833 ret := _mock.Called(ctx)
1834
1835 if len(ret) == 0 {
1836 panic("no return value specified for GetDefaultKeybindings")
1837 }
1838
1839 var r0 port.KeybindingsConfig
1840 var r1 error
1841 if returnFunc, ok := ret.Get(0).(func(context.Context) (port.KeybindingsConfig, error)); ok {
1842 return returnFunc(ctx)
1843 }
1844 if returnFunc, ok := ret.Get(0).(func(context.Context) port.KeybindingsConfig); ok {
1845 r0 = returnFunc(ctx)
1846 } else {
1847 r0 = ret.Get(0).(port.KeybindingsConfig)
1848 }
1849 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
1850 r1 = returnFunc(ctx)
1851 } else {
1852 r1 = ret.Error(1)
1853 }
1854 return r0, r1
1855}
1856
1857// MockKeybindingsProvider_GetDefaultKeybindings_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetDefaultKeybindings'
1858type MockKeybindingsProvider_GetDefaultKeybindings_Call struct {
1859 *mock.Call
1860}
1861
1862// GetDefaultKeybindings is a helper method to define mock.On call
1863// - ctx context.Context
1864func (_e *MockKeybindingsProvider_Expecter) GetDefaultKeybindings(ctx interface{}) *MockKeybindingsProvider_GetDefaultKeybindings_Call {
1865 return &MockKeybindingsProvider_GetDefaultKeybindings_Call{Call: _e.mock.On("GetDefaultKeybindings", ctx)}
1866}
1867
1868func (_c *MockKeybindingsProvider_GetDefaultKeybindings_Call) Run(run func(ctx context.Context)) *MockKeybindingsProvider_GetDefaultKeybindings_Call {
1869 _c.Call.Run(func(args mock.Arguments) {
1870 var arg0 context.Context
1871 if args[0] != nil {
1872 arg0 = args[0].(context.Context)
1873 }
1874 run(
1875 arg0,
1876 )
1877 })
1878 return _c
1879}
1880
1881func (_c *MockKeybindingsProvider_GetDefaultKeybindings_Call) Return(keybindingsConfig port.KeybindingsConfig, err error) *MockKeybindingsProvider_GetDefaultKeybindings_Call {
1882 _c.Call.Return(keybindingsConfig, err)
1883 return _c
1884}
1885
1886func (_c *MockKeybindingsProvider_GetDefaultKeybindings_Call) RunAndReturn(run func(ctx context.Context) (port.KeybindingsConfig, error)) *MockKeybindingsProvider_GetDefaultKeybindings_Call {
1887 _c.Call.Return(run)
1888 return _c
1889}
1890
1891// GetKeybindings provides a mock function for the type MockKeybindingsProvider
1892func (_mock *MockKeybindingsProvider) GetKeybindings(ctx context.Context) (port.KeybindingsConfig, error) {
1893 ret := _mock.Called(ctx)
1894
1895 if len(ret) == 0 {
1896 panic("no return value specified for GetKeybindings")
1897 }
1898
1899 var r0 port.KeybindingsConfig
1900 var r1 error
1901 if returnFunc, ok := ret.Get(0).(func(context.Context) (port.KeybindingsConfig, error)); ok {
1902 return returnFunc(ctx)
1903 }
1904 if returnFunc, ok := ret.Get(0).(func(context.Context) port.KeybindingsConfig); ok {
1905 r0 = returnFunc(ctx)
1906 } else {
1907 r0 = ret.Get(0).(port.KeybindingsConfig)
1908 }
1909 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
1910 r1 = returnFunc(ctx)
1911 } else {
1912 r1 = ret.Error(1)
1913 }
1914 return r0, r1
1915}
1916
1917// MockKeybindingsProvider_GetKeybindings_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetKeybindings'
1918type MockKeybindingsProvider_GetKeybindings_Call struct {
1919 *mock.Call
1920}
1921
1922// GetKeybindings is a helper method to define mock.On call
1923// - ctx context.Context
1924func (_e *MockKeybindingsProvider_Expecter) GetKeybindings(ctx interface{}) *MockKeybindingsProvider_GetKeybindings_Call {
1925 return &MockKeybindingsProvider_GetKeybindings_Call{Call: _e.mock.On("GetKeybindings", ctx)}
1926}
1927
1928func (_c *MockKeybindingsProvider_GetKeybindings_Call) Run(run func(ctx context.Context)) *MockKeybindingsProvider_GetKeybindings_Call {
1929 _c.Call.Run(func(args mock.Arguments) {
1930 var arg0 context.Context
1931 if args[0] != nil {
1932 arg0 = args[0].(context.Context)
1933 }
1934 run(
1935 arg0,
1936 )
1937 })
1938 return _c
1939}
1940
1941func (_c *MockKeybindingsProvider_GetKeybindings_Call) Return(keybindingsConfig port.KeybindingsConfig, err error) *MockKeybindingsProvider_GetKeybindings_Call {
1942 _c.Call.Return(keybindingsConfig, err)
1943 return _c
1944}
1945
1946func (_c *MockKeybindingsProvider_GetKeybindings_Call) RunAndReturn(run func(ctx context.Context) (port.KeybindingsConfig, error)) *MockKeybindingsProvider_GetKeybindings_Call {
1947 _c.Call.Return(run)
1948 return _c
1949}
1950
1951// 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.
1952// The first argument is typically a *testing.T value.
1953func NewMockKeybindingsSaver(t interface {
1954 mock.TestingT
1955 Cleanup(func())
1956}) *MockKeybindingsSaver {
1957 mock := &MockKeybindingsSaver{}
1958 mock.Mock.Test(t)
1959
1960 t.Cleanup(func() { mock.AssertExpectations(t) })
1961
1962 return mock
1963}
1964
1965// MockKeybindingsSaver is an autogenerated mock type for the KeybindingsSaver type
1966type MockKeybindingsSaver struct {
1967 mock.Mock
1968}
1969
1970type MockKeybindingsSaver_Expecter struct {
1971 mock *mock.Mock
1972}
1973
1974func (_m *MockKeybindingsSaver) EXPECT() *MockKeybindingsSaver_Expecter {
1975 return &MockKeybindingsSaver_Expecter{mock: &_m.Mock}
1976}
1977
1978// ResetAllKeybindings provides a mock function for the type MockKeybindingsSaver
1979func (_mock *MockKeybindingsSaver) ResetAllKeybindings(ctx context.Context) error {
1980 ret := _mock.Called(ctx)
1981
1982 if len(ret) == 0 {
1983 panic("no return value specified for ResetAllKeybindings")
1984 }
1985
1986 var r0 error
1987 if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
1988 r0 = returnFunc(ctx)
1989 } else {
1990 r0 = ret.Error(0)
1991 }
1992 return r0
1993}
1994
1995// MockKeybindingsSaver_ResetAllKeybindings_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResetAllKeybindings'
1996type MockKeybindingsSaver_ResetAllKeybindings_Call struct {
1997 *mock.Call
1998}
1999
2000// ResetAllKeybindings is a helper method to define mock.On call
2001// - ctx context.Context
2002func (_e *MockKeybindingsSaver_Expecter) ResetAllKeybindings(ctx interface{}) *MockKeybindingsSaver_ResetAllKeybindings_Call {
2003 return &MockKeybindingsSaver_ResetAllKeybindings_Call{Call: _e.mock.On("ResetAllKeybindings", ctx)}
2004}
2005
2006func (_c *MockKeybindingsSaver_ResetAllKeybindings_Call) Run(run func(ctx context.Context)) *MockKeybindingsSaver_ResetAllKeybindings_Call {
2007 _c.Call.Run(func(args mock.Arguments) {
2008 var arg0 context.Context
2009 if args[0] != nil {
2010 arg0 = args[0].(context.Context)
2011 }
2012 run(
2013 arg0,
2014 )
2015 })
2016 return _c
2017}
2018
2019func (_c *MockKeybindingsSaver_ResetAllKeybindings_Call) Return(err error) *MockKeybindingsSaver_ResetAllKeybindings_Call {
2020 _c.Call.Return(err)
2021 return _c
2022}
2023
2024func (_c *MockKeybindingsSaver_ResetAllKeybindings_Call) RunAndReturn(run func(ctx context.Context) error) *MockKeybindingsSaver_ResetAllKeybindings_Call {
2025 _c.Call.Return(run)
2026 return _c
2027}
2028
2029// ResetKeybinding provides a mock function for the type MockKeybindingsSaver
2030func (_mock *MockKeybindingsSaver) ResetKeybinding(ctx context.Context, req port.ResetKeybindingRequest) error {
2031 ret := _mock.Called(ctx, req)
2032
2033 if len(ret) == 0 {
2034 panic("no return value specified for ResetKeybinding")
2035 }
2036
2037 var r0 error
2038 if returnFunc, ok := ret.Get(0).(func(context.Context, port.ResetKeybindingRequest) error); ok {
2039 r0 = returnFunc(ctx, req)
2040 } else {
2041 r0 = ret.Error(0)
2042 }
2043 return r0
2044}
2045
2046// MockKeybindingsSaver_ResetKeybinding_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResetKeybinding'
2047type MockKeybindingsSaver_ResetKeybinding_Call struct {
2048 *mock.Call
2049}
2050
2051// ResetKeybinding is a helper method to define mock.On call
2052// - ctx context.Context
2053// - req port.ResetKeybindingRequest
2054func (_e *MockKeybindingsSaver_Expecter) ResetKeybinding(ctx interface{}, req interface{}) *MockKeybindingsSaver_ResetKeybinding_Call {
2055 return &MockKeybindingsSaver_ResetKeybinding_Call{Call: _e.mock.On("ResetKeybinding", ctx, req)}
2056}
2057
2058func (_c *MockKeybindingsSaver_ResetKeybinding_Call) Run(run func(ctx context.Context, req port.ResetKeybindingRequest)) *MockKeybindingsSaver_ResetKeybinding_Call {
2059 _c.Call.Run(func(args mock.Arguments) {
2060 var arg0 context.Context
2061 if args[0] != nil {
2062 arg0 = args[0].(context.Context)
2063 }
2064 var arg1 port.ResetKeybindingRequest
2065 if args[1] != nil {
2066 arg1 = args[1].(port.ResetKeybindingRequest)
2067 }
2068 run(
2069 arg0,
2070 arg1,
2071 )
2072 })
2073 return _c
2074}
2075
2076func (_c *MockKeybindingsSaver_ResetKeybinding_Call) Return(err error) *MockKeybindingsSaver_ResetKeybinding_Call {
2077 _c.Call.Return(err)
2078 return _c
2079}
2080
2081func (_c *MockKeybindingsSaver_ResetKeybinding_Call) RunAndReturn(run func(ctx context.Context, req port.ResetKeybindingRequest) error) *MockKeybindingsSaver_ResetKeybinding_Call {
2082 _c.Call.Return(run)
2083 return _c
2084}
2085
2086// SetKeybinding provides a mock function for the type MockKeybindingsSaver
2087func (_mock *MockKeybindingsSaver) SetKeybinding(ctx context.Context, req port.SetKeybindingRequest) error {
2088 ret := _mock.Called(ctx, req)
2089
2090 if len(ret) == 0 {
2091 panic("no return value specified for SetKeybinding")
2092 }
2093
2094 var r0 error
2095 if returnFunc, ok := ret.Get(0).(func(context.Context, port.SetKeybindingRequest) error); ok {
2096 r0 = returnFunc(ctx, req)
2097 } else {
2098 r0 = ret.Error(0)
2099 }
2100 return r0
2101}
2102
2103// MockKeybindingsSaver_SetKeybinding_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetKeybinding'
2104type MockKeybindingsSaver_SetKeybinding_Call struct {
2105 *mock.Call
2106}
2107
2108// SetKeybinding is a helper method to define mock.On call
2109// - ctx context.Context
2110// - req port.SetKeybindingRequest
2111func (_e *MockKeybindingsSaver_Expecter) SetKeybinding(ctx interface{}, req interface{}) *MockKeybindingsSaver_SetKeybinding_Call {
2112 return &MockKeybindingsSaver_SetKeybinding_Call{Call: _e.mock.On("SetKeybinding", ctx, req)}
2113}
2114
2115func (_c *MockKeybindingsSaver_SetKeybinding_Call) Run(run func(ctx context.Context, req port.SetKeybindingRequest)) *MockKeybindingsSaver_SetKeybinding_Call {
2116 _c.Call.Run(func(args mock.Arguments) {
2117 var arg0 context.Context
2118 if args[0] != nil {
2119 arg0 = args[0].(context.Context)
2120 }
2121 var arg1 port.SetKeybindingRequest
2122 if args[1] != nil {
2123 arg1 = args[1].(port.SetKeybindingRequest)
2124 }
2125 run(
2126 arg0,
2127 arg1,
2128 )
2129 })
2130 return _c
2131}
2132
2133func (_c *MockKeybindingsSaver_SetKeybinding_Call) Return(err error) *MockKeybindingsSaver_SetKeybinding_Call {
2134 _c.Call.Return(err)
2135 return _c
2136}
2137
2138func (_c *MockKeybindingsSaver_SetKeybinding_Call) RunAndReturn(run func(ctx context.Context, req port.SetKeybindingRequest) error) *MockKeybindingsSaver_SetKeybinding_Call {
2139 _c.Call.Return(run)
2140 return _c
2141}
2142
2143// 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.
2144// The first argument is typically a *testing.T value.
2145func NewMockPermissionDialogPresenter(t interface {
2146 mock.TestingT
2147 Cleanup(func())
2148}) *MockPermissionDialogPresenter {
2149 mock := &MockPermissionDialogPresenter{}
2150 mock.Mock.Test(t)
2151
2152 t.Cleanup(func() { mock.AssertExpectations(t) })
2153
2154 return mock
2155}
2156
2157// MockPermissionDialogPresenter is an autogenerated mock type for the PermissionDialogPresenter type
2158type MockPermissionDialogPresenter struct {
2159 mock.Mock
2160}
2161
2162type MockPermissionDialogPresenter_Expecter struct {
2163 mock *mock.Mock
2164}
2165
2166func (_m *MockPermissionDialogPresenter) EXPECT() *MockPermissionDialogPresenter_Expecter {
2167 return &MockPermissionDialogPresenter_Expecter{mock: &_m.Mock}
2168}
2169
2170// ShowPermissionDialog provides a mock function for the type MockPermissionDialogPresenter
2171func (_mock *MockPermissionDialogPresenter) ShowPermissionDialog(ctx context.Context, origin string, permTypes []entity.PermissionType, callback func(result port.PermissionDialogResult)) {
2172 _mock.Called(ctx, origin, permTypes, callback)
2173 return
2174}
2175
2176// MockPermissionDialogPresenter_ShowPermissionDialog_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ShowPermissionDialog'
2177type MockPermissionDialogPresenter_ShowPermissionDialog_Call struct {
2178 *mock.Call
2179}
2180
2181// ShowPermissionDialog is a helper method to define mock.On call
2182// - ctx context.Context
2183// - origin string
2184// - permTypes []entity.PermissionType
2185// - callback func(result port.PermissionDialogResult)
2186func (_e *MockPermissionDialogPresenter_Expecter) ShowPermissionDialog(ctx interface{}, origin interface{}, permTypes interface{}, callback interface{}) *MockPermissionDialogPresenter_ShowPermissionDialog_Call {
2187 return &MockPermissionDialogPresenter_ShowPermissionDialog_Call{Call: _e.mock.On("ShowPermissionDialog", ctx, origin, permTypes, callback)}
2188}
2189
2190func (_c *MockPermissionDialogPresenter_ShowPermissionDialog_Call) Run(run func(ctx context.Context, origin string, permTypes []entity.PermissionType, callback func(result port.PermissionDialogResult))) *MockPermissionDialogPresenter_ShowPermissionDialog_Call {
2191 _c.Call.Run(func(args mock.Arguments) {
2192 var arg0 context.Context
2193 if args[0] != nil {
2194 arg0 = args[0].(context.Context)
2195 }
2196 var arg1 string
2197 if args[1] != nil {
2198 arg1 = args[1].(string)
2199 }
2200 var arg2 []entity.PermissionType
2201 if args[2] != nil {
2202 arg2 = args[2].([]entity.PermissionType)
2203 }
2204 var arg3 func(result port.PermissionDialogResult)
2205 if args[3] != nil {
2206 arg3 = args[3].(func(result port.PermissionDialogResult))
2207 }
2208 run(
2209 arg0,
2210 arg1,
2211 arg2,
2212 arg3,
2213 )
2214 })
2215 return _c
2216}
2217
2218func (_c *MockPermissionDialogPresenter_ShowPermissionDialog_Call) Return() *MockPermissionDialogPresenter_ShowPermissionDialog_Call {
2219 _c.Call.Return()
2220 return _c
2221}
2222
2223func (_c *MockPermissionDialogPresenter_ShowPermissionDialog_Call) RunAndReturn(run func(ctx context.Context, origin string, permTypes []entity.PermissionType, callback func(result port.PermissionDialogResult))) *MockPermissionDialogPresenter_ShowPermissionDialog_Call {
2224 _c.Run(run)
2225 return _c
2226}
2227
2228// 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.
2229// The first argument is typically a *testing.T value.
2230func NewMockSessionLogger(t interface {
2231 mock.TestingT
2232 Cleanup(func())
2233}) *MockSessionLogger {
2234 mock := &MockSessionLogger{}
2235 mock.Mock.Test(t)
2236
2237 t.Cleanup(func() { mock.AssertExpectations(t) })
2238
2239 return mock
2240}
2241
2242// MockSessionLogger is an autogenerated mock type for the SessionLogger type
2243type MockSessionLogger struct {
2244 mock.Mock
2245}
2246
2247type MockSessionLogger_Expecter struct {
2248 mock *mock.Mock
2249}
2250
2251func (_m *MockSessionLogger) EXPECT() *MockSessionLogger_Expecter {
2252 return &MockSessionLogger_Expecter{mock: &_m.Mock}
2253}
2254
2255// CreateLogger provides a mock function for the type MockSessionLogger
2256func (_mock *MockSessionLogger) CreateLogger(ctx context.Context, sessionID entity.SessionID, cfg port.SessionLogConfig) (zerolog.Logger, func(), error) {
2257 ret := _mock.Called(ctx, sessionID, cfg)
2258
2259 if len(ret) == 0 {
2260 panic("no return value specified for CreateLogger")
2261 }
2262
2263 var r0 zerolog.Logger
2264 var r1 func()
2265 var r2 error
2266 if returnFunc, ok := ret.Get(0).(func(context.Context, entity.SessionID, port.SessionLogConfig) (zerolog.Logger, func(), error)); ok {
2267 return returnFunc(ctx, sessionID, cfg)
2268 }
2269 if returnFunc, ok := ret.Get(0).(func(context.Context, entity.SessionID, port.SessionLogConfig) zerolog.Logger); ok {
2270 r0 = returnFunc(ctx, sessionID, cfg)
2271 } else {
2272 r0 = ret.Get(0).(zerolog.Logger)
2273 }
2274 if returnFunc, ok := ret.Get(1).(func(context.Context, entity.SessionID, port.SessionLogConfig) func()); ok {
2275 r1 = returnFunc(ctx, sessionID, cfg)
2276 } else {
2277 if ret.Get(1) != nil {
2278 r1 = ret.Get(1).(func())
2279 }
2280 }
2281 if returnFunc, ok := ret.Get(2).(func(context.Context, entity.SessionID, port.SessionLogConfig) error); ok {
2282 r2 = returnFunc(ctx, sessionID, cfg)
2283 } else {
2284 r2 = ret.Error(2)
2285 }
2286 return r0, r1, r2
2287}
2288
2289// MockSessionLogger_CreateLogger_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateLogger'
2290type MockSessionLogger_CreateLogger_Call struct {
2291 *mock.Call
2292}
2293
2294// CreateLogger is a helper method to define mock.On call
2295// - ctx context.Context
2296// - sessionID entity.SessionID
2297// - cfg port.SessionLogConfig
2298func (_e *MockSessionLogger_Expecter) CreateLogger(ctx interface{}, sessionID interface{}, cfg interface{}) *MockSessionLogger_CreateLogger_Call {
2299 return &MockSessionLogger_CreateLogger_Call{Call: _e.mock.On("CreateLogger", ctx, sessionID, cfg)}
2300}
2301
2302func (_c *MockSessionLogger_CreateLogger_Call) Run(run func(ctx context.Context, sessionID entity.SessionID, cfg port.SessionLogConfig)) *MockSessionLogger_CreateLogger_Call {
2303 _c.Call.Run(func(args mock.Arguments) {
2304 var arg0 context.Context
2305 if args[0] != nil {
2306 arg0 = args[0].(context.Context)
2307 }
2308 var arg1 entity.SessionID
2309 if args[1] != nil {
2310 arg1 = args[1].(entity.SessionID)
2311 }
2312 var arg2 port.SessionLogConfig
2313 if args[2] != nil {
2314 arg2 = args[2].(port.SessionLogConfig)
2315 }
2316 run(
2317 arg0,
2318 arg1,
2319 arg2,
2320 )
2321 })
2322 return _c
2323}
2324
2325func (_c *MockSessionLogger_CreateLogger_Call) Return(logger zerolog.Logger, fn func(), err error) *MockSessionLogger_CreateLogger_Call {
2326 _c.Call.Return(logger, fn, err)
2327 return _c
2328}
2329
2330func (_c *MockSessionLogger_CreateLogger_Call) RunAndReturn(run func(ctx context.Context, sessionID entity.SessionID, cfg port.SessionLogConfig) (zerolog.Logger, func(), error)) *MockSessionLogger_CreateLogger_Call {
2331 _c.Call.Return(run)
2332 return _c
2333}
2334
2335// 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.
2336// The first argument is typically a *testing.T value.
2337func NewMockTabListProvider(t interface {
2338 mock.TestingT
2339 Cleanup(func())
2340}) *MockTabListProvider {
2341 mock := &MockTabListProvider{}
2342 mock.Mock.Test(t)
2343
2344 t.Cleanup(func() { mock.AssertExpectations(t) })
2345
2346 return mock
2347}
2348
2349// MockTabListProvider is an autogenerated mock type for the TabListProvider type
2350type MockTabListProvider struct {
2351 mock.Mock
2352}
2353
2354type MockTabListProvider_Expecter struct {
2355 mock *mock.Mock
2356}
2357
2358func (_m *MockTabListProvider) EXPECT() *MockTabListProvider_Expecter {
2359 return &MockTabListProvider_Expecter{mock: &_m.Mock}
2360}
2361
2362// GetSessionID provides a mock function for the type MockTabListProvider
2363func (_mock *MockTabListProvider) GetSessionID() entity.SessionID {
2364 ret := _mock.Called()
2365
2366 if len(ret) == 0 {
2367 panic("no return value specified for GetSessionID")
2368 }
2369
2370 var r0 entity.SessionID
2371 if returnFunc, ok := ret.Get(0).(func() entity.SessionID); ok {
2372 r0 = returnFunc()
2373 } else {
2374 r0 = ret.Get(0).(entity.SessionID)
2375 }
2376 return r0
2377}
2378
2379// MockTabListProvider_GetSessionID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSessionID'
2380type MockTabListProvider_GetSessionID_Call struct {
2381 *mock.Call
2382}
2383
2384// GetSessionID is a helper method to define mock.On call
2385func (_e *MockTabListProvider_Expecter) GetSessionID() *MockTabListProvider_GetSessionID_Call {
2386 return &MockTabListProvider_GetSessionID_Call{Call: _e.mock.On("GetSessionID")}
2387}
2388
2389func (_c *MockTabListProvider_GetSessionID_Call) Run(run func()) *MockTabListProvider_GetSessionID_Call {
2390 _c.Call.Run(func(args mock.Arguments) {
2391 run()
2392 })
2393 return _c
2394}
2395
2396func (_c *MockTabListProvider_GetSessionID_Call) Return(sessionID entity.SessionID) *MockTabListProvider_GetSessionID_Call {
2397 _c.Call.Return(sessionID)
2398 return _c
2399}
2400
2401func (_c *MockTabListProvider_GetSessionID_Call) RunAndReturn(run func() entity.SessionID) *MockTabListProvider_GetSessionID_Call {
2402 _c.Call.Return(run)
2403 return _c
2404}
2405
2406// GetTabList provides a mock function for the type MockTabListProvider
2407func (_mock *MockTabListProvider) GetTabList() *entity.TabList {
2408 ret := _mock.Called()
2409
2410 if len(ret) == 0 {
2411 panic("no return value specified for GetTabList")
2412 }
2413
2414 var r0 *entity.TabList
2415 if returnFunc, ok := ret.Get(0).(func() *entity.TabList); ok {
2416 r0 = returnFunc()
2417 } else {
2418 if ret.Get(0) != nil {
2419 r0 = ret.Get(0).(*entity.TabList)
2420 }
2421 }
2422 return r0
2423}
2424
2425// MockTabListProvider_GetTabList_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTabList'
2426type MockTabListProvider_GetTabList_Call struct {
2427 *mock.Call
2428}
2429
2430// GetTabList is a helper method to define mock.On call
2431func (_e *MockTabListProvider_Expecter) GetTabList() *MockTabListProvider_GetTabList_Call {
2432 return &MockTabListProvider_GetTabList_Call{Call: _e.mock.On("GetTabList")}
2433}
2434
2435func (_c *MockTabListProvider_GetTabList_Call) Run(run func()) *MockTabListProvider_GetTabList_Call {
2436 _c.Call.Run(func(args mock.Arguments) {
2437 run()
2438 })
2439 return _c
2440}
2441
2442func (_c *MockTabListProvider_GetTabList_Call) Return(tabList *entity.TabList) *MockTabListProvider_GetTabList_Call {
2443 _c.Call.Return(tabList)
2444 return _c
2445}
2446
2447func (_c *MockTabListProvider_GetTabList_Call) RunAndReturn(run func() *entity.TabList) *MockTabListProvider_GetTabList_Call {
2448 _c.Call.Return(run)
2449 return _c
2450}
2451
2452// 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.
2453// The first argument is typically a *testing.T value.
2454func NewMockSessionSpawner(t interface {
2455 mock.TestingT
2456 Cleanup(func())
2457}) *MockSessionSpawner {
2458 mock := &MockSessionSpawner{}
2459 mock.Mock.Test(t)
2460
2461 t.Cleanup(func() { mock.AssertExpectations(t) })
2462
2463 return mock
2464}
2465
2466// MockSessionSpawner is an autogenerated mock type for the SessionSpawner type
2467type MockSessionSpawner struct {
2468 mock.Mock
2469}
2470
2471type MockSessionSpawner_Expecter struct {
2472 mock *mock.Mock
2473}
2474
2475func (_m *MockSessionSpawner) EXPECT() *MockSessionSpawner_Expecter {
2476 return &MockSessionSpawner_Expecter{mock: &_m.Mock}
2477}
2478
2479// SpawnWithSession provides a mock function for the type MockSessionSpawner
2480func (_mock *MockSessionSpawner) SpawnWithSession(sessionID entity.SessionID) error {
2481 ret := _mock.Called(sessionID)
2482
2483 if len(ret) == 0 {
2484 panic("no return value specified for SpawnWithSession")
2485 }
2486
2487 var r0 error
2488 if returnFunc, ok := ret.Get(0).(func(entity.SessionID) error); ok {
2489 r0 = returnFunc(sessionID)
2490 } else {
2491 r0 = ret.Error(0)
2492 }
2493 return r0
2494}
2495
2496// MockSessionSpawner_SpawnWithSession_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SpawnWithSession'
2497type MockSessionSpawner_SpawnWithSession_Call struct {
2498 *mock.Call
2499}
2500
2501// SpawnWithSession is a helper method to define mock.On call
2502// - sessionID entity.SessionID
2503func (_e *MockSessionSpawner_Expecter) SpawnWithSession(sessionID interface{}) *MockSessionSpawner_SpawnWithSession_Call {
2504 return &MockSessionSpawner_SpawnWithSession_Call{Call: _e.mock.On("SpawnWithSession", sessionID)}
2505}
2506
2507func (_c *MockSessionSpawner_SpawnWithSession_Call) Run(run func(sessionID entity.SessionID)) *MockSessionSpawner_SpawnWithSession_Call {
2508 _c.Call.Run(func(args mock.Arguments) {
2509 var arg0 entity.SessionID
2510 if args[0] != nil {
2511 arg0 = args[0].(entity.SessionID)
2512 }
2513 run(
2514 arg0,
2515 )
2516 })
2517 return _c
2518}
2519
2520func (_c *MockSessionSpawner_SpawnWithSession_Call) Return(err error) *MockSessionSpawner_SpawnWithSession_Call {
2521 _c.Call.Return(err)
2522 return _c
2523}
2524
2525func (_c *MockSessionSpawner_SpawnWithSession_Call) RunAndReturn(run func(sessionID entity.SessionID) error) *MockSessionSpawner_SpawnWithSession_Call {
2526 _c.Call.Return(run)
2527 return _c
2528}
2529
2530// 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.
2531// The first argument is typically a *testing.T value.
2532func NewMockTextInputTarget(t interface {
2533 mock.TestingT
2534 Cleanup(func())
2535}) *MockTextInputTarget {
2536 mock := &MockTextInputTarget{}
2537 mock.Mock.Test(t)
2538
2539 t.Cleanup(func() { mock.AssertExpectations(t) })
2540
2541 return mock
2542}
2543
2544// MockTextInputTarget is an autogenerated mock type for the TextInputTarget type
2545type MockTextInputTarget struct {
2546 mock.Mock
2547}
2548
2549type MockTextInputTarget_Expecter struct {
2550 mock *mock.Mock
2551}
2552
2553func (_m *MockTextInputTarget) EXPECT() *MockTextInputTarget_Expecter {
2554 return &MockTextInputTarget_Expecter{mock: &_m.Mock}
2555}
2556
2557// DeleteBeforeCursor provides a mock function for the type MockTextInputTarget
2558func (_mock *MockTextInputTarget) DeleteBeforeCursor(ctx context.Context, n int) error {
2559 ret := _mock.Called(ctx, n)
2560
2561 if len(ret) == 0 {
2562 panic("no return value specified for DeleteBeforeCursor")
2563 }
2564
2565 var r0 error
2566 if returnFunc, ok := ret.Get(0).(func(context.Context, int) error); ok {
2567 r0 = returnFunc(ctx, n)
2568 } else {
2569 r0 = ret.Error(0)
2570 }
2571 return r0
2572}
2573
2574// MockTextInputTarget_DeleteBeforeCursor_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteBeforeCursor'
2575type MockTextInputTarget_DeleteBeforeCursor_Call struct {
2576 *mock.Call
2577}
2578
2579// DeleteBeforeCursor is a helper method to define mock.On call
2580// - ctx context.Context
2581// - n int
2582func (_e *MockTextInputTarget_Expecter) DeleteBeforeCursor(ctx interface{}, n interface{}) *MockTextInputTarget_DeleteBeforeCursor_Call {
2583 return &MockTextInputTarget_DeleteBeforeCursor_Call{Call: _e.mock.On("DeleteBeforeCursor", ctx, n)}
2584}
2585
2586func (_c *MockTextInputTarget_DeleteBeforeCursor_Call) Run(run func(ctx context.Context, n int)) *MockTextInputTarget_DeleteBeforeCursor_Call {
2587 _c.Call.Run(func(args mock.Arguments) {
2588 var arg0 context.Context
2589 if args[0] != nil {
2590 arg0 = args[0].(context.Context)
2591 }
2592 var arg1 int
2593 if args[1] != nil {
2594 arg1 = args[1].(int)
2595 }
2596 run(
2597 arg0,
2598 arg1,
2599 )
2600 })
2601 return _c
2602}
2603
2604func (_c *MockTextInputTarget_DeleteBeforeCursor_Call) Return(err error) *MockTextInputTarget_DeleteBeforeCursor_Call {
2605 _c.Call.Return(err)
2606 return _c
2607}
2608
2609func (_c *MockTextInputTarget_DeleteBeforeCursor_Call) RunAndReturn(run func(ctx context.Context, n int) error) *MockTextInputTarget_DeleteBeforeCursor_Call {
2610 _c.Call.Return(run)
2611 return _c
2612}
2613
2614// InsertText provides a mock function for the type MockTextInputTarget
2615func (_mock *MockTextInputTarget) InsertText(ctx context.Context, text string) error {
2616 ret := _mock.Called(ctx, text)
2617
2618 if len(ret) == 0 {
2619 panic("no return value specified for InsertText")
2620 }
2621
2622 var r0 error
2623 if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
2624 r0 = returnFunc(ctx, text)
2625 } else {
2626 r0 = ret.Error(0)
2627 }
2628 return r0
2629}
2630
2631// MockTextInputTarget_InsertText_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'InsertText'
2632type MockTextInputTarget_InsertText_Call struct {
2633 *mock.Call
2634}
2635
2636// InsertText is a helper method to define mock.On call
2637// - ctx context.Context
2638// - text string
2639func (_e *MockTextInputTarget_Expecter) InsertText(ctx interface{}, text interface{}) *MockTextInputTarget_InsertText_Call {
2640 return &MockTextInputTarget_InsertText_Call{Call: _e.mock.On("InsertText", ctx, text)}
2641}
2642
2643func (_c *MockTextInputTarget_InsertText_Call) Run(run func(ctx context.Context, text string)) *MockTextInputTarget_InsertText_Call {
2644 _c.Call.Run(func(args mock.Arguments) {
2645 var arg0 context.Context
2646 if args[0] != nil {
2647 arg0 = args[0].(context.Context)
2648 }
2649 var arg1 string
2650 if args[1] != nil {
2651 arg1 = args[1].(string)
2652 }
2653 run(
2654 arg0,
2655 arg1,
2656 )
2657 })
2658 return _c
2659}
2660
2661func (_c *MockTextInputTarget_InsertText_Call) Return(err error) *MockTextInputTarget_InsertText_Call {
2662 _c.Call.Return(err)
2663 return _c
2664}
2665
2666func (_c *MockTextInputTarget_InsertText_Call) RunAndReturn(run func(ctx context.Context, text string) error) *MockTextInputTarget_InsertText_Call {
2667 _c.Call.Return(run)
2668 return _c
2669}
2670
2671// 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.
2672// The first argument is typically a *testing.T value.
2673func NewMockFocusedInputProvider(t interface {
2674 mock.TestingT
2675 Cleanup(func())
2676}) *MockFocusedInputProvider {
2677 mock := &MockFocusedInputProvider{}
2678 mock.Mock.Test(t)
2679
2680 t.Cleanup(func() { mock.AssertExpectations(t) })
2681
2682 return mock
2683}
2684
2685// MockFocusedInputProvider is an autogenerated mock type for the FocusedInputProvider type
2686type MockFocusedInputProvider struct {
2687 mock.Mock
2688}
2689
2690type MockFocusedInputProvider_Expecter struct {
2691 mock *mock.Mock
2692}
2693
2694func (_m *MockFocusedInputProvider) EXPECT() *MockFocusedInputProvider_Expecter {
2695 return &MockFocusedInputProvider_Expecter{mock: &_m.Mock}
2696}
2697
2698// GetFocusedInput provides a mock function for the type MockFocusedInputProvider
2699func (_mock *MockFocusedInputProvider) GetFocusedInput() port.TextInputTarget {
2700 ret := _mock.Called()
2701
2702 if len(ret) == 0 {
2703 panic("no return value specified for GetFocusedInput")
2704 }
2705
2706 var r0 port.TextInputTarget
2707 if returnFunc, ok := ret.Get(0).(func() port.TextInputTarget); ok {
2708 r0 = returnFunc()
2709 } else {
2710 if ret.Get(0) != nil {
2711 r0 = ret.Get(0).(port.TextInputTarget)
2712 }
2713 }
2714 return r0
2715}
2716
2717// MockFocusedInputProvider_GetFocusedInput_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetFocusedInput'
2718type MockFocusedInputProvider_GetFocusedInput_Call struct {
2719 *mock.Call
2720}
2721
2722// GetFocusedInput is a helper method to define mock.On call
2723func (_e *MockFocusedInputProvider_Expecter) GetFocusedInput() *MockFocusedInputProvider_GetFocusedInput_Call {
2724 return &MockFocusedInputProvider_GetFocusedInput_Call{Call: _e.mock.On("GetFocusedInput")}
2725}
2726
2727func (_c *MockFocusedInputProvider_GetFocusedInput_Call) Run(run func()) *MockFocusedInputProvider_GetFocusedInput_Call {
2728 _c.Call.Run(func(args mock.Arguments) {
2729 run()
2730 })
2731 return _c
2732}
2733
2734func (_c *MockFocusedInputProvider_GetFocusedInput_Call) Return(textInputTarget port.TextInputTarget) *MockFocusedInputProvider_GetFocusedInput_Call {
2735 _c.Call.Return(textInputTarget)
2736 return _c
2737}
2738
2739func (_c *MockFocusedInputProvider_GetFocusedInput_Call) RunAndReturn(run func() port.TextInputTarget) *MockFocusedInputProvider_GetFocusedInput_Call {
2740 _c.Call.Return(run)
2741 return _c
2742}
2743
2744// SetFocusedInput provides a mock function for the type MockFocusedInputProvider
2745func (_mock *MockFocusedInputProvider) SetFocusedInput(target port.TextInputTarget) {
2746 _mock.Called(target)
2747 return
2748}
2749
2750// MockFocusedInputProvider_SetFocusedInput_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetFocusedInput'
2751type MockFocusedInputProvider_SetFocusedInput_Call struct {
2752 *mock.Call
2753}
2754
2755// SetFocusedInput is a helper method to define mock.On call
2756// - target port.TextInputTarget
2757func (_e *MockFocusedInputProvider_Expecter) SetFocusedInput(target interface{}) *MockFocusedInputProvider_SetFocusedInput_Call {
2758 return &MockFocusedInputProvider_SetFocusedInput_Call{Call: _e.mock.On("SetFocusedInput", target)}
2759}
2760
2761func (_c *MockFocusedInputProvider_SetFocusedInput_Call) Run(run func(target port.TextInputTarget)) *MockFocusedInputProvider_SetFocusedInput_Call {
2762 _c.Call.Run(func(args mock.Arguments) {
2763 var arg0 port.TextInputTarget
2764 if args[0] != nil {
2765 arg0 = args[0].(port.TextInputTarget)
2766 }
2767 run(
2768 arg0,
2769 )
2770 })
2771 return _c
2772}
2773
2774func (_c *MockFocusedInputProvider_SetFocusedInput_Call) Return() *MockFocusedInputProvider_SetFocusedInput_Call {
2775 _c.Call.Return()
2776 return _c
2777}
2778
2779func (_c *MockFocusedInputProvider_SetFocusedInput_Call) RunAndReturn(run func(target port.TextInputTarget)) *MockFocusedInputProvider_SetFocusedInput_Call {
2780 _c.Run(run)
2781 return _c
2782}
2783
2784// 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.
2785// The first argument is typically a *testing.T value.
2786func NewMockMemoryPressureApplier(t interface {
2787 mock.TestingT
2788 Cleanup(func())
2789}) *MockMemoryPressureApplier {
2790 mock := &MockMemoryPressureApplier{}
2791 mock.Mock.Test(t)
2792
2793 t.Cleanup(func() { mock.AssertExpectations(t) })
2794
2795 return mock
2796}
2797
2798// MockMemoryPressureApplier is an autogenerated mock type for the MemoryPressureApplier type
2799type MockMemoryPressureApplier struct {
2800 mock.Mock
2801}
2802
2803type MockMemoryPressureApplier_Expecter struct {
2804 mock *mock.Mock
2805}
2806
2807func (_m *MockMemoryPressureApplier) EXPECT() *MockMemoryPressureApplier_Expecter {
2808 return &MockMemoryPressureApplier_Expecter{mock: &_m.Mock}
2809}
2810
2811// ApplyNetworkProcessSettings provides a mock function for the type MockMemoryPressureApplier
2812func (_mock *MockMemoryPressureApplier) ApplyNetworkProcessSettings(ctx context.Context, cfg *port.MemoryPressureConfig) error {
2813 ret := _mock.Called(ctx, cfg)
2814
2815 if len(ret) == 0 {
2816 panic("no return value specified for ApplyNetworkProcessSettings")
2817 }
2818
2819 var r0 error
2820 if returnFunc, ok := ret.Get(0).(func(context.Context, *port.MemoryPressureConfig) error); ok {
2821 r0 = returnFunc(ctx, cfg)
2822 } else {
2823 r0 = ret.Error(0)
2824 }
2825 return r0
2826}
2827
2828// MockMemoryPressureApplier_ApplyNetworkProcessSettings_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ApplyNetworkProcessSettings'
2829type MockMemoryPressureApplier_ApplyNetworkProcessSettings_Call struct {
2830 *mock.Call
2831}
2832
2833// ApplyNetworkProcessSettings is a helper method to define mock.On call
2834// - ctx context.Context
2835// - cfg *port.MemoryPressureConfig
2836func (_e *MockMemoryPressureApplier_Expecter) ApplyNetworkProcessSettings(ctx interface{}, cfg interface{}) *MockMemoryPressureApplier_ApplyNetworkProcessSettings_Call {
2837 return &MockMemoryPressureApplier_ApplyNetworkProcessSettings_Call{Call: _e.mock.On("ApplyNetworkProcessSettings", ctx, cfg)}
2838}
2839
2840func (_c *MockMemoryPressureApplier_ApplyNetworkProcessSettings_Call) Run(run func(ctx context.Context, cfg *port.MemoryPressureConfig)) *MockMemoryPressureApplier_ApplyNetworkProcessSettings_Call {
2841 _c.Call.Run(func(args mock.Arguments) {
2842 var arg0 context.Context
2843 if args[0] != nil {
2844 arg0 = args[0].(context.Context)
2845 }
2846 var arg1 *port.MemoryPressureConfig
2847 if args[1] != nil {
2848 arg1 = args[1].(*port.MemoryPressureConfig)
2849 }
2850 run(
2851 arg0,
2852 arg1,
2853 )
2854 })
2855 return _c
2856}
2857
2858func (_c *MockMemoryPressureApplier_ApplyNetworkProcessSettings_Call) Return(err error) *MockMemoryPressureApplier_ApplyNetworkProcessSettings_Call {
2859 _c.Call.Return(err)
2860 return _c
2861}
2862
2863func (_c *MockMemoryPressureApplier_ApplyNetworkProcessSettings_Call) RunAndReturn(run func(ctx context.Context, cfg *port.MemoryPressureConfig) error) *MockMemoryPressureApplier_ApplyNetworkProcessSettings_Call {
2864 _c.Call.Return(run)
2865 return _c
2866}
2867
2868// ApplyWebProcessSettings provides a mock function for the type MockMemoryPressureApplier
2869func (_mock *MockMemoryPressureApplier) ApplyWebProcessSettings(ctx context.Context, cfg *port.MemoryPressureConfig) (any, error) {
2870 ret := _mock.Called(ctx, cfg)
2871
2872 if len(ret) == 0 {
2873 panic("no return value specified for ApplyWebProcessSettings")
2874 }
2875
2876 var r0 any
2877 var r1 error
2878 if returnFunc, ok := ret.Get(0).(func(context.Context, *port.MemoryPressureConfig) (any, error)); ok {
2879 return returnFunc(ctx, cfg)
2880 }
2881 if returnFunc, ok := ret.Get(0).(func(context.Context, *port.MemoryPressureConfig) any); ok {
2882 r0 = returnFunc(ctx, cfg)
2883 } else {
2884 if ret.Get(0) != nil {
2885 r0 = ret.Get(0).(any)
2886 }
2887 }
2888 if returnFunc, ok := ret.Get(1).(func(context.Context, *port.MemoryPressureConfig) error); ok {
2889 r1 = returnFunc(ctx, cfg)
2890 } else {
2891 r1 = ret.Error(1)
2892 }
2893 return r0, r1
2894}
2895
2896// MockMemoryPressureApplier_ApplyWebProcessSettings_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ApplyWebProcessSettings'
2897type MockMemoryPressureApplier_ApplyWebProcessSettings_Call struct {
2898 *mock.Call
2899}
2900
2901// ApplyWebProcessSettings is a helper method to define mock.On call
2902// - ctx context.Context
2903// - cfg *port.MemoryPressureConfig
2904func (_e *MockMemoryPressureApplier_Expecter) ApplyWebProcessSettings(ctx interface{}, cfg interface{}) *MockMemoryPressureApplier_ApplyWebProcessSettings_Call {
2905 return &MockMemoryPressureApplier_ApplyWebProcessSettings_Call{Call: _e.mock.On("ApplyWebProcessSettings", ctx, cfg)}
2906}
2907
2908func (_c *MockMemoryPressureApplier_ApplyWebProcessSettings_Call) Run(run func(ctx context.Context, cfg *port.MemoryPressureConfig)) *MockMemoryPressureApplier_ApplyWebProcessSettings_Call {
2909 _c.Call.Run(func(args mock.Arguments) {
2910 var arg0 context.Context
2911 if args[0] != nil {
2912 arg0 = args[0].(context.Context)
2913 }
2914 var arg1 *port.MemoryPressureConfig
2915 if args[1] != nil {
2916 arg1 = args[1].(*port.MemoryPressureConfig)
2917 }
2918 run(
2919 arg0,
2920 arg1,
2921 )
2922 })
2923 return _c
2924}
2925
2926func (_c *MockMemoryPressureApplier_ApplyWebProcessSettings_Call) Return(v any, err error) *MockMemoryPressureApplier_ApplyWebProcessSettings_Call {
2927 _c.Call.Return(v, err)
2928 return _c
2929}
2930
2931func (_c *MockMemoryPressureApplier_ApplyWebProcessSettings_Call) RunAndReturn(run func(ctx context.Context, cfg *port.MemoryPressureConfig) (any, error)) *MockMemoryPressureApplier_ApplyWebProcessSettings_Call {
2932 _c.Call.Return(run)
2933 return _c
2934}
2935
2936// NewMockWebKitContextProvider creates a new instance of MockWebKitContextProvider. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
2937// The first argument is typically a *testing.T value.
2938func NewMockWebKitContextProvider(t interface {
2939 mock.TestingT
2940 Cleanup(func())
2941}) *MockWebKitContextProvider {
2942 mock := &MockWebKitContextProvider{}
2943 mock.Mock.Test(t)
2944
2945 t.Cleanup(func() { mock.AssertExpectations(t) })
2946
2947 return mock
2948}
2949
2950// MockWebKitContextProvider is an autogenerated mock type for the WebKitContextProvider type
2951type MockWebKitContextProvider struct {
2952 mock.Mock
2953}
2954
2955type MockWebKitContextProvider_Expecter struct {
2956 mock *mock.Mock
2957}
2958
2959func (_m *MockWebKitContextProvider) EXPECT() *MockWebKitContextProvider_Expecter {
2960 return &MockWebKitContextProvider_Expecter{mock: &_m.Mock}
2961}
2962
2963// CacheDir provides a mock function for the type MockWebKitContextProvider
2964func (_mock *MockWebKitContextProvider) CacheDir() string {
2965 ret := _mock.Called()
2966
2967 if len(ret) == 0 {
2968 panic("no return value specified for CacheDir")
2969 }
2970
2971 var r0 string
2972 if returnFunc, ok := ret.Get(0).(func() string); ok {
2973 r0 = returnFunc()
2974 } else {
2975 r0 = ret.Get(0).(string)
2976 }
2977 return r0
2978}
2979
2980// MockWebKitContextProvider_CacheDir_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CacheDir'
2981type MockWebKitContextProvider_CacheDir_Call struct {
2982 *mock.Call
2983}
2984
2985// CacheDir is a helper method to define mock.On call
2986func (_e *MockWebKitContextProvider_Expecter) CacheDir() *MockWebKitContextProvider_CacheDir_Call {
2987 return &MockWebKitContextProvider_CacheDir_Call{Call: _e.mock.On("CacheDir")}
2988}
2989
2990func (_c *MockWebKitContextProvider_CacheDir_Call) Run(run func()) *MockWebKitContextProvider_CacheDir_Call {
2991 _c.Call.Run(func(args mock.Arguments) {
2992 run()
2993 })
2994 return _c
2995}
2996
2997func (_c *MockWebKitContextProvider_CacheDir_Call) Return(s string) *MockWebKitContextProvider_CacheDir_Call {
2998 _c.Call.Return(s)
2999 return _c
3000}
3001
3002func (_c *MockWebKitContextProvider_CacheDir_Call) RunAndReturn(run func() string) *MockWebKitContextProvider_CacheDir_Call {
3003 _c.Call.Return(run)
3004 return _c
3005}
3006
3007// Close provides a mock function for the type MockWebKitContextProvider
3008func (_mock *MockWebKitContextProvider) Close() error {
3009 ret := _mock.Called()
3010
3011 if len(ret) == 0 {
3012 panic("no return value specified for Close")
3013 }
3014
3015 var r0 error
3016 if returnFunc, ok := ret.Get(0).(func() error); ok {
3017 r0 = returnFunc()
3018 } else {
3019 r0 = ret.Error(0)
3020 }
3021 return r0
3022}
3023
3024// MockWebKitContextProvider_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
3025type MockWebKitContextProvider_Close_Call struct {
3026 *mock.Call
3027}
3028
3029// Close is a helper method to define mock.On call
3030func (_e *MockWebKitContextProvider_Expecter) Close() *MockWebKitContextProvider_Close_Call {
3031 return &MockWebKitContextProvider_Close_Call{Call: _e.mock.On("Close")}
3032}
3033
3034func (_c *MockWebKitContextProvider_Close_Call) Run(run func()) *MockWebKitContextProvider_Close_Call {
3035 _c.Call.Run(func(args mock.Arguments) {
3036 run()
3037 })
3038 return _c
3039}
3040
3041func (_c *MockWebKitContextProvider_Close_Call) Return(err error) *MockWebKitContextProvider_Close_Call {
3042 _c.Call.Return(err)
3043 return _c
3044}
3045
3046func (_c *MockWebKitContextProvider_Close_Call) RunAndReturn(run func() error) *MockWebKitContextProvider_Close_Call {
3047 _c.Call.Return(run)
3048 return _c
3049}
3050
3051// DataDir provides a mock function for the type MockWebKitContextProvider
3052func (_mock *MockWebKitContextProvider) DataDir() string {
3053 ret := _mock.Called()
3054
3055 if len(ret) == 0 {
3056 panic("no return value specified for DataDir")
3057 }
3058
3059 var r0 string
3060 if returnFunc, ok := ret.Get(0).(func() string); ok {
3061 r0 = returnFunc()
3062 } else {
3063 r0 = ret.Get(0).(string)
3064 }
3065 return r0
3066}
3067
3068// MockWebKitContextProvider_DataDir_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DataDir'
3069type MockWebKitContextProvider_DataDir_Call struct {
3070 *mock.Call
3071}
3072
3073// DataDir is a helper method to define mock.On call
3074func (_e *MockWebKitContextProvider_Expecter) DataDir() *MockWebKitContextProvider_DataDir_Call {
3075 return &MockWebKitContextProvider_DataDir_Call{Call: _e.mock.On("DataDir")}
3076}
3077
3078func (_c *MockWebKitContextProvider_DataDir_Call) Run(run func()) *MockWebKitContextProvider_DataDir_Call {
3079 _c.Call.Run(func(args mock.Arguments) {
3080 run()
3081 })
3082 return _c
3083}
3084
3085func (_c *MockWebKitContextProvider_DataDir_Call) Return(s string) *MockWebKitContextProvider_DataDir_Call {
3086 _c.Call.Return(s)
3087 return _c
3088}
3089
3090func (_c *MockWebKitContextProvider_DataDir_Call) RunAndReturn(run func() string) *MockWebKitContextProvider_DataDir_Call {
3091 _c.Call.Return(run)
3092 return _c
3093}
3094
3095// Initialize provides a mock function for the type MockWebKitContextProvider
3096func (_mock *MockWebKitContextProvider) Initialize(ctx context.Context, opts port.WebKitContextOptions) error {
3097 ret := _mock.Called(ctx, opts)
3098
3099 if len(ret) == 0 {
3100 panic("no return value specified for Initialize")
3101 }
3102
3103 var r0 error
3104 if returnFunc, ok := ret.Get(0).(func(context.Context, port.WebKitContextOptions) error); ok {
3105 r0 = returnFunc(ctx, opts)
3106 } else {
3107 r0 = ret.Error(0)
3108 }
3109 return r0
3110}
3111
3112// MockWebKitContextProvider_Initialize_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Initialize'
3113type MockWebKitContextProvider_Initialize_Call struct {
3114 *mock.Call
3115}
3116
3117// Initialize is a helper method to define mock.On call
3118// - ctx context.Context
3119// - opts port.WebKitContextOptions
3120func (_e *MockWebKitContextProvider_Expecter) Initialize(ctx interface{}, opts interface{}) *MockWebKitContextProvider_Initialize_Call {
3121 return &MockWebKitContextProvider_Initialize_Call{Call: _e.mock.On("Initialize", ctx, opts)}
3122}
3123
3124func (_c *MockWebKitContextProvider_Initialize_Call) Run(run func(ctx context.Context, opts port.WebKitContextOptions)) *MockWebKitContextProvider_Initialize_Call {
3125 _c.Call.Run(func(args mock.Arguments) {
3126 var arg0 context.Context
3127 if args[0] != nil {
3128 arg0 = args[0].(context.Context)
3129 }
3130 var arg1 port.WebKitContextOptions
3131 if args[1] != nil {
3132 arg1 = args[1].(port.WebKitContextOptions)
3133 }
3134 run(
3135 arg0,
3136 arg1,
3137 )
3138 })
3139 return _c
3140}
3141
3142func (_c *MockWebKitContextProvider_Initialize_Call) Return(err error) *MockWebKitContextProvider_Initialize_Call {
3143 _c.Call.Return(err)
3144 return _c
3145}
3146
3147func (_c *MockWebKitContextProvider_Initialize_Call) RunAndReturn(run func(ctx context.Context, opts port.WebKitContextOptions) error) *MockWebKitContextProvider_Initialize_Call {
3148 _c.Call.Return(run)
3149 return _c
3150}
3151
3152// PrefetchDNS provides a mock function for the type MockWebKitContextProvider
3153func (_mock *MockWebKitContextProvider) PrefetchDNS(hostname string) {
3154 _mock.Called(hostname)
3155 return
3156}
3157
3158// MockWebKitContextProvider_PrefetchDNS_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PrefetchDNS'
3159type MockWebKitContextProvider_PrefetchDNS_Call struct {
3160 *mock.Call
3161}
3162
3163// PrefetchDNS is a helper method to define mock.On call
3164// - hostname string
3165func (_e *MockWebKitContextProvider_Expecter) PrefetchDNS(hostname interface{}) *MockWebKitContextProvider_PrefetchDNS_Call {
3166 return &MockWebKitContextProvider_PrefetchDNS_Call{Call: _e.mock.On("PrefetchDNS", hostname)}
3167}
3168
3169func (_c *MockWebKitContextProvider_PrefetchDNS_Call) Run(run func(hostname string)) *MockWebKitContextProvider_PrefetchDNS_Call {
3170 _c.Call.Run(func(args mock.Arguments) {
3171 var arg0 string
3172 if args[0] != nil {
3173 arg0 = args[0].(string)
3174 }
3175 run(
3176 arg0,
3177 )
3178 })
3179 return _c
3180}
3181
3182func (_c *MockWebKitContextProvider_PrefetchDNS_Call) Return() *MockWebKitContextProvider_PrefetchDNS_Call {
3183 _c.Call.Return()
3184 return _c
3185}
3186
3187func (_c *MockWebKitContextProvider_PrefetchDNS_Call) RunAndReturn(run func(hostname string)) *MockWebKitContextProvider_PrefetchDNS_Call {
3188 _c.Run(run)
3189 return _c
3190}
3191
3192// 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.
3193// The first argument is typically a *testing.T value.
3194func NewMockWebView(t interface {
3195 mock.TestingT
3196 Cleanup(func())
3197}) *MockWebView {
3198 mock := &MockWebView{}
3199 mock.Mock.Test(t)
3200
3201 t.Cleanup(func() { mock.AssertExpectations(t) })
3202
3203 return mock
3204}
3205
3206// MockWebView is an autogenerated mock type for the WebView type
3207type MockWebView struct {
3208 mock.Mock
3209}
3210
3211type MockWebView_Expecter struct {
3212 mock *mock.Mock
3213}
3214
3215func (_m *MockWebView) EXPECT() *MockWebView_Expecter {
3216 return &MockWebView_Expecter{mock: &_m.Mock}
3217}
3218
3219// CanGoBack provides a mock function for the type MockWebView
3220func (_mock *MockWebView) CanGoBack() bool {
3221 ret := _mock.Called()
3222
3223 if len(ret) == 0 {
3224 panic("no return value specified for CanGoBack")
3225 }
3226
3227 var r0 bool
3228 if returnFunc, ok := ret.Get(0).(func() bool); ok {
3229 r0 = returnFunc()
3230 } else {
3231 r0 = ret.Get(0).(bool)
3232 }
3233 return r0
3234}
3235
3236// MockWebView_CanGoBack_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CanGoBack'
3237type MockWebView_CanGoBack_Call struct {
3238 *mock.Call
3239}
3240
3241// CanGoBack is a helper method to define mock.On call
3242func (_e *MockWebView_Expecter) CanGoBack() *MockWebView_CanGoBack_Call {
3243 return &MockWebView_CanGoBack_Call{Call: _e.mock.On("CanGoBack")}
3244}
3245
3246func (_c *MockWebView_CanGoBack_Call) Run(run func()) *MockWebView_CanGoBack_Call {
3247 _c.Call.Run(func(args mock.Arguments) {
3248 run()
3249 })
3250 return _c
3251}
3252
3253func (_c *MockWebView_CanGoBack_Call) Return(b bool) *MockWebView_CanGoBack_Call {
3254 _c.Call.Return(b)
3255 return _c
3256}
3257
3258func (_c *MockWebView_CanGoBack_Call) RunAndReturn(run func() bool) *MockWebView_CanGoBack_Call {
3259 _c.Call.Return(run)
3260 return _c
3261}
3262
3263// CanGoForward provides a mock function for the type MockWebView
3264func (_mock *MockWebView) CanGoForward() bool {
3265 ret := _mock.Called()
3266
3267 if len(ret) == 0 {
3268 panic("no return value specified for CanGoForward")
3269 }
3270
3271 var r0 bool
3272 if returnFunc, ok := ret.Get(0).(func() bool); ok {
3273 r0 = returnFunc()
3274 } else {
3275 r0 = ret.Get(0).(bool)
3276 }
3277 return r0
3278}
3279
3280// MockWebView_CanGoForward_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CanGoForward'
3281type MockWebView_CanGoForward_Call struct {
3282 *mock.Call
3283}
3284
3285// CanGoForward is a helper method to define mock.On call
3286func (_e *MockWebView_Expecter) CanGoForward() *MockWebView_CanGoForward_Call {
3287 return &MockWebView_CanGoForward_Call{Call: _e.mock.On("CanGoForward")}
3288}
3289
3290func (_c *MockWebView_CanGoForward_Call) Run(run func()) *MockWebView_CanGoForward_Call {
3291 _c.Call.Run(func(args mock.Arguments) {
3292 run()
3293 })
3294 return _c
3295}
3296
3297func (_c *MockWebView_CanGoForward_Call) Return(b bool) *MockWebView_CanGoForward_Call {
3298 _c.Call.Return(b)
3299 return _c
3300}
3301
3302func (_c *MockWebView_CanGoForward_Call) RunAndReturn(run func() bool) *MockWebView_CanGoForward_Call {
3303 _c.Call.Return(run)
3304 return _c
3305}
3306
3307// Destroy provides a mock function for the type MockWebView
3308func (_mock *MockWebView) Destroy() {
3309 _mock.Called()
3310 return
3311}
3312
3313// MockWebView_Destroy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Destroy'
3314type MockWebView_Destroy_Call struct {
3315 *mock.Call
3316}
3317
3318// Destroy is a helper method to define mock.On call
3319func (_e *MockWebView_Expecter) Destroy() *MockWebView_Destroy_Call {
3320 return &MockWebView_Destroy_Call{Call: _e.mock.On("Destroy")}
3321}
3322
3323func (_c *MockWebView_Destroy_Call) Run(run func()) *MockWebView_Destroy_Call {
3324 _c.Call.Run(func(args mock.Arguments) {
3325 run()
3326 })
3327 return _c
3328}
3329
3330func (_c *MockWebView_Destroy_Call) Return() *MockWebView_Destroy_Call {
3331 _c.Call.Return()
3332 return _c
3333}
3334
3335func (_c *MockWebView_Destroy_Call) RunAndReturn(run func()) *MockWebView_Destroy_Call {
3336 _c.Run(run)
3337 return _c
3338}
3339
3340// EstimatedProgress provides a mock function for the type MockWebView
3341func (_mock *MockWebView) EstimatedProgress() float64 {
3342 ret := _mock.Called()
3343
3344 if len(ret) == 0 {
3345 panic("no return value specified for EstimatedProgress")
3346 }
3347
3348 var r0 float64
3349 if returnFunc, ok := ret.Get(0).(func() float64); ok {
3350 r0 = returnFunc()
3351 } else {
3352 r0 = ret.Get(0).(float64)
3353 }
3354 return r0
3355}
3356
3357// MockWebView_EstimatedProgress_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EstimatedProgress'
3358type MockWebView_EstimatedProgress_Call struct {
3359 *mock.Call
3360}
3361
3362// EstimatedProgress is a helper method to define mock.On call
3363func (_e *MockWebView_Expecter) EstimatedProgress() *MockWebView_EstimatedProgress_Call {
3364 return &MockWebView_EstimatedProgress_Call{Call: _e.mock.On("EstimatedProgress")}
3365}
3366
3367func (_c *MockWebView_EstimatedProgress_Call) Run(run func()) *MockWebView_EstimatedProgress_Call {
3368 _c.Call.Run(func(args mock.Arguments) {
3369 run()
3370 })
3371 return _c
3372}
3373
3374func (_c *MockWebView_EstimatedProgress_Call) Return(f float64) *MockWebView_EstimatedProgress_Call {
3375 _c.Call.Return(f)
3376 return _c
3377}
3378
3379func (_c *MockWebView_EstimatedProgress_Call) RunAndReturn(run func() float64) *MockWebView_EstimatedProgress_Call {
3380 _c.Call.Return(run)
3381 return _c
3382}
3383
3384// GetFindController provides a mock function for the type MockWebView
3385func (_mock *MockWebView) GetFindController() port.FindController {
3386 ret := _mock.Called()
3387
3388 if len(ret) == 0 {
3389 panic("no return value specified for GetFindController")
3390 }
3391
3392 var r0 port.FindController
3393 if returnFunc, ok := ret.Get(0).(func() port.FindController); ok {
3394 r0 = returnFunc()
3395 } else {
3396 if ret.Get(0) != nil {
3397 r0 = ret.Get(0).(port.FindController)
3398 }
3399 }
3400 return r0
3401}
3402
3403// MockWebView_GetFindController_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetFindController'
3404type MockWebView_GetFindController_Call struct {
3405 *mock.Call
3406}
3407
3408// GetFindController is a helper method to define mock.On call
3409func (_e *MockWebView_Expecter) GetFindController() *MockWebView_GetFindController_Call {
3410 return &MockWebView_GetFindController_Call{Call: _e.mock.On("GetFindController")}
3411}
3412
3413func (_c *MockWebView_GetFindController_Call) Run(run func()) *MockWebView_GetFindController_Call {
3414 _c.Call.Run(func(args mock.Arguments) {
3415 run()
3416 })
3417 return _c
3418}
3419
3420func (_c *MockWebView_GetFindController_Call) Return(findController port.FindController) *MockWebView_GetFindController_Call {
3421 _c.Call.Return(findController)
3422 return _c
3423}
3424
3425func (_c *MockWebView_GetFindController_Call) RunAndReturn(run func() port.FindController) *MockWebView_GetFindController_Call {
3426 _c.Call.Return(run)
3427 return _c
3428}
3429
3430// GetZoomLevel provides a mock function for the type MockWebView
3431func (_mock *MockWebView) GetZoomLevel() float64 {
3432 ret := _mock.Called()
3433
3434 if len(ret) == 0 {
3435 panic("no return value specified for GetZoomLevel")
3436 }
3437
3438 var r0 float64
3439 if returnFunc, ok := ret.Get(0).(func() float64); ok {
3440 r0 = returnFunc()
3441 } else {
3442 r0 = ret.Get(0).(float64)
3443 }
3444 return r0
3445}
3446
3447// MockWebView_GetZoomLevel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetZoomLevel'
3448type MockWebView_GetZoomLevel_Call struct {
3449 *mock.Call
3450}
3451
3452// GetZoomLevel is a helper method to define mock.On call
3453func (_e *MockWebView_Expecter) GetZoomLevel() *MockWebView_GetZoomLevel_Call {
3454 return &MockWebView_GetZoomLevel_Call{Call: _e.mock.On("GetZoomLevel")}
3455}
3456
3457func (_c *MockWebView_GetZoomLevel_Call) Run(run func()) *MockWebView_GetZoomLevel_Call {
3458 _c.Call.Run(func(args mock.Arguments) {
3459 run()
3460 })
3461 return _c
3462}
3463
3464func (_c *MockWebView_GetZoomLevel_Call) Return(f float64) *MockWebView_GetZoomLevel_Call {
3465 _c.Call.Return(f)
3466 return _c
3467}
3468
3469func (_c *MockWebView_GetZoomLevel_Call) RunAndReturn(run func() float64) *MockWebView_GetZoomLevel_Call {
3470 _c.Call.Return(run)
3471 return _c
3472}
3473
3474// GoBack provides a mock function for the type MockWebView
3475func (_mock *MockWebView) GoBack(ctx context.Context) error {
3476 ret := _mock.Called(ctx)
3477
3478 if len(ret) == 0 {
3479 panic("no return value specified for GoBack")
3480 }
3481
3482 var r0 error
3483 if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
3484 r0 = returnFunc(ctx)
3485 } else {
3486 r0 = ret.Error(0)
3487 }
3488 return r0
3489}
3490
3491// MockWebView_GoBack_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GoBack'
3492type MockWebView_GoBack_Call struct {
3493 *mock.Call
3494}
3495
3496// GoBack is a helper method to define mock.On call
3497// - ctx context.Context
3498func (_e *MockWebView_Expecter) GoBack(ctx interface{}) *MockWebView_GoBack_Call {
3499 return &MockWebView_GoBack_Call{Call: _e.mock.On("GoBack", ctx)}
3500}
3501
3502func (_c *MockWebView_GoBack_Call) Run(run func(ctx context.Context)) *MockWebView_GoBack_Call {
3503 _c.Call.Run(func(args mock.Arguments) {
3504 var arg0 context.Context
3505 if args[0] != nil {
3506 arg0 = args[0].(context.Context)
3507 }
3508 run(
3509 arg0,
3510 )
3511 })
3512 return _c
3513}
3514
3515func (_c *MockWebView_GoBack_Call) Return(err error) *MockWebView_GoBack_Call {
3516 _c.Call.Return(err)
3517 return _c
3518}
3519
3520func (_c *MockWebView_GoBack_Call) RunAndReturn(run func(ctx context.Context) error) *MockWebView_GoBack_Call {
3521 _c.Call.Return(run)
3522 return _c
3523}
3524
3525// GoForward provides a mock function for the type MockWebView
3526func (_mock *MockWebView) GoForward(ctx context.Context) error {
3527 ret := _mock.Called(ctx)
3528
3529 if len(ret) == 0 {
3530 panic("no return value specified for GoForward")
3531 }
3532
3533 var r0 error
3534 if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
3535 r0 = returnFunc(ctx)
3536 } else {
3537 r0 = ret.Error(0)
3538 }
3539 return r0
3540}
3541
3542// MockWebView_GoForward_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GoForward'
3543type MockWebView_GoForward_Call struct {
3544 *mock.Call
3545}
3546
3547// GoForward is a helper method to define mock.On call
3548// - ctx context.Context
3549func (_e *MockWebView_Expecter) GoForward(ctx interface{}) *MockWebView_GoForward_Call {
3550 return &MockWebView_GoForward_Call{Call: _e.mock.On("GoForward", ctx)}
3551}
3552
3553func (_c *MockWebView_GoForward_Call) Run(run func(ctx context.Context)) *MockWebView_GoForward_Call {
3554 _c.Call.Run(func(args mock.Arguments) {
3555 var arg0 context.Context
3556 if args[0] != nil {
3557 arg0 = args[0].(context.Context)
3558 }
3559 run(
3560 arg0,
3561 )
3562 })
3563 return _c
3564}
3565
3566func (_c *MockWebView_GoForward_Call) Return(err error) *MockWebView_GoForward_Call {
3567 _c.Call.Return(err)
3568 return _c
3569}
3570
3571func (_c *MockWebView_GoForward_Call) RunAndReturn(run func(ctx context.Context) error) *MockWebView_GoForward_Call {
3572 _c.Call.Return(run)
3573 return _c
3574}
3575
3576// ID provides a mock function for the type MockWebView
3577func (_mock *MockWebView) ID() port.WebViewID {
3578 ret := _mock.Called()
3579
3580 if len(ret) == 0 {
3581 panic("no return value specified for ID")
3582 }
3583
3584 var r0 port.WebViewID
3585 if returnFunc, ok := ret.Get(0).(func() port.WebViewID); ok {
3586 r0 = returnFunc()
3587 } else {
3588 r0 = ret.Get(0).(port.WebViewID)
3589 }
3590 return r0
3591}
3592
3593// MockWebView_ID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ID'
3594type MockWebView_ID_Call struct {
3595 *mock.Call
3596}
3597
3598// ID is a helper method to define mock.On call
3599func (_e *MockWebView_Expecter) ID() *MockWebView_ID_Call {
3600 return &MockWebView_ID_Call{Call: _e.mock.On("ID")}
3601}
3602
3603func (_c *MockWebView_ID_Call) Run(run func()) *MockWebView_ID_Call {
3604 _c.Call.Run(func(args mock.Arguments) {
3605 run()
3606 })
3607 return _c
3608}
3609
3610func (_c *MockWebView_ID_Call) Return(webViewID port.WebViewID) *MockWebView_ID_Call {
3611 _c.Call.Return(webViewID)
3612 return _c
3613}
3614
3615func (_c *MockWebView_ID_Call) RunAndReturn(run func() port.WebViewID) *MockWebView_ID_Call {
3616 _c.Call.Return(run)
3617 return _c
3618}
3619
3620// IsDestroyed provides a mock function for the type MockWebView
3621func (_mock *MockWebView) IsDestroyed() bool {
3622 ret := _mock.Called()
3623
3624 if len(ret) == 0 {
3625 panic("no return value specified for IsDestroyed")
3626 }
3627
3628 var r0 bool
3629 if returnFunc, ok := ret.Get(0).(func() bool); ok {
3630 r0 = returnFunc()
3631 } else {
3632 r0 = ret.Get(0).(bool)
3633 }
3634 return r0
3635}
3636
3637// MockWebView_IsDestroyed_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsDestroyed'
3638type MockWebView_IsDestroyed_Call struct {
3639 *mock.Call
3640}
3641
3642// IsDestroyed is a helper method to define mock.On call
3643func (_e *MockWebView_Expecter) IsDestroyed() *MockWebView_IsDestroyed_Call {
3644 return &MockWebView_IsDestroyed_Call{Call: _e.mock.On("IsDestroyed")}
3645}
3646
3647func (_c *MockWebView_IsDestroyed_Call) Run(run func()) *MockWebView_IsDestroyed_Call {
3648 _c.Call.Run(func(args mock.Arguments) {
3649 run()
3650 })
3651 return _c
3652}
3653
3654func (_c *MockWebView_IsDestroyed_Call) Return(b bool) *MockWebView_IsDestroyed_Call {
3655 _c.Call.Return(b)
3656 return _c
3657}
3658
3659func (_c *MockWebView_IsDestroyed_Call) RunAndReturn(run func() bool) *MockWebView_IsDestroyed_Call {
3660 _c.Call.Return(run)
3661 return _c
3662}
3663
3664// IsFullscreen provides a mock function for the type MockWebView
3665func (_mock *MockWebView) IsFullscreen() bool {
3666 ret := _mock.Called()
3667
3668 if len(ret) == 0 {
3669 panic("no return value specified for IsFullscreen")
3670 }
3671
3672 var r0 bool
3673 if returnFunc, ok := ret.Get(0).(func() bool); ok {
3674 r0 = returnFunc()
3675 } else {
3676 r0 = ret.Get(0).(bool)
3677 }
3678 return r0
3679}
3680
3681// MockWebView_IsFullscreen_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsFullscreen'
3682type MockWebView_IsFullscreen_Call struct {
3683 *mock.Call
3684}
3685
3686// IsFullscreen is a helper method to define mock.On call
3687func (_e *MockWebView_Expecter) IsFullscreen() *MockWebView_IsFullscreen_Call {
3688 return &MockWebView_IsFullscreen_Call{Call: _e.mock.On("IsFullscreen")}
3689}
3690
3691func (_c *MockWebView_IsFullscreen_Call) Run(run func()) *MockWebView_IsFullscreen_Call {
3692 _c.Call.Run(func(args mock.Arguments) {
3693 run()
3694 })
3695 return _c
3696}
3697
3698func (_c *MockWebView_IsFullscreen_Call) Return(b bool) *MockWebView_IsFullscreen_Call {
3699 _c.Call.Return(b)
3700 return _c
3701}
3702
3703func (_c *MockWebView_IsFullscreen_Call) RunAndReturn(run func() bool) *MockWebView_IsFullscreen_Call {
3704 _c.Call.Return(run)
3705 return _c
3706}
3707
3708// IsLoading provides a mock function for the type MockWebView
3709func (_mock *MockWebView) IsLoading() bool {
3710 ret := _mock.Called()
3711
3712 if len(ret) == 0 {
3713 panic("no return value specified for IsLoading")
3714 }
3715
3716 var r0 bool
3717 if returnFunc, ok := ret.Get(0).(func() bool); ok {
3718 r0 = returnFunc()
3719 } else {
3720 r0 = ret.Get(0).(bool)
3721 }
3722 return r0
3723}
3724
3725// MockWebView_IsLoading_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsLoading'
3726type MockWebView_IsLoading_Call struct {
3727 *mock.Call
3728}
3729
3730// IsLoading is a helper method to define mock.On call
3731func (_e *MockWebView_Expecter) IsLoading() *MockWebView_IsLoading_Call {
3732 return &MockWebView_IsLoading_Call{Call: _e.mock.On("IsLoading")}
3733}
3734
3735func (_c *MockWebView_IsLoading_Call) Run(run func()) *MockWebView_IsLoading_Call {
3736 _c.Call.Run(func(args mock.Arguments) {
3737 run()
3738 })
3739 return _c
3740}
3741
3742func (_c *MockWebView_IsLoading_Call) Return(b bool) *MockWebView_IsLoading_Call {
3743 _c.Call.Return(b)
3744 return _c
3745}
3746
3747func (_c *MockWebView_IsLoading_Call) RunAndReturn(run func() bool) *MockWebView_IsLoading_Call {
3748 _c.Call.Return(run)
3749 return _c
3750}
3751
3752// IsPlayingAudio provides a mock function for the type MockWebView
3753func (_mock *MockWebView) IsPlayingAudio() bool {
3754 ret := _mock.Called()
3755
3756 if len(ret) == 0 {
3757 panic("no return value specified for IsPlayingAudio")
3758 }
3759
3760 var r0 bool
3761 if returnFunc, ok := ret.Get(0).(func() bool); ok {
3762 r0 = returnFunc()
3763 } else {
3764 r0 = ret.Get(0).(bool)
3765 }
3766 return r0
3767}
3768
3769// MockWebView_IsPlayingAudio_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsPlayingAudio'
3770type MockWebView_IsPlayingAudio_Call struct {
3771 *mock.Call
3772}
3773
3774// IsPlayingAudio is a helper method to define mock.On call
3775func (_e *MockWebView_Expecter) IsPlayingAudio() *MockWebView_IsPlayingAudio_Call {
3776 return &MockWebView_IsPlayingAudio_Call{Call: _e.mock.On("IsPlayingAudio")}
3777}
3778
3779func (_c *MockWebView_IsPlayingAudio_Call) Run(run func()) *MockWebView_IsPlayingAudio_Call {
3780 _c.Call.Run(func(args mock.Arguments) {
3781 run()
3782 })
3783 return _c
3784}
3785
3786func (_c *MockWebView_IsPlayingAudio_Call) Return(b bool) *MockWebView_IsPlayingAudio_Call {
3787 _c.Call.Return(b)
3788 return _c
3789}
3790
3791func (_c *MockWebView_IsPlayingAudio_Call) RunAndReturn(run func() bool) *MockWebView_IsPlayingAudio_Call {
3792 _c.Call.Return(run)
3793 return _c
3794}
3795
3796// LoadHTML provides a mock function for the type MockWebView
3797func (_mock *MockWebView) LoadHTML(ctx context.Context, content string, baseURI string) error {
3798 ret := _mock.Called(ctx, content, baseURI)
3799
3800 if len(ret) == 0 {
3801 panic("no return value specified for LoadHTML")
3802 }
3803
3804 var r0 error
3805 if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) error); ok {
3806 r0 = returnFunc(ctx, content, baseURI)
3807 } else {
3808 r0 = ret.Error(0)
3809 }
3810 return r0
3811}
3812
3813// MockWebView_LoadHTML_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LoadHTML'
3814type MockWebView_LoadHTML_Call struct {
3815 *mock.Call
3816}
3817
3818// LoadHTML is a helper method to define mock.On call
3819// - ctx context.Context
3820// - content string
3821// - baseURI string
3822func (_e *MockWebView_Expecter) LoadHTML(ctx interface{}, content interface{}, baseURI interface{}) *MockWebView_LoadHTML_Call {
3823 return &MockWebView_LoadHTML_Call{Call: _e.mock.On("LoadHTML", ctx, content, baseURI)}
3824}
3825
3826func (_c *MockWebView_LoadHTML_Call) Run(run func(ctx context.Context, content string, baseURI string)) *MockWebView_LoadHTML_Call {
3827 _c.Call.Run(func(args mock.Arguments) {
3828 var arg0 context.Context
3829 if args[0] != nil {
3830 arg0 = args[0].(context.Context)
3831 }
3832 var arg1 string
3833 if args[1] != nil {
3834 arg1 = args[1].(string)
3835 }
3836 var arg2 string
3837 if args[2] != nil {
3838 arg2 = args[2].(string)
3839 }
3840 run(
3841 arg0,
3842 arg1,
3843 arg2,
3844 )
3845 })
3846 return _c
3847}
3848
3849func (_c *MockWebView_LoadHTML_Call) Return(err error) *MockWebView_LoadHTML_Call {
3850 _c.Call.Return(err)
3851 return _c
3852}
3853
3854func (_c *MockWebView_LoadHTML_Call) RunAndReturn(run func(ctx context.Context, content string, baseURI string) error) *MockWebView_LoadHTML_Call {
3855 _c.Call.Return(run)
3856 return _c
3857}
3858
3859// LoadURI provides a mock function for the type MockWebView
3860func (_mock *MockWebView) LoadURI(ctx context.Context, uri string) error {
3861 ret := _mock.Called(ctx, uri)
3862
3863 if len(ret) == 0 {
3864 panic("no return value specified for LoadURI")
3865 }
3866
3867 var r0 error
3868 if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
3869 r0 = returnFunc(ctx, uri)
3870 } else {
3871 r0 = ret.Error(0)
3872 }
3873 return r0
3874}
3875
3876// MockWebView_LoadURI_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LoadURI'
3877type MockWebView_LoadURI_Call struct {
3878 *mock.Call
3879}
3880
3881// LoadURI is a helper method to define mock.On call
3882// - ctx context.Context
3883// - uri string
3884func (_e *MockWebView_Expecter) LoadURI(ctx interface{}, uri interface{}) *MockWebView_LoadURI_Call {
3885 return &MockWebView_LoadURI_Call{Call: _e.mock.On("LoadURI", ctx, uri)}
3886}
3887
3888func (_c *MockWebView_LoadURI_Call) Run(run func(ctx context.Context, uri string)) *MockWebView_LoadURI_Call {
3889 _c.Call.Run(func(args mock.Arguments) {
3890 var arg0 context.Context
3891 if args[0] != nil {
3892 arg0 = args[0].(context.Context)
3893 }
3894 var arg1 string
3895 if args[1] != nil {
3896 arg1 = args[1].(string)
3897 }
3898 run(
3899 arg0,
3900 arg1,
3901 )
3902 })
3903 return _c
3904}
3905
3906func (_c *MockWebView_LoadURI_Call) Return(err error) *MockWebView_LoadURI_Call {
3907 _c.Call.Return(err)
3908 return _c
3909}
3910
3911func (_c *MockWebView_LoadURI_Call) RunAndReturn(run func(ctx context.Context, uri string) error) *MockWebView_LoadURI_Call {
3912 _c.Call.Return(run)
3913 return _c
3914}
3915
3916// Reload provides a mock function for the type MockWebView
3917func (_mock *MockWebView) Reload(ctx context.Context) error {
3918 ret := _mock.Called(ctx)
3919
3920 if len(ret) == 0 {
3921 panic("no return value specified for Reload")
3922 }
3923
3924 var r0 error
3925 if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
3926 r0 = returnFunc(ctx)
3927 } else {
3928 r0 = ret.Error(0)
3929 }
3930 return r0
3931}
3932
3933// MockWebView_Reload_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Reload'
3934type MockWebView_Reload_Call struct {
3935 *mock.Call
3936}
3937
3938// Reload is a helper method to define mock.On call
3939// - ctx context.Context
3940func (_e *MockWebView_Expecter) Reload(ctx interface{}) *MockWebView_Reload_Call {
3941 return &MockWebView_Reload_Call{Call: _e.mock.On("Reload", ctx)}
3942}
3943
3944func (_c *MockWebView_Reload_Call) Run(run func(ctx context.Context)) *MockWebView_Reload_Call {
3945 _c.Call.Run(func(args mock.Arguments) {
3946 var arg0 context.Context
3947 if args[0] != nil {
3948 arg0 = args[0].(context.Context)
3949 }
3950 run(
3951 arg0,
3952 )
3953 })
3954 return _c
3955}
3956
3957func (_c *MockWebView_Reload_Call) Return(err error) *MockWebView_Reload_Call {
3958 _c.Call.Return(err)
3959 return _c
3960}
3961
3962func (_c *MockWebView_Reload_Call) RunAndReturn(run func(ctx context.Context) error) *MockWebView_Reload_Call {
3963 _c.Call.Return(run)
3964 return _c
3965}
3966
3967// ReloadBypassCache provides a mock function for the type MockWebView
3968func (_mock *MockWebView) ReloadBypassCache(ctx context.Context) error {
3969 ret := _mock.Called(ctx)
3970
3971 if len(ret) == 0 {
3972 panic("no return value specified for ReloadBypassCache")
3973 }
3974
3975 var r0 error
3976 if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
3977 r0 = returnFunc(ctx)
3978 } else {
3979 r0 = ret.Error(0)
3980 }
3981 return r0
3982}
3983
3984// MockWebView_ReloadBypassCache_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReloadBypassCache'
3985type MockWebView_ReloadBypassCache_Call struct {
3986 *mock.Call
3987}
3988
3989// ReloadBypassCache is a helper method to define mock.On call
3990// - ctx context.Context
3991func (_e *MockWebView_Expecter) ReloadBypassCache(ctx interface{}) *MockWebView_ReloadBypassCache_Call {
3992 return &MockWebView_ReloadBypassCache_Call{Call: _e.mock.On("ReloadBypassCache", ctx)}
3993}
3994
3995func (_c *MockWebView_ReloadBypassCache_Call) Run(run func(ctx context.Context)) *MockWebView_ReloadBypassCache_Call {
3996 _c.Call.Run(func(args mock.Arguments) {
3997 var arg0 context.Context
3998 if args[0] != nil {
3999 arg0 = args[0].(context.Context)
4000 }
4001 run(
4002 arg0,
4003 )
4004 })
4005 return _c
4006}
4007
4008func (_c *MockWebView_ReloadBypassCache_Call) Return(err error) *MockWebView_ReloadBypassCache_Call {
4009 _c.Call.Return(err)
4010 return _c
4011}
4012
4013func (_c *MockWebView_ReloadBypassCache_Call) RunAndReturn(run func(ctx context.Context) error) *MockWebView_ReloadBypassCache_Call {
4014 _c.Call.Return(run)
4015 return _c
4016}
4017
4018// SetCallbacks provides a mock function for the type MockWebView
4019func (_mock *MockWebView) SetCallbacks(callbacks *port.WebViewCallbacks) {
4020 _mock.Called(callbacks)
4021 return
4022}
4023
4024// MockWebView_SetCallbacks_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetCallbacks'
4025type MockWebView_SetCallbacks_Call struct {
4026 *mock.Call
4027}
4028
4029// SetCallbacks is a helper method to define mock.On call
4030// - callbacks *port.WebViewCallbacks
4031func (_e *MockWebView_Expecter) SetCallbacks(callbacks interface{}) *MockWebView_SetCallbacks_Call {
4032 return &MockWebView_SetCallbacks_Call{Call: _e.mock.On("SetCallbacks", callbacks)}
4033}
4034
4035func (_c *MockWebView_SetCallbacks_Call) Run(run func(callbacks *port.WebViewCallbacks)) *MockWebView_SetCallbacks_Call {
4036 _c.Call.Run(func(args mock.Arguments) {
4037 var arg0 *port.WebViewCallbacks
4038 if args[0] != nil {
4039 arg0 = args[0].(*port.WebViewCallbacks)
4040 }
4041 run(
4042 arg0,
4043 )
4044 })
4045 return _c
4046}
4047
4048func (_c *MockWebView_SetCallbacks_Call) Return() *MockWebView_SetCallbacks_Call {
4049 _c.Call.Return()
4050 return _c
4051}
4052
4053func (_c *MockWebView_SetCallbacks_Call) RunAndReturn(run func(callbacks *port.WebViewCallbacks)) *MockWebView_SetCallbacks_Call {
4054 _c.Run(run)
4055 return _c
4056}
4057
4058// SetZoomLevel provides a mock function for the type MockWebView
4059func (_mock *MockWebView) SetZoomLevel(ctx context.Context, level float64) error {
4060 ret := _mock.Called(ctx, level)
4061
4062 if len(ret) == 0 {
4063 panic("no return value specified for SetZoomLevel")
4064 }
4065
4066 var r0 error
4067 if returnFunc, ok := ret.Get(0).(func(context.Context, float64) error); ok {
4068 r0 = returnFunc(ctx, level)
4069 } else {
4070 r0 = ret.Error(0)
4071 }
4072 return r0
4073}
4074
4075// MockWebView_SetZoomLevel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetZoomLevel'
4076type MockWebView_SetZoomLevel_Call struct {
4077 *mock.Call
4078}
4079
4080// SetZoomLevel is a helper method to define mock.On call
4081// - ctx context.Context
4082// - level float64
4083func (_e *MockWebView_Expecter) SetZoomLevel(ctx interface{}, level interface{}) *MockWebView_SetZoomLevel_Call {
4084 return &MockWebView_SetZoomLevel_Call{Call: _e.mock.On("SetZoomLevel", ctx, level)}
4085}
4086
4087func (_c *MockWebView_SetZoomLevel_Call) Run(run func(ctx context.Context, level float64)) *MockWebView_SetZoomLevel_Call {
4088 _c.Call.Run(func(args mock.Arguments) {
4089 var arg0 context.Context
4090 if args[0] != nil {
4091 arg0 = args[0].(context.Context)
4092 }
4093 var arg1 float64
4094 if args[1] != nil {
4095 arg1 = args[1].(float64)
4096 }
4097 run(
4098 arg0,
4099 arg1,
4100 )
4101 })
4102 return _c
4103}
4104
4105func (_c *MockWebView_SetZoomLevel_Call) Return(err error) *MockWebView_SetZoomLevel_Call {
4106 _c.Call.Return(err)
4107 return _c
4108}
4109
4110func (_c *MockWebView_SetZoomLevel_Call) RunAndReturn(run func(ctx context.Context, level float64) error) *MockWebView_SetZoomLevel_Call {
4111 _c.Call.Return(run)
4112 return _c
4113}
4114
4115// State provides a mock function for the type MockWebView
4116func (_mock *MockWebView) State() port.WebViewState {
4117 ret := _mock.Called()
4118
4119 if len(ret) == 0 {
4120 panic("no return value specified for State")
4121 }
4122
4123 var r0 port.WebViewState
4124 if returnFunc, ok := ret.Get(0).(func() port.WebViewState); ok {
4125 r0 = returnFunc()
4126 } else {
4127 r0 = ret.Get(0).(port.WebViewState)
4128 }
4129 return r0
4130}
4131
4132// MockWebView_State_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'State'
4133type MockWebView_State_Call struct {
4134 *mock.Call
4135}
4136
4137// State is a helper method to define mock.On call
4138func (_e *MockWebView_Expecter) State() *MockWebView_State_Call {
4139 return &MockWebView_State_Call{Call: _e.mock.On("State")}
4140}
4141
4142func (_c *MockWebView_State_Call) Run(run func()) *MockWebView_State_Call {
4143 _c.Call.Run(func(args mock.Arguments) {
4144 run()
4145 })
4146 return _c
4147}
4148
4149func (_c *MockWebView_State_Call) Return(webViewState port.WebViewState) *MockWebView_State_Call {
4150 _c.Call.Return(webViewState)
4151 return _c
4152}
4153
4154func (_c *MockWebView_State_Call) RunAndReturn(run func() port.WebViewState) *MockWebView_State_Call {
4155 _c.Call.Return(run)
4156 return _c
4157}
4158
4159// Stop provides a mock function for the type MockWebView
4160func (_mock *MockWebView) Stop(ctx context.Context) error {
4161 ret := _mock.Called(ctx)
4162
4163 if len(ret) == 0 {
4164 panic("no return value specified for Stop")
4165 }
4166
4167 var r0 error
4168 if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
4169 r0 = returnFunc(ctx)
4170 } else {
4171 r0 = ret.Error(0)
4172 }
4173 return r0
4174}
4175
4176// MockWebView_Stop_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Stop'
4177type MockWebView_Stop_Call struct {
4178 *mock.Call
4179}
4180
4181// Stop is a helper method to define mock.On call
4182// - ctx context.Context
4183func (_e *MockWebView_Expecter) Stop(ctx interface{}) *MockWebView_Stop_Call {
4184 return &MockWebView_Stop_Call{Call: _e.mock.On("Stop", ctx)}
4185}
4186
4187func (_c *MockWebView_Stop_Call) Run(run func(ctx context.Context)) *MockWebView_Stop_Call {
4188 _c.Call.Run(func(args mock.Arguments) {
4189 var arg0 context.Context
4190 if args[0] != nil {
4191 arg0 = args[0].(context.Context)
4192 }
4193 run(
4194 arg0,
4195 )
4196 })
4197 return _c
4198}
4199
4200func (_c *MockWebView_Stop_Call) Return(err error) *MockWebView_Stop_Call {
4201 _c.Call.Return(err)
4202 return _c
4203}
4204
4205func (_c *MockWebView_Stop_Call) RunAndReturn(run func(ctx context.Context) error) *MockWebView_Stop_Call {
4206 _c.Call.Return(run)
4207 return _c
4208}
4209
4210// Title provides a mock function for the type MockWebView
4211func (_mock *MockWebView) Title() string {
4212 ret := _mock.Called()
4213
4214 if len(ret) == 0 {
4215 panic("no return value specified for Title")
4216 }
4217
4218 var r0 string
4219 if returnFunc, ok := ret.Get(0).(func() string); ok {
4220 r0 = returnFunc()
4221 } else {
4222 r0 = ret.Get(0).(string)
4223 }
4224 return r0
4225}
4226
4227// MockWebView_Title_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Title'
4228type MockWebView_Title_Call struct {
4229 *mock.Call
4230}
4231
4232// Title is a helper method to define mock.On call
4233func (_e *MockWebView_Expecter) Title() *MockWebView_Title_Call {
4234 return &MockWebView_Title_Call{Call: _e.mock.On("Title")}
4235}
4236
4237func (_c *MockWebView_Title_Call) Run(run func()) *MockWebView_Title_Call {
4238 _c.Call.Run(func(args mock.Arguments) {
4239 run()
4240 })
4241 return _c
4242}
4243
4244func (_c *MockWebView_Title_Call) Return(s string) *MockWebView_Title_Call {
4245 _c.Call.Return(s)
4246 return _c
4247}
4248
4249func (_c *MockWebView_Title_Call) RunAndReturn(run func() string) *MockWebView_Title_Call {
4250 _c.Call.Return(run)
4251 return _c
4252}
4253
4254// URI provides a mock function for the type MockWebView
4255func (_mock *MockWebView) URI() string {
4256 ret := _mock.Called()
4257
4258 if len(ret) == 0 {
4259 panic("no return value specified for URI")
4260 }
4261
4262 var r0 string
4263 if returnFunc, ok := ret.Get(0).(func() string); ok {
4264 r0 = returnFunc()
4265 } else {
4266 r0 = ret.Get(0).(string)
4267 }
4268 return r0
4269}
4270
4271// MockWebView_URI_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'URI'
4272type MockWebView_URI_Call struct {
4273 *mock.Call
4274}
4275
4276// URI is a helper method to define mock.On call
4277func (_e *MockWebView_Expecter) URI() *MockWebView_URI_Call {
4278 return &MockWebView_URI_Call{Call: _e.mock.On("URI")}
4279}
4280
4281func (_c *MockWebView_URI_Call) Run(run func()) *MockWebView_URI_Call {
4282 _c.Call.Run(func(args mock.Arguments) {
4283 run()
4284 })
4285 return _c
4286}
4287
4288func (_c *MockWebView_URI_Call) Return(s string) *MockWebView_URI_Call {
4289 _c.Call.Return(s)
4290 return _c
4291}
4292
4293func (_c *MockWebView_URI_Call) RunAndReturn(run func() string) *MockWebView_URI_Call {
4294 _c.Call.Return(run)
4295 return _c
4296}
4297
4298// 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.
4299// The first argument is typically a *testing.T value.
4300func NewMockWebViewPool(t interface {
4301 mock.TestingT
4302 Cleanup(func())
4303}) *MockWebViewPool {
4304 mock := &MockWebViewPool{}
4305 mock.Mock.Test(t)
4306
4307 t.Cleanup(func() { mock.AssertExpectations(t) })
4308
4309 return mock
4310}
4311
4312// MockWebViewPool is an autogenerated mock type for the WebViewPool type
4313type MockWebViewPool struct {
4314 mock.Mock
4315}
4316
4317type MockWebViewPool_Expecter struct {
4318 mock *mock.Mock
4319}
4320
4321func (_m *MockWebViewPool) EXPECT() *MockWebViewPool_Expecter {
4322 return &MockWebViewPool_Expecter{mock: &_m.Mock}
4323}
4324
4325// Acquire provides a mock function for the type MockWebViewPool
4326func (_mock *MockWebViewPool) Acquire(ctx context.Context) (port.WebView, error) {
4327 ret := _mock.Called(ctx)
4328
4329 if len(ret) == 0 {
4330 panic("no return value specified for Acquire")
4331 }
4332
4333 var r0 port.WebView
4334 var r1 error
4335 if returnFunc, ok := ret.Get(0).(func(context.Context) (port.WebView, error)); ok {
4336 return returnFunc(ctx)
4337 }
4338 if returnFunc, ok := ret.Get(0).(func(context.Context) port.WebView); ok {
4339 r0 = returnFunc(ctx)
4340 } else {
4341 if ret.Get(0) != nil {
4342 r0 = ret.Get(0).(port.WebView)
4343 }
4344 }
4345 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
4346 r1 = returnFunc(ctx)
4347 } else {
4348 r1 = ret.Error(1)
4349 }
4350 return r0, r1
4351}
4352
4353// MockWebViewPool_Acquire_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Acquire'
4354type MockWebViewPool_Acquire_Call struct {
4355 *mock.Call
4356}
4357
4358// Acquire is a helper method to define mock.On call
4359// - ctx context.Context
4360func (_e *MockWebViewPool_Expecter) Acquire(ctx interface{}) *MockWebViewPool_Acquire_Call {
4361 return &MockWebViewPool_Acquire_Call{Call: _e.mock.On("Acquire", ctx)}
4362}
4363
4364func (_c *MockWebViewPool_Acquire_Call) Run(run func(ctx context.Context)) *MockWebViewPool_Acquire_Call {
4365 _c.Call.Run(func(args mock.Arguments) {
4366 var arg0 context.Context
4367 if args[0] != nil {
4368 arg0 = args[0].(context.Context)
4369 }
4370 run(
4371 arg0,
4372 )
4373 })
4374 return _c
4375}
4376
4377func (_c *MockWebViewPool_Acquire_Call) Return(webView port.WebView, err error) *MockWebViewPool_Acquire_Call {
4378 _c.Call.Return(webView, err)
4379 return _c
4380}
4381
4382func (_c *MockWebViewPool_Acquire_Call) RunAndReturn(run func(ctx context.Context) (port.WebView, error)) *MockWebViewPool_Acquire_Call {
4383 _c.Call.Return(run)
4384 return _c
4385}
4386
4387// Close provides a mock function for the type MockWebViewPool
4388func (_mock *MockWebViewPool) Close() {
4389 _mock.Called()
4390 return
4391}
4392
4393// MockWebViewPool_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
4394type MockWebViewPool_Close_Call struct {
4395 *mock.Call
4396}
4397
4398// Close is a helper method to define mock.On call
4399func (_e *MockWebViewPool_Expecter) Close() *MockWebViewPool_Close_Call {
4400 return &MockWebViewPool_Close_Call{Call: _e.mock.On("Close")}
4401}
4402
4403func (_c *MockWebViewPool_Close_Call) Run(run func()) *MockWebViewPool_Close_Call {
4404 _c.Call.Run(func(args mock.Arguments) {
4405 run()
4406 })
4407 return _c
4408}
4409
4410func (_c *MockWebViewPool_Close_Call) Return() *MockWebViewPool_Close_Call {
4411 _c.Call.Return()
4412 return _c
4413}
4414
4415func (_c *MockWebViewPool_Close_Call) RunAndReturn(run func()) *MockWebViewPool_Close_Call {
4416 _c.Run(run)
4417 return _c
4418}
4419
4420// Prewarm provides a mock function for the type MockWebViewPool
4421func (_mock *MockWebViewPool) Prewarm(count int) {
4422 _mock.Called(count)
4423 return
4424}
4425
4426// MockWebViewPool_Prewarm_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Prewarm'
4427type MockWebViewPool_Prewarm_Call struct {
4428 *mock.Call
4429}
4430
4431// Prewarm is a helper method to define mock.On call
4432// - count int
4433func (_e *MockWebViewPool_Expecter) Prewarm(count interface{}) *MockWebViewPool_Prewarm_Call {
4434 return &MockWebViewPool_Prewarm_Call{Call: _e.mock.On("Prewarm", count)}
4435}
4436
4437func (_c *MockWebViewPool_Prewarm_Call) Run(run func(count int)) *MockWebViewPool_Prewarm_Call {
4438 _c.Call.Run(func(args mock.Arguments) {
4439 var arg0 int
4440 if args[0] != nil {
4441 arg0 = args[0].(int)
4442 }
4443 run(
4444 arg0,
4445 )
4446 })
4447 return _c
4448}
4449
4450func (_c *MockWebViewPool_Prewarm_Call) Return() *MockWebViewPool_Prewarm_Call {
4451 _c.Call.Return()
4452 return _c
4453}
4454
4455func (_c *MockWebViewPool_Prewarm_Call) RunAndReturn(run func(count int)) *MockWebViewPool_Prewarm_Call {
4456 _c.Run(run)
4457 return _c
4458}
4459
4460// Release provides a mock function for the type MockWebViewPool
4461func (_mock *MockWebViewPool) Release(wv port.WebView) {
4462 _mock.Called(wv)
4463 return
4464}
4465
4466// MockWebViewPool_Release_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Release'
4467type MockWebViewPool_Release_Call struct {
4468 *mock.Call
4469}
4470
4471// Release is a helper method to define mock.On call
4472// - wv port.WebView
4473func (_e *MockWebViewPool_Expecter) Release(wv interface{}) *MockWebViewPool_Release_Call {
4474 return &MockWebViewPool_Release_Call{Call: _e.mock.On("Release", wv)}
4475}
4476
4477func (_c *MockWebViewPool_Release_Call) Run(run func(wv port.WebView)) *MockWebViewPool_Release_Call {
4478 _c.Call.Run(func(args mock.Arguments) {
4479 var arg0 port.WebView
4480 if args[0] != nil {
4481 arg0 = args[0].(port.WebView)
4482 }
4483 run(
4484 arg0,
4485 )
4486 })
4487 return _c
4488}
4489
4490func (_c *MockWebViewPool_Release_Call) Return() *MockWebViewPool_Release_Call {
4491 _c.Call.Return()
4492 return _c
4493}
4494
4495func (_c *MockWebViewPool_Release_Call) RunAndReturn(run func(wv port.WebView)) *MockWebViewPool_Release_Call {
4496 _c.Run(run)
4497 return _c
4498}
4499
4500// Size provides a mock function for the type MockWebViewPool
4501func (_mock *MockWebViewPool) Size() int {
4502 ret := _mock.Called()
4503
4504 if len(ret) == 0 {
4505 panic("no return value specified for Size")
4506 }
4507
4508 var r0 int
4509 if returnFunc, ok := ret.Get(0).(func() int); ok {
4510 r0 = returnFunc()
4511 } else {
4512 r0 = ret.Get(0).(int)
4513 }
4514 return r0
4515}
4516
4517// MockWebViewPool_Size_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Size'
4518type MockWebViewPool_Size_Call struct {
4519 *mock.Call
4520}
4521
4522// Size is a helper method to define mock.On call
4523func (_e *MockWebViewPool_Expecter) Size() *MockWebViewPool_Size_Call {
4524 return &MockWebViewPool_Size_Call{Call: _e.mock.On("Size")}
4525}
4526
4527func (_c *MockWebViewPool_Size_Call) Run(run func()) *MockWebViewPool_Size_Call {
4528 _c.Call.Run(func(args mock.Arguments) {
4529 run()
4530 })
4531 return _c
4532}
4533
4534func (_c *MockWebViewPool_Size_Call) Return(n int) *MockWebViewPool_Size_Call {
4535 _c.Call.Return(n)
4536 return _c
4537}
4538
4539func (_c *MockWebViewPool_Size_Call) RunAndReturn(run func() int) *MockWebViewPool_Size_Call {
4540 _c.Call.Return(run)
4541 return _c
4542}
4543
4544// 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.
4545// The first argument is typically a *testing.T value.
4546func NewMockWebViewFactory(t interface {
4547 mock.TestingT
4548 Cleanup(func())
4549}) *MockWebViewFactory {
4550 mock := &MockWebViewFactory{}
4551 mock.Mock.Test(t)
4552
4553 t.Cleanup(func() { mock.AssertExpectations(t) })
4554
4555 return mock
4556}
4557
4558// MockWebViewFactory is an autogenerated mock type for the WebViewFactory type
4559type MockWebViewFactory struct {
4560 mock.Mock
4561}
4562
4563type MockWebViewFactory_Expecter struct {
4564 mock *mock.Mock
4565}
4566
4567func (_m *MockWebViewFactory) EXPECT() *MockWebViewFactory_Expecter {
4568 return &MockWebViewFactory_Expecter{mock: &_m.Mock}
4569}
4570
4571// Create provides a mock function for the type MockWebViewFactory
4572func (_mock *MockWebViewFactory) Create(ctx context.Context) (port.WebView, error) {
4573 ret := _mock.Called(ctx)
4574
4575 if len(ret) == 0 {
4576 panic("no return value specified for Create")
4577 }
4578
4579 var r0 port.WebView
4580 var r1 error
4581 if returnFunc, ok := ret.Get(0).(func(context.Context) (port.WebView, error)); ok {
4582 return returnFunc(ctx)
4583 }
4584 if returnFunc, ok := ret.Get(0).(func(context.Context) port.WebView); ok {
4585 r0 = returnFunc(ctx)
4586 } else {
4587 if ret.Get(0) != nil {
4588 r0 = ret.Get(0).(port.WebView)
4589 }
4590 }
4591 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
4592 r1 = returnFunc(ctx)
4593 } else {
4594 r1 = ret.Error(1)
4595 }
4596 return r0, r1
4597}
4598
4599// MockWebViewFactory_Create_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Create'
4600type MockWebViewFactory_Create_Call struct {
4601 *mock.Call
4602}
4603
4604// Create is a helper method to define mock.On call
4605// - ctx context.Context
4606func (_e *MockWebViewFactory_Expecter) Create(ctx interface{}) *MockWebViewFactory_Create_Call {
4607 return &MockWebViewFactory_Create_Call{Call: _e.mock.On("Create", ctx)}
4608}
4609
4610func (_c *MockWebViewFactory_Create_Call) Run(run func(ctx context.Context)) *MockWebViewFactory_Create_Call {
4611 _c.Call.Run(func(args mock.Arguments) {
4612 var arg0 context.Context
4613 if args[0] != nil {
4614 arg0 = args[0].(context.Context)
4615 }
4616 run(
4617 arg0,
4618 )
4619 })
4620 return _c
4621}
4622
4623func (_c *MockWebViewFactory_Create_Call) Return(webView port.WebView, err error) *MockWebViewFactory_Create_Call {
4624 _c.Call.Return(webView, err)
4625 return _c
4626}
4627
4628func (_c *MockWebViewFactory_Create_Call) RunAndReturn(run func(ctx context.Context) (port.WebView, error)) *MockWebViewFactory_Create_Call {
4629 _c.Call.Return(run)
4630 return _c
4631}
4632
4633// CreateRelated provides a mock function for the type MockWebViewFactory
4634func (_mock *MockWebViewFactory) CreateRelated(ctx context.Context, parentID port.WebViewID) (port.WebView, error) {
4635 ret := _mock.Called(ctx, parentID)
4636
4637 if len(ret) == 0 {
4638 panic("no return value specified for CreateRelated")
4639 }
4640
4641 var r0 port.WebView
4642 var r1 error
4643 if returnFunc, ok := ret.Get(0).(func(context.Context, port.WebViewID) (port.WebView, error)); ok {
4644 return returnFunc(ctx, parentID)
4645 }
4646 if returnFunc, ok := ret.Get(0).(func(context.Context, port.WebViewID) port.WebView); ok {
4647 r0 = returnFunc(ctx, parentID)
4648 } else {
4649 if ret.Get(0) != nil {
4650 r0 = ret.Get(0).(port.WebView)
4651 }
4652 }
4653 if returnFunc, ok := ret.Get(1).(func(context.Context, port.WebViewID) error); ok {
4654 r1 = returnFunc(ctx, parentID)
4655 } else {
4656 r1 = ret.Error(1)
4657 }
4658 return r0, r1
4659}
4660
4661// MockWebViewFactory_CreateRelated_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateRelated'
4662type MockWebViewFactory_CreateRelated_Call struct {
4663 *mock.Call
4664}
4665
4666// CreateRelated is a helper method to define mock.On call
4667// - ctx context.Context
4668// - parentID port.WebViewID
4669func (_e *MockWebViewFactory_Expecter) CreateRelated(ctx interface{}, parentID interface{}) *MockWebViewFactory_CreateRelated_Call {
4670 return &MockWebViewFactory_CreateRelated_Call{Call: _e.mock.On("CreateRelated", ctx, parentID)}
4671}
4672
4673func (_c *MockWebViewFactory_CreateRelated_Call) Run(run func(ctx context.Context, parentID port.WebViewID)) *MockWebViewFactory_CreateRelated_Call {
4674 _c.Call.Run(func(args mock.Arguments) {
4675 var arg0 context.Context
4676 if args[0] != nil {
4677 arg0 = args[0].(context.Context)
4678 }
4679 var arg1 port.WebViewID
4680 if args[1] != nil {
4681 arg1 = args[1].(port.WebViewID)
4682 }
4683 run(
4684 arg0,
4685 arg1,
4686 )
4687 })
4688 return _c
4689}
4690
4691func (_c *MockWebViewFactory_CreateRelated_Call) Return(webView port.WebView, err error) *MockWebViewFactory_CreateRelated_Call {
4692 _c.Call.Return(webView, err)
4693 return _c
4694}
4695
4696func (_c *MockWebViewFactory_CreateRelated_Call) RunAndReturn(run func(ctx context.Context, parentID port.WebViewID) (port.WebView, error)) *MockWebViewFactory_CreateRelated_Call {
4697 _c.Call.Return(run)
4698 return _c
4699}