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// 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.
1285// The first argument is typically a *testing.T value.
1286func NewMockFontDetector(t interface {
1287 mock.TestingT
1288 Cleanup(func())
1289}) *MockFontDetector {
1290 mock := &MockFontDetector{}
1291 mock.Mock.Test(t)
1292
1293 t.Cleanup(func() { mock.AssertExpectations(t) })
1294
1295 return mock
1296}
1297
1298// MockFontDetector is an autogenerated mock type for the FontDetector type
1299type MockFontDetector struct {
1300 mock.Mock
1301}
1302
1303type MockFontDetector_Expecter struct {
1304 mock *mock.Mock
1305}
1306
1307func (_m *MockFontDetector) EXPECT() *MockFontDetector_Expecter {
1308 return &MockFontDetector_Expecter{mock: &_m.Mock}
1309}
1310
1311// GetAvailableFonts provides a mock function for the type MockFontDetector
1312func (_mock *MockFontDetector) GetAvailableFonts(ctx context.Context) ([]string, error) {
1313 ret := _mock.Called(ctx)
1314
1315 if len(ret) == 0 {
1316 panic("no return value specified for GetAvailableFonts")
1317 }
1318
1319 var r0 []string
1320 var r1 error
1321 if returnFunc, ok := ret.Get(0).(func(context.Context) ([]string, error)); ok {
1322 return returnFunc(ctx)
1323 }
1324 if returnFunc, ok := ret.Get(0).(func(context.Context) []string); ok {
1325 r0 = returnFunc(ctx)
1326 } else {
1327 if ret.Get(0) != nil {
1328 r0 = ret.Get(0).([]string)
1329 }
1330 }
1331 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
1332 r1 = returnFunc(ctx)
1333 } else {
1334 r1 = ret.Error(1)
1335 }
1336 return r0, r1
1337}
1338
1339// MockFontDetector_GetAvailableFonts_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAvailableFonts'
1340type MockFontDetector_GetAvailableFonts_Call struct {
1341 *mock.Call
1342}
1343
1344// GetAvailableFonts is a helper method to define mock.On call
1345// - ctx context.Context
1346func (_e *MockFontDetector_Expecter) GetAvailableFonts(ctx interface{}) *MockFontDetector_GetAvailableFonts_Call {
1347 return &MockFontDetector_GetAvailableFonts_Call{Call: _e.mock.On("GetAvailableFonts", ctx)}
1348}
1349
1350func (_c *MockFontDetector_GetAvailableFonts_Call) Run(run func(ctx context.Context)) *MockFontDetector_GetAvailableFonts_Call {
1351 _c.Call.Run(func(args mock.Arguments) {
1352 var arg0 context.Context
1353 if args[0] != nil {
1354 arg0 = args[0].(context.Context)
1355 }
1356 run(
1357 arg0,
1358 )
1359 })
1360 return _c
1361}
1362
1363func (_c *MockFontDetector_GetAvailableFonts_Call) Return(strings []string, err error) *MockFontDetector_GetAvailableFonts_Call {
1364 _c.Call.Return(strings, err)
1365 return _c
1366}
1367
1368func (_c *MockFontDetector_GetAvailableFonts_Call) RunAndReturn(run func(ctx context.Context) ([]string, error)) *MockFontDetector_GetAvailableFonts_Call {
1369 _c.Call.Return(run)
1370 return _c
1371}
1372
1373// IsAvailable provides a mock function for the type MockFontDetector
1374func (_mock *MockFontDetector) IsAvailable(ctx context.Context) bool {
1375 ret := _mock.Called(ctx)
1376
1377 if len(ret) == 0 {
1378 panic("no return value specified for IsAvailable")
1379 }
1380
1381 var r0 bool
1382 if returnFunc, ok := ret.Get(0).(func(context.Context) bool); ok {
1383 r0 = returnFunc(ctx)
1384 } else {
1385 r0 = ret.Get(0).(bool)
1386 }
1387 return r0
1388}
1389
1390// MockFontDetector_IsAvailable_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsAvailable'
1391type MockFontDetector_IsAvailable_Call struct {
1392 *mock.Call
1393}
1394
1395// IsAvailable is a helper method to define mock.On call
1396// - ctx context.Context
1397func (_e *MockFontDetector_Expecter) IsAvailable(ctx interface{}) *MockFontDetector_IsAvailable_Call {
1398 return &MockFontDetector_IsAvailable_Call{Call: _e.mock.On("IsAvailable", ctx)}
1399}
1400
1401func (_c *MockFontDetector_IsAvailable_Call) Run(run func(ctx context.Context)) *MockFontDetector_IsAvailable_Call {
1402 _c.Call.Run(func(args mock.Arguments) {
1403 var arg0 context.Context
1404 if args[0] != nil {
1405 arg0 = args[0].(context.Context)
1406 }
1407 run(
1408 arg0,
1409 )
1410 })
1411 return _c
1412}
1413
1414func (_c *MockFontDetector_IsAvailable_Call) Return(b bool) *MockFontDetector_IsAvailable_Call {
1415 _c.Call.Return(b)
1416 return _c
1417}
1418
1419func (_c *MockFontDetector_IsAvailable_Call) RunAndReturn(run func(ctx context.Context) bool) *MockFontDetector_IsAvailable_Call {
1420 _c.Call.Return(run)
1421 return _c
1422}
1423
1424// SelectBestFont provides a mock function for the type MockFontDetector
1425func (_mock *MockFontDetector) SelectBestFont(ctx context.Context, category port.FontCategory, fallbackChain []string) string {
1426 ret := _mock.Called(ctx, category, fallbackChain)
1427
1428 if len(ret) == 0 {
1429 panic("no return value specified for SelectBestFont")
1430 }
1431
1432 var r0 string
1433 if returnFunc, ok := ret.Get(0).(func(context.Context, port.FontCategory, []string) string); ok {
1434 r0 = returnFunc(ctx, category, fallbackChain)
1435 } else {
1436 r0 = ret.Get(0).(string)
1437 }
1438 return r0
1439}
1440
1441// MockFontDetector_SelectBestFont_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SelectBestFont'
1442type MockFontDetector_SelectBestFont_Call struct {
1443 *mock.Call
1444}
1445
1446// SelectBestFont is a helper method to define mock.On call
1447// - ctx context.Context
1448// - category port.FontCategory
1449// - fallbackChain []string
1450func (_e *MockFontDetector_Expecter) SelectBestFont(ctx interface{}, category interface{}, fallbackChain interface{}) *MockFontDetector_SelectBestFont_Call {
1451 return &MockFontDetector_SelectBestFont_Call{Call: _e.mock.On("SelectBestFont", ctx, category, fallbackChain)}
1452}
1453
1454func (_c *MockFontDetector_SelectBestFont_Call) Run(run func(ctx context.Context, category port.FontCategory, fallbackChain []string)) *MockFontDetector_SelectBestFont_Call {
1455 _c.Call.Run(func(args mock.Arguments) {
1456 var arg0 context.Context
1457 if args[0] != nil {
1458 arg0 = args[0].(context.Context)
1459 }
1460 var arg1 port.FontCategory
1461 if args[1] != nil {
1462 arg1 = args[1].(port.FontCategory)
1463 }
1464 var arg2 []string
1465 if args[2] != nil {
1466 arg2 = args[2].([]string)
1467 }
1468 run(
1469 arg0,
1470 arg1,
1471 arg2,
1472 )
1473 })
1474 return _c
1475}
1476
1477func (_c *MockFontDetector_SelectBestFont_Call) Return(s string) *MockFontDetector_SelectBestFont_Call {
1478 _c.Call.Return(s)
1479 return _c
1480}
1481
1482func (_c *MockFontDetector_SelectBestFont_Call) RunAndReturn(run func(ctx context.Context, category port.FontCategory, fallbackChain []string) string) *MockFontDetector_SelectBestFont_Call {
1483 _c.Call.Return(run)
1484 return _c
1485}
1486
1487// 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.
1488// The first argument is typically a *testing.T value.
1489func NewMockHardwareSurveyor(t interface {
1490 mock.TestingT
1491 Cleanup(func())
1492}) *MockHardwareSurveyor {
1493 mock := &MockHardwareSurveyor{}
1494 mock.Mock.Test(t)
1495
1496 t.Cleanup(func() { mock.AssertExpectations(t) })
1497
1498 return mock
1499}
1500
1501// MockHardwareSurveyor is an autogenerated mock type for the HardwareSurveyor type
1502type MockHardwareSurveyor struct {
1503 mock.Mock
1504}
1505
1506type MockHardwareSurveyor_Expecter struct {
1507 mock *mock.Mock
1508}
1509
1510func (_m *MockHardwareSurveyor) EXPECT() *MockHardwareSurveyor_Expecter {
1511 return &MockHardwareSurveyor_Expecter{mock: &_m.Mock}
1512}
1513
1514// Survey provides a mock function for the type MockHardwareSurveyor
1515func (_mock *MockHardwareSurveyor) Survey(ctx context.Context) port.HardwareInfo {
1516 ret := _mock.Called(ctx)
1517
1518 if len(ret) == 0 {
1519 panic("no return value specified for Survey")
1520 }
1521
1522 var r0 port.HardwareInfo
1523 if returnFunc, ok := ret.Get(0).(func(context.Context) port.HardwareInfo); ok {
1524 r0 = returnFunc(ctx)
1525 } else {
1526 r0 = ret.Get(0).(port.HardwareInfo)
1527 }
1528 return r0
1529}
1530
1531// MockHardwareSurveyor_Survey_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Survey'
1532type MockHardwareSurveyor_Survey_Call struct {
1533 *mock.Call
1534}
1535
1536// Survey is a helper method to define mock.On call
1537// - ctx context.Context
1538func (_e *MockHardwareSurveyor_Expecter) Survey(ctx interface{}) *MockHardwareSurveyor_Survey_Call {
1539 return &MockHardwareSurveyor_Survey_Call{Call: _e.mock.On("Survey", ctx)}
1540}
1541
1542func (_c *MockHardwareSurveyor_Survey_Call) Run(run func(ctx context.Context)) *MockHardwareSurveyor_Survey_Call {
1543 _c.Call.Run(func(args mock.Arguments) {
1544 var arg0 context.Context
1545 if args[0] != nil {
1546 arg0 = args[0].(context.Context)
1547 }
1548 run(
1549 arg0,
1550 )
1551 })
1552 return _c
1553}
1554
1555func (_c *MockHardwareSurveyor_Survey_Call) Return(hardwareInfo port.HardwareInfo) *MockHardwareSurveyor_Survey_Call {
1556 _c.Call.Return(hardwareInfo)
1557 return _c
1558}
1559
1560func (_c *MockHardwareSurveyor_Survey_Call) RunAndReturn(run func(ctx context.Context) port.HardwareInfo) *MockHardwareSurveyor_Survey_Call {
1561 _c.Call.Return(run)
1562 return _c
1563}
1564
1565// 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.
1566// The first argument is typically a *testing.T value.
1567func NewMockKeybindingsProvider(t interface {
1568 mock.TestingT
1569 Cleanup(func())
1570}) *MockKeybindingsProvider {
1571 mock := &MockKeybindingsProvider{}
1572 mock.Mock.Test(t)
1573
1574 t.Cleanup(func() { mock.AssertExpectations(t) })
1575
1576 return mock
1577}
1578
1579// MockKeybindingsProvider is an autogenerated mock type for the KeybindingsProvider type
1580type MockKeybindingsProvider struct {
1581 mock.Mock
1582}
1583
1584type MockKeybindingsProvider_Expecter struct {
1585 mock *mock.Mock
1586}
1587
1588func (_m *MockKeybindingsProvider) EXPECT() *MockKeybindingsProvider_Expecter {
1589 return &MockKeybindingsProvider_Expecter{mock: &_m.Mock}
1590}
1591
1592// CheckConflicts provides a mock function for the type MockKeybindingsProvider
1593func (_mock *MockKeybindingsProvider) CheckConflicts(ctx context.Context, mode string, action string, keys []string) ([]port.KeybindingConflict, error) {
1594 ret := _mock.Called(ctx, mode, action, keys)
1595
1596 if len(ret) == 0 {
1597 panic("no return value specified for CheckConflicts")
1598 }
1599
1600 var r0 []port.KeybindingConflict
1601 var r1 error
1602 if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, []string) ([]port.KeybindingConflict, error)); ok {
1603 return returnFunc(ctx, mode, action, keys)
1604 }
1605 if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, []string) []port.KeybindingConflict); ok {
1606 r0 = returnFunc(ctx, mode, action, keys)
1607 } else {
1608 if ret.Get(0) != nil {
1609 r0 = ret.Get(0).([]port.KeybindingConflict)
1610 }
1611 }
1612 if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, []string) error); ok {
1613 r1 = returnFunc(ctx, mode, action, keys)
1614 } else {
1615 r1 = ret.Error(1)
1616 }
1617 return r0, r1
1618}
1619
1620// MockKeybindingsProvider_CheckConflicts_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CheckConflicts'
1621type MockKeybindingsProvider_CheckConflicts_Call struct {
1622 *mock.Call
1623}
1624
1625// CheckConflicts is a helper method to define mock.On call
1626// - ctx context.Context
1627// - mode string
1628// - action string
1629// - keys []string
1630func (_e *MockKeybindingsProvider_Expecter) CheckConflicts(ctx interface{}, mode interface{}, action interface{}, keys interface{}) *MockKeybindingsProvider_CheckConflicts_Call {
1631 return &MockKeybindingsProvider_CheckConflicts_Call{Call: _e.mock.On("CheckConflicts", ctx, mode, action, keys)}
1632}
1633
1634func (_c *MockKeybindingsProvider_CheckConflicts_Call) Run(run func(ctx context.Context, mode string, action string, keys []string)) *MockKeybindingsProvider_CheckConflicts_Call {
1635 _c.Call.Run(func(args mock.Arguments) {
1636 var arg0 context.Context
1637 if args[0] != nil {
1638 arg0 = args[0].(context.Context)
1639 }
1640 var arg1 string
1641 if args[1] != nil {
1642 arg1 = args[1].(string)
1643 }
1644 var arg2 string
1645 if args[2] != nil {
1646 arg2 = args[2].(string)
1647 }
1648 var arg3 []string
1649 if args[3] != nil {
1650 arg3 = args[3].([]string)
1651 }
1652 run(
1653 arg0,
1654 arg1,
1655 arg2,
1656 arg3,
1657 )
1658 })
1659 return _c
1660}
1661
1662func (_c *MockKeybindingsProvider_CheckConflicts_Call) Return(keybindingConflicts []port.KeybindingConflict, err error) *MockKeybindingsProvider_CheckConflicts_Call {
1663 _c.Call.Return(keybindingConflicts, err)
1664 return _c
1665}
1666
1667func (_c *MockKeybindingsProvider_CheckConflicts_Call) RunAndReturn(run func(ctx context.Context, mode string, action string, keys []string) ([]port.KeybindingConflict, error)) *MockKeybindingsProvider_CheckConflicts_Call {
1668 _c.Call.Return(run)
1669 return _c
1670}
1671
1672// GetDefaultKeybindings provides a mock function for the type MockKeybindingsProvider
1673func (_mock *MockKeybindingsProvider) GetDefaultKeybindings(ctx context.Context) (port.KeybindingsConfig, error) {
1674 ret := _mock.Called(ctx)
1675
1676 if len(ret) == 0 {
1677 panic("no return value specified for GetDefaultKeybindings")
1678 }
1679
1680 var r0 port.KeybindingsConfig
1681 var r1 error
1682 if returnFunc, ok := ret.Get(0).(func(context.Context) (port.KeybindingsConfig, error)); ok {
1683 return returnFunc(ctx)
1684 }
1685 if returnFunc, ok := ret.Get(0).(func(context.Context) port.KeybindingsConfig); ok {
1686 r0 = returnFunc(ctx)
1687 } else {
1688 r0 = ret.Get(0).(port.KeybindingsConfig)
1689 }
1690 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
1691 r1 = returnFunc(ctx)
1692 } else {
1693 r1 = ret.Error(1)
1694 }
1695 return r0, r1
1696}
1697
1698// MockKeybindingsProvider_GetDefaultKeybindings_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetDefaultKeybindings'
1699type MockKeybindingsProvider_GetDefaultKeybindings_Call struct {
1700 *mock.Call
1701}
1702
1703// GetDefaultKeybindings is a helper method to define mock.On call
1704// - ctx context.Context
1705func (_e *MockKeybindingsProvider_Expecter) GetDefaultKeybindings(ctx interface{}) *MockKeybindingsProvider_GetDefaultKeybindings_Call {
1706 return &MockKeybindingsProvider_GetDefaultKeybindings_Call{Call: _e.mock.On("GetDefaultKeybindings", ctx)}
1707}
1708
1709func (_c *MockKeybindingsProvider_GetDefaultKeybindings_Call) Run(run func(ctx context.Context)) *MockKeybindingsProvider_GetDefaultKeybindings_Call {
1710 _c.Call.Run(func(args mock.Arguments) {
1711 var arg0 context.Context
1712 if args[0] != nil {
1713 arg0 = args[0].(context.Context)
1714 }
1715 run(
1716 arg0,
1717 )
1718 })
1719 return _c
1720}
1721
1722func (_c *MockKeybindingsProvider_GetDefaultKeybindings_Call) Return(keybindingsConfig port.KeybindingsConfig, err error) *MockKeybindingsProvider_GetDefaultKeybindings_Call {
1723 _c.Call.Return(keybindingsConfig, err)
1724 return _c
1725}
1726
1727func (_c *MockKeybindingsProvider_GetDefaultKeybindings_Call) RunAndReturn(run func(ctx context.Context) (port.KeybindingsConfig, error)) *MockKeybindingsProvider_GetDefaultKeybindings_Call {
1728 _c.Call.Return(run)
1729 return _c
1730}
1731
1732// GetKeybindings provides a mock function for the type MockKeybindingsProvider
1733func (_mock *MockKeybindingsProvider) GetKeybindings(ctx context.Context) (port.KeybindingsConfig, error) {
1734 ret := _mock.Called(ctx)
1735
1736 if len(ret) == 0 {
1737 panic("no return value specified for GetKeybindings")
1738 }
1739
1740 var r0 port.KeybindingsConfig
1741 var r1 error
1742 if returnFunc, ok := ret.Get(0).(func(context.Context) (port.KeybindingsConfig, error)); ok {
1743 return returnFunc(ctx)
1744 }
1745 if returnFunc, ok := ret.Get(0).(func(context.Context) port.KeybindingsConfig); ok {
1746 r0 = returnFunc(ctx)
1747 } else {
1748 r0 = ret.Get(0).(port.KeybindingsConfig)
1749 }
1750 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
1751 r1 = returnFunc(ctx)
1752 } else {
1753 r1 = ret.Error(1)
1754 }
1755 return r0, r1
1756}
1757
1758// MockKeybindingsProvider_GetKeybindings_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetKeybindings'
1759type MockKeybindingsProvider_GetKeybindings_Call struct {
1760 *mock.Call
1761}
1762
1763// GetKeybindings is a helper method to define mock.On call
1764// - ctx context.Context
1765func (_e *MockKeybindingsProvider_Expecter) GetKeybindings(ctx interface{}) *MockKeybindingsProvider_GetKeybindings_Call {
1766 return &MockKeybindingsProvider_GetKeybindings_Call{Call: _e.mock.On("GetKeybindings", ctx)}
1767}
1768
1769func (_c *MockKeybindingsProvider_GetKeybindings_Call) Run(run func(ctx context.Context)) *MockKeybindingsProvider_GetKeybindings_Call {
1770 _c.Call.Run(func(args mock.Arguments) {
1771 var arg0 context.Context
1772 if args[0] != nil {
1773 arg0 = args[0].(context.Context)
1774 }
1775 run(
1776 arg0,
1777 )
1778 })
1779 return _c
1780}
1781
1782func (_c *MockKeybindingsProvider_GetKeybindings_Call) Return(keybindingsConfig port.KeybindingsConfig, err error) *MockKeybindingsProvider_GetKeybindings_Call {
1783 _c.Call.Return(keybindingsConfig, err)
1784 return _c
1785}
1786
1787func (_c *MockKeybindingsProvider_GetKeybindings_Call) RunAndReturn(run func(ctx context.Context) (port.KeybindingsConfig, error)) *MockKeybindingsProvider_GetKeybindings_Call {
1788 _c.Call.Return(run)
1789 return _c
1790}
1791
1792// 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.
1793// The first argument is typically a *testing.T value.
1794func NewMockKeybindingsSaver(t interface {
1795 mock.TestingT
1796 Cleanup(func())
1797}) *MockKeybindingsSaver {
1798 mock := &MockKeybindingsSaver{}
1799 mock.Mock.Test(t)
1800
1801 t.Cleanup(func() { mock.AssertExpectations(t) })
1802
1803 return mock
1804}
1805
1806// MockKeybindingsSaver is an autogenerated mock type for the KeybindingsSaver type
1807type MockKeybindingsSaver struct {
1808 mock.Mock
1809}
1810
1811type MockKeybindingsSaver_Expecter struct {
1812 mock *mock.Mock
1813}
1814
1815func (_m *MockKeybindingsSaver) EXPECT() *MockKeybindingsSaver_Expecter {
1816 return &MockKeybindingsSaver_Expecter{mock: &_m.Mock}
1817}
1818
1819// ResetAllKeybindings provides a mock function for the type MockKeybindingsSaver
1820func (_mock *MockKeybindingsSaver) ResetAllKeybindings(ctx context.Context) error {
1821 ret := _mock.Called(ctx)
1822
1823 if len(ret) == 0 {
1824 panic("no return value specified for ResetAllKeybindings")
1825 }
1826
1827 var r0 error
1828 if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
1829 r0 = returnFunc(ctx)
1830 } else {
1831 r0 = ret.Error(0)
1832 }
1833 return r0
1834}
1835
1836// MockKeybindingsSaver_ResetAllKeybindings_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResetAllKeybindings'
1837type MockKeybindingsSaver_ResetAllKeybindings_Call struct {
1838 *mock.Call
1839}
1840
1841// ResetAllKeybindings is a helper method to define mock.On call
1842// - ctx context.Context
1843func (_e *MockKeybindingsSaver_Expecter) ResetAllKeybindings(ctx interface{}) *MockKeybindingsSaver_ResetAllKeybindings_Call {
1844 return &MockKeybindingsSaver_ResetAllKeybindings_Call{Call: _e.mock.On("ResetAllKeybindings", ctx)}
1845}
1846
1847func (_c *MockKeybindingsSaver_ResetAllKeybindings_Call) Run(run func(ctx context.Context)) *MockKeybindingsSaver_ResetAllKeybindings_Call {
1848 _c.Call.Run(func(args mock.Arguments) {
1849 var arg0 context.Context
1850 if args[0] != nil {
1851 arg0 = args[0].(context.Context)
1852 }
1853 run(
1854 arg0,
1855 )
1856 })
1857 return _c
1858}
1859
1860func (_c *MockKeybindingsSaver_ResetAllKeybindings_Call) Return(err error) *MockKeybindingsSaver_ResetAllKeybindings_Call {
1861 _c.Call.Return(err)
1862 return _c
1863}
1864
1865func (_c *MockKeybindingsSaver_ResetAllKeybindings_Call) RunAndReturn(run func(ctx context.Context) error) *MockKeybindingsSaver_ResetAllKeybindings_Call {
1866 _c.Call.Return(run)
1867 return _c
1868}
1869
1870// ResetKeybinding provides a mock function for the type MockKeybindingsSaver
1871func (_mock *MockKeybindingsSaver) ResetKeybinding(ctx context.Context, req port.ResetKeybindingRequest) error {
1872 ret := _mock.Called(ctx, req)
1873
1874 if len(ret) == 0 {
1875 panic("no return value specified for ResetKeybinding")
1876 }
1877
1878 var r0 error
1879 if returnFunc, ok := ret.Get(0).(func(context.Context, port.ResetKeybindingRequest) error); ok {
1880 r0 = returnFunc(ctx, req)
1881 } else {
1882 r0 = ret.Error(0)
1883 }
1884 return r0
1885}
1886
1887// MockKeybindingsSaver_ResetKeybinding_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResetKeybinding'
1888type MockKeybindingsSaver_ResetKeybinding_Call struct {
1889 *mock.Call
1890}
1891
1892// ResetKeybinding is a helper method to define mock.On call
1893// - ctx context.Context
1894// - req port.ResetKeybindingRequest
1895func (_e *MockKeybindingsSaver_Expecter) ResetKeybinding(ctx interface{}, req interface{}) *MockKeybindingsSaver_ResetKeybinding_Call {
1896 return &MockKeybindingsSaver_ResetKeybinding_Call{Call: _e.mock.On("ResetKeybinding", ctx, req)}
1897}
1898
1899func (_c *MockKeybindingsSaver_ResetKeybinding_Call) Run(run func(ctx context.Context, req port.ResetKeybindingRequest)) *MockKeybindingsSaver_ResetKeybinding_Call {
1900 _c.Call.Run(func(args mock.Arguments) {
1901 var arg0 context.Context
1902 if args[0] != nil {
1903 arg0 = args[0].(context.Context)
1904 }
1905 var arg1 port.ResetKeybindingRequest
1906 if args[1] != nil {
1907 arg1 = args[1].(port.ResetKeybindingRequest)
1908 }
1909 run(
1910 arg0,
1911 arg1,
1912 )
1913 })
1914 return _c
1915}
1916
1917func (_c *MockKeybindingsSaver_ResetKeybinding_Call) Return(err error) *MockKeybindingsSaver_ResetKeybinding_Call {
1918 _c.Call.Return(err)
1919 return _c
1920}
1921
1922func (_c *MockKeybindingsSaver_ResetKeybinding_Call) RunAndReturn(run func(ctx context.Context, req port.ResetKeybindingRequest) error) *MockKeybindingsSaver_ResetKeybinding_Call {
1923 _c.Call.Return(run)
1924 return _c
1925}
1926
1927// SetKeybinding provides a mock function for the type MockKeybindingsSaver
1928func (_mock *MockKeybindingsSaver) SetKeybinding(ctx context.Context, req port.SetKeybindingRequest) error {
1929 ret := _mock.Called(ctx, req)
1930
1931 if len(ret) == 0 {
1932 panic("no return value specified for SetKeybinding")
1933 }
1934
1935 var r0 error
1936 if returnFunc, ok := ret.Get(0).(func(context.Context, port.SetKeybindingRequest) error); ok {
1937 r0 = returnFunc(ctx, req)
1938 } else {
1939 r0 = ret.Error(0)
1940 }
1941 return r0
1942}
1943
1944// MockKeybindingsSaver_SetKeybinding_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetKeybinding'
1945type MockKeybindingsSaver_SetKeybinding_Call struct {
1946 *mock.Call
1947}
1948
1949// SetKeybinding is a helper method to define mock.On call
1950// - ctx context.Context
1951// - req port.SetKeybindingRequest
1952func (_e *MockKeybindingsSaver_Expecter) SetKeybinding(ctx interface{}, req interface{}) *MockKeybindingsSaver_SetKeybinding_Call {
1953 return &MockKeybindingsSaver_SetKeybinding_Call{Call: _e.mock.On("SetKeybinding", ctx, req)}
1954}
1955
1956func (_c *MockKeybindingsSaver_SetKeybinding_Call) Run(run func(ctx context.Context, req port.SetKeybindingRequest)) *MockKeybindingsSaver_SetKeybinding_Call {
1957 _c.Call.Run(func(args mock.Arguments) {
1958 var arg0 context.Context
1959 if args[0] != nil {
1960 arg0 = args[0].(context.Context)
1961 }
1962 var arg1 port.SetKeybindingRequest
1963 if args[1] != nil {
1964 arg1 = args[1].(port.SetKeybindingRequest)
1965 }
1966 run(
1967 arg0,
1968 arg1,
1969 )
1970 })
1971 return _c
1972}
1973
1974func (_c *MockKeybindingsSaver_SetKeybinding_Call) Return(err error) *MockKeybindingsSaver_SetKeybinding_Call {
1975 _c.Call.Return(err)
1976 return _c
1977}
1978
1979func (_c *MockKeybindingsSaver_SetKeybinding_Call) RunAndReturn(run func(ctx context.Context, req port.SetKeybindingRequest) error) *MockKeybindingsSaver_SetKeybinding_Call {
1980 _c.Call.Return(run)
1981 return _c
1982}
1983
1984// 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.
1985// The first argument is typically a *testing.T value.
1986func NewMockSessionLogger(t interface {
1987 mock.TestingT
1988 Cleanup(func())
1989}) *MockSessionLogger {
1990 mock := &MockSessionLogger{}
1991 mock.Mock.Test(t)
1992
1993 t.Cleanup(func() { mock.AssertExpectations(t) })
1994
1995 return mock
1996}
1997
1998// MockSessionLogger is an autogenerated mock type for the SessionLogger type
1999type MockSessionLogger struct {
2000 mock.Mock
2001}
2002
2003type MockSessionLogger_Expecter struct {
2004 mock *mock.Mock
2005}
2006
2007func (_m *MockSessionLogger) EXPECT() *MockSessionLogger_Expecter {
2008 return &MockSessionLogger_Expecter{mock: &_m.Mock}
2009}
2010
2011// CreateLogger provides a mock function for the type MockSessionLogger
2012func (_mock *MockSessionLogger) CreateLogger(ctx context.Context, sessionID entity.SessionID, cfg port.SessionLogConfig) (zerolog.Logger, func(), error) {
2013 ret := _mock.Called(ctx, sessionID, cfg)
2014
2015 if len(ret) == 0 {
2016 panic("no return value specified for CreateLogger")
2017 }
2018
2019 var r0 zerolog.Logger
2020 var r1 func()
2021 var r2 error
2022 if returnFunc, ok := ret.Get(0).(func(context.Context, entity.SessionID, port.SessionLogConfig) (zerolog.Logger, func(), error)); ok {
2023 return returnFunc(ctx, sessionID, cfg)
2024 }
2025 if returnFunc, ok := ret.Get(0).(func(context.Context, entity.SessionID, port.SessionLogConfig) zerolog.Logger); ok {
2026 r0 = returnFunc(ctx, sessionID, cfg)
2027 } else {
2028 r0 = ret.Get(0).(zerolog.Logger)
2029 }
2030 if returnFunc, ok := ret.Get(1).(func(context.Context, entity.SessionID, port.SessionLogConfig) func()); ok {
2031 r1 = returnFunc(ctx, sessionID, cfg)
2032 } else {
2033 if ret.Get(1) != nil {
2034 r1 = ret.Get(1).(func())
2035 }
2036 }
2037 if returnFunc, ok := ret.Get(2).(func(context.Context, entity.SessionID, port.SessionLogConfig) error); ok {
2038 r2 = returnFunc(ctx, sessionID, cfg)
2039 } else {
2040 r2 = ret.Error(2)
2041 }
2042 return r0, r1, r2
2043}
2044
2045// MockSessionLogger_CreateLogger_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateLogger'
2046type MockSessionLogger_CreateLogger_Call struct {
2047 *mock.Call
2048}
2049
2050// CreateLogger is a helper method to define mock.On call
2051// - ctx context.Context
2052// - sessionID entity.SessionID
2053// - cfg port.SessionLogConfig
2054func (_e *MockSessionLogger_Expecter) CreateLogger(ctx interface{}, sessionID interface{}, cfg interface{}) *MockSessionLogger_CreateLogger_Call {
2055 return &MockSessionLogger_CreateLogger_Call{Call: _e.mock.On("CreateLogger", ctx, sessionID, cfg)}
2056}
2057
2058func (_c *MockSessionLogger_CreateLogger_Call) Run(run func(ctx context.Context, sessionID entity.SessionID, cfg port.SessionLogConfig)) *MockSessionLogger_CreateLogger_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 entity.SessionID
2065 if args[1] != nil {
2066 arg1 = args[1].(entity.SessionID)
2067 }
2068 var arg2 port.SessionLogConfig
2069 if args[2] != nil {
2070 arg2 = args[2].(port.SessionLogConfig)
2071 }
2072 run(
2073 arg0,
2074 arg1,
2075 arg2,
2076 )
2077 })
2078 return _c
2079}
2080
2081func (_c *MockSessionLogger_CreateLogger_Call) Return(logger zerolog.Logger, fn func(), err error) *MockSessionLogger_CreateLogger_Call {
2082 _c.Call.Return(logger, fn, err)
2083 return _c
2084}
2085
2086func (_c *MockSessionLogger_CreateLogger_Call) RunAndReturn(run func(ctx context.Context, sessionID entity.SessionID, cfg port.SessionLogConfig) (zerolog.Logger, func(), error)) *MockSessionLogger_CreateLogger_Call {
2087 _c.Call.Return(run)
2088 return _c
2089}
2090
2091// 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.
2092// The first argument is typically a *testing.T value.
2093func NewMockTabListProvider(t interface {
2094 mock.TestingT
2095 Cleanup(func())
2096}) *MockTabListProvider {
2097 mock := &MockTabListProvider{}
2098 mock.Mock.Test(t)
2099
2100 t.Cleanup(func() { mock.AssertExpectations(t) })
2101
2102 return mock
2103}
2104
2105// MockTabListProvider is an autogenerated mock type for the TabListProvider type
2106type MockTabListProvider struct {
2107 mock.Mock
2108}
2109
2110type MockTabListProvider_Expecter struct {
2111 mock *mock.Mock
2112}
2113
2114func (_m *MockTabListProvider) EXPECT() *MockTabListProvider_Expecter {
2115 return &MockTabListProvider_Expecter{mock: &_m.Mock}
2116}
2117
2118// GetSessionID provides a mock function for the type MockTabListProvider
2119func (_mock *MockTabListProvider) GetSessionID() entity.SessionID {
2120 ret := _mock.Called()
2121
2122 if len(ret) == 0 {
2123 panic("no return value specified for GetSessionID")
2124 }
2125
2126 var r0 entity.SessionID
2127 if returnFunc, ok := ret.Get(0).(func() entity.SessionID); ok {
2128 r0 = returnFunc()
2129 } else {
2130 r0 = ret.Get(0).(entity.SessionID)
2131 }
2132 return r0
2133}
2134
2135// MockTabListProvider_GetSessionID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSessionID'
2136type MockTabListProvider_GetSessionID_Call struct {
2137 *mock.Call
2138}
2139
2140// GetSessionID is a helper method to define mock.On call
2141func (_e *MockTabListProvider_Expecter) GetSessionID() *MockTabListProvider_GetSessionID_Call {
2142 return &MockTabListProvider_GetSessionID_Call{Call: _e.mock.On("GetSessionID")}
2143}
2144
2145func (_c *MockTabListProvider_GetSessionID_Call) Run(run func()) *MockTabListProvider_GetSessionID_Call {
2146 _c.Call.Run(func(args mock.Arguments) {
2147 run()
2148 })
2149 return _c
2150}
2151
2152func (_c *MockTabListProvider_GetSessionID_Call) Return(sessionID entity.SessionID) *MockTabListProvider_GetSessionID_Call {
2153 _c.Call.Return(sessionID)
2154 return _c
2155}
2156
2157func (_c *MockTabListProvider_GetSessionID_Call) RunAndReturn(run func() entity.SessionID) *MockTabListProvider_GetSessionID_Call {
2158 _c.Call.Return(run)
2159 return _c
2160}
2161
2162// GetTabList provides a mock function for the type MockTabListProvider
2163func (_mock *MockTabListProvider) GetTabList() *entity.TabList {
2164 ret := _mock.Called()
2165
2166 if len(ret) == 0 {
2167 panic("no return value specified for GetTabList")
2168 }
2169
2170 var r0 *entity.TabList
2171 if returnFunc, ok := ret.Get(0).(func() *entity.TabList); ok {
2172 r0 = returnFunc()
2173 } else {
2174 if ret.Get(0) != nil {
2175 r0 = ret.Get(0).(*entity.TabList)
2176 }
2177 }
2178 return r0
2179}
2180
2181// MockTabListProvider_GetTabList_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTabList'
2182type MockTabListProvider_GetTabList_Call struct {
2183 *mock.Call
2184}
2185
2186// GetTabList is a helper method to define mock.On call
2187func (_e *MockTabListProvider_Expecter) GetTabList() *MockTabListProvider_GetTabList_Call {
2188 return &MockTabListProvider_GetTabList_Call{Call: _e.mock.On("GetTabList")}
2189}
2190
2191func (_c *MockTabListProvider_GetTabList_Call) Run(run func()) *MockTabListProvider_GetTabList_Call {
2192 _c.Call.Run(func(args mock.Arguments) {
2193 run()
2194 })
2195 return _c
2196}
2197
2198func (_c *MockTabListProvider_GetTabList_Call) Return(tabList *entity.TabList) *MockTabListProvider_GetTabList_Call {
2199 _c.Call.Return(tabList)
2200 return _c
2201}
2202
2203func (_c *MockTabListProvider_GetTabList_Call) RunAndReturn(run func() *entity.TabList) *MockTabListProvider_GetTabList_Call {
2204 _c.Call.Return(run)
2205 return _c
2206}
2207
2208// 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.
2209// The first argument is typically a *testing.T value.
2210func NewMockSessionSpawner(t interface {
2211 mock.TestingT
2212 Cleanup(func())
2213}) *MockSessionSpawner {
2214 mock := &MockSessionSpawner{}
2215 mock.Mock.Test(t)
2216
2217 t.Cleanup(func() { mock.AssertExpectations(t) })
2218
2219 return mock
2220}
2221
2222// MockSessionSpawner is an autogenerated mock type for the SessionSpawner type
2223type MockSessionSpawner struct {
2224 mock.Mock
2225}
2226
2227type MockSessionSpawner_Expecter struct {
2228 mock *mock.Mock
2229}
2230
2231func (_m *MockSessionSpawner) EXPECT() *MockSessionSpawner_Expecter {
2232 return &MockSessionSpawner_Expecter{mock: &_m.Mock}
2233}
2234
2235// SpawnWithSession provides a mock function for the type MockSessionSpawner
2236func (_mock *MockSessionSpawner) SpawnWithSession(sessionID entity.SessionID) error {
2237 ret := _mock.Called(sessionID)
2238
2239 if len(ret) == 0 {
2240 panic("no return value specified for SpawnWithSession")
2241 }
2242
2243 var r0 error
2244 if returnFunc, ok := ret.Get(0).(func(entity.SessionID) error); ok {
2245 r0 = returnFunc(sessionID)
2246 } else {
2247 r0 = ret.Error(0)
2248 }
2249 return r0
2250}
2251
2252// MockSessionSpawner_SpawnWithSession_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SpawnWithSession'
2253type MockSessionSpawner_SpawnWithSession_Call struct {
2254 *mock.Call
2255}
2256
2257// SpawnWithSession is a helper method to define mock.On call
2258// - sessionID entity.SessionID
2259func (_e *MockSessionSpawner_Expecter) SpawnWithSession(sessionID interface{}) *MockSessionSpawner_SpawnWithSession_Call {
2260 return &MockSessionSpawner_SpawnWithSession_Call{Call: _e.mock.On("SpawnWithSession", sessionID)}
2261}
2262
2263func (_c *MockSessionSpawner_SpawnWithSession_Call) Run(run func(sessionID entity.SessionID)) *MockSessionSpawner_SpawnWithSession_Call {
2264 _c.Call.Run(func(args mock.Arguments) {
2265 var arg0 entity.SessionID
2266 if args[0] != nil {
2267 arg0 = args[0].(entity.SessionID)
2268 }
2269 run(
2270 arg0,
2271 )
2272 })
2273 return _c
2274}
2275
2276func (_c *MockSessionSpawner_SpawnWithSession_Call) Return(err error) *MockSessionSpawner_SpawnWithSession_Call {
2277 _c.Call.Return(err)
2278 return _c
2279}
2280
2281func (_c *MockSessionSpawner_SpawnWithSession_Call) RunAndReturn(run func(sessionID entity.SessionID) error) *MockSessionSpawner_SpawnWithSession_Call {
2282 _c.Call.Return(run)
2283 return _c
2284}
2285
2286// 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.
2287// The first argument is typically a *testing.T value.
2288func NewMockTextInputTarget(t interface {
2289 mock.TestingT
2290 Cleanup(func())
2291}) *MockTextInputTarget {
2292 mock := &MockTextInputTarget{}
2293 mock.Mock.Test(t)
2294
2295 t.Cleanup(func() { mock.AssertExpectations(t) })
2296
2297 return mock
2298}
2299
2300// MockTextInputTarget is an autogenerated mock type for the TextInputTarget type
2301type MockTextInputTarget struct {
2302 mock.Mock
2303}
2304
2305type MockTextInputTarget_Expecter struct {
2306 mock *mock.Mock
2307}
2308
2309func (_m *MockTextInputTarget) EXPECT() *MockTextInputTarget_Expecter {
2310 return &MockTextInputTarget_Expecter{mock: &_m.Mock}
2311}
2312
2313// DeleteBeforeCursor provides a mock function for the type MockTextInputTarget
2314func (_mock *MockTextInputTarget) DeleteBeforeCursor(ctx context.Context, n int) error {
2315 ret := _mock.Called(ctx, n)
2316
2317 if len(ret) == 0 {
2318 panic("no return value specified for DeleteBeforeCursor")
2319 }
2320
2321 var r0 error
2322 if returnFunc, ok := ret.Get(0).(func(context.Context, int) error); ok {
2323 r0 = returnFunc(ctx, n)
2324 } else {
2325 r0 = ret.Error(0)
2326 }
2327 return r0
2328}
2329
2330// MockTextInputTarget_DeleteBeforeCursor_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteBeforeCursor'
2331type MockTextInputTarget_DeleteBeforeCursor_Call struct {
2332 *mock.Call
2333}
2334
2335// DeleteBeforeCursor is a helper method to define mock.On call
2336// - ctx context.Context
2337// - n int
2338func (_e *MockTextInputTarget_Expecter) DeleteBeforeCursor(ctx interface{}, n interface{}) *MockTextInputTarget_DeleteBeforeCursor_Call {
2339 return &MockTextInputTarget_DeleteBeforeCursor_Call{Call: _e.mock.On("DeleteBeforeCursor", ctx, n)}
2340}
2341
2342func (_c *MockTextInputTarget_DeleteBeforeCursor_Call) Run(run func(ctx context.Context, n int)) *MockTextInputTarget_DeleteBeforeCursor_Call {
2343 _c.Call.Run(func(args mock.Arguments) {
2344 var arg0 context.Context
2345 if args[0] != nil {
2346 arg0 = args[0].(context.Context)
2347 }
2348 var arg1 int
2349 if args[1] != nil {
2350 arg1 = args[1].(int)
2351 }
2352 run(
2353 arg0,
2354 arg1,
2355 )
2356 })
2357 return _c
2358}
2359
2360func (_c *MockTextInputTarget_DeleteBeforeCursor_Call) Return(err error) *MockTextInputTarget_DeleteBeforeCursor_Call {
2361 _c.Call.Return(err)
2362 return _c
2363}
2364
2365func (_c *MockTextInputTarget_DeleteBeforeCursor_Call) RunAndReturn(run func(ctx context.Context, n int) error) *MockTextInputTarget_DeleteBeforeCursor_Call {
2366 _c.Call.Return(run)
2367 return _c
2368}
2369
2370// InsertText provides a mock function for the type MockTextInputTarget
2371func (_mock *MockTextInputTarget) InsertText(ctx context.Context, text string) error {
2372 ret := _mock.Called(ctx, text)
2373
2374 if len(ret) == 0 {
2375 panic("no return value specified for InsertText")
2376 }
2377
2378 var r0 error
2379 if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
2380 r0 = returnFunc(ctx, text)
2381 } else {
2382 r0 = ret.Error(0)
2383 }
2384 return r0
2385}
2386
2387// MockTextInputTarget_InsertText_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'InsertText'
2388type MockTextInputTarget_InsertText_Call struct {
2389 *mock.Call
2390}
2391
2392// InsertText is a helper method to define mock.On call
2393// - ctx context.Context
2394// - text string
2395func (_e *MockTextInputTarget_Expecter) InsertText(ctx interface{}, text interface{}) *MockTextInputTarget_InsertText_Call {
2396 return &MockTextInputTarget_InsertText_Call{Call: _e.mock.On("InsertText", ctx, text)}
2397}
2398
2399func (_c *MockTextInputTarget_InsertText_Call) Run(run func(ctx context.Context, text string)) *MockTextInputTarget_InsertText_Call {
2400 _c.Call.Run(func(args mock.Arguments) {
2401 var arg0 context.Context
2402 if args[0] != nil {
2403 arg0 = args[0].(context.Context)
2404 }
2405 var arg1 string
2406 if args[1] != nil {
2407 arg1 = args[1].(string)
2408 }
2409 run(
2410 arg0,
2411 arg1,
2412 )
2413 })
2414 return _c
2415}
2416
2417func (_c *MockTextInputTarget_InsertText_Call) Return(err error) *MockTextInputTarget_InsertText_Call {
2418 _c.Call.Return(err)
2419 return _c
2420}
2421
2422func (_c *MockTextInputTarget_InsertText_Call) RunAndReturn(run func(ctx context.Context, text string) error) *MockTextInputTarget_InsertText_Call {
2423 _c.Call.Return(run)
2424 return _c
2425}
2426
2427// 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.
2428// The first argument is typically a *testing.T value.
2429func NewMockFocusedInputProvider(t interface {
2430 mock.TestingT
2431 Cleanup(func())
2432}) *MockFocusedInputProvider {
2433 mock := &MockFocusedInputProvider{}
2434 mock.Mock.Test(t)
2435
2436 t.Cleanup(func() { mock.AssertExpectations(t) })
2437
2438 return mock
2439}
2440
2441// MockFocusedInputProvider is an autogenerated mock type for the FocusedInputProvider type
2442type MockFocusedInputProvider struct {
2443 mock.Mock
2444}
2445
2446type MockFocusedInputProvider_Expecter struct {
2447 mock *mock.Mock
2448}
2449
2450func (_m *MockFocusedInputProvider) EXPECT() *MockFocusedInputProvider_Expecter {
2451 return &MockFocusedInputProvider_Expecter{mock: &_m.Mock}
2452}
2453
2454// GetFocusedInput provides a mock function for the type MockFocusedInputProvider
2455func (_mock *MockFocusedInputProvider) GetFocusedInput() port.TextInputTarget {
2456 ret := _mock.Called()
2457
2458 if len(ret) == 0 {
2459 panic("no return value specified for GetFocusedInput")
2460 }
2461
2462 var r0 port.TextInputTarget
2463 if returnFunc, ok := ret.Get(0).(func() port.TextInputTarget); ok {
2464 r0 = returnFunc()
2465 } else {
2466 if ret.Get(0) != nil {
2467 r0 = ret.Get(0).(port.TextInputTarget)
2468 }
2469 }
2470 return r0
2471}
2472
2473// MockFocusedInputProvider_GetFocusedInput_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetFocusedInput'
2474type MockFocusedInputProvider_GetFocusedInput_Call struct {
2475 *mock.Call
2476}
2477
2478// GetFocusedInput is a helper method to define mock.On call
2479func (_e *MockFocusedInputProvider_Expecter) GetFocusedInput() *MockFocusedInputProvider_GetFocusedInput_Call {
2480 return &MockFocusedInputProvider_GetFocusedInput_Call{Call: _e.mock.On("GetFocusedInput")}
2481}
2482
2483func (_c *MockFocusedInputProvider_GetFocusedInput_Call) Run(run func()) *MockFocusedInputProvider_GetFocusedInput_Call {
2484 _c.Call.Run(func(args mock.Arguments) {
2485 run()
2486 })
2487 return _c
2488}
2489
2490func (_c *MockFocusedInputProvider_GetFocusedInput_Call) Return(textInputTarget port.TextInputTarget) *MockFocusedInputProvider_GetFocusedInput_Call {
2491 _c.Call.Return(textInputTarget)
2492 return _c
2493}
2494
2495func (_c *MockFocusedInputProvider_GetFocusedInput_Call) RunAndReturn(run func() port.TextInputTarget) *MockFocusedInputProvider_GetFocusedInput_Call {
2496 _c.Call.Return(run)
2497 return _c
2498}
2499
2500// SetFocusedInput provides a mock function for the type MockFocusedInputProvider
2501func (_mock *MockFocusedInputProvider) SetFocusedInput(target port.TextInputTarget) {
2502 _mock.Called(target)
2503 return
2504}
2505
2506// MockFocusedInputProvider_SetFocusedInput_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetFocusedInput'
2507type MockFocusedInputProvider_SetFocusedInput_Call struct {
2508 *mock.Call
2509}
2510
2511// SetFocusedInput is a helper method to define mock.On call
2512// - target port.TextInputTarget
2513func (_e *MockFocusedInputProvider_Expecter) SetFocusedInput(target interface{}) *MockFocusedInputProvider_SetFocusedInput_Call {
2514 return &MockFocusedInputProvider_SetFocusedInput_Call{Call: _e.mock.On("SetFocusedInput", target)}
2515}
2516
2517func (_c *MockFocusedInputProvider_SetFocusedInput_Call) Run(run func(target port.TextInputTarget)) *MockFocusedInputProvider_SetFocusedInput_Call {
2518 _c.Call.Run(func(args mock.Arguments) {
2519 var arg0 port.TextInputTarget
2520 if args[0] != nil {
2521 arg0 = args[0].(port.TextInputTarget)
2522 }
2523 run(
2524 arg0,
2525 )
2526 })
2527 return _c
2528}
2529
2530func (_c *MockFocusedInputProvider_SetFocusedInput_Call) Return() *MockFocusedInputProvider_SetFocusedInput_Call {
2531 _c.Call.Return()
2532 return _c
2533}
2534
2535func (_c *MockFocusedInputProvider_SetFocusedInput_Call) RunAndReturn(run func(target port.TextInputTarget)) *MockFocusedInputProvider_SetFocusedInput_Call {
2536 _c.Run(run)
2537 return _c
2538}
2539
2540// 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.
2541// The first argument is typically a *testing.T value.
2542func NewMockMemoryPressureApplier(t interface {
2543 mock.TestingT
2544 Cleanup(func())
2545}) *MockMemoryPressureApplier {
2546 mock := &MockMemoryPressureApplier{}
2547 mock.Mock.Test(t)
2548
2549 t.Cleanup(func() { mock.AssertExpectations(t) })
2550
2551 return mock
2552}
2553
2554// MockMemoryPressureApplier is an autogenerated mock type for the MemoryPressureApplier type
2555type MockMemoryPressureApplier struct {
2556 mock.Mock
2557}
2558
2559type MockMemoryPressureApplier_Expecter struct {
2560 mock *mock.Mock
2561}
2562
2563func (_m *MockMemoryPressureApplier) EXPECT() *MockMemoryPressureApplier_Expecter {
2564 return &MockMemoryPressureApplier_Expecter{mock: &_m.Mock}
2565}
2566
2567// ApplyNetworkProcessSettings provides a mock function for the type MockMemoryPressureApplier
2568func (_mock *MockMemoryPressureApplier) ApplyNetworkProcessSettings(ctx context.Context, cfg *port.MemoryPressureConfig) error {
2569 ret := _mock.Called(ctx, cfg)
2570
2571 if len(ret) == 0 {
2572 panic("no return value specified for ApplyNetworkProcessSettings")
2573 }
2574
2575 var r0 error
2576 if returnFunc, ok := ret.Get(0).(func(context.Context, *port.MemoryPressureConfig) error); ok {
2577 r0 = returnFunc(ctx, cfg)
2578 } else {
2579 r0 = ret.Error(0)
2580 }
2581 return r0
2582}
2583
2584// MockMemoryPressureApplier_ApplyNetworkProcessSettings_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ApplyNetworkProcessSettings'
2585type MockMemoryPressureApplier_ApplyNetworkProcessSettings_Call struct {
2586 *mock.Call
2587}
2588
2589// ApplyNetworkProcessSettings is a helper method to define mock.On call
2590// - ctx context.Context
2591// - cfg *port.MemoryPressureConfig
2592func (_e *MockMemoryPressureApplier_Expecter) ApplyNetworkProcessSettings(ctx interface{}, cfg interface{}) *MockMemoryPressureApplier_ApplyNetworkProcessSettings_Call {
2593 return &MockMemoryPressureApplier_ApplyNetworkProcessSettings_Call{Call: _e.mock.On("ApplyNetworkProcessSettings", ctx, cfg)}
2594}
2595
2596func (_c *MockMemoryPressureApplier_ApplyNetworkProcessSettings_Call) Run(run func(ctx context.Context, cfg *port.MemoryPressureConfig)) *MockMemoryPressureApplier_ApplyNetworkProcessSettings_Call {
2597 _c.Call.Run(func(args mock.Arguments) {
2598 var arg0 context.Context
2599 if args[0] != nil {
2600 arg0 = args[0].(context.Context)
2601 }
2602 var arg1 *port.MemoryPressureConfig
2603 if args[1] != nil {
2604 arg1 = args[1].(*port.MemoryPressureConfig)
2605 }
2606 run(
2607 arg0,
2608 arg1,
2609 )
2610 })
2611 return _c
2612}
2613
2614func (_c *MockMemoryPressureApplier_ApplyNetworkProcessSettings_Call) Return(err error) *MockMemoryPressureApplier_ApplyNetworkProcessSettings_Call {
2615 _c.Call.Return(err)
2616 return _c
2617}
2618
2619func (_c *MockMemoryPressureApplier_ApplyNetworkProcessSettings_Call) RunAndReturn(run func(ctx context.Context, cfg *port.MemoryPressureConfig) error) *MockMemoryPressureApplier_ApplyNetworkProcessSettings_Call {
2620 _c.Call.Return(run)
2621 return _c
2622}
2623
2624// ApplyWebProcessSettings provides a mock function for the type MockMemoryPressureApplier
2625func (_mock *MockMemoryPressureApplier) ApplyWebProcessSettings(ctx context.Context, cfg *port.MemoryPressureConfig) (any, error) {
2626 ret := _mock.Called(ctx, cfg)
2627
2628 if len(ret) == 0 {
2629 panic("no return value specified for ApplyWebProcessSettings")
2630 }
2631
2632 var r0 any
2633 var r1 error
2634 if returnFunc, ok := ret.Get(0).(func(context.Context, *port.MemoryPressureConfig) (any, error)); ok {
2635 return returnFunc(ctx, cfg)
2636 }
2637 if returnFunc, ok := ret.Get(0).(func(context.Context, *port.MemoryPressureConfig) any); ok {
2638 r0 = returnFunc(ctx, cfg)
2639 } else {
2640 if ret.Get(0) != nil {
2641 r0 = ret.Get(0).(any)
2642 }
2643 }
2644 if returnFunc, ok := ret.Get(1).(func(context.Context, *port.MemoryPressureConfig) error); ok {
2645 r1 = returnFunc(ctx, cfg)
2646 } else {
2647 r1 = ret.Error(1)
2648 }
2649 return r0, r1
2650}
2651
2652// MockMemoryPressureApplier_ApplyWebProcessSettings_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ApplyWebProcessSettings'
2653type MockMemoryPressureApplier_ApplyWebProcessSettings_Call struct {
2654 *mock.Call
2655}
2656
2657// ApplyWebProcessSettings is a helper method to define mock.On call
2658// - ctx context.Context
2659// - cfg *port.MemoryPressureConfig
2660func (_e *MockMemoryPressureApplier_Expecter) ApplyWebProcessSettings(ctx interface{}, cfg interface{}) *MockMemoryPressureApplier_ApplyWebProcessSettings_Call {
2661 return &MockMemoryPressureApplier_ApplyWebProcessSettings_Call{Call: _e.mock.On("ApplyWebProcessSettings", ctx, cfg)}
2662}
2663
2664func (_c *MockMemoryPressureApplier_ApplyWebProcessSettings_Call) Run(run func(ctx context.Context, cfg *port.MemoryPressureConfig)) *MockMemoryPressureApplier_ApplyWebProcessSettings_Call {
2665 _c.Call.Run(func(args mock.Arguments) {
2666 var arg0 context.Context
2667 if args[0] != nil {
2668 arg0 = args[0].(context.Context)
2669 }
2670 var arg1 *port.MemoryPressureConfig
2671 if args[1] != nil {
2672 arg1 = args[1].(*port.MemoryPressureConfig)
2673 }
2674 run(
2675 arg0,
2676 arg1,
2677 )
2678 })
2679 return _c
2680}
2681
2682func (_c *MockMemoryPressureApplier_ApplyWebProcessSettings_Call) Return(v any, err error) *MockMemoryPressureApplier_ApplyWebProcessSettings_Call {
2683 _c.Call.Return(v, err)
2684 return _c
2685}
2686
2687func (_c *MockMemoryPressureApplier_ApplyWebProcessSettings_Call) RunAndReturn(run func(ctx context.Context, cfg *port.MemoryPressureConfig) (any, error)) *MockMemoryPressureApplier_ApplyWebProcessSettings_Call {
2688 _c.Call.Return(run)
2689 return _c
2690}
2691
2692// 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.
2693// The first argument is typically a *testing.T value.
2694func NewMockWebKitContextProvider(t interface {
2695 mock.TestingT
2696 Cleanup(func())
2697}) *MockWebKitContextProvider {
2698 mock := &MockWebKitContextProvider{}
2699 mock.Mock.Test(t)
2700
2701 t.Cleanup(func() { mock.AssertExpectations(t) })
2702
2703 return mock
2704}
2705
2706// MockWebKitContextProvider is an autogenerated mock type for the WebKitContextProvider type
2707type MockWebKitContextProvider struct {
2708 mock.Mock
2709}
2710
2711type MockWebKitContextProvider_Expecter struct {
2712 mock *mock.Mock
2713}
2714
2715func (_m *MockWebKitContextProvider) EXPECT() *MockWebKitContextProvider_Expecter {
2716 return &MockWebKitContextProvider_Expecter{mock: &_m.Mock}
2717}
2718
2719// CacheDir provides a mock function for the type MockWebKitContextProvider
2720func (_mock *MockWebKitContextProvider) CacheDir() string {
2721 ret := _mock.Called()
2722
2723 if len(ret) == 0 {
2724 panic("no return value specified for CacheDir")
2725 }
2726
2727 var r0 string
2728 if returnFunc, ok := ret.Get(0).(func() string); ok {
2729 r0 = returnFunc()
2730 } else {
2731 r0 = ret.Get(0).(string)
2732 }
2733 return r0
2734}
2735
2736// MockWebKitContextProvider_CacheDir_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CacheDir'
2737type MockWebKitContextProvider_CacheDir_Call struct {
2738 *mock.Call
2739}
2740
2741// CacheDir is a helper method to define mock.On call
2742func (_e *MockWebKitContextProvider_Expecter) CacheDir() *MockWebKitContextProvider_CacheDir_Call {
2743 return &MockWebKitContextProvider_CacheDir_Call{Call: _e.mock.On("CacheDir")}
2744}
2745
2746func (_c *MockWebKitContextProvider_CacheDir_Call) Run(run func()) *MockWebKitContextProvider_CacheDir_Call {
2747 _c.Call.Run(func(args mock.Arguments) {
2748 run()
2749 })
2750 return _c
2751}
2752
2753func (_c *MockWebKitContextProvider_CacheDir_Call) Return(s string) *MockWebKitContextProvider_CacheDir_Call {
2754 _c.Call.Return(s)
2755 return _c
2756}
2757
2758func (_c *MockWebKitContextProvider_CacheDir_Call) RunAndReturn(run func() string) *MockWebKitContextProvider_CacheDir_Call {
2759 _c.Call.Return(run)
2760 return _c
2761}
2762
2763// Close provides a mock function for the type MockWebKitContextProvider
2764func (_mock *MockWebKitContextProvider) Close() error {
2765 ret := _mock.Called()
2766
2767 if len(ret) == 0 {
2768 panic("no return value specified for Close")
2769 }
2770
2771 var r0 error
2772 if returnFunc, ok := ret.Get(0).(func() error); ok {
2773 r0 = returnFunc()
2774 } else {
2775 r0 = ret.Error(0)
2776 }
2777 return r0
2778}
2779
2780// MockWebKitContextProvider_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
2781type MockWebKitContextProvider_Close_Call struct {
2782 *mock.Call
2783}
2784
2785// Close is a helper method to define mock.On call
2786func (_e *MockWebKitContextProvider_Expecter) Close() *MockWebKitContextProvider_Close_Call {
2787 return &MockWebKitContextProvider_Close_Call{Call: _e.mock.On("Close")}
2788}
2789
2790func (_c *MockWebKitContextProvider_Close_Call) Run(run func()) *MockWebKitContextProvider_Close_Call {
2791 _c.Call.Run(func(args mock.Arguments) {
2792 run()
2793 })
2794 return _c
2795}
2796
2797func (_c *MockWebKitContextProvider_Close_Call) Return(err error) *MockWebKitContextProvider_Close_Call {
2798 _c.Call.Return(err)
2799 return _c
2800}
2801
2802func (_c *MockWebKitContextProvider_Close_Call) RunAndReturn(run func() error) *MockWebKitContextProvider_Close_Call {
2803 _c.Call.Return(run)
2804 return _c
2805}
2806
2807// DataDir provides a mock function for the type MockWebKitContextProvider
2808func (_mock *MockWebKitContextProvider) DataDir() string {
2809 ret := _mock.Called()
2810
2811 if len(ret) == 0 {
2812 panic("no return value specified for DataDir")
2813 }
2814
2815 var r0 string
2816 if returnFunc, ok := ret.Get(0).(func() string); ok {
2817 r0 = returnFunc()
2818 } else {
2819 r0 = ret.Get(0).(string)
2820 }
2821 return r0
2822}
2823
2824// MockWebKitContextProvider_DataDir_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DataDir'
2825type MockWebKitContextProvider_DataDir_Call struct {
2826 *mock.Call
2827}
2828
2829// DataDir is a helper method to define mock.On call
2830func (_e *MockWebKitContextProvider_Expecter) DataDir() *MockWebKitContextProvider_DataDir_Call {
2831 return &MockWebKitContextProvider_DataDir_Call{Call: _e.mock.On("DataDir")}
2832}
2833
2834func (_c *MockWebKitContextProvider_DataDir_Call) Run(run func()) *MockWebKitContextProvider_DataDir_Call {
2835 _c.Call.Run(func(args mock.Arguments) {
2836 run()
2837 })
2838 return _c
2839}
2840
2841func (_c *MockWebKitContextProvider_DataDir_Call) Return(s string) *MockWebKitContextProvider_DataDir_Call {
2842 _c.Call.Return(s)
2843 return _c
2844}
2845
2846func (_c *MockWebKitContextProvider_DataDir_Call) RunAndReturn(run func() string) *MockWebKitContextProvider_DataDir_Call {
2847 _c.Call.Return(run)
2848 return _c
2849}
2850
2851// Initialize provides a mock function for the type MockWebKitContextProvider
2852func (_mock *MockWebKitContextProvider) Initialize(ctx context.Context, opts port.WebKitContextOptions) error {
2853 ret := _mock.Called(ctx, opts)
2854
2855 if len(ret) == 0 {
2856 panic("no return value specified for Initialize")
2857 }
2858
2859 var r0 error
2860 if returnFunc, ok := ret.Get(0).(func(context.Context, port.WebKitContextOptions) error); ok {
2861 r0 = returnFunc(ctx, opts)
2862 } else {
2863 r0 = ret.Error(0)
2864 }
2865 return r0
2866}
2867
2868// MockWebKitContextProvider_Initialize_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Initialize'
2869type MockWebKitContextProvider_Initialize_Call struct {
2870 *mock.Call
2871}
2872
2873// Initialize is a helper method to define mock.On call
2874// - ctx context.Context
2875// - opts port.WebKitContextOptions
2876func (_e *MockWebKitContextProvider_Expecter) Initialize(ctx interface{}, opts interface{}) *MockWebKitContextProvider_Initialize_Call {
2877 return &MockWebKitContextProvider_Initialize_Call{Call: _e.mock.On("Initialize", ctx, opts)}
2878}
2879
2880func (_c *MockWebKitContextProvider_Initialize_Call) Run(run func(ctx context.Context, opts port.WebKitContextOptions)) *MockWebKitContextProvider_Initialize_Call {
2881 _c.Call.Run(func(args mock.Arguments) {
2882 var arg0 context.Context
2883 if args[0] != nil {
2884 arg0 = args[0].(context.Context)
2885 }
2886 var arg1 port.WebKitContextOptions
2887 if args[1] != nil {
2888 arg1 = args[1].(port.WebKitContextOptions)
2889 }
2890 run(
2891 arg0,
2892 arg1,
2893 )
2894 })
2895 return _c
2896}
2897
2898func (_c *MockWebKitContextProvider_Initialize_Call) Return(err error) *MockWebKitContextProvider_Initialize_Call {
2899 _c.Call.Return(err)
2900 return _c
2901}
2902
2903func (_c *MockWebKitContextProvider_Initialize_Call) RunAndReturn(run func(ctx context.Context, opts port.WebKitContextOptions) error) *MockWebKitContextProvider_Initialize_Call {
2904 _c.Call.Return(run)
2905 return _c
2906}
2907
2908// PrefetchDNS provides a mock function for the type MockWebKitContextProvider
2909func (_mock *MockWebKitContextProvider) PrefetchDNS(hostname string) {
2910 _mock.Called(hostname)
2911 return
2912}
2913
2914// MockWebKitContextProvider_PrefetchDNS_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PrefetchDNS'
2915type MockWebKitContextProvider_PrefetchDNS_Call struct {
2916 *mock.Call
2917}
2918
2919// PrefetchDNS is a helper method to define mock.On call
2920// - hostname string
2921func (_e *MockWebKitContextProvider_Expecter) PrefetchDNS(hostname interface{}) *MockWebKitContextProvider_PrefetchDNS_Call {
2922 return &MockWebKitContextProvider_PrefetchDNS_Call{Call: _e.mock.On("PrefetchDNS", hostname)}
2923}
2924
2925func (_c *MockWebKitContextProvider_PrefetchDNS_Call) Run(run func(hostname string)) *MockWebKitContextProvider_PrefetchDNS_Call {
2926 _c.Call.Run(func(args mock.Arguments) {
2927 var arg0 string
2928 if args[0] != nil {
2929 arg0 = args[0].(string)
2930 }
2931 run(
2932 arg0,
2933 )
2934 })
2935 return _c
2936}
2937
2938func (_c *MockWebKitContextProvider_PrefetchDNS_Call) Return() *MockWebKitContextProvider_PrefetchDNS_Call {
2939 _c.Call.Return()
2940 return _c
2941}
2942
2943func (_c *MockWebKitContextProvider_PrefetchDNS_Call) RunAndReturn(run func(hostname string)) *MockWebKitContextProvider_PrefetchDNS_Call {
2944 _c.Run(run)
2945 return _c
2946}
2947
2948// 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.
2949// The first argument is typically a *testing.T value.
2950func NewMockWebView(t interface {
2951 mock.TestingT
2952 Cleanup(func())
2953}) *MockWebView {
2954 mock := &MockWebView{}
2955 mock.Mock.Test(t)
2956
2957 t.Cleanup(func() { mock.AssertExpectations(t) })
2958
2959 return mock
2960}
2961
2962// MockWebView is an autogenerated mock type for the WebView type
2963type MockWebView struct {
2964 mock.Mock
2965}
2966
2967type MockWebView_Expecter struct {
2968 mock *mock.Mock
2969}
2970
2971func (_m *MockWebView) EXPECT() *MockWebView_Expecter {
2972 return &MockWebView_Expecter{mock: &_m.Mock}
2973}
2974
2975// CanGoBack provides a mock function for the type MockWebView
2976func (_mock *MockWebView) CanGoBack() bool {
2977 ret := _mock.Called()
2978
2979 if len(ret) == 0 {
2980 panic("no return value specified for CanGoBack")
2981 }
2982
2983 var r0 bool
2984 if returnFunc, ok := ret.Get(0).(func() bool); ok {
2985 r0 = returnFunc()
2986 } else {
2987 r0 = ret.Get(0).(bool)
2988 }
2989 return r0
2990}
2991
2992// MockWebView_CanGoBack_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CanGoBack'
2993type MockWebView_CanGoBack_Call struct {
2994 *mock.Call
2995}
2996
2997// CanGoBack is a helper method to define mock.On call
2998func (_e *MockWebView_Expecter) CanGoBack() *MockWebView_CanGoBack_Call {
2999 return &MockWebView_CanGoBack_Call{Call: _e.mock.On("CanGoBack")}
3000}
3001
3002func (_c *MockWebView_CanGoBack_Call) Run(run func()) *MockWebView_CanGoBack_Call {
3003 _c.Call.Run(func(args mock.Arguments) {
3004 run()
3005 })
3006 return _c
3007}
3008
3009func (_c *MockWebView_CanGoBack_Call) Return(b bool) *MockWebView_CanGoBack_Call {
3010 _c.Call.Return(b)
3011 return _c
3012}
3013
3014func (_c *MockWebView_CanGoBack_Call) RunAndReturn(run func() bool) *MockWebView_CanGoBack_Call {
3015 _c.Call.Return(run)
3016 return _c
3017}
3018
3019// CanGoForward provides a mock function for the type MockWebView
3020func (_mock *MockWebView) CanGoForward() bool {
3021 ret := _mock.Called()
3022
3023 if len(ret) == 0 {
3024 panic("no return value specified for CanGoForward")
3025 }
3026
3027 var r0 bool
3028 if returnFunc, ok := ret.Get(0).(func() bool); ok {
3029 r0 = returnFunc()
3030 } else {
3031 r0 = ret.Get(0).(bool)
3032 }
3033 return r0
3034}
3035
3036// MockWebView_CanGoForward_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CanGoForward'
3037type MockWebView_CanGoForward_Call struct {
3038 *mock.Call
3039}
3040
3041// CanGoForward is a helper method to define mock.On call
3042func (_e *MockWebView_Expecter) CanGoForward() *MockWebView_CanGoForward_Call {
3043 return &MockWebView_CanGoForward_Call{Call: _e.mock.On("CanGoForward")}
3044}
3045
3046func (_c *MockWebView_CanGoForward_Call) Run(run func()) *MockWebView_CanGoForward_Call {
3047 _c.Call.Run(func(args mock.Arguments) {
3048 run()
3049 })
3050 return _c
3051}
3052
3053func (_c *MockWebView_CanGoForward_Call) Return(b bool) *MockWebView_CanGoForward_Call {
3054 _c.Call.Return(b)
3055 return _c
3056}
3057
3058func (_c *MockWebView_CanGoForward_Call) RunAndReturn(run func() bool) *MockWebView_CanGoForward_Call {
3059 _c.Call.Return(run)
3060 return _c
3061}
3062
3063// Destroy provides a mock function for the type MockWebView
3064func (_mock *MockWebView) Destroy() {
3065 _mock.Called()
3066 return
3067}
3068
3069// MockWebView_Destroy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Destroy'
3070type MockWebView_Destroy_Call struct {
3071 *mock.Call
3072}
3073
3074// Destroy is a helper method to define mock.On call
3075func (_e *MockWebView_Expecter) Destroy() *MockWebView_Destroy_Call {
3076 return &MockWebView_Destroy_Call{Call: _e.mock.On("Destroy")}
3077}
3078
3079func (_c *MockWebView_Destroy_Call) Run(run func()) *MockWebView_Destroy_Call {
3080 _c.Call.Run(func(args mock.Arguments) {
3081 run()
3082 })
3083 return _c
3084}
3085
3086func (_c *MockWebView_Destroy_Call) Return() *MockWebView_Destroy_Call {
3087 _c.Call.Return()
3088 return _c
3089}
3090
3091func (_c *MockWebView_Destroy_Call) RunAndReturn(run func()) *MockWebView_Destroy_Call {
3092 _c.Run(run)
3093 return _c
3094}
3095
3096// EstimatedProgress provides a mock function for the type MockWebView
3097func (_mock *MockWebView) EstimatedProgress() float64 {
3098 ret := _mock.Called()
3099
3100 if len(ret) == 0 {
3101 panic("no return value specified for EstimatedProgress")
3102 }
3103
3104 var r0 float64
3105 if returnFunc, ok := ret.Get(0).(func() float64); ok {
3106 r0 = returnFunc()
3107 } else {
3108 r0 = ret.Get(0).(float64)
3109 }
3110 return r0
3111}
3112
3113// MockWebView_EstimatedProgress_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EstimatedProgress'
3114type MockWebView_EstimatedProgress_Call struct {
3115 *mock.Call
3116}
3117
3118// EstimatedProgress is a helper method to define mock.On call
3119func (_e *MockWebView_Expecter) EstimatedProgress() *MockWebView_EstimatedProgress_Call {
3120 return &MockWebView_EstimatedProgress_Call{Call: _e.mock.On("EstimatedProgress")}
3121}
3122
3123func (_c *MockWebView_EstimatedProgress_Call) Run(run func()) *MockWebView_EstimatedProgress_Call {
3124 _c.Call.Run(func(args mock.Arguments) {
3125 run()
3126 })
3127 return _c
3128}
3129
3130func (_c *MockWebView_EstimatedProgress_Call) Return(f float64) *MockWebView_EstimatedProgress_Call {
3131 _c.Call.Return(f)
3132 return _c
3133}
3134
3135func (_c *MockWebView_EstimatedProgress_Call) RunAndReturn(run func() float64) *MockWebView_EstimatedProgress_Call {
3136 _c.Call.Return(run)
3137 return _c
3138}
3139
3140// GetFindController provides a mock function for the type MockWebView
3141func (_mock *MockWebView) GetFindController() port.FindController {
3142 ret := _mock.Called()
3143
3144 if len(ret) == 0 {
3145 panic("no return value specified for GetFindController")
3146 }
3147
3148 var r0 port.FindController
3149 if returnFunc, ok := ret.Get(0).(func() port.FindController); ok {
3150 r0 = returnFunc()
3151 } else {
3152 if ret.Get(0) != nil {
3153 r0 = ret.Get(0).(port.FindController)
3154 }
3155 }
3156 return r0
3157}
3158
3159// MockWebView_GetFindController_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetFindController'
3160type MockWebView_GetFindController_Call struct {
3161 *mock.Call
3162}
3163
3164// GetFindController is a helper method to define mock.On call
3165func (_e *MockWebView_Expecter) GetFindController() *MockWebView_GetFindController_Call {
3166 return &MockWebView_GetFindController_Call{Call: _e.mock.On("GetFindController")}
3167}
3168
3169func (_c *MockWebView_GetFindController_Call) Run(run func()) *MockWebView_GetFindController_Call {
3170 _c.Call.Run(func(args mock.Arguments) {
3171 run()
3172 })
3173 return _c
3174}
3175
3176func (_c *MockWebView_GetFindController_Call) Return(findController port.FindController) *MockWebView_GetFindController_Call {
3177 _c.Call.Return(findController)
3178 return _c
3179}
3180
3181func (_c *MockWebView_GetFindController_Call) RunAndReturn(run func() port.FindController) *MockWebView_GetFindController_Call {
3182 _c.Call.Return(run)
3183 return _c
3184}
3185
3186// GetZoomLevel provides a mock function for the type MockWebView
3187func (_mock *MockWebView) GetZoomLevel() float64 {
3188 ret := _mock.Called()
3189
3190 if len(ret) == 0 {
3191 panic("no return value specified for GetZoomLevel")
3192 }
3193
3194 var r0 float64
3195 if returnFunc, ok := ret.Get(0).(func() float64); ok {
3196 r0 = returnFunc()
3197 } else {
3198 r0 = ret.Get(0).(float64)
3199 }
3200 return r0
3201}
3202
3203// MockWebView_GetZoomLevel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetZoomLevel'
3204type MockWebView_GetZoomLevel_Call struct {
3205 *mock.Call
3206}
3207
3208// GetZoomLevel is a helper method to define mock.On call
3209func (_e *MockWebView_Expecter) GetZoomLevel() *MockWebView_GetZoomLevel_Call {
3210 return &MockWebView_GetZoomLevel_Call{Call: _e.mock.On("GetZoomLevel")}
3211}
3212
3213func (_c *MockWebView_GetZoomLevel_Call) Run(run func()) *MockWebView_GetZoomLevel_Call {
3214 _c.Call.Run(func(args mock.Arguments) {
3215 run()
3216 })
3217 return _c
3218}
3219
3220func (_c *MockWebView_GetZoomLevel_Call) Return(f float64) *MockWebView_GetZoomLevel_Call {
3221 _c.Call.Return(f)
3222 return _c
3223}
3224
3225func (_c *MockWebView_GetZoomLevel_Call) RunAndReturn(run func() float64) *MockWebView_GetZoomLevel_Call {
3226 _c.Call.Return(run)
3227 return _c
3228}
3229
3230// GoBack provides a mock function for the type MockWebView
3231func (_mock *MockWebView) GoBack(ctx context.Context) error {
3232 ret := _mock.Called(ctx)
3233
3234 if len(ret) == 0 {
3235 panic("no return value specified for GoBack")
3236 }
3237
3238 var r0 error
3239 if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
3240 r0 = returnFunc(ctx)
3241 } else {
3242 r0 = ret.Error(0)
3243 }
3244 return r0
3245}
3246
3247// MockWebView_GoBack_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GoBack'
3248type MockWebView_GoBack_Call struct {
3249 *mock.Call
3250}
3251
3252// GoBack is a helper method to define mock.On call
3253// - ctx context.Context
3254func (_e *MockWebView_Expecter) GoBack(ctx interface{}) *MockWebView_GoBack_Call {
3255 return &MockWebView_GoBack_Call{Call: _e.mock.On("GoBack", ctx)}
3256}
3257
3258func (_c *MockWebView_GoBack_Call) Run(run func(ctx context.Context)) *MockWebView_GoBack_Call {
3259 _c.Call.Run(func(args mock.Arguments) {
3260 var arg0 context.Context
3261 if args[0] != nil {
3262 arg0 = args[0].(context.Context)
3263 }
3264 run(
3265 arg0,
3266 )
3267 })
3268 return _c
3269}
3270
3271func (_c *MockWebView_GoBack_Call) Return(err error) *MockWebView_GoBack_Call {
3272 _c.Call.Return(err)
3273 return _c
3274}
3275
3276func (_c *MockWebView_GoBack_Call) RunAndReturn(run func(ctx context.Context) error) *MockWebView_GoBack_Call {
3277 _c.Call.Return(run)
3278 return _c
3279}
3280
3281// GoForward provides a mock function for the type MockWebView
3282func (_mock *MockWebView) GoForward(ctx context.Context) error {
3283 ret := _mock.Called(ctx)
3284
3285 if len(ret) == 0 {
3286 panic("no return value specified for GoForward")
3287 }
3288
3289 var r0 error
3290 if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
3291 r0 = returnFunc(ctx)
3292 } else {
3293 r0 = ret.Error(0)
3294 }
3295 return r0
3296}
3297
3298// MockWebView_GoForward_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GoForward'
3299type MockWebView_GoForward_Call struct {
3300 *mock.Call
3301}
3302
3303// GoForward is a helper method to define mock.On call
3304// - ctx context.Context
3305func (_e *MockWebView_Expecter) GoForward(ctx interface{}) *MockWebView_GoForward_Call {
3306 return &MockWebView_GoForward_Call{Call: _e.mock.On("GoForward", ctx)}
3307}
3308
3309func (_c *MockWebView_GoForward_Call) Run(run func(ctx context.Context)) *MockWebView_GoForward_Call {
3310 _c.Call.Run(func(args mock.Arguments) {
3311 var arg0 context.Context
3312 if args[0] != nil {
3313 arg0 = args[0].(context.Context)
3314 }
3315 run(
3316 arg0,
3317 )
3318 })
3319 return _c
3320}
3321
3322func (_c *MockWebView_GoForward_Call) Return(err error) *MockWebView_GoForward_Call {
3323 _c.Call.Return(err)
3324 return _c
3325}
3326
3327func (_c *MockWebView_GoForward_Call) RunAndReturn(run func(ctx context.Context) error) *MockWebView_GoForward_Call {
3328 _c.Call.Return(run)
3329 return _c
3330}
3331
3332// ID provides a mock function for the type MockWebView
3333func (_mock *MockWebView) ID() port.WebViewID {
3334 ret := _mock.Called()
3335
3336 if len(ret) == 0 {
3337 panic("no return value specified for ID")
3338 }
3339
3340 var r0 port.WebViewID
3341 if returnFunc, ok := ret.Get(0).(func() port.WebViewID); ok {
3342 r0 = returnFunc()
3343 } else {
3344 r0 = ret.Get(0).(port.WebViewID)
3345 }
3346 return r0
3347}
3348
3349// MockWebView_ID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ID'
3350type MockWebView_ID_Call struct {
3351 *mock.Call
3352}
3353
3354// ID is a helper method to define mock.On call
3355func (_e *MockWebView_Expecter) ID() *MockWebView_ID_Call {
3356 return &MockWebView_ID_Call{Call: _e.mock.On("ID")}
3357}
3358
3359func (_c *MockWebView_ID_Call) Run(run func()) *MockWebView_ID_Call {
3360 _c.Call.Run(func(args mock.Arguments) {
3361 run()
3362 })
3363 return _c
3364}
3365
3366func (_c *MockWebView_ID_Call) Return(webViewID port.WebViewID) *MockWebView_ID_Call {
3367 _c.Call.Return(webViewID)
3368 return _c
3369}
3370
3371func (_c *MockWebView_ID_Call) RunAndReturn(run func() port.WebViewID) *MockWebView_ID_Call {
3372 _c.Call.Return(run)
3373 return _c
3374}
3375
3376// IsDestroyed provides a mock function for the type MockWebView
3377func (_mock *MockWebView) IsDestroyed() bool {
3378 ret := _mock.Called()
3379
3380 if len(ret) == 0 {
3381 panic("no return value specified for IsDestroyed")
3382 }
3383
3384 var r0 bool
3385 if returnFunc, ok := ret.Get(0).(func() bool); ok {
3386 r0 = returnFunc()
3387 } else {
3388 r0 = ret.Get(0).(bool)
3389 }
3390 return r0
3391}
3392
3393// MockWebView_IsDestroyed_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsDestroyed'
3394type MockWebView_IsDestroyed_Call struct {
3395 *mock.Call
3396}
3397
3398// IsDestroyed is a helper method to define mock.On call
3399func (_e *MockWebView_Expecter) IsDestroyed() *MockWebView_IsDestroyed_Call {
3400 return &MockWebView_IsDestroyed_Call{Call: _e.mock.On("IsDestroyed")}
3401}
3402
3403func (_c *MockWebView_IsDestroyed_Call) Run(run func()) *MockWebView_IsDestroyed_Call {
3404 _c.Call.Run(func(args mock.Arguments) {
3405 run()
3406 })
3407 return _c
3408}
3409
3410func (_c *MockWebView_IsDestroyed_Call) Return(b bool) *MockWebView_IsDestroyed_Call {
3411 _c.Call.Return(b)
3412 return _c
3413}
3414
3415func (_c *MockWebView_IsDestroyed_Call) RunAndReturn(run func() bool) *MockWebView_IsDestroyed_Call {
3416 _c.Call.Return(run)
3417 return _c
3418}
3419
3420// IsFullscreen provides a mock function for the type MockWebView
3421func (_mock *MockWebView) IsFullscreen() bool {
3422 ret := _mock.Called()
3423
3424 if len(ret) == 0 {
3425 panic("no return value specified for IsFullscreen")
3426 }
3427
3428 var r0 bool
3429 if returnFunc, ok := ret.Get(0).(func() bool); ok {
3430 r0 = returnFunc()
3431 } else {
3432 r0 = ret.Get(0).(bool)
3433 }
3434 return r0
3435}
3436
3437// MockWebView_IsFullscreen_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsFullscreen'
3438type MockWebView_IsFullscreen_Call struct {
3439 *mock.Call
3440}
3441
3442// IsFullscreen is a helper method to define mock.On call
3443func (_e *MockWebView_Expecter) IsFullscreen() *MockWebView_IsFullscreen_Call {
3444 return &MockWebView_IsFullscreen_Call{Call: _e.mock.On("IsFullscreen")}
3445}
3446
3447func (_c *MockWebView_IsFullscreen_Call) Run(run func()) *MockWebView_IsFullscreen_Call {
3448 _c.Call.Run(func(args mock.Arguments) {
3449 run()
3450 })
3451 return _c
3452}
3453
3454func (_c *MockWebView_IsFullscreen_Call) Return(b bool) *MockWebView_IsFullscreen_Call {
3455 _c.Call.Return(b)
3456 return _c
3457}
3458
3459func (_c *MockWebView_IsFullscreen_Call) RunAndReturn(run func() bool) *MockWebView_IsFullscreen_Call {
3460 _c.Call.Return(run)
3461 return _c
3462}
3463
3464// IsLoading provides a mock function for the type MockWebView
3465func (_mock *MockWebView) IsLoading() bool {
3466 ret := _mock.Called()
3467
3468 if len(ret) == 0 {
3469 panic("no return value specified for IsLoading")
3470 }
3471
3472 var r0 bool
3473 if returnFunc, ok := ret.Get(0).(func() bool); ok {
3474 r0 = returnFunc()
3475 } else {
3476 r0 = ret.Get(0).(bool)
3477 }
3478 return r0
3479}
3480
3481// MockWebView_IsLoading_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsLoading'
3482type MockWebView_IsLoading_Call struct {
3483 *mock.Call
3484}
3485
3486// IsLoading is a helper method to define mock.On call
3487func (_e *MockWebView_Expecter) IsLoading() *MockWebView_IsLoading_Call {
3488 return &MockWebView_IsLoading_Call{Call: _e.mock.On("IsLoading")}
3489}
3490
3491func (_c *MockWebView_IsLoading_Call) Run(run func()) *MockWebView_IsLoading_Call {
3492 _c.Call.Run(func(args mock.Arguments) {
3493 run()
3494 })
3495 return _c
3496}
3497
3498func (_c *MockWebView_IsLoading_Call) Return(b bool) *MockWebView_IsLoading_Call {
3499 _c.Call.Return(b)
3500 return _c
3501}
3502
3503func (_c *MockWebView_IsLoading_Call) RunAndReturn(run func() bool) *MockWebView_IsLoading_Call {
3504 _c.Call.Return(run)
3505 return _c
3506}
3507
3508// IsPlayingAudio provides a mock function for the type MockWebView
3509func (_mock *MockWebView) IsPlayingAudio() bool {
3510 ret := _mock.Called()
3511
3512 if len(ret) == 0 {
3513 panic("no return value specified for IsPlayingAudio")
3514 }
3515
3516 var r0 bool
3517 if returnFunc, ok := ret.Get(0).(func() bool); ok {
3518 r0 = returnFunc()
3519 } else {
3520 r0 = ret.Get(0).(bool)
3521 }
3522 return r0
3523}
3524
3525// MockWebView_IsPlayingAudio_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsPlayingAudio'
3526type MockWebView_IsPlayingAudio_Call struct {
3527 *mock.Call
3528}
3529
3530// IsPlayingAudio is a helper method to define mock.On call
3531func (_e *MockWebView_Expecter) IsPlayingAudio() *MockWebView_IsPlayingAudio_Call {
3532 return &MockWebView_IsPlayingAudio_Call{Call: _e.mock.On("IsPlayingAudio")}
3533}
3534
3535func (_c *MockWebView_IsPlayingAudio_Call) Run(run func()) *MockWebView_IsPlayingAudio_Call {
3536 _c.Call.Run(func(args mock.Arguments) {
3537 run()
3538 })
3539 return _c
3540}
3541
3542func (_c *MockWebView_IsPlayingAudio_Call) Return(b bool) *MockWebView_IsPlayingAudio_Call {
3543 _c.Call.Return(b)
3544 return _c
3545}
3546
3547func (_c *MockWebView_IsPlayingAudio_Call) RunAndReturn(run func() bool) *MockWebView_IsPlayingAudio_Call {
3548 _c.Call.Return(run)
3549 return _c
3550}
3551
3552// LoadHTML provides a mock function for the type MockWebView
3553func (_mock *MockWebView) LoadHTML(ctx context.Context, content string, baseURI string) error {
3554 ret := _mock.Called(ctx, content, baseURI)
3555
3556 if len(ret) == 0 {
3557 panic("no return value specified for LoadHTML")
3558 }
3559
3560 var r0 error
3561 if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) error); ok {
3562 r0 = returnFunc(ctx, content, baseURI)
3563 } else {
3564 r0 = ret.Error(0)
3565 }
3566 return r0
3567}
3568
3569// MockWebView_LoadHTML_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LoadHTML'
3570type MockWebView_LoadHTML_Call struct {
3571 *mock.Call
3572}
3573
3574// LoadHTML is a helper method to define mock.On call
3575// - ctx context.Context
3576// - content string
3577// - baseURI string
3578func (_e *MockWebView_Expecter) LoadHTML(ctx interface{}, content interface{}, baseURI interface{}) *MockWebView_LoadHTML_Call {
3579 return &MockWebView_LoadHTML_Call{Call: _e.mock.On("LoadHTML", ctx, content, baseURI)}
3580}
3581
3582func (_c *MockWebView_LoadHTML_Call) Run(run func(ctx context.Context, content string, baseURI string)) *MockWebView_LoadHTML_Call {
3583 _c.Call.Run(func(args mock.Arguments) {
3584 var arg0 context.Context
3585 if args[0] != nil {
3586 arg0 = args[0].(context.Context)
3587 }
3588 var arg1 string
3589 if args[1] != nil {
3590 arg1 = args[1].(string)
3591 }
3592 var arg2 string
3593 if args[2] != nil {
3594 arg2 = args[2].(string)
3595 }
3596 run(
3597 arg0,
3598 arg1,
3599 arg2,
3600 )
3601 })
3602 return _c
3603}
3604
3605func (_c *MockWebView_LoadHTML_Call) Return(err error) *MockWebView_LoadHTML_Call {
3606 _c.Call.Return(err)
3607 return _c
3608}
3609
3610func (_c *MockWebView_LoadHTML_Call) RunAndReturn(run func(ctx context.Context, content string, baseURI string) error) *MockWebView_LoadHTML_Call {
3611 _c.Call.Return(run)
3612 return _c
3613}
3614
3615// LoadURI provides a mock function for the type MockWebView
3616func (_mock *MockWebView) LoadURI(ctx context.Context, uri string) error {
3617 ret := _mock.Called(ctx, uri)
3618
3619 if len(ret) == 0 {
3620 panic("no return value specified for LoadURI")
3621 }
3622
3623 var r0 error
3624 if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
3625 r0 = returnFunc(ctx, uri)
3626 } else {
3627 r0 = ret.Error(0)
3628 }
3629 return r0
3630}
3631
3632// MockWebView_LoadURI_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LoadURI'
3633type MockWebView_LoadURI_Call struct {
3634 *mock.Call
3635}
3636
3637// LoadURI is a helper method to define mock.On call
3638// - ctx context.Context
3639// - uri string
3640func (_e *MockWebView_Expecter) LoadURI(ctx interface{}, uri interface{}) *MockWebView_LoadURI_Call {
3641 return &MockWebView_LoadURI_Call{Call: _e.mock.On("LoadURI", ctx, uri)}
3642}
3643
3644func (_c *MockWebView_LoadURI_Call) Run(run func(ctx context.Context, uri string)) *MockWebView_LoadURI_Call {
3645 _c.Call.Run(func(args mock.Arguments) {
3646 var arg0 context.Context
3647 if args[0] != nil {
3648 arg0 = args[0].(context.Context)
3649 }
3650 var arg1 string
3651 if args[1] != nil {
3652 arg1 = args[1].(string)
3653 }
3654 run(
3655 arg0,
3656 arg1,
3657 )
3658 })
3659 return _c
3660}
3661
3662func (_c *MockWebView_LoadURI_Call) Return(err error) *MockWebView_LoadURI_Call {
3663 _c.Call.Return(err)
3664 return _c
3665}
3666
3667func (_c *MockWebView_LoadURI_Call) RunAndReturn(run func(ctx context.Context, uri string) error) *MockWebView_LoadURI_Call {
3668 _c.Call.Return(run)
3669 return _c
3670}
3671
3672// Reload provides a mock function for the type MockWebView
3673func (_mock *MockWebView) Reload(ctx context.Context) error {
3674 ret := _mock.Called(ctx)
3675
3676 if len(ret) == 0 {
3677 panic("no return value specified for Reload")
3678 }
3679
3680 var r0 error
3681 if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
3682 r0 = returnFunc(ctx)
3683 } else {
3684 r0 = ret.Error(0)
3685 }
3686 return r0
3687}
3688
3689// MockWebView_Reload_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Reload'
3690type MockWebView_Reload_Call struct {
3691 *mock.Call
3692}
3693
3694// Reload is a helper method to define mock.On call
3695// - ctx context.Context
3696func (_e *MockWebView_Expecter) Reload(ctx interface{}) *MockWebView_Reload_Call {
3697 return &MockWebView_Reload_Call{Call: _e.mock.On("Reload", ctx)}
3698}
3699
3700func (_c *MockWebView_Reload_Call) Run(run func(ctx context.Context)) *MockWebView_Reload_Call {
3701 _c.Call.Run(func(args mock.Arguments) {
3702 var arg0 context.Context
3703 if args[0] != nil {
3704 arg0 = args[0].(context.Context)
3705 }
3706 run(
3707 arg0,
3708 )
3709 })
3710 return _c
3711}
3712
3713func (_c *MockWebView_Reload_Call) Return(err error) *MockWebView_Reload_Call {
3714 _c.Call.Return(err)
3715 return _c
3716}
3717
3718func (_c *MockWebView_Reload_Call) RunAndReturn(run func(ctx context.Context) error) *MockWebView_Reload_Call {
3719 _c.Call.Return(run)
3720 return _c
3721}
3722
3723// ReloadBypassCache provides a mock function for the type MockWebView
3724func (_mock *MockWebView) ReloadBypassCache(ctx context.Context) error {
3725 ret := _mock.Called(ctx)
3726
3727 if len(ret) == 0 {
3728 panic("no return value specified for ReloadBypassCache")
3729 }
3730
3731 var r0 error
3732 if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
3733 r0 = returnFunc(ctx)
3734 } else {
3735 r0 = ret.Error(0)
3736 }
3737 return r0
3738}
3739
3740// MockWebView_ReloadBypassCache_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReloadBypassCache'
3741type MockWebView_ReloadBypassCache_Call struct {
3742 *mock.Call
3743}
3744
3745// ReloadBypassCache is a helper method to define mock.On call
3746// - ctx context.Context
3747func (_e *MockWebView_Expecter) ReloadBypassCache(ctx interface{}) *MockWebView_ReloadBypassCache_Call {
3748 return &MockWebView_ReloadBypassCache_Call{Call: _e.mock.On("ReloadBypassCache", ctx)}
3749}
3750
3751func (_c *MockWebView_ReloadBypassCache_Call) Run(run func(ctx context.Context)) *MockWebView_ReloadBypassCache_Call {
3752 _c.Call.Run(func(args mock.Arguments) {
3753 var arg0 context.Context
3754 if args[0] != nil {
3755 arg0 = args[0].(context.Context)
3756 }
3757 run(
3758 arg0,
3759 )
3760 })
3761 return _c
3762}
3763
3764func (_c *MockWebView_ReloadBypassCache_Call) Return(err error) *MockWebView_ReloadBypassCache_Call {
3765 _c.Call.Return(err)
3766 return _c
3767}
3768
3769func (_c *MockWebView_ReloadBypassCache_Call) RunAndReturn(run func(ctx context.Context) error) *MockWebView_ReloadBypassCache_Call {
3770 _c.Call.Return(run)
3771 return _c
3772}
3773
3774// SetCallbacks provides a mock function for the type MockWebView
3775func (_mock *MockWebView) SetCallbacks(callbacks *port.WebViewCallbacks) {
3776 _mock.Called(callbacks)
3777 return
3778}
3779
3780// MockWebView_SetCallbacks_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetCallbacks'
3781type MockWebView_SetCallbacks_Call struct {
3782 *mock.Call
3783}
3784
3785// SetCallbacks is a helper method to define mock.On call
3786// - callbacks *port.WebViewCallbacks
3787func (_e *MockWebView_Expecter) SetCallbacks(callbacks interface{}) *MockWebView_SetCallbacks_Call {
3788 return &MockWebView_SetCallbacks_Call{Call: _e.mock.On("SetCallbacks", callbacks)}
3789}
3790
3791func (_c *MockWebView_SetCallbacks_Call) Run(run func(callbacks *port.WebViewCallbacks)) *MockWebView_SetCallbacks_Call {
3792 _c.Call.Run(func(args mock.Arguments) {
3793 var arg0 *port.WebViewCallbacks
3794 if args[0] != nil {
3795 arg0 = args[0].(*port.WebViewCallbacks)
3796 }
3797 run(
3798 arg0,
3799 )
3800 })
3801 return _c
3802}
3803
3804func (_c *MockWebView_SetCallbacks_Call) Return() *MockWebView_SetCallbacks_Call {
3805 _c.Call.Return()
3806 return _c
3807}
3808
3809func (_c *MockWebView_SetCallbacks_Call) RunAndReturn(run func(callbacks *port.WebViewCallbacks)) *MockWebView_SetCallbacks_Call {
3810 _c.Run(run)
3811 return _c
3812}
3813
3814// SetZoomLevel provides a mock function for the type MockWebView
3815func (_mock *MockWebView) SetZoomLevel(ctx context.Context, level float64) error {
3816 ret := _mock.Called(ctx, level)
3817
3818 if len(ret) == 0 {
3819 panic("no return value specified for SetZoomLevel")
3820 }
3821
3822 var r0 error
3823 if returnFunc, ok := ret.Get(0).(func(context.Context, float64) error); ok {
3824 r0 = returnFunc(ctx, level)
3825 } else {
3826 r0 = ret.Error(0)
3827 }
3828 return r0
3829}
3830
3831// MockWebView_SetZoomLevel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetZoomLevel'
3832type MockWebView_SetZoomLevel_Call struct {
3833 *mock.Call
3834}
3835
3836// SetZoomLevel is a helper method to define mock.On call
3837// - ctx context.Context
3838// - level float64
3839func (_e *MockWebView_Expecter) SetZoomLevel(ctx interface{}, level interface{}) *MockWebView_SetZoomLevel_Call {
3840 return &MockWebView_SetZoomLevel_Call{Call: _e.mock.On("SetZoomLevel", ctx, level)}
3841}
3842
3843func (_c *MockWebView_SetZoomLevel_Call) Run(run func(ctx context.Context, level float64)) *MockWebView_SetZoomLevel_Call {
3844 _c.Call.Run(func(args mock.Arguments) {
3845 var arg0 context.Context
3846 if args[0] != nil {
3847 arg0 = args[0].(context.Context)
3848 }
3849 var arg1 float64
3850 if args[1] != nil {
3851 arg1 = args[1].(float64)
3852 }
3853 run(
3854 arg0,
3855 arg1,
3856 )
3857 })
3858 return _c
3859}
3860
3861func (_c *MockWebView_SetZoomLevel_Call) Return(err error) *MockWebView_SetZoomLevel_Call {
3862 _c.Call.Return(err)
3863 return _c
3864}
3865
3866func (_c *MockWebView_SetZoomLevel_Call) RunAndReturn(run func(ctx context.Context, level float64) error) *MockWebView_SetZoomLevel_Call {
3867 _c.Call.Return(run)
3868 return _c
3869}
3870
3871// State provides a mock function for the type MockWebView
3872func (_mock *MockWebView) State() port.WebViewState {
3873 ret := _mock.Called()
3874
3875 if len(ret) == 0 {
3876 panic("no return value specified for State")
3877 }
3878
3879 var r0 port.WebViewState
3880 if returnFunc, ok := ret.Get(0).(func() port.WebViewState); ok {
3881 r0 = returnFunc()
3882 } else {
3883 r0 = ret.Get(0).(port.WebViewState)
3884 }
3885 return r0
3886}
3887
3888// MockWebView_State_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'State'
3889type MockWebView_State_Call struct {
3890 *mock.Call
3891}
3892
3893// State is a helper method to define mock.On call
3894func (_e *MockWebView_Expecter) State() *MockWebView_State_Call {
3895 return &MockWebView_State_Call{Call: _e.mock.On("State")}
3896}
3897
3898func (_c *MockWebView_State_Call) Run(run func()) *MockWebView_State_Call {
3899 _c.Call.Run(func(args mock.Arguments) {
3900 run()
3901 })
3902 return _c
3903}
3904
3905func (_c *MockWebView_State_Call) Return(webViewState port.WebViewState) *MockWebView_State_Call {
3906 _c.Call.Return(webViewState)
3907 return _c
3908}
3909
3910func (_c *MockWebView_State_Call) RunAndReturn(run func() port.WebViewState) *MockWebView_State_Call {
3911 _c.Call.Return(run)
3912 return _c
3913}
3914
3915// Stop provides a mock function for the type MockWebView
3916func (_mock *MockWebView) Stop(ctx context.Context) error {
3917 ret := _mock.Called(ctx)
3918
3919 if len(ret) == 0 {
3920 panic("no return value specified for Stop")
3921 }
3922
3923 var r0 error
3924 if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
3925 r0 = returnFunc(ctx)
3926 } else {
3927 r0 = ret.Error(0)
3928 }
3929 return r0
3930}
3931
3932// MockWebView_Stop_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Stop'
3933type MockWebView_Stop_Call struct {
3934 *mock.Call
3935}
3936
3937// Stop is a helper method to define mock.On call
3938// - ctx context.Context
3939func (_e *MockWebView_Expecter) Stop(ctx interface{}) *MockWebView_Stop_Call {
3940 return &MockWebView_Stop_Call{Call: _e.mock.On("Stop", ctx)}
3941}
3942
3943func (_c *MockWebView_Stop_Call) Run(run func(ctx context.Context)) *MockWebView_Stop_Call {
3944 _c.Call.Run(func(args mock.Arguments) {
3945 var arg0 context.Context
3946 if args[0] != nil {
3947 arg0 = args[0].(context.Context)
3948 }
3949 run(
3950 arg0,
3951 )
3952 })
3953 return _c
3954}
3955
3956func (_c *MockWebView_Stop_Call) Return(err error) *MockWebView_Stop_Call {
3957 _c.Call.Return(err)
3958 return _c
3959}
3960
3961func (_c *MockWebView_Stop_Call) RunAndReturn(run func(ctx context.Context) error) *MockWebView_Stop_Call {
3962 _c.Call.Return(run)
3963 return _c
3964}
3965
3966// Title provides a mock function for the type MockWebView
3967func (_mock *MockWebView) Title() string {
3968 ret := _mock.Called()
3969
3970 if len(ret) == 0 {
3971 panic("no return value specified for Title")
3972 }
3973
3974 var r0 string
3975 if returnFunc, ok := ret.Get(0).(func() string); ok {
3976 r0 = returnFunc()
3977 } else {
3978 r0 = ret.Get(0).(string)
3979 }
3980 return r0
3981}
3982
3983// MockWebView_Title_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Title'
3984type MockWebView_Title_Call struct {
3985 *mock.Call
3986}
3987
3988// Title is a helper method to define mock.On call
3989func (_e *MockWebView_Expecter) Title() *MockWebView_Title_Call {
3990 return &MockWebView_Title_Call{Call: _e.mock.On("Title")}
3991}
3992
3993func (_c *MockWebView_Title_Call) Run(run func()) *MockWebView_Title_Call {
3994 _c.Call.Run(func(args mock.Arguments) {
3995 run()
3996 })
3997 return _c
3998}
3999
4000func (_c *MockWebView_Title_Call) Return(s string) *MockWebView_Title_Call {
4001 _c.Call.Return(s)
4002 return _c
4003}
4004
4005func (_c *MockWebView_Title_Call) RunAndReturn(run func() string) *MockWebView_Title_Call {
4006 _c.Call.Return(run)
4007 return _c
4008}
4009
4010// URI provides a mock function for the type MockWebView
4011func (_mock *MockWebView) URI() string {
4012 ret := _mock.Called()
4013
4014 if len(ret) == 0 {
4015 panic("no return value specified for URI")
4016 }
4017
4018 var r0 string
4019 if returnFunc, ok := ret.Get(0).(func() string); ok {
4020 r0 = returnFunc()
4021 } else {
4022 r0 = ret.Get(0).(string)
4023 }
4024 return r0
4025}
4026
4027// MockWebView_URI_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'URI'
4028type MockWebView_URI_Call struct {
4029 *mock.Call
4030}
4031
4032// URI is a helper method to define mock.On call
4033func (_e *MockWebView_Expecter) URI() *MockWebView_URI_Call {
4034 return &MockWebView_URI_Call{Call: _e.mock.On("URI")}
4035}
4036
4037func (_c *MockWebView_URI_Call) Run(run func()) *MockWebView_URI_Call {
4038 _c.Call.Run(func(args mock.Arguments) {
4039 run()
4040 })
4041 return _c
4042}
4043
4044func (_c *MockWebView_URI_Call) Return(s string) *MockWebView_URI_Call {
4045 _c.Call.Return(s)
4046 return _c
4047}
4048
4049func (_c *MockWebView_URI_Call) RunAndReturn(run func() string) *MockWebView_URI_Call {
4050 _c.Call.Return(run)
4051 return _c
4052}
4053
4054// 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.
4055// The first argument is typically a *testing.T value.
4056func NewMockWebViewPool(t interface {
4057 mock.TestingT
4058 Cleanup(func())
4059}) *MockWebViewPool {
4060 mock := &MockWebViewPool{}
4061 mock.Mock.Test(t)
4062
4063 t.Cleanup(func() { mock.AssertExpectations(t) })
4064
4065 return mock
4066}
4067
4068// MockWebViewPool is an autogenerated mock type for the WebViewPool type
4069type MockWebViewPool struct {
4070 mock.Mock
4071}
4072
4073type MockWebViewPool_Expecter struct {
4074 mock *mock.Mock
4075}
4076
4077func (_m *MockWebViewPool) EXPECT() *MockWebViewPool_Expecter {
4078 return &MockWebViewPool_Expecter{mock: &_m.Mock}
4079}
4080
4081// Acquire provides a mock function for the type MockWebViewPool
4082func (_mock *MockWebViewPool) Acquire(ctx context.Context) (port.WebView, error) {
4083 ret := _mock.Called(ctx)
4084
4085 if len(ret) == 0 {
4086 panic("no return value specified for Acquire")
4087 }
4088
4089 var r0 port.WebView
4090 var r1 error
4091 if returnFunc, ok := ret.Get(0).(func(context.Context) (port.WebView, error)); ok {
4092 return returnFunc(ctx)
4093 }
4094 if returnFunc, ok := ret.Get(0).(func(context.Context) port.WebView); ok {
4095 r0 = returnFunc(ctx)
4096 } else {
4097 if ret.Get(0) != nil {
4098 r0 = ret.Get(0).(port.WebView)
4099 }
4100 }
4101 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
4102 r1 = returnFunc(ctx)
4103 } else {
4104 r1 = ret.Error(1)
4105 }
4106 return r0, r1
4107}
4108
4109// MockWebViewPool_Acquire_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Acquire'
4110type MockWebViewPool_Acquire_Call struct {
4111 *mock.Call
4112}
4113
4114// Acquire is a helper method to define mock.On call
4115// - ctx context.Context
4116func (_e *MockWebViewPool_Expecter) Acquire(ctx interface{}) *MockWebViewPool_Acquire_Call {
4117 return &MockWebViewPool_Acquire_Call{Call: _e.mock.On("Acquire", ctx)}
4118}
4119
4120func (_c *MockWebViewPool_Acquire_Call) Run(run func(ctx context.Context)) *MockWebViewPool_Acquire_Call {
4121 _c.Call.Run(func(args mock.Arguments) {
4122 var arg0 context.Context
4123 if args[0] != nil {
4124 arg0 = args[0].(context.Context)
4125 }
4126 run(
4127 arg0,
4128 )
4129 })
4130 return _c
4131}
4132
4133func (_c *MockWebViewPool_Acquire_Call) Return(webView port.WebView, err error) *MockWebViewPool_Acquire_Call {
4134 _c.Call.Return(webView, err)
4135 return _c
4136}
4137
4138func (_c *MockWebViewPool_Acquire_Call) RunAndReturn(run func(ctx context.Context) (port.WebView, error)) *MockWebViewPool_Acquire_Call {
4139 _c.Call.Return(run)
4140 return _c
4141}
4142
4143// Close provides a mock function for the type MockWebViewPool
4144func (_mock *MockWebViewPool) Close() {
4145 _mock.Called()
4146 return
4147}
4148
4149// MockWebViewPool_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
4150type MockWebViewPool_Close_Call struct {
4151 *mock.Call
4152}
4153
4154// Close is a helper method to define mock.On call
4155func (_e *MockWebViewPool_Expecter) Close() *MockWebViewPool_Close_Call {
4156 return &MockWebViewPool_Close_Call{Call: _e.mock.On("Close")}
4157}
4158
4159func (_c *MockWebViewPool_Close_Call) Run(run func()) *MockWebViewPool_Close_Call {
4160 _c.Call.Run(func(args mock.Arguments) {
4161 run()
4162 })
4163 return _c
4164}
4165
4166func (_c *MockWebViewPool_Close_Call) Return() *MockWebViewPool_Close_Call {
4167 _c.Call.Return()
4168 return _c
4169}
4170
4171func (_c *MockWebViewPool_Close_Call) RunAndReturn(run func()) *MockWebViewPool_Close_Call {
4172 _c.Run(run)
4173 return _c
4174}
4175
4176// Prewarm provides a mock function for the type MockWebViewPool
4177func (_mock *MockWebViewPool) Prewarm(count int) {
4178 _mock.Called(count)
4179 return
4180}
4181
4182// MockWebViewPool_Prewarm_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Prewarm'
4183type MockWebViewPool_Prewarm_Call struct {
4184 *mock.Call
4185}
4186
4187// Prewarm is a helper method to define mock.On call
4188// - count int
4189func (_e *MockWebViewPool_Expecter) Prewarm(count interface{}) *MockWebViewPool_Prewarm_Call {
4190 return &MockWebViewPool_Prewarm_Call{Call: _e.mock.On("Prewarm", count)}
4191}
4192
4193func (_c *MockWebViewPool_Prewarm_Call) Run(run func(count int)) *MockWebViewPool_Prewarm_Call {
4194 _c.Call.Run(func(args mock.Arguments) {
4195 var arg0 int
4196 if args[0] != nil {
4197 arg0 = args[0].(int)
4198 }
4199 run(
4200 arg0,
4201 )
4202 })
4203 return _c
4204}
4205
4206func (_c *MockWebViewPool_Prewarm_Call) Return() *MockWebViewPool_Prewarm_Call {
4207 _c.Call.Return()
4208 return _c
4209}
4210
4211func (_c *MockWebViewPool_Prewarm_Call) RunAndReturn(run func(count int)) *MockWebViewPool_Prewarm_Call {
4212 _c.Run(run)
4213 return _c
4214}
4215
4216// Release provides a mock function for the type MockWebViewPool
4217func (_mock *MockWebViewPool) Release(wv port.WebView) {
4218 _mock.Called(wv)
4219 return
4220}
4221
4222// MockWebViewPool_Release_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Release'
4223type MockWebViewPool_Release_Call struct {
4224 *mock.Call
4225}
4226
4227// Release is a helper method to define mock.On call
4228// - wv port.WebView
4229func (_e *MockWebViewPool_Expecter) Release(wv interface{}) *MockWebViewPool_Release_Call {
4230 return &MockWebViewPool_Release_Call{Call: _e.mock.On("Release", wv)}
4231}
4232
4233func (_c *MockWebViewPool_Release_Call) Run(run func(wv port.WebView)) *MockWebViewPool_Release_Call {
4234 _c.Call.Run(func(args mock.Arguments) {
4235 var arg0 port.WebView
4236 if args[0] != nil {
4237 arg0 = args[0].(port.WebView)
4238 }
4239 run(
4240 arg0,
4241 )
4242 })
4243 return _c
4244}
4245
4246func (_c *MockWebViewPool_Release_Call) Return() *MockWebViewPool_Release_Call {
4247 _c.Call.Return()
4248 return _c
4249}
4250
4251func (_c *MockWebViewPool_Release_Call) RunAndReturn(run func(wv port.WebView)) *MockWebViewPool_Release_Call {
4252 _c.Run(run)
4253 return _c
4254}
4255
4256// Size provides a mock function for the type MockWebViewPool
4257func (_mock *MockWebViewPool) Size() int {
4258 ret := _mock.Called()
4259
4260 if len(ret) == 0 {
4261 panic("no return value specified for Size")
4262 }
4263
4264 var r0 int
4265 if returnFunc, ok := ret.Get(0).(func() int); ok {
4266 r0 = returnFunc()
4267 } else {
4268 r0 = ret.Get(0).(int)
4269 }
4270 return r0
4271}
4272
4273// MockWebViewPool_Size_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Size'
4274type MockWebViewPool_Size_Call struct {
4275 *mock.Call
4276}
4277
4278// Size is a helper method to define mock.On call
4279func (_e *MockWebViewPool_Expecter) Size() *MockWebViewPool_Size_Call {
4280 return &MockWebViewPool_Size_Call{Call: _e.mock.On("Size")}
4281}
4282
4283func (_c *MockWebViewPool_Size_Call) Run(run func()) *MockWebViewPool_Size_Call {
4284 _c.Call.Run(func(args mock.Arguments) {
4285 run()
4286 })
4287 return _c
4288}
4289
4290func (_c *MockWebViewPool_Size_Call) Return(n int) *MockWebViewPool_Size_Call {
4291 _c.Call.Return(n)
4292 return _c
4293}
4294
4295func (_c *MockWebViewPool_Size_Call) RunAndReturn(run func() int) *MockWebViewPool_Size_Call {
4296 _c.Call.Return(run)
4297 return _c
4298}
4299
4300// 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.
4301// The first argument is typically a *testing.T value.
4302func NewMockWebViewFactory(t interface {
4303 mock.TestingT
4304 Cleanup(func())
4305}) *MockWebViewFactory {
4306 mock := &MockWebViewFactory{}
4307 mock.Mock.Test(t)
4308
4309 t.Cleanup(func() { mock.AssertExpectations(t) })
4310
4311 return mock
4312}
4313
4314// MockWebViewFactory is an autogenerated mock type for the WebViewFactory type
4315type MockWebViewFactory struct {
4316 mock.Mock
4317}
4318
4319type MockWebViewFactory_Expecter struct {
4320 mock *mock.Mock
4321}
4322
4323func (_m *MockWebViewFactory) EXPECT() *MockWebViewFactory_Expecter {
4324 return &MockWebViewFactory_Expecter{mock: &_m.Mock}
4325}
4326
4327// Create provides a mock function for the type MockWebViewFactory
4328func (_mock *MockWebViewFactory) Create(ctx context.Context) (port.WebView, error) {
4329 ret := _mock.Called(ctx)
4330
4331 if len(ret) == 0 {
4332 panic("no return value specified for Create")
4333 }
4334
4335 var r0 port.WebView
4336 var r1 error
4337 if returnFunc, ok := ret.Get(0).(func(context.Context) (port.WebView, error)); ok {
4338 return returnFunc(ctx)
4339 }
4340 if returnFunc, ok := ret.Get(0).(func(context.Context) port.WebView); ok {
4341 r0 = returnFunc(ctx)
4342 } else {
4343 if ret.Get(0) != nil {
4344 r0 = ret.Get(0).(port.WebView)
4345 }
4346 }
4347 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
4348 r1 = returnFunc(ctx)
4349 } else {
4350 r1 = ret.Error(1)
4351 }
4352 return r0, r1
4353}
4354
4355// MockWebViewFactory_Create_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Create'
4356type MockWebViewFactory_Create_Call struct {
4357 *mock.Call
4358}
4359
4360// Create is a helper method to define mock.On call
4361// - ctx context.Context
4362func (_e *MockWebViewFactory_Expecter) Create(ctx interface{}) *MockWebViewFactory_Create_Call {
4363 return &MockWebViewFactory_Create_Call{Call: _e.mock.On("Create", ctx)}
4364}
4365
4366func (_c *MockWebViewFactory_Create_Call) Run(run func(ctx context.Context)) *MockWebViewFactory_Create_Call {
4367 _c.Call.Run(func(args mock.Arguments) {
4368 var arg0 context.Context
4369 if args[0] != nil {
4370 arg0 = args[0].(context.Context)
4371 }
4372 run(
4373 arg0,
4374 )
4375 })
4376 return _c
4377}
4378
4379func (_c *MockWebViewFactory_Create_Call) Return(webView port.WebView, err error) *MockWebViewFactory_Create_Call {
4380 _c.Call.Return(webView, err)
4381 return _c
4382}
4383
4384func (_c *MockWebViewFactory_Create_Call) RunAndReturn(run func(ctx context.Context) (port.WebView, error)) *MockWebViewFactory_Create_Call {
4385 _c.Call.Return(run)
4386 return _c
4387}
4388
4389// CreateRelated provides a mock function for the type MockWebViewFactory
4390func (_mock *MockWebViewFactory) CreateRelated(ctx context.Context, parentID port.WebViewID) (port.WebView, error) {
4391 ret := _mock.Called(ctx, parentID)
4392
4393 if len(ret) == 0 {
4394 panic("no return value specified for CreateRelated")
4395 }
4396
4397 var r0 port.WebView
4398 var r1 error
4399 if returnFunc, ok := ret.Get(0).(func(context.Context, port.WebViewID) (port.WebView, error)); ok {
4400 return returnFunc(ctx, parentID)
4401 }
4402 if returnFunc, ok := ret.Get(0).(func(context.Context, port.WebViewID) port.WebView); ok {
4403 r0 = returnFunc(ctx, parentID)
4404 } else {
4405 if ret.Get(0) != nil {
4406 r0 = ret.Get(0).(port.WebView)
4407 }
4408 }
4409 if returnFunc, ok := ret.Get(1).(func(context.Context, port.WebViewID) error); ok {
4410 r1 = returnFunc(ctx, parentID)
4411 } else {
4412 r1 = ret.Error(1)
4413 }
4414 return r0, r1
4415}
4416
4417// MockWebViewFactory_CreateRelated_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateRelated'
4418type MockWebViewFactory_CreateRelated_Call struct {
4419 *mock.Call
4420}
4421
4422// CreateRelated is a helper method to define mock.On call
4423// - ctx context.Context
4424// - parentID port.WebViewID
4425func (_e *MockWebViewFactory_Expecter) CreateRelated(ctx interface{}, parentID interface{}) *MockWebViewFactory_CreateRelated_Call {
4426 return &MockWebViewFactory_CreateRelated_Call{Call: _e.mock.On("CreateRelated", ctx, parentID)}
4427}
4428
4429func (_c *MockWebViewFactory_CreateRelated_Call) Run(run func(ctx context.Context, parentID port.WebViewID)) *MockWebViewFactory_CreateRelated_Call {
4430 _c.Call.Run(func(args mock.Arguments) {
4431 var arg0 context.Context
4432 if args[0] != nil {
4433 arg0 = args[0].(context.Context)
4434 }
4435 var arg1 port.WebViewID
4436 if args[1] != nil {
4437 arg1 = args[1].(port.WebViewID)
4438 }
4439 run(
4440 arg0,
4441 arg1,
4442 )
4443 })
4444 return _c
4445}
4446
4447func (_c *MockWebViewFactory_CreateRelated_Call) Return(webView port.WebView, err error) *MockWebViewFactory_CreateRelated_Call {
4448 _c.Call.Return(webView, err)
4449 return _c
4450}
4451
4452func (_c *MockWebViewFactory_CreateRelated_Call) RunAndReturn(run func(ctx context.Context, parentID port.WebViewID) (port.WebView, error)) *MockWebViewFactory_CreateRelated_Call {
4453 _c.Call.Return(run)
4454 return _c
4455}