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// 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.
1041// The first argument is typically a *testing.T value.
1042func NewMockDatabaseProvider(t interface {
1043 mock.TestingT
1044 Cleanup(func())
1045}) *MockDatabaseProvider {
1046 mock := &MockDatabaseProvider{}
1047 mock.Mock.Test(t)
1048
1049 t.Cleanup(func() { mock.AssertExpectations(t) })
1050
1051 return mock
1052}
1053
1054// MockDatabaseProvider is an autogenerated mock type for the DatabaseProvider type
1055type MockDatabaseProvider struct {
1056 mock.Mock
1057}
1058
1059type MockDatabaseProvider_Expecter struct {
1060 mock *mock.Mock
1061}
1062
1063func (_m *MockDatabaseProvider) EXPECT() *MockDatabaseProvider_Expecter {
1064 return &MockDatabaseProvider_Expecter{mock: &_m.Mock}
1065}
1066
1067// Close provides a mock function for the type MockDatabaseProvider
1068func (_mock *MockDatabaseProvider) Close() error {
1069 ret := _mock.Called()
1070
1071 if len(ret) == 0 {
1072 panic("no return value specified for Close")
1073 }
1074
1075 var r0 error
1076 if returnFunc, ok := ret.Get(0).(func() error); ok {
1077 r0 = returnFunc()
1078 } else {
1079 r0 = ret.Error(0)
1080 }
1081 return r0
1082}
1083
1084// MockDatabaseProvider_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
1085type MockDatabaseProvider_Close_Call struct {
1086 *mock.Call
1087}
1088
1089// Close is a helper method to define mock.On call
1090func (_e *MockDatabaseProvider_Expecter) Close() *MockDatabaseProvider_Close_Call {
1091 return &MockDatabaseProvider_Close_Call{Call: _e.mock.On("Close")}
1092}
1093
1094func (_c *MockDatabaseProvider_Close_Call) Run(run func()) *MockDatabaseProvider_Close_Call {
1095 _c.Call.Run(func(args mock.Arguments) {
1096 run()
1097 })
1098 return _c
1099}
1100
1101func (_c *MockDatabaseProvider_Close_Call) Return(err error) *MockDatabaseProvider_Close_Call {
1102 _c.Call.Return(err)
1103 return _c
1104}
1105
1106func (_c *MockDatabaseProvider_Close_Call) RunAndReturn(run func() error) *MockDatabaseProvider_Close_Call {
1107 _c.Call.Return(run)
1108 return _c
1109}
1110
1111// DB provides a mock function for the type MockDatabaseProvider
1112func (_mock *MockDatabaseProvider) DB(ctx context.Context) (*sql.DB, error) {
1113 ret := _mock.Called(ctx)
1114
1115 if len(ret) == 0 {
1116 panic("no return value specified for DB")
1117 }
1118
1119 var r0 *sql.DB
1120 var r1 error
1121 if returnFunc, ok := ret.Get(0).(func(context.Context) (*sql.DB, error)); ok {
1122 return returnFunc(ctx)
1123 }
1124 if returnFunc, ok := ret.Get(0).(func(context.Context) *sql.DB); ok {
1125 r0 = returnFunc(ctx)
1126 } else {
1127 if ret.Get(0) != nil {
1128 r0 = ret.Get(0).(*sql.DB)
1129 }
1130 }
1131 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
1132 r1 = returnFunc(ctx)
1133 } else {
1134 r1 = ret.Error(1)
1135 }
1136 return r0, r1
1137}
1138
1139// MockDatabaseProvider_DB_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DB'
1140type MockDatabaseProvider_DB_Call struct {
1141 *mock.Call
1142}
1143
1144// DB is a helper method to define mock.On call
1145// - ctx context.Context
1146func (_e *MockDatabaseProvider_Expecter) DB(ctx interface{}) *MockDatabaseProvider_DB_Call {
1147 return &MockDatabaseProvider_DB_Call{Call: _e.mock.On("DB", ctx)}
1148}
1149
1150func (_c *MockDatabaseProvider_DB_Call) Run(run func(ctx context.Context)) *MockDatabaseProvider_DB_Call {
1151 _c.Call.Run(func(args mock.Arguments) {
1152 var arg0 context.Context
1153 if args[0] != nil {
1154 arg0 = args[0].(context.Context)
1155 }
1156 run(
1157 arg0,
1158 )
1159 })
1160 return _c
1161}
1162
1163func (_c *MockDatabaseProvider_DB_Call) Return(dB *sql.DB, err error) *MockDatabaseProvider_DB_Call {
1164 _c.Call.Return(dB, err)
1165 return _c
1166}
1167
1168func (_c *MockDatabaseProvider_DB_Call) RunAndReturn(run func(ctx context.Context) (*sql.DB, error)) *MockDatabaseProvider_DB_Call {
1169 _c.Call.Return(run)
1170 return _c
1171}
1172
1173// IsInitialized provides a mock function for the type MockDatabaseProvider
1174func (_mock *MockDatabaseProvider) IsInitialized() bool {
1175 ret := _mock.Called()
1176
1177 if len(ret) == 0 {
1178 panic("no return value specified for IsInitialized")
1179 }
1180
1181 var r0 bool
1182 if returnFunc, ok := ret.Get(0).(func() bool); ok {
1183 r0 = returnFunc()
1184 } else {
1185 r0 = ret.Get(0).(bool)
1186 }
1187 return r0
1188}
1189
1190// MockDatabaseProvider_IsInitialized_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsInitialized'
1191type MockDatabaseProvider_IsInitialized_Call struct {
1192 *mock.Call
1193}
1194
1195// IsInitialized is a helper method to define mock.On call
1196func (_e *MockDatabaseProvider_Expecter) IsInitialized() *MockDatabaseProvider_IsInitialized_Call {
1197 return &MockDatabaseProvider_IsInitialized_Call{Call: _e.mock.On("IsInitialized")}
1198}
1199
1200func (_c *MockDatabaseProvider_IsInitialized_Call) Run(run func()) *MockDatabaseProvider_IsInitialized_Call {
1201 _c.Call.Run(func(args mock.Arguments) {
1202 run()
1203 })
1204 return _c
1205}
1206
1207func (_c *MockDatabaseProvider_IsInitialized_Call) Return(b bool) *MockDatabaseProvider_IsInitialized_Call {
1208 _c.Call.Return(b)
1209 return _c
1210}
1211
1212func (_c *MockDatabaseProvider_IsInitialized_Call) RunAndReturn(run func() bool) *MockDatabaseProvider_IsInitialized_Call {
1213 _c.Call.Return(run)
1214 return _c
1215}
1216
1217// 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.
1218// The first argument is typically a *testing.T value.
1219func NewMockFontDetector(t interface {
1220 mock.TestingT
1221 Cleanup(func())
1222}) *MockFontDetector {
1223 mock := &MockFontDetector{}
1224 mock.Mock.Test(t)
1225
1226 t.Cleanup(func() { mock.AssertExpectations(t) })
1227
1228 return mock
1229}
1230
1231// MockFontDetector is an autogenerated mock type for the FontDetector type
1232type MockFontDetector struct {
1233 mock.Mock
1234}
1235
1236type MockFontDetector_Expecter struct {
1237 mock *mock.Mock
1238}
1239
1240func (_m *MockFontDetector) EXPECT() *MockFontDetector_Expecter {
1241 return &MockFontDetector_Expecter{mock: &_m.Mock}
1242}
1243
1244// GetAvailableFonts provides a mock function for the type MockFontDetector
1245func (_mock *MockFontDetector) GetAvailableFonts(ctx context.Context) ([]string, error) {
1246 ret := _mock.Called(ctx)
1247
1248 if len(ret) == 0 {
1249 panic("no return value specified for GetAvailableFonts")
1250 }
1251
1252 var r0 []string
1253 var r1 error
1254 if returnFunc, ok := ret.Get(0).(func(context.Context) ([]string, error)); ok {
1255 return returnFunc(ctx)
1256 }
1257 if returnFunc, ok := ret.Get(0).(func(context.Context) []string); ok {
1258 r0 = returnFunc(ctx)
1259 } else {
1260 if ret.Get(0) != nil {
1261 r0 = ret.Get(0).([]string)
1262 }
1263 }
1264 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
1265 r1 = returnFunc(ctx)
1266 } else {
1267 r1 = ret.Error(1)
1268 }
1269 return r0, r1
1270}
1271
1272// MockFontDetector_GetAvailableFonts_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAvailableFonts'
1273type MockFontDetector_GetAvailableFonts_Call struct {
1274 *mock.Call
1275}
1276
1277// GetAvailableFonts is a helper method to define mock.On call
1278// - ctx context.Context
1279func (_e *MockFontDetector_Expecter) GetAvailableFonts(ctx interface{}) *MockFontDetector_GetAvailableFonts_Call {
1280 return &MockFontDetector_GetAvailableFonts_Call{Call: _e.mock.On("GetAvailableFonts", ctx)}
1281}
1282
1283func (_c *MockFontDetector_GetAvailableFonts_Call) Run(run func(ctx context.Context)) *MockFontDetector_GetAvailableFonts_Call {
1284 _c.Call.Run(func(args mock.Arguments) {
1285 var arg0 context.Context
1286 if args[0] != nil {
1287 arg0 = args[0].(context.Context)
1288 }
1289 run(
1290 arg0,
1291 )
1292 })
1293 return _c
1294}
1295
1296func (_c *MockFontDetector_GetAvailableFonts_Call) Return(strings []string, err error) *MockFontDetector_GetAvailableFonts_Call {
1297 _c.Call.Return(strings, err)
1298 return _c
1299}
1300
1301func (_c *MockFontDetector_GetAvailableFonts_Call) RunAndReturn(run func(ctx context.Context) ([]string, error)) *MockFontDetector_GetAvailableFonts_Call {
1302 _c.Call.Return(run)
1303 return _c
1304}
1305
1306// IsAvailable provides a mock function for the type MockFontDetector
1307func (_mock *MockFontDetector) IsAvailable(ctx context.Context) bool {
1308 ret := _mock.Called(ctx)
1309
1310 if len(ret) == 0 {
1311 panic("no return value specified for IsAvailable")
1312 }
1313
1314 var r0 bool
1315 if returnFunc, ok := ret.Get(0).(func(context.Context) bool); ok {
1316 r0 = returnFunc(ctx)
1317 } else {
1318 r0 = ret.Get(0).(bool)
1319 }
1320 return r0
1321}
1322
1323// MockFontDetector_IsAvailable_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsAvailable'
1324type MockFontDetector_IsAvailable_Call struct {
1325 *mock.Call
1326}
1327
1328// IsAvailable is a helper method to define mock.On call
1329// - ctx context.Context
1330func (_e *MockFontDetector_Expecter) IsAvailable(ctx interface{}) *MockFontDetector_IsAvailable_Call {
1331 return &MockFontDetector_IsAvailable_Call{Call: _e.mock.On("IsAvailable", ctx)}
1332}
1333
1334func (_c *MockFontDetector_IsAvailable_Call) Run(run func(ctx context.Context)) *MockFontDetector_IsAvailable_Call {
1335 _c.Call.Run(func(args mock.Arguments) {
1336 var arg0 context.Context
1337 if args[0] != nil {
1338 arg0 = args[0].(context.Context)
1339 }
1340 run(
1341 arg0,
1342 )
1343 })
1344 return _c
1345}
1346
1347func (_c *MockFontDetector_IsAvailable_Call) Return(b bool) *MockFontDetector_IsAvailable_Call {
1348 _c.Call.Return(b)
1349 return _c
1350}
1351
1352func (_c *MockFontDetector_IsAvailable_Call) RunAndReturn(run func(ctx context.Context) bool) *MockFontDetector_IsAvailable_Call {
1353 _c.Call.Return(run)
1354 return _c
1355}
1356
1357// SelectBestFont provides a mock function for the type MockFontDetector
1358func (_mock *MockFontDetector) SelectBestFont(ctx context.Context, category port.FontCategory, fallbackChain []string) string {
1359 ret := _mock.Called(ctx, category, fallbackChain)
1360
1361 if len(ret) == 0 {
1362 panic("no return value specified for SelectBestFont")
1363 }
1364
1365 var r0 string
1366 if returnFunc, ok := ret.Get(0).(func(context.Context, port.FontCategory, []string) string); ok {
1367 r0 = returnFunc(ctx, category, fallbackChain)
1368 } else {
1369 r0 = ret.Get(0).(string)
1370 }
1371 return r0
1372}
1373
1374// MockFontDetector_SelectBestFont_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SelectBestFont'
1375type MockFontDetector_SelectBestFont_Call struct {
1376 *mock.Call
1377}
1378
1379// SelectBestFont is a helper method to define mock.On call
1380// - ctx context.Context
1381// - category port.FontCategory
1382// - fallbackChain []string
1383func (_e *MockFontDetector_Expecter) SelectBestFont(ctx interface{}, category interface{}, fallbackChain interface{}) *MockFontDetector_SelectBestFont_Call {
1384 return &MockFontDetector_SelectBestFont_Call{Call: _e.mock.On("SelectBestFont", ctx, category, fallbackChain)}
1385}
1386
1387func (_c *MockFontDetector_SelectBestFont_Call) Run(run func(ctx context.Context, category port.FontCategory, fallbackChain []string)) *MockFontDetector_SelectBestFont_Call {
1388 _c.Call.Run(func(args mock.Arguments) {
1389 var arg0 context.Context
1390 if args[0] != nil {
1391 arg0 = args[0].(context.Context)
1392 }
1393 var arg1 port.FontCategory
1394 if args[1] != nil {
1395 arg1 = args[1].(port.FontCategory)
1396 }
1397 var arg2 []string
1398 if args[2] != nil {
1399 arg2 = args[2].([]string)
1400 }
1401 run(
1402 arg0,
1403 arg1,
1404 arg2,
1405 )
1406 })
1407 return _c
1408}
1409
1410func (_c *MockFontDetector_SelectBestFont_Call) Return(s string) *MockFontDetector_SelectBestFont_Call {
1411 _c.Call.Return(s)
1412 return _c
1413}
1414
1415func (_c *MockFontDetector_SelectBestFont_Call) RunAndReturn(run func(ctx context.Context, category port.FontCategory, fallbackChain []string) string) *MockFontDetector_SelectBestFont_Call {
1416 _c.Call.Return(run)
1417 return _c
1418}
1419
1420// 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.
1421// The first argument is typically a *testing.T value.
1422func NewMockHardwareSurveyor(t interface {
1423 mock.TestingT
1424 Cleanup(func())
1425}) *MockHardwareSurveyor {
1426 mock := &MockHardwareSurveyor{}
1427 mock.Mock.Test(t)
1428
1429 t.Cleanup(func() { mock.AssertExpectations(t) })
1430
1431 return mock
1432}
1433
1434// MockHardwareSurveyor is an autogenerated mock type for the HardwareSurveyor type
1435type MockHardwareSurveyor struct {
1436 mock.Mock
1437}
1438
1439type MockHardwareSurveyor_Expecter struct {
1440 mock *mock.Mock
1441}
1442
1443func (_m *MockHardwareSurveyor) EXPECT() *MockHardwareSurveyor_Expecter {
1444 return &MockHardwareSurveyor_Expecter{mock: &_m.Mock}
1445}
1446
1447// Survey provides a mock function for the type MockHardwareSurveyor
1448func (_mock *MockHardwareSurveyor) Survey(ctx context.Context) port.HardwareInfo {
1449 ret := _mock.Called(ctx)
1450
1451 if len(ret) == 0 {
1452 panic("no return value specified for Survey")
1453 }
1454
1455 var r0 port.HardwareInfo
1456 if returnFunc, ok := ret.Get(0).(func(context.Context) port.HardwareInfo); ok {
1457 r0 = returnFunc(ctx)
1458 } else {
1459 r0 = ret.Get(0).(port.HardwareInfo)
1460 }
1461 return r0
1462}
1463
1464// MockHardwareSurveyor_Survey_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Survey'
1465type MockHardwareSurveyor_Survey_Call struct {
1466 *mock.Call
1467}
1468
1469// Survey is a helper method to define mock.On call
1470// - ctx context.Context
1471func (_e *MockHardwareSurveyor_Expecter) Survey(ctx interface{}) *MockHardwareSurveyor_Survey_Call {
1472 return &MockHardwareSurveyor_Survey_Call{Call: _e.mock.On("Survey", ctx)}
1473}
1474
1475func (_c *MockHardwareSurveyor_Survey_Call) Run(run func(ctx context.Context)) *MockHardwareSurveyor_Survey_Call {
1476 _c.Call.Run(func(args mock.Arguments) {
1477 var arg0 context.Context
1478 if args[0] != nil {
1479 arg0 = args[0].(context.Context)
1480 }
1481 run(
1482 arg0,
1483 )
1484 })
1485 return _c
1486}
1487
1488func (_c *MockHardwareSurveyor_Survey_Call) Return(hardwareInfo port.HardwareInfo) *MockHardwareSurveyor_Survey_Call {
1489 _c.Call.Return(hardwareInfo)
1490 return _c
1491}
1492
1493func (_c *MockHardwareSurveyor_Survey_Call) RunAndReturn(run func(ctx context.Context) port.HardwareInfo) *MockHardwareSurveyor_Survey_Call {
1494 _c.Call.Return(run)
1495 return _c
1496}
1497
1498// 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.
1499// The first argument is typically a *testing.T value.
1500func NewMockSessionLogger(t interface {
1501 mock.TestingT
1502 Cleanup(func())
1503}) *MockSessionLogger {
1504 mock := &MockSessionLogger{}
1505 mock.Mock.Test(t)
1506
1507 t.Cleanup(func() { mock.AssertExpectations(t) })
1508
1509 return mock
1510}
1511
1512// MockSessionLogger is an autogenerated mock type for the SessionLogger type
1513type MockSessionLogger struct {
1514 mock.Mock
1515}
1516
1517type MockSessionLogger_Expecter struct {
1518 mock *mock.Mock
1519}
1520
1521func (_m *MockSessionLogger) EXPECT() *MockSessionLogger_Expecter {
1522 return &MockSessionLogger_Expecter{mock: &_m.Mock}
1523}
1524
1525// CreateLogger provides a mock function for the type MockSessionLogger
1526func (_mock *MockSessionLogger) CreateLogger(ctx context.Context, sessionID entity.SessionID, cfg port.SessionLogConfig) (zerolog.Logger, func(), error) {
1527 ret := _mock.Called(ctx, sessionID, cfg)
1528
1529 if len(ret) == 0 {
1530 panic("no return value specified for CreateLogger")
1531 }
1532
1533 var r0 zerolog.Logger
1534 var r1 func()
1535 var r2 error
1536 if returnFunc, ok := ret.Get(0).(func(context.Context, entity.SessionID, port.SessionLogConfig) (zerolog.Logger, func(), error)); ok {
1537 return returnFunc(ctx, sessionID, cfg)
1538 }
1539 if returnFunc, ok := ret.Get(0).(func(context.Context, entity.SessionID, port.SessionLogConfig) zerolog.Logger); ok {
1540 r0 = returnFunc(ctx, sessionID, cfg)
1541 } else {
1542 r0 = ret.Get(0).(zerolog.Logger)
1543 }
1544 if returnFunc, ok := ret.Get(1).(func(context.Context, entity.SessionID, port.SessionLogConfig) func()); ok {
1545 r1 = returnFunc(ctx, sessionID, cfg)
1546 } else {
1547 if ret.Get(1) != nil {
1548 r1 = ret.Get(1).(func())
1549 }
1550 }
1551 if returnFunc, ok := ret.Get(2).(func(context.Context, entity.SessionID, port.SessionLogConfig) error); ok {
1552 r2 = returnFunc(ctx, sessionID, cfg)
1553 } else {
1554 r2 = ret.Error(2)
1555 }
1556 return r0, r1, r2
1557}
1558
1559// MockSessionLogger_CreateLogger_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateLogger'
1560type MockSessionLogger_CreateLogger_Call struct {
1561 *mock.Call
1562}
1563
1564// CreateLogger is a helper method to define mock.On call
1565// - ctx context.Context
1566// - sessionID entity.SessionID
1567// - cfg port.SessionLogConfig
1568func (_e *MockSessionLogger_Expecter) CreateLogger(ctx interface{}, sessionID interface{}, cfg interface{}) *MockSessionLogger_CreateLogger_Call {
1569 return &MockSessionLogger_CreateLogger_Call{Call: _e.mock.On("CreateLogger", ctx, sessionID, cfg)}
1570}
1571
1572func (_c *MockSessionLogger_CreateLogger_Call) Run(run func(ctx context.Context, sessionID entity.SessionID, cfg port.SessionLogConfig)) *MockSessionLogger_CreateLogger_Call {
1573 _c.Call.Run(func(args mock.Arguments) {
1574 var arg0 context.Context
1575 if args[0] != nil {
1576 arg0 = args[0].(context.Context)
1577 }
1578 var arg1 entity.SessionID
1579 if args[1] != nil {
1580 arg1 = args[1].(entity.SessionID)
1581 }
1582 var arg2 port.SessionLogConfig
1583 if args[2] != nil {
1584 arg2 = args[2].(port.SessionLogConfig)
1585 }
1586 run(
1587 arg0,
1588 arg1,
1589 arg2,
1590 )
1591 })
1592 return _c
1593}
1594
1595func (_c *MockSessionLogger_CreateLogger_Call) Return(logger zerolog.Logger, fn func(), err error) *MockSessionLogger_CreateLogger_Call {
1596 _c.Call.Return(logger, fn, err)
1597 return _c
1598}
1599
1600func (_c *MockSessionLogger_CreateLogger_Call) RunAndReturn(run func(ctx context.Context, sessionID entity.SessionID, cfg port.SessionLogConfig) (zerolog.Logger, func(), error)) *MockSessionLogger_CreateLogger_Call {
1601 _c.Call.Return(run)
1602 return _c
1603}
1604
1605// 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.
1606// The first argument is typically a *testing.T value.
1607func NewMockTabListProvider(t interface {
1608 mock.TestingT
1609 Cleanup(func())
1610}) *MockTabListProvider {
1611 mock := &MockTabListProvider{}
1612 mock.Mock.Test(t)
1613
1614 t.Cleanup(func() { mock.AssertExpectations(t) })
1615
1616 return mock
1617}
1618
1619// MockTabListProvider is an autogenerated mock type for the TabListProvider type
1620type MockTabListProvider struct {
1621 mock.Mock
1622}
1623
1624type MockTabListProvider_Expecter struct {
1625 mock *mock.Mock
1626}
1627
1628func (_m *MockTabListProvider) EXPECT() *MockTabListProvider_Expecter {
1629 return &MockTabListProvider_Expecter{mock: &_m.Mock}
1630}
1631
1632// GetSessionID provides a mock function for the type MockTabListProvider
1633func (_mock *MockTabListProvider) GetSessionID() entity.SessionID {
1634 ret := _mock.Called()
1635
1636 if len(ret) == 0 {
1637 panic("no return value specified for GetSessionID")
1638 }
1639
1640 var r0 entity.SessionID
1641 if returnFunc, ok := ret.Get(0).(func() entity.SessionID); ok {
1642 r0 = returnFunc()
1643 } else {
1644 r0 = ret.Get(0).(entity.SessionID)
1645 }
1646 return r0
1647}
1648
1649// MockTabListProvider_GetSessionID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSessionID'
1650type MockTabListProvider_GetSessionID_Call struct {
1651 *mock.Call
1652}
1653
1654// GetSessionID is a helper method to define mock.On call
1655func (_e *MockTabListProvider_Expecter) GetSessionID() *MockTabListProvider_GetSessionID_Call {
1656 return &MockTabListProvider_GetSessionID_Call{Call: _e.mock.On("GetSessionID")}
1657}
1658
1659func (_c *MockTabListProvider_GetSessionID_Call) Run(run func()) *MockTabListProvider_GetSessionID_Call {
1660 _c.Call.Run(func(args mock.Arguments) {
1661 run()
1662 })
1663 return _c
1664}
1665
1666func (_c *MockTabListProvider_GetSessionID_Call) Return(sessionID entity.SessionID) *MockTabListProvider_GetSessionID_Call {
1667 _c.Call.Return(sessionID)
1668 return _c
1669}
1670
1671func (_c *MockTabListProvider_GetSessionID_Call) RunAndReturn(run func() entity.SessionID) *MockTabListProvider_GetSessionID_Call {
1672 _c.Call.Return(run)
1673 return _c
1674}
1675
1676// GetTabList provides a mock function for the type MockTabListProvider
1677func (_mock *MockTabListProvider) GetTabList() *entity.TabList {
1678 ret := _mock.Called()
1679
1680 if len(ret) == 0 {
1681 panic("no return value specified for GetTabList")
1682 }
1683
1684 var r0 *entity.TabList
1685 if returnFunc, ok := ret.Get(0).(func() *entity.TabList); ok {
1686 r0 = returnFunc()
1687 } else {
1688 if ret.Get(0) != nil {
1689 r0 = ret.Get(0).(*entity.TabList)
1690 }
1691 }
1692 return r0
1693}
1694
1695// MockTabListProvider_GetTabList_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTabList'
1696type MockTabListProvider_GetTabList_Call struct {
1697 *mock.Call
1698}
1699
1700// GetTabList is a helper method to define mock.On call
1701func (_e *MockTabListProvider_Expecter) GetTabList() *MockTabListProvider_GetTabList_Call {
1702 return &MockTabListProvider_GetTabList_Call{Call: _e.mock.On("GetTabList")}
1703}
1704
1705func (_c *MockTabListProvider_GetTabList_Call) Run(run func()) *MockTabListProvider_GetTabList_Call {
1706 _c.Call.Run(func(args mock.Arguments) {
1707 run()
1708 })
1709 return _c
1710}
1711
1712func (_c *MockTabListProvider_GetTabList_Call) Return(tabList *entity.TabList) *MockTabListProvider_GetTabList_Call {
1713 _c.Call.Return(tabList)
1714 return _c
1715}
1716
1717func (_c *MockTabListProvider_GetTabList_Call) RunAndReturn(run func() *entity.TabList) *MockTabListProvider_GetTabList_Call {
1718 _c.Call.Return(run)
1719 return _c
1720}
1721
1722// 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.
1723// The first argument is typically a *testing.T value.
1724func NewMockSessionSpawner(t interface {
1725 mock.TestingT
1726 Cleanup(func())
1727}) *MockSessionSpawner {
1728 mock := &MockSessionSpawner{}
1729 mock.Mock.Test(t)
1730
1731 t.Cleanup(func() { mock.AssertExpectations(t) })
1732
1733 return mock
1734}
1735
1736// MockSessionSpawner is an autogenerated mock type for the SessionSpawner type
1737type MockSessionSpawner struct {
1738 mock.Mock
1739}
1740
1741type MockSessionSpawner_Expecter struct {
1742 mock *mock.Mock
1743}
1744
1745func (_m *MockSessionSpawner) EXPECT() *MockSessionSpawner_Expecter {
1746 return &MockSessionSpawner_Expecter{mock: &_m.Mock}
1747}
1748
1749// SpawnWithSession provides a mock function for the type MockSessionSpawner
1750func (_mock *MockSessionSpawner) SpawnWithSession(sessionID entity.SessionID) error {
1751 ret := _mock.Called(sessionID)
1752
1753 if len(ret) == 0 {
1754 panic("no return value specified for SpawnWithSession")
1755 }
1756
1757 var r0 error
1758 if returnFunc, ok := ret.Get(0).(func(entity.SessionID) error); ok {
1759 r0 = returnFunc(sessionID)
1760 } else {
1761 r0 = ret.Error(0)
1762 }
1763 return r0
1764}
1765
1766// MockSessionSpawner_SpawnWithSession_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SpawnWithSession'
1767type MockSessionSpawner_SpawnWithSession_Call struct {
1768 *mock.Call
1769}
1770
1771// SpawnWithSession is a helper method to define mock.On call
1772// - sessionID entity.SessionID
1773func (_e *MockSessionSpawner_Expecter) SpawnWithSession(sessionID interface{}) *MockSessionSpawner_SpawnWithSession_Call {
1774 return &MockSessionSpawner_SpawnWithSession_Call{Call: _e.mock.On("SpawnWithSession", sessionID)}
1775}
1776
1777func (_c *MockSessionSpawner_SpawnWithSession_Call) Run(run func(sessionID entity.SessionID)) *MockSessionSpawner_SpawnWithSession_Call {
1778 _c.Call.Run(func(args mock.Arguments) {
1779 var arg0 entity.SessionID
1780 if args[0] != nil {
1781 arg0 = args[0].(entity.SessionID)
1782 }
1783 run(
1784 arg0,
1785 )
1786 })
1787 return _c
1788}
1789
1790func (_c *MockSessionSpawner_SpawnWithSession_Call) Return(err error) *MockSessionSpawner_SpawnWithSession_Call {
1791 _c.Call.Return(err)
1792 return _c
1793}
1794
1795func (_c *MockSessionSpawner_SpawnWithSession_Call) RunAndReturn(run func(sessionID entity.SessionID) error) *MockSessionSpawner_SpawnWithSession_Call {
1796 _c.Call.Return(run)
1797 return _c
1798}
1799
1800// 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.
1801// The first argument is typically a *testing.T value.
1802func NewMockTextInputTarget(t interface {
1803 mock.TestingT
1804 Cleanup(func())
1805}) *MockTextInputTarget {
1806 mock := &MockTextInputTarget{}
1807 mock.Mock.Test(t)
1808
1809 t.Cleanup(func() { mock.AssertExpectations(t) })
1810
1811 return mock
1812}
1813
1814// MockTextInputTarget is an autogenerated mock type for the TextInputTarget type
1815type MockTextInputTarget struct {
1816 mock.Mock
1817}
1818
1819type MockTextInputTarget_Expecter struct {
1820 mock *mock.Mock
1821}
1822
1823func (_m *MockTextInputTarget) EXPECT() *MockTextInputTarget_Expecter {
1824 return &MockTextInputTarget_Expecter{mock: &_m.Mock}
1825}
1826
1827// DeleteBeforeCursor provides a mock function for the type MockTextInputTarget
1828func (_mock *MockTextInputTarget) DeleteBeforeCursor(ctx context.Context, n int) error {
1829 ret := _mock.Called(ctx, n)
1830
1831 if len(ret) == 0 {
1832 panic("no return value specified for DeleteBeforeCursor")
1833 }
1834
1835 var r0 error
1836 if returnFunc, ok := ret.Get(0).(func(context.Context, int) error); ok {
1837 r0 = returnFunc(ctx, n)
1838 } else {
1839 r0 = ret.Error(0)
1840 }
1841 return r0
1842}
1843
1844// MockTextInputTarget_DeleteBeforeCursor_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteBeforeCursor'
1845type MockTextInputTarget_DeleteBeforeCursor_Call struct {
1846 *mock.Call
1847}
1848
1849// DeleteBeforeCursor is a helper method to define mock.On call
1850// - ctx context.Context
1851// - n int
1852func (_e *MockTextInputTarget_Expecter) DeleteBeforeCursor(ctx interface{}, n interface{}) *MockTextInputTarget_DeleteBeforeCursor_Call {
1853 return &MockTextInputTarget_DeleteBeforeCursor_Call{Call: _e.mock.On("DeleteBeforeCursor", ctx, n)}
1854}
1855
1856func (_c *MockTextInputTarget_DeleteBeforeCursor_Call) Run(run func(ctx context.Context, n int)) *MockTextInputTarget_DeleteBeforeCursor_Call {
1857 _c.Call.Run(func(args mock.Arguments) {
1858 var arg0 context.Context
1859 if args[0] != nil {
1860 arg0 = args[0].(context.Context)
1861 }
1862 var arg1 int
1863 if args[1] != nil {
1864 arg1 = args[1].(int)
1865 }
1866 run(
1867 arg0,
1868 arg1,
1869 )
1870 })
1871 return _c
1872}
1873
1874func (_c *MockTextInputTarget_DeleteBeforeCursor_Call) Return(err error) *MockTextInputTarget_DeleteBeforeCursor_Call {
1875 _c.Call.Return(err)
1876 return _c
1877}
1878
1879func (_c *MockTextInputTarget_DeleteBeforeCursor_Call) RunAndReturn(run func(ctx context.Context, n int) error) *MockTextInputTarget_DeleteBeforeCursor_Call {
1880 _c.Call.Return(run)
1881 return _c
1882}
1883
1884// InsertText provides a mock function for the type MockTextInputTarget
1885func (_mock *MockTextInputTarget) InsertText(ctx context.Context, text string) error {
1886 ret := _mock.Called(ctx, text)
1887
1888 if len(ret) == 0 {
1889 panic("no return value specified for InsertText")
1890 }
1891
1892 var r0 error
1893 if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
1894 r0 = returnFunc(ctx, text)
1895 } else {
1896 r0 = ret.Error(0)
1897 }
1898 return r0
1899}
1900
1901// MockTextInputTarget_InsertText_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'InsertText'
1902type MockTextInputTarget_InsertText_Call struct {
1903 *mock.Call
1904}
1905
1906// InsertText is a helper method to define mock.On call
1907// - ctx context.Context
1908// - text string
1909func (_e *MockTextInputTarget_Expecter) InsertText(ctx interface{}, text interface{}) *MockTextInputTarget_InsertText_Call {
1910 return &MockTextInputTarget_InsertText_Call{Call: _e.mock.On("InsertText", ctx, text)}
1911}
1912
1913func (_c *MockTextInputTarget_InsertText_Call) Run(run func(ctx context.Context, text string)) *MockTextInputTarget_InsertText_Call {
1914 _c.Call.Run(func(args mock.Arguments) {
1915 var arg0 context.Context
1916 if args[0] != nil {
1917 arg0 = args[0].(context.Context)
1918 }
1919 var arg1 string
1920 if args[1] != nil {
1921 arg1 = args[1].(string)
1922 }
1923 run(
1924 arg0,
1925 arg1,
1926 )
1927 })
1928 return _c
1929}
1930
1931func (_c *MockTextInputTarget_InsertText_Call) Return(err error) *MockTextInputTarget_InsertText_Call {
1932 _c.Call.Return(err)
1933 return _c
1934}
1935
1936func (_c *MockTextInputTarget_InsertText_Call) RunAndReturn(run func(ctx context.Context, text string) error) *MockTextInputTarget_InsertText_Call {
1937 _c.Call.Return(run)
1938 return _c
1939}
1940
1941// 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.
1942// The first argument is typically a *testing.T value.
1943func NewMockFocusedInputProvider(t interface {
1944 mock.TestingT
1945 Cleanup(func())
1946}) *MockFocusedInputProvider {
1947 mock := &MockFocusedInputProvider{}
1948 mock.Mock.Test(t)
1949
1950 t.Cleanup(func() { mock.AssertExpectations(t) })
1951
1952 return mock
1953}
1954
1955// MockFocusedInputProvider is an autogenerated mock type for the FocusedInputProvider type
1956type MockFocusedInputProvider struct {
1957 mock.Mock
1958}
1959
1960type MockFocusedInputProvider_Expecter struct {
1961 mock *mock.Mock
1962}
1963
1964func (_m *MockFocusedInputProvider) EXPECT() *MockFocusedInputProvider_Expecter {
1965 return &MockFocusedInputProvider_Expecter{mock: &_m.Mock}
1966}
1967
1968// GetFocusedInput provides a mock function for the type MockFocusedInputProvider
1969func (_mock *MockFocusedInputProvider) GetFocusedInput() port.TextInputTarget {
1970 ret := _mock.Called()
1971
1972 if len(ret) == 0 {
1973 panic("no return value specified for GetFocusedInput")
1974 }
1975
1976 var r0 port.TextInputTarget
1977 if returnFunc, ok := ret.Get(0).(func() port.TextInputTarget); ok {
1978 r0 = returnFunc()
1979 } else {
1980 if ret.Get(0) != nil {
1981 r0 = ret.Get(0).(port.TextInputTarget)
1982 }
1983 }
1984 return r0
1985}
1986
1987// MockFocusedInputProvider_GetFocusedInput_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetFocusedInput'
1988type MockFocusedInputProvider_GetFocusedInput_Call struct {
1989 *mock.Call
1990}
1991
1992// GetFocusedInput is a helper method to define mock.On call
1993func (_e *MockFocusedInputProvider_Expecter) GetFocusedInput() *MockFocusedInputProvider_GetFocusedInput_Call {
1994 return &MockFocusedInputProvider_GetFocusedInput_Call{Call: _e.mock.On("GetFocusedInput")}
1995}
1996
1997func (_c *MockFocusedInputProvider_GetFocusedInput_Call) Run(run func()) *MockFocusedInputProvider_GetFocusedInput_Call {
1998 _c.Call.Run(func(args mock.Arguments) {
1999 run()
2000 })
2001 return _c
2002}
2003
2004func (_c *MockFocusedInputProvider_GetFocusedInput_Call) Return(textInputTarget port.TextInputTarget) *MockFocusedInputProvider_GetFocusedInput_Call {
2005 _c.Call.Return(textInputTarget)
2006 return _c
2007}
2008
2009func (_c *MockFocusedInputProvider_GetFocusedInput_Call) RunAndReturn(run func() port.TextInputTarget) *MockFocusedInputProvider_GetFocusedInput_Call {
2010 _c.Call.Return(run)
2011 return _c
2012}
2013
2014// SetFocusedInput provides a mock function for the type MockFocusedInputProvider
2015func (_mock *MockFocusedInputProvider) SetFocusedInput(target port.TextInputTarget) {
2016 _mock.Called(target)
2017 return
2018}
2019
2020// MockFocusedInputProvider_SetFocusedInput_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetFocusedInput'
2021type MockFocusedInputProvider_SetFocusedInput_Call struct {
2022 *mock.Call
2023}
2024
2025// SetFocusedInput is a helper method to define mock.On call
2026// - target port.TextInputTarget
2027func (_e *MockFocusedInputProvider_Expecter) SetFocusedInput(target interface{}) *MockFocusedInputProvider_SetFocusedInput_Call {
2028 return &MockFocusedInputProvider_SetFocusedInput_Call{Call: _e.mock.On("SetFocusedInput", target)}
2029}
2030
2031func (_c *MockFocusedInputProvider_SetFocusedInput_Call) Run(run func(target port.TextInputTarget)) *MockFocusedInputProvider_SetFocusedInput_Call {
2032 _c.Call.Run(func(args mock.Arguments) {
2033 var arg0 port.TextInputTarget
2034 if args[0] != nil {
2035 arg0 = args[0].(port.TextInputTarget)
2036 }
2037 run(
2038 arg0,
2039 )
2040 })
2041 return _c
2042}
2043
2044func (_c *MockFocusedInputProvider_SetFocusedInput_Call) Return() *MockFocusedInputProvider_SetFocusedInput_Call {
2045 _c.Call.Return()
2046 return _c
2047}
2048
2049func (_c *MockFocusedInputProvider_SetFocusedInput_Call) RunAndReturn(run func(target port.TextInputTarget)) *MockFocusedInputProvider_SetFocusedInput_Call {
2050 _c.Run(run)
2051 return _c
2052}
2053
2054// 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.
2055// The first argument is typically a *testing.T value.
2056func NewMockMemoryPressureApplier(t interface {
2057 mock.TestingT
2058 Cleanup(func())
2059}) *MockMemoryPressureApplier {
2060 mock := &MockMemoryPressureApplier{}
2061 mock.Mock.Test(t)
2062
2063 t.Cleanup(func() { mock.AssertExpectations(t) })
2064
2065 return mock
2066}
2067
2068// MockMemoryPressureApplier is an autogenerated mock type for the MemoryPressureApplier type
2069type MockMemoryPressureApplier struct {
2070 mock.Mock
2071}
2072
2073type MockMemoryPressureApplier_Expecter struct {
2074 mock *mock.Mock
2075}
2076
2077func (_m *MockMemoryPressureApplier) EXPECT() *MockMemoryPressureApplier_Expecter {
2078 return &MockMemoryPressureApplier_Expecter{mock: &_m.Mock}
2079}
2080
2081// ApplyNetworkProcessSettings provides a mock function for the type MockMemoryPressureApplier
2082func (_mock *MockMemoryPressureApplier) ApplyNetworkProcessSettings(ctx context.Context, cfg *port.MemoryPressureConfig) error {
2083 ret := _mock.Called(ctx, cfg)
2084
2085 if len(ret) == 0 {
2086 panic("no return value specified for ApplyNetworkProcessSettings")
2087 }
2088
2089 var r0 error
2090 if returnFunc, ok := ret.Get(0).(func(context.Context, *port.MemoryPressureConfig) error); ok {
2091 r0 = returnFunc(ctx, cfg)
2092 } else {
2093 r0 = ret.Error(0)
2094 }
2095 return r0
2096}
2097
2098// MockMemoryPressureApplier_ApplyNetworkProcessSettings_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ApplyNetworkProcessSettings'
2099type MockMemoryPressureApplier_ApplyNetworkProcessSettings_Call struct {
2100 *mock.Call
2101}
2102
2103// ApplyNetworkProcessSettings is a helper method to define mock.On call
2104// - ctx context.Context
2105// - cfg *port.MemoryPressureConfig
2106func (_e *MockMemoryPressureApplier_Expecter) ApplyNetworkProcessSettings(ctx interface{}, cfg interface{}) *MockMemoryPressureApplier_ApplyNetworkProcessSettings_Call {
2107 return &MockMemoryPressureApplier_ApplyNetworkProcessSettings_Call{Call: _e.mock.On("ApplyNetworkProcessSettings", ctx, cfg)}
2108}
2109
2110func (_c *MockMemoryPressureApplier_ApplyNetworkProcessSettings_Call) Run(run func(ctx context.Context, cfg *port.MemoryPressureConfig)) *MockMemoryPressureApplier_ApplyNetworkProcessSettings_Call {
2111 _c.Call.Run(func(args mock.Arguments) {
2112 var arg0 context.Context
2113 if args[0] != nil {
2114 arg0 = args[0].(context.Context)
2115 }
2116 var arg1 *port.MemoryPressureConfig
2117 if args[1] != nil {
2118 arg1 = args[1].(*port.MemoryPressureConfig)
2119 }
2120 run(
2121 arg0,
2122 arg1,
2123 )
2124 })
2125 return _c
2126}
2127
2128func (_c *MockMemoryPressureApplier_ApplyNetworkProcessSettings_Call) Return(err error) *MockMemoryPressureApplier_ApplyNetworkProcessSettings_Call {
2129 _c.Call.Return(err)
2130 return _c
2131}
2132
2133func (_c *MockMemoryPressureApplier_ApplyNetworkProcessSettings_Call) RunAndReturn(run func(ctx context.Context, cfg *port.MemoryPressureConfig) error) *MockMemoryPressureApplier_ApplyNetworkProcessSettings_Call {
2134 _c.Call.Return(run)
2135 return _c
2136}
2137
2138// ApplyWebProcessSettings provides a mock function for the type MockMemoryPressureApplier
2139func (_mock *MockMemoryPressureApplier) ApplyWebProcessSettings(ctx context.Context, cfg *port.MemoryPressureConfig) (any, error) {
2140 ret := _mock.Called(ctx, cfg)
2141
2142 if len(ret) == 0 {
2143 panic("no return value specified for ApplyWebProcessSettings")
2144 }
2145
2146 var r0 any
2147 var r1 error
2148 if returnFunc, ok := ret.Get(0).(func(context.Context, *port.MemoryPressureConfig) (any, error)); ok {
2149 return returnFunc(ctx, cfg)
2150 }
2151 if returnFunc, ok := ret.Get(0).(func(context.Context, *port.MemoryPressureConfig) any); ok {
2152 r0 = returnFunc(ctx, cfg)
2153 } else {
2154 if ret.Get(0) != nil {
2155 r0 = ret.Get(0).(any)
2156 }
2157 }
2158 if returnFunc, ok := ret.Get(1).(func(context.Context, *port.MemoryPressureConfig) error); ok {
2159 r1 = returnFunc(ctx, cfg)
2160 } else {
2161 r1 = ret.Error(1)
2162 }
2163 return r0, r1
2164}
2165
2166// MockMemoryPressureApplier_ApplyWebProcessSettings_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ApplyWebProcessSettings'
2167type MockMemoryPressureApplier_ApplyWebProcessSettings_Call struct {
2168 *mock.Call
2169}
2170
2171// ApplyWebProcessSettings is a helper method to define mock.On call
2172// - ctx context.Context
2173// - cfg *port.MemoryPressureConfig
2174func (_e *MockMemoryPressureApplier_Expecter) ApplyWebProcessSettings(ctx interface{}, cfg interface{}) *MockMemoryPressureApplier_ApplyWebProcessSettings_Call {
2175 return &MockMemoryPressureApplier_ApplyWebProcessSettings_Call{Call: _e.mock.On("ApplyWebProcessSettings", ctx, cfg)}
2176}
2177
2178func (_c *MockMemoryPressureApplier_ApplyWebProcessSettings_Call) Run(run func(ctx context.Context, cfg *port.MemoryPressureConfig)) *MockMemoryPressureApplier_ApplyWebProcessSettings_Call {
2179 _c.Call.Run(func(args mock.Arguments) {
2180 var arg0 context.Context
2181 if args[0] != nil {
2182 arg0 = args[0].(context.Context)
2183 }
2184 var arg1 *port.MemoryPressureConfig
2185 if args[1] != nil {
2186 arg1 = args[1].(*port.MemoryPressureConfig)
2187 }
2188 run(
2189 arg0,
2190 arg1,
2191 )
2192 })
2193 return _c
2194}
2195
2196func (_c *MockMemoryPressureApplier_ApplyWebProcessSettings_Call) Return(v any, err error) *MockMemoryPressureApplier_ApplyWebProcessSettings_Call {
2197 _c.Call.Return(v, err)
2198 return _c
2199}
2200
2201func (_c *MockMemoryPressureApplier_ApplyWebProcessSettings_Call) RunAndReturn(run func(ctx context.Context, cfg *port.MemoryPressureConfig) (any, error)) *MockMemoryPressureApplier_ApplyWebProcessSettings_Call {
2202 _c.Call.Return(run)
2203 return _c
2204}
2205
2206// 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.
2207// The first argument is typically a *testing.T value.
2208func NewMockWebKitContextProvider(t interface {
2209 mock.TestingT
2210 Cleanup(func())
2211}) *MockWebKitContextProvider {
2212 mock := &MockWebKitContextProvider{}
2213 mock.Mock.Test(t)
2214
2215 t.Cleanup(func() { mock.AssertExpectations(t) })
2216
2217 return mock
2218}
2219
2220// MockWebKitContextProvider is an autogenerated mock type for the WebKitContextProvider type
2221type MockWebKitContextProvider struct {
2222 mock.Mock
2223}
2224
2225type MockWebKitContextProvider_Expecter struct {
2226 mock *mock.Mock
2227}
2228
2229func (_m *MockWebKitContextProvider) EXPECT() *MockWebKitContextProvider_Expecter {
2230 return &MockWebKitContextProvider_Expecter{mock: &_m.Mock}
2231}
2232
2233// CacheDir provides a mock function for the type MockWebKitContextProvider
2234func (_mock *MockWebKitContextProvider) CacheDir() string {
2235 ret := _mock.Called()
2236
2237 if len(ret) == 0 {
2238 panic("no return value specified for CacheDir")
2239 }
2240
2241 var r0 string
2242 if returnFunc, ok := ret.Get(0).(func() string); ok {
2243 r0 = returnFunc()
2244 } else {
2245 r0 = ret.Get(0).(string)
2246 }
2247 return r0
2248}
2249
2250// MockWebKitContextProvider_CacheDir_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CacheDir'
2251type MockWebKitContextProvider_CacheDir_Call struct {
2252 *mock.Call
2253}
2254
2255// CacheDir is a helper method to define mock.On call
2256func (_e *MockWebKitContextProvider_Expecter) CacheDir() *MockWebKitContextProvider_CacheDir_Call {
2257 return &MockWebKitContextProvider_CacheDir_Call{Call: _e.mock.On("CacheDir")}
2258}
2259
2260func (_c *MockWebKitContextProvider_CacheDir_Call) Run(run func()) *MockWebKitContextProvider_CacheDir_Call {
2261 _c.Call.Run(func(args mock.Arguments) {
2262 run()
2263 })
2264 return _c
2265}
2266
2267func (_c *MockWebKitContextProvider_CacheDir_Call) Return(s string) *MockWebKitContextProvider_CacheDir_Call {
2268 _c.Call.Return(s)
2269 return _c
2270}
2271
2272func (_c *MockWebKitContextProvider_CacheDir_Call) RunAndReturn(run func() string) *MockWebKitContextProvider_CacheDir_Call {
2273 _c.Call.Return(run)
2274 return _c
2275}
2276
2277// Close provides a mock function for the type MockWebKitContextProvider
2278func (_mock *MockWebKitContextProvider) Close() error {
2279 ret := _mock.Called()
2280
2281 if len(ret) == 0 {
2282 panic("no return value specified for Close")
2283 }
2284
2285 var r0 error
2286 if returnFunc, ok := ret.Get(0).(func() error); ok {
2287 r0 = returnFunc()
2288 } else {
2289 r0 = ret.Error(0)
2290 }
2291 return r0
2292}
2293
2294// MockWebKitContextProvider_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
2295type MockWebKitContextProvider_Close_Call struct {
2296 *mock.Call
2297}
2298
2299// Close is a helper method to define mock.On call
2300func (_e *MockWebKitContextProvider_Expecter) Close() *MockWebKitContextProvider_Close_Call {
2301 return &MockWebKitContextProvider_Close_Call{Call: _e.mock.On("Close")}
2302}
2303
2304func (_c *MockWebKitContextProvider_Close_Call) Run(run func()) *MockWebKitContextProvider_Close_Call {
2305 _c.Call.Run(func(args mock.Arguments) {
2306 run()
2307 })
2308 return _c
2309}
2310
2311func (_c *MockWebKitContextProvider_Close_Call) Return(err error) *MockWebKitContextProvider_Close_Call {
2312 _c.Call.Return(err)
2313 return _c
2314}
2315
2316func (_c *MockWebKitContextProvider_Close_Call) RunAndReturn(run func() error) *MockWebKitContextProvider_Close_Call {
2317 _c.Call.Return(run)
2318 return _c
2319}
2320
2321// DataDir provides a mock function for the type MockWebKitContextProvider
2322func (_mock *MockWebKitContextProvider) DataDir() string {
2323 ret := _mock.Called()
2324
2325 if len(ret) == 0 {
2326 panic("no return value specified for DataDir")
2327 }
2328
2329 var r0 string
2330 if returnFunc, ok := ret.Get(0).(func() string); ok {
2331 r0 = returnFunc()
2332 } else {
2333 r0 = ret.Get(0).(string)
2334 }
2335 return r0
2336}
2337
2338// MockWebKitContextProvider_DataDir_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DataDir'
2339type MockWebKitContextProvider_DataDir_Call struct {
2340 *mock.Call
2341}
2342
2343// DataDir is a helper method to define mock.On call
2344func (_e *MockWebKitContextProvider_Expecter) DataDir() *MockWebKitContextProvider_DataDir_Call {
2345 return &MockWebKitContextProvider_DataDir_Call{Call: _e.mock.On("DataDir")}
2346}
2347
2348func (_c *MockWebKitContextProvider_DataDir_Call) Run(run func()) *MockWebKitContextProvider_DataDir_Call {
2349 _c.Call.Run(func(args mock.Arguments) {
2350 run()
2351 })
2352 return _c
2353}
2354
2355func (_c *MockWebKitContextProvider_DataDir_Call) Return(s string) *MockWebKitContextProvider_DataDir_Call {
2356 _c.Call.Return(s)
2357 return _c
2358}
2359
2360func (_c *MockWebKitContextProvider_DataDir_Call) RunAndReturn(run func() string) *MockWebKitContextProvider_DataDir_Call {
2361 _c.Call.Return(run)
2362 return _c
2363}
2364
2365// Initialize provides a mock function for the type MockWebKitContextProvider
2366func (_mock *MockWebKitContextProvider) Initialize(ctx context.Context, opts port.WebKitContextOptions) error {
2367 ret := _mock.Called(ctx, opts)
2368
2369 if len(ret) == 0 {
2370 panic("no return value specified for Initialize")
2371 }
2372
2373 var r0 error
2374 if returnFunc, ok := ret.Get(0).(func(context.Context, port.WebKitContextOptions) error); ok {
2375 r0 = returnFunc(ctx, opts)
2376 } else {
2377 r0 = ret.Error(0)
2378 }
2379 return r0
2380}
2381
2382// MockWebKitContextProvider_Initialize_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Initialize'
2383type MockWebKitContextProvider_Initialize_Call struct {
2384 *mock.Call
2385}
2386
2387// Initialize is a helper method to define mock.On call
2388// - ctx context.Context
2389// - opts port.WebKitContextOptions
2390func (_e *MockWebKitContextProvider_Expecter) Initialize(ctx interface{}, opts interface{}) *MockWebKitContextProvider_Initialize_Call {
2391 return &MockWebKitContextProvider_Initialize_Call{Call: _e.mock.On("Initialize", ctx, opts)}
2392}
2393
2394func (_c *MockWebKitContextProvider_Initialize_Call) Run(run func(ctx context.Context, opts port.WebKitContextOptions)) *MockWebKitContextProvider_Initialize_Call {
2395 _c.Call.Run(func(args mock.Arguments) {
2396 var arg0 context.Context
2397 if args[0] != nil {
2398 arg0 = args[0].(context.Context)
2399 }
2400 var arg1 port.WebKitContextOptions
2401 if args[1] != nil {
2402 arg1 = args[1].(port.WebKitContextOptions)
2403 }
2404 run(
2405 arg0,
2406 arg1,
2407 )
2408 })
2409 return _c
2410}
2411
2412func (_c *MockWebKitContextProvider_Initialize_Call) Return(err error) *MockWebKitContextProvider_Initialize_Call {
2413 _c.Call.Return(err)
2414 return _c
2415}
2416
2417func (_c *MockWebKitContextProvider_Initialize_Call) RunAndReturn(run func(ctx context.Context, opts port.WebKitContextOptions) error) *MockWebKitContextProvider_Initialize_Call {
2418 _c.Call.Return(run)
2419 return _c
2420}
2421
2422// PrefetchDNS provides a mock function for the type MockWebKitContextProvider
2423func (_mock *MockWebKitContextProvider) PrefetchDNS(hostname string) {
2424 _mock.Called(hostname)
2425 return
2426}
2427
2428// MockWebKitContextProvider_PrefetchDNS_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PrefetchDNS'
2429type MockWebKitContextProvider_PrefetchDNS_Call struct {
2430 *mock.Call
2431}
2432
2433// PrefetchDNS is a helper method to define mock.On call
2434// - hostname string
2435func (_e *MockWebKitContextProvider_Expecter) PrefetchDNS(hostname interface{}) *MockWebKitContextProvider_PrefetchDNS_Call {
2436 return &MockWebKitContextProvider_PrefetchDNS_Call{Call: _e.mock.On("PrefetchDNS", hostname)}
2437}
2438
2439func (_c *MockWebKitContextProvider_PrefetchDNS_Call) Run(run func(hostname string)) *MockWebKitContextProvider_PrefetchDNS_Call {
2440 _c.Call.Run(func(args mock.Arguments) {
2441 var arg0 string
2442 if args[0] != nil {
2443 arg0 = args[0].(string)
2444 }
2445 run(
2446 arg0,
2447 )
2448 })
2449 return _c
2450}
2451
2452func (_c *MockWebKitContextProvider_PrefetchDNS_Call) Return() *MockWebKitContextProvider_PrefetchDNS_Call {
2453 _c.Call.Return()
2454 return _c
2455}
2456
2457func (_c *MockWebKitContextProvider_PrefetchDNS_Call) RunAndReturn(run func(hostname string)) *MockWebKitContextProvider_PrefetchDNS_Call {
2458 _c.Run(run)
2459 return _c
2460}
2461
2462// 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.
2463// The first argument is typically a *testing.T value.
2464func NewMockWebView(t interface {
2465 mock.TestingT
2466 Cleanup(func())
2467}) *MockWebView {
2468 mock := &MockWebView{}
2469 mock.Mock.Test(t)
2470
2471 t.Cleanup(func() { mock.AssertExpectations(t) })
2472
2473 return mock
2474}
2475
2476// MockWebView is an autogenerated mock type for the WebView type
2477type MockWebView struct {
2478 mock.Mock
2479}
2480
2481type MockWebView_Expecter struct {
2482 mock *mock.Mock
2483}
2484
2485func (_m *MockWebView) EXPECT() *MockWebView_Expecter {
2486 return &MockWebView_Expecter{mock: &_m.Mock}
2487}
2488
2489// CanGoBack provides a mock function for the type MockWebView
2490func (_mock *MockWebView) CanGoBack() bool {
2491 ret := _mock.Called()
2492
2493 if len(ret) == 0 {
2494 panic("no return value specified for CanGoBack")
2495 }
2496
2497 var r0 bool
2498 if returnFunc, ok := ret.Get(0).(func() bool); ok {
2499 r0 = returnFunc()
2500 } else {
2501 r0 = ret.Get(0).(bool)
2502 }
2503 return r0
2504}
2505
2506// MockWebView_CanGoBack_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CanGoBack'
2507type MockWebView_CanGoBack_Call struct {
2508 *mock.Call
2509}
2510
2511// CanGoBack is a helper method to define mock.On call
2512func (_e *MockWebView_Expecter) CanGoBack() *MockWebView_CanGoBack_Call {
2513 return &MockWebView_CanGoBack_Call{Call: _e.mock.On("CanGoBack")}
2514}
2515
2516func (_c *MockWebView_CanGoBack_Call) Run(run func()) *MockWebView_CanGoBack_Call {
2517 _c.Call.Run(func(args mock.Arguments) {
2518 run()
2519 })
2520 return _c
2521}
2522
2523func (_c *MockWebView_CanGoBack_Call) Return(b bool) *MockWebView_CanGoBack_Call {
2524 _c.Call.Return(b)
2525 return _c
2526}
2527
2528func (_c *MockWebView_CanGoBack_Call) RunAndReturn(run func() bool) *MockWebView_CanGoBack_Call {
2529 _c.Call.Return(run)
2530 return _c
2531}
2532
2533// CanGoForward provides a mock function for the type MockWebView
2534func (_mock *MockWebView) CanGoForward() bool {
2535 ret := _mock.Called()
2536
2537 if len(ret) == 0 {
2538 panic("no return value specified for CanGoForward")
2539 }
2540
2541 var r0 bool
2542 if returnFunc, ok := ret.Get(0).(func() bool); ok {
2543 r0 = returnFunc()
2544 } else {
2545 r0 = ret.Get(0).(bool)
2546 }
2547 return r0
2548}
2549
2550// MockWebView_CanGoForward_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CanGoForward'
2551type MockWebView_CanGoForward_Call struct {
2552 *mock.Call
2553}
2554
2555// CanGoForward is a helper method to define mock.On call
2556func (_e *MockWebView_Expecter) CanGoForward() *MockWebView_CanGoForward_Call {
2557 return &MockWebView_CanGoForward_Call{Call: _e.mock.On("CanGoForward")}
2558}
2559
2560func (_c *MockWebView_CanGoForward_Call) Run(run func()) *MockWebView_CanGoForward_Call {
2561 _c.Call.Run(func(args mock.Arguments) {
2562 run()
2563 })
2564 return _c
2565}
2566
2567func (_c *MockWebView_CanGoForward_Call) Return(b bool) *MockWebView_CanGoForward_Call {
2568 _c.Call.Return(b)
2569 return _c
2570}
2571
2572func (_c *MockWebView_CanGoForward_Call) RunAndReturn(run func() bool) *MockWebView_CanGoForward_Call {
2573 _c.Call.Return(run)
2574 return _c
2575}
2576
2577// Destroy provides a mock function for the type MockWebView
2578func (_mock *MockWebView) Destroy() {
2579 _mock.Called()
2580 return
2581}
2582
2583// MockWebView_Destroy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Destroy'
2584type MockWebView_Destroy_Call struct {
2585 *mock.Call
2586}
2587
2588// Destroy is a helper method to define mock.On call
2589func (_e *MockWebView_Expecter) Destroy() *MockWebView_Destroy_Call {
2590 return &MockWebView_Destroy_Call{Call: _e.mock.On("Destroy")}
2591}
2592
2593func (_c *MockWebView_Destroy_Call) Run(run func()) *MockWebView_Destroy_Call {
2594 _c.Call.Run(func(args mock.Arguments) {
2595 run()
2596 })
2597 return _c
2598}
2599
2600func (_c *MockWebView_Destroy_Call) Return() *MockWebView_Destroy_Call {
2601 _c.Call.Return()
2602 return _c
2603}
2604
2605func (_c *MockWebView_Destroy_Call) RunAndReturn(run func()) *MockWebView_Destroy_Call {
2606 _c.Run(run)
2607 return _c
2608}
2609
2610// EstimatedProgress provides a mock function for the type MockWebView
2611func (_mock *MockWebView) EstimatedProgress() float64 {
2612 ret := _mock.Called()
2613
2614 if len(ret) == 0 {
2615 panic("no return value specified for EstimatedProgress")
2616 }
2617
2618 var r0 float64
2619 if returnFunc, ok := ret.Get(0).(func() float64); ok {
2620 r0 = returnFunc()
2621 } else {
2622 r0 = ret.Get(0).(float64)
2623 }
2624 return r0
2625}
2626
2627// MockWebView_EstimatedProgress_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EstimatedProgress'
2628type MockWebView_EstimatedProgress_Call struct {
2629 *mock.Call
2630}
2631
2632// EstimatedProgress is a helper method to define mock.On call
2633func (_e *MockWebView_Expecter) EstimatedProgress() *MockWebView_EstimatedProgress_Call {
2634 return &MockWebView_EstimatedProgress_Call{Call: _e.mock.On("EstimatedProgress")}
2635}
2636
2637func (_c *MockWebView_EstimatedProgress_Call) Run(run func()) *MockWebView_EstimatedProgress_Call {
2638 _c.Call.Run(func(args mock.Arguments) {
2639 run()
2640 })
2641 return _c
2642}
2643
2644func (_c *MockWebView_EstimatedProgress_Call) Return(f float64) *MockWebView_EstimatedProgress_Call {
2645 _c.Call.Return(f)
2646 return _c
2647}
2648
2649func (_c *MockWebView_EstimatedProgress_Call) RunAndReturn(run func() float64) *MockWebView_EstimatedProgress_Call {
2650 _c.Call.Return(run)
2651 return _c
2652}
2653
2654// GetFindController provides a mock function for the type MockWebView
2655func (_mock *MockWebView) GetFindController() port.FindController {
2656 ret := _mock.Called()
2657
2658 if len(ret) == 0 {
2659 panic("no return value specified for GetFindController")
2660 }
2661
2662 var r0 port.FindController
2663 if returnFunc, ok := ret.Get(0).(func() port.FindController); ok {
2664 r0 = returnFunc()
2665 } else {
2666 if ret.Get(0) != nil {
2667 r0 = ret.Get(0).(port.FindController)
2668 }
2669 }
2670 return r0
2671}
2672
2673// MockWebView_GetFindController_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetFindController'
2674type MockWebView_GetFindController_Call struct {
2675 *mock.Call
2676}
2677
2678// GetFindController is a helper method to define mock.On call
2679func (_e *MockWebView_Expecter) GetFindController() *MockWebView_GetFindController_Call {
2680 return &MockWebView_GetFindController_Call{Call: _e.mock.On("GetFindController")}
2681}
2682
2683func (_c *MockWebView_GetFindController_Call) Run(run func()) *MockWebView_GetFindController_Call {
2684 _c.Call.Run(func(args mock.Arguments) {
2685 run()
2686 })
2687 return _c
2688}
2689
2690func (_c *MockWebView_GetFindController_Call) Return(findController port.FindController) *MockWebView_GetFindController_Call {
2691 _c.Call.Return(findController)
2692 return _c
2693}
2694
2695func (_c *MockWebView_GetFindController_Call) RunAndReturn(run func() port.FindController) *MockWebView_GetFindController_Call {
2696 _c.Call.Return(run)
2697 return _c
2698}
2699
2700// GetZoomLevel provides a mock function for the type MockWebView
2701func (_mock *MockWebView) GetZoomLevel() float64 {
2702 ret := _mock.Called()
2703
2704 if len(ret) == 0 {
2705 panic("no return value specified for GetZoomLevel")
2706 }
2707
2708 var r0 float64
2709 if returnFunc, ok := ret.Get(0).(func() float64); ok {
2710 r0 = returnFunc()
2711 } else {
2712 r0 = ret.Get(0).(float64)
2713 }
2714 return r0
2715}
2716
2717// MockWebView_GetZoomLevel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetZoomLevel'
2718type MockWebView_GetZoomLevel_Call struct {
2719 *mock.Call
2720}
2721
2722// GetZoomLevel is a helper method to define mock.On call
2723func (_e *MockWebView_Expecter) GetZoomLevel() *MockWebView_GetZoomLevel_Call {
2724 return &MockWebView_GetZoomLevel_Call{Call: _e.mock.On("GetZoomLevel")}
2725}
2726
2727func (_c *MockWebView_GetZoomLevel_Call) Run(run func()) *MockWebView_GetZoomLevel_Call {
2728 _c.Call.Run(func(args mock.Arguments) {
2729 run()
2730 })
2731 return _c
2732}
2733
2734func (_c *MockWebView_GetZoomLevel_Call) Return(f float64) *MockWebView_GetZoomLevel_Call {
2735 _c.Call.Return(f)
2736 return _c
2737}
2738
2739func (_c *MockWebView_GetZoomLevel_Call) RunAndReturn(run func() float64) *MockWebView_GetZoomLevel_Call {
2740 _c.Call.Return(run)
2741 return _c
2742}
2743
2744// GoBack provides a mock function for the type MockWebView
2745func (_mock *MockWebView) GoBack(ctx context.Context) error {
2746 ret := _mock.Called(ctx)
2747
2748 if len(ret) == 0 {
2749 panic("no return value specified for GoBack")
2750 }
2751
2752 var r0 error
2753 if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
2754 r0 = returnFunc(ctx)
2755 } else {
2756 r0 = ret.Error(0)
2757 }
2758 return r0
2759}
2760
2761// MockWebView_GoBack_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GoBack'
2762type MockWebView_GoBack_Call struct {
2763 *mock.Call
2764}
2765
2766// GoBack is a helper method to define mock.On call
2767// - ctx context.Context
2768func (_e *MockWebView_Expecter) GoBack(ctx interface{}) *MockWebView_GoBack_Call {
2769 return &MockWebView_GoBack_Call{Call: _e.mock.On("GoBack", ctx)}
2770}
2771
2772func (_c *MockWebView_GoBack_Call) Run(run func(ctx context.Context)) *MockWebView_GoBack_Call {
2773 _c.Call.Run(func(args mock.Arguments) {
2774 var arg0 context.Context
2775 if args[0] != nil {
2776 arg0 = args[0].(context.Context)
2777 }
2778 run(
2779 arg0,
2780 )
2781 })
2782 return _c
2783}
2784
2785func (_c *MockWebView_GoBack_Call) Return(err error) *MockWebView_GoBack_Call {
2786 _c.Call.Return(err)
2787 return _c
2788}
2789
2790func (_c *MockWebView_GoBack_Call) RunAndReturn(run func(ctx context.Context) error) *MockWebView_GoBack_Call {
2791 _c.Call.Return(run)
2792 return _c
2793}
2794
2795// GoForward provides a mock function for the type MockWebView
2796func (_mock *MockWebView) GoForward(ctx context.Context) error {
2797 ret := _mock.Called(ctx)
2798
2799 if len(ret) == 0 {
2800 panic("no return value specified for GoForward")
2801 }
2802
2803 var r0 error
2804 if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
2805 r0 = returnFunc(ctx)
2806 } else {
2807 r0 = ret.Error(0)
2808 }
2809 return r0
2810}
2811
2812// MockWebView_GoForward_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GoForward'
2813type MockWebView_GoForward_Call struct {
2814 *mock.Call
2815}
2816
2817// GoForward is a helper method to define mock.On call
2818// - ctx context.Context
2819func (_e *MockWebView_Expecter) GoForward(ctx interface{}) *MockWebView_GoForward_Call {
2820 return &MockWebView_GoForward_Call{Call: _e.mock.On("GoForward", ctx)}
2821}
2822
2823func (_c *MockWebView_GoForward_Call) Run(run func(ctx context.Context)) *MockWebView_GoForward_Call {
2824 _c.Call.Run(func(args mock.Arguments) {
2825 var arg0 context.Context
2826 if args[0] != nil {
2827 arg0 = args[0].(context.Context)
2828 }
2829 run(
2830 arg0,
2831 )
2832 })
2833 return _c
2834}
2835
2836func (_c *MockWebView_GoForward_Call) Return(err error) *MockWebView_GoForward_Call {
2837 _c.Call.Return(err)
2838 return _c
2839}
2840
2841func (_c *MockWebView_GoForward_Call) RunAndReturn(run func(ctx context.Context) error) *MockWebView_GoForward_Call {
2842 _c.Call.Return(run)
2843 return _c
2844}
2845
2846// ID provides a mock function for the type MockWebView
2847func (_mock *MockWebView) ID() port.WebViewID {
2848 ret := _mock.Called()
2849
2850 if len(ret) == 0 {
2851 panic("no return value specified for ID")
2852 }
2853
2854 var r0 port.WebViewID
2855 if returnFunc, ok := ret.Get(0).(func() port.WebViewID); ok {
2856 r0 = returnFunc()
2857 } else {
2858 r0 = ret.Get(0).(port.WebViewID)
2859 }
2860 return r0
2861}
2862
2863// MockWebView_ID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ID'
2864type MockWebView_ID_Call struct {
2865 *mock.Call
2866}
2867
2868// ID is a helper method to define mock.On call
2869func (_e *MockWebView_Expecter) ID() *MockWebView_ID_Call {
2870 return &MockWebView_ID_Call{Call: _e.mock.On("ID")}
2871}
2872
2873func (_c *MockWebView_ID_Call) Run(run func()) *MockWebView_ID_Call {
2874 _c.Call.Run(func(args mock.Arguments) {
2875 run()
2876 })
2877 return _c
2878}
2879
2880func (_c *MockWebView_ID_Call) Return(webViewID port.WebViewID) *MockWebView_ID_Call {
2881 _c.Call.Return(webViewID)
2882 return _c
2883}
2884
2885func (_c *MockWebView_ID_Call) RunAndReturn(run func() port.WebViewID) *MockWebView_ID_Call {
2886 _c.Call.Return(run)
2887 return _c
2888}
2889
2890// IsDestroyed provides a mock function for the type MockWebView
2891func (_mock *MockWebView) IsDestroyed() bool {
2892 ret := _mock.Called()
2893
2894 if len(ret) == 0 {
2895 panic("no return value specified for IsDestroyed")
2896 }
2897
2898 var r0 bool
2899 if returnFunc, ok := ret.Get(0).(func() bool); ok {
2900 r0 = returnFunc()
2901 } else {
2902 r0 = ret.Get(0).(bool)
2903 }
2904 return r0
2905}
2906
2907// MockWebView_IsDestroyed_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsDestroyed'
2908type MockWebView_IsDestroyed_Call struct {
2909 *mock.Call
2910}
2911
2912// IsDestroyed is a helper method to define mock.On call
2913func (_e *MockWebView_Expecter) IsDestroyed() *MockWebView_IsDestroyed_Call {
2914 return &MockWebView_IsDestroyed_Call{Call: _e.mock.On("IsDestroyed")}
2915}
2916
2917func (_c *MockWebView_IsDestroyed_Call) Run(run func()) *MockWebView_IsDestroyed_Call {
2918 _c.Call.Run(func(args mock.Arguments) {
2919 run()
2920 })
2921 return _c
2922}
2923
2924func (_c *MockWebView_IsDestroyed_Call) Return(b bool) *MockWebView_IsDestroyed_Call {
2925 _c.Call.Return(b)
2926 return _c
2927}
2928
2929func (_c *MockWebView_IsDestroyed_Call) RunAndReturn(run func() bool) *MockWebView_IsDestroyed_Call {
2930 _c.Call.Return(run)
2931 return _c
2932}
2933
2934// IsFullscreen provides a mock function for the type MockWebView
2935func (_mock *MockWebView) IsFullscreen() bool {
2936 ret := _mock.Called()
2937
2938 if len(ret) == 0 {
2939 panic("no return value specified for IsFullscreen")
2940 }
2941
2942 var r0 bool
2943 if returnFunc, ok := ret.Get(0).(func() bool); ok {
2944 r0 = returnFunc()
2945 } else {
2946 r0 = ret.Get(0).(bool)
2947 }
2948 return r0
2949}
2950
2951// MockWebView_IsFullscreen_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsFullscreen'
2952type MockWebView_IsFullscreen_Call struct {
2953 *mock.Call
2954}
2955
2956// IsFullscreen is a helper method to define mock.On call
2957func (_e *MockWebView_Expecter) IsFullscreen() *MockWebView_IsFullscreen_Call {
2958 return &MockWebView_IsFullscreen_Call{Call: _e.mock.On("IsFullscreen")}
2959}
2960
2961func (_c *MockWebView_IsFullscreen_Call) Run(run func()) *MockWebView_IsFullscreen_Call {
2962 _c.Call.Run(func(args mock.Arguments) {
2963 run()
2964 })
2965 return _c
2966}
2967
2968func (_c *MockWebView_IsFullscreen_Call) Return(b bool) *MockWebView_IsFullscreen_Call {
2969 _c.Call.Return(b)
2970 return _c
2971}
2972
2973func (_c *MockWebView_IsFullscreen_Call) RunAndReturn(run func() bool) *MockWebView_IsFullscreen_Call {
2974 _c.Call.Return(run)
2975 return _c
2976}
2977
2978// IsLoading provides a mock function for the type MockWebView
2979func (_mock *MockWebView) IsLoading() bool {
2980 ret := _mock.Called()
2981
2982 if len(ret) == 0 {
2983 panic("no return value specified for IsLoading")
2984 }
2985
2986 var r0 bool
2987 if returnFunc, ok := ret.Get(0).(func() bool); ok {
2988 r0 = returnFunc()
2989 } else {
2990 r0 = ret.Get(0).(bool)
2991 }
2992 return r0
2993}
2994
2995// MockWebView_IsLoading_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsLoading'
2996type MockWebView_IsLoading_Call struct {
2997 *mock.Call
2998}
2999
3000// IsLoading is a helper method to define mock.On call
3001func (_e *MockWebView_Expecter) IsLoading() *MockWebView_IsLoading_Call {
3002 return &MockWebView_IsLoading_Call{Call: _e.mock.On("IsLoading")}
3003}
3004
3005func (_c *MockWebView_IsLoading_Call) Run(run func()) *MockWebView_IsLoading_Call {
3006 _c.Call.Run(func(args mock.Arguments) {
3007 run()
3008 })
3009 return _c
3010}
3011
3012func (_c *MockWebView_IsLoading_Call) Return(b bool) *MockWebView_IsLoading_Call {
3013 _c.Call.Return(b)
3014 return _c
3015}
3016
3017func (_c *MockWebView_IsLoading_Call) RunAndReturn(run func() bool) *MockWebView_IsLoading_Call {
3018 _c.Call.Return(run)
3019 return _c
3020}
3021
3022// IsPlayingAudio provides a mock function for the type MockWebView
3023func (_mock *MockWebView) IsPlayingAudio() bool {
3024 ret := _mock.Called()
3025
3026 if len(ret) == 0 {
3027 panic("no return value specified for IsPlayingAudio")
3028 }
3029
3030 var r0 bool
3031 if returnFunc, ok := ret.Get(0).(func() bool); ok {
3032 r0 = returnFunc()
3033 } else {
3034 r0 = ret.Get(0).(bool)
3035 }
3036 return r0
3037}
3038
3039// MockWebView_IsPlayingAudio_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsPlayingAudio'
3040type MockWebView_IsPlayingAudio_Call struct {
3041 *mock.Call
3042}
3043
3044// IsPlayingAudio is a helper method to define mock.On call
3045func (_e *MockWebView_Expecter) IsPlayingAudio() *MockWebView_IsPlayingAudio_Call {
3046 return &MockWebView_IsPlayingAudio_Call{Call: _e.mock.On("IsPlayingAudio")}
3047}
3048
3049func (_c *MockWebView_IsPlayingAudio_Call) Run(run func()) *MockWebView_IsPlayingAudio_Call {
3050 _c.Call.Run(func(args mock.Arguments) {
3051 run()
3052 })
3053 return _c
3054}
3055
3056func (_c *MockWebView_IsPlayingAudio_Call) Return(b bool) *MockWebView_IsPlayingAudio_Call {
3057 _c.Call.Return(b)
3058 return _c
3059}
3060
3061func (_c *MockWebView_IsPlayingAudio_Call) RunAndReturn(run func() bool) *MockWebView_IsPlayingAudio_Call {
3062 _c.Call.Return(run)
3063 return _c
3064}
3065
3066// LoadHTML provides a mock function for the type MockWebView
3067func (_mock *MockWebView) LoadHTML(ctx context.Context, content string, baseURI string) error {
3068 ret := _mock.Called(ctx, content, baseURI)
3069
3070 if len(ret) == 0 {
3071 panic("no return value specified for LoadHTML")
3072 }
3073
3074 var r0 error
3075 if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) error); ok {
3076 r0 = returnFunc(ctx, content, baseURI)
3077 } else {
3078 r0 = ret.Error(0)
3079 }
3080 return r0
3081}
3082
3083// MockWebView_LoadHTML_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LoadHTML'
3084type MockWebView_LoadHTML_Call struct {
3085 *mock.Call
3086}
3087
3088// LoadHTML is a helper method to define mock.On call
3089// - ctx context.Context
3090// - content string
3091// - baseURI string
3092func (_e *MockWebView_Expecter) LoadHTML(ctx interface{}, content interface{}, baseURI interface{}) *MockWebView_LoadHTML_Call {
3093 return &MockWebView_LoadHTML_Call{Call: _e.mock.On("LoadHTML", ctx, content, baseURI)}
3094}
3095
3096func (_c *MockWebView_LoadHTML_Call) Run(run func(ctx context.Context, content string, baseURI string)) *MockWebView_LoadHTML_Call {
3097 _c.Call.Run(func(args mock.Arguments) {
3098 var arg0 context.Context
3099 if args[0] != nil {
3100 arg0 = args[0].(context.Context)
3101 }
3102 var arg1 string
3103 if args[1] != nil {
3104 arg1 = args[1].(string)
3105 }
3106 var arg2 string
3107 if args[2] != nil {
3108 arg2 = args[2].(string)
3109 }
3110 run(
3111 arg0,
3112 arg1,
3113 arg2,
3114 )
3115 })
3116 return _c
3117}
3118
3119func (_c *MockWebView_LoadHTML_Call) Return(err error) *MockWebView_LoadHTML_Call {
3120 _c.Call.Return(err)
3121 return _c
3122}
3123
3124func (_c *MockWebView_LoadHTML_Call) RunAndReturn(run func(ctx context.Context, content string, baseURI string) error) *MockWebView_LoadHTML_Call {
3125 _c.Call.Return(run)
3126 return _c
3127}
3128
3129// LoadURI provides a mock function for the type MockWebView
3130func (_mock *MockWebView) LoadURI(ctx context.Context, uri string) error {
3131 ret := _mock.Called(ctx, uri)
3132
3133 if len(ret) == 0 {
3134 panic("no return value specified for LoadURI")
3135 }
3136
3137 var r0 error
3138 if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
3139 r0 = returnFunc(ctx, uri)
3140 } else {
3141 r0 = ret.Error(0)
3142 }
3143 return r0
3144}
3145
3146// MockWebView_LoadURI_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LoadURI'
3147type MockWebView_LoadURI_Call struct {
3148 *mock.Call
3149}
3150
3151// LoadURI is a helper method to define mock.On call
3152// - ctx context.Context
3153// - uri string
3154func (_e *MockWebView_Expecter) LoadURI(ctx interface{}, uri interface{}) *MockWebView_LoadURI_Call {
3155 return &MockWebView_LoadURI_Call{Call: _e.mock.On("LoadURI", ctx, uri)}
3156}
3157
3158func (_c *MockWebView_LoadURI_Call) Run(run func(ctx context.Context, uri string)) *MockWebView_LoadURI_Call {
3159 _c.Call.Run(func(args mock.Arguments) {
3160 var arg0 context.Context
3161 if args[0] != nil {
3162 arg0 = args[0].(context.Context)
3163 }
3164 var arg1 string
3165 if args[1] != nil {
3166 arg1 = args[1].(string)
3167 }
3168 run(
3169 arg0,
3170 arg1,
3171 )
3172 })
3173 return _c
3174}
3175
3176func (_c *MockWebView_LoadURI_Call) Return(err error) *MockWebView_LoadURI_Call {
3177 _c.Call.Return(err)
3178 return _c
3179}
3180
3181func (_c *MockWebView_LoadURI_Call) RunAndReturn(run func(ctx context.Context, uri string) error) *MockWebView_LoadURI_Call {
3182 _c.Call.Return(run)
3183 return _c
3184}
3185
3186// Reload provides a mock function for the type MockWebView
3187func (_mock *MockWebView) Reload(ctx context.Context) error {
3188 ret := _mock.Called(ctx)
3189
3190 if len(ret) == 0 {
3191 panic("no return value specified for Reload")
3192 }
3193
3194 var r0 error
3195 if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
3196 r0 = returnFunc(ctx)
3197 } else {
3198 r0 = ret.Error(0)
3199 }
3200 return r0
3201}
3202
3203// MockWebView_Reload_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Reload'
3204type MockWebView_Reload_Call struct {
3205 *mock.Call
3206}
3207
3208// Reload is a helper method to define mock.On call
3209// - ctx context.Context
3210func (_e *MockWebView_Expecter) Reload(ctx interface{}) *MockWebView_Reload_Call {
3211 return &MockWebView_Reload_Call{Call: _e.mock.On("Reload", ctx)}
3212}
3213
3214func (_c *MockWebView_Reload_Call) Run(run func(ctx context.Context)) *MockWebView_Reload_Call {
3215 _c.Call.Run(func(args mock.Arguments) {
3216 var arg0 context.Context
3217 if args[0] != nil {
3218 arg0 = args[0].(context.Context)
3219 }
3220 run(
3221 arg0,
3222 )
3223 })
3224 return _c
3225}
3226
3227func (_c *MockWebView_Reload_Call) Return(err error) *MockWebView_Reload_Call {
3228 _c.Call.Return(err)
3229 return _c
3230}
3231
3232func (_c *MockWebView_Reload_Call) RunAndReturn(run func(ctx context.Context) error) *MockWebView_Reload_Call {
3233 _c.Call.Return(run)
3234 return _c
3235}
3236
3237// ReloadBypassCache provides a mock function for the type MockWebView
3238func (_mock *MockWebView) ReloadBypassCache(ctx context.Context) error {
3239 ret := _mock.Called(ctx)
3240
3241 if len(ret) == 0 {
3242 panic("no return value specified for ReloadBypassCache")
3243 }
3244
3245 var r0 error
3246 if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
3247 r0 = returnFunc(ctx)
3248 } else {
3249 r0 = ret.Error(0)
3250 }
3251 return r0
3252}
3253
3254// MockWebView_ReloadBypassCache_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReloadBypassCache'
3255type MockWebView_ReloadBypassCache_Call struct {
3256 *mock.Call
3257}
3258
3259// ReloadBypassCache is a helper method to define mock.On call
3260// - ctx context.Context
3261func (_e *MockWebView_Expecter) ReloadBypassCache(ctx interface{}) *MockWebView_ReloadBypassCache_Call {
3262 return &MockWebView_ReloadBypassCache_Call{Call: _e.mock.On("ReloadBypassCache", ctx)}
3263}
3264
3265func (_c *MockWebView_ReloadBypassCache_Call) Run(run func(ctx context.Context)) *MockWebView_ReloadBypassCache_Call {
3266 _c.Call.Run(func(args mock.Arguments) {
3267 var arg0 context.Context
3268 if args[0] != nil {
3269 arg0 = args[0].(context.Context)
3270 }
3271 run(
3272 arg0,
3273 )
3274 })
3275 return _c
3276}
3277
3278func (_c *MockWebView_ReloadBypassCache_Call) Return(err error) *MockWebView_ReloadBypassCache_Call {
3279 _c.Call.Return(err)
3280 return _c
3281}
3282
3283func (_c *MockWebView_ReloadBypassCache_Call) RunAndReturn(run func(ctx context.Context) error) *MockWebView_ReloadBypassCache_Call {
3284 _c.Call.Return(run)
3285 return _c
3286}
3287
3288// SetCallbacks provides a mock function for the type MockWebView
3289func (_mock *MockWebView) SetCallbacks(callbacks *port.WebViewCallbacks) {
3290 _mock.Called(callbacks)
3291 return
3292}
3293
3294// MockWebView_SetCallbacks_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetCallbacks'
3295type MockWebView_SetCallbacks_Call struct {
3296 *mock.Call
3297}
3298
3299// SetCallbacks is a helper method to define mock.On call
3300// - callbacks *port.WebViewCallbacks
3301func (_e *MockWebView_Expecter) SetCallbacks(callbacks interface{}) *MockWebView_SetCallbacks_Call {
3302 return &MockWebView_SetCallbacks_Call{Call: _e.mock.On("SetCallbacks", callbacks)}
3303}
3304
3305func (_c *MockWebView_SetCallbacks_Call) Run(run func(callbacks *port.WebViewCallbacks)) *MockWebView_SetCallbacks_Call {
3306 _c.Call.Run(func(args mock.Arguments) {
3307 var arg0 *port.WebViewCallbacks
3308 if args[0] != nil {
3309 arg0 = args[0].(*port.WebViewCallbacks)
3310 }
3311 run(
3312 arg0,
3313 )
3314 })
3315 return _c
3316}
3317
3318func (_c *MockWebView_SetCallbacks_Call) Return() *MockWebView_SetCallbacks_Call {
3319 _c.Call.Return()
3320 return _c
3321}
3322
3323func (_c *MockWebView_SetCallbacks_Call) RunAndReturn(run func(callbacks *port.WebViewCallbacks)) *MockWebView_SetCallbacks_Call {
3324 _c.Run(run)
3325 return _c
3326}
3327
3328// SetZoomLevel provides a mock function for the type MockWebView
3329func (_mock *MockWebView) SetZoomLevel(ctx context.Context, level float64) error {
3330 ret := _mock.Called(ctx, level)
3331
3332 if len(ret) == 0 {
3333 panic("no return value specified for SetZoomLevel")
3334 }
3335
3336 var r0 error
3337 if returnFunc, ok := ret.Get(0).(func(context.Context, float64) error); ok {
3338 r0 = returnFunc(ctx, level)
3339 } else {
3340 r0 = ret.Error(0)
3341 }
3342 return r0
3343}
3344
3345// MockWebView_SetZoomLevel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetZoomLevel'
3346type MockWebView_SetZoomLevel_Call struct {
3347 *mock.Call
3348}
3349
3350// SetZoomLevel is a helper method to define mock.On call
3351// - ctx context.Context
3352// - level float64
3353func (_e *MockWebView_Expecter) SetZoomLevel(ctx interface{}, level interface{}) *MockWebView_SetZoomLevel_Call {
3354 return &MockWebView_SetZoomLevel_Call{Call: _e.mock.On("SetZoomLevel", ctx, level)}
3355}
3356
3357func (_c *MockWebView_SetZoomLevel_Call) Run(run func(ctx context.Context, level float64)) *MockWebView_SetZoomLevel_Call {
3358 _c.Call.Run(func(args mock.Arguments) {
3359 var arg0 context.Context
3360 if args[0] != nil {
3361 arg0 = args[0].(context.Context)
3362 }
3363 var arg1 float64
3364 if args[1] != nil {
3365 arg1 = args[1].(float64)
3366 }
3367 run(
3368 arg0,
3369 arg1,
3370 )
3371 })
3372 return _c
3373}
3374
3375func (_c *MockWebView_SetZoomLevel_Call) Return(err error) *MockWebView_SetZoomLevel_Call {
3376 _c.Call.Return(err)
3377 return _c
3378}
3379
3380func (_c *MockWebView_SetZoomLevel_Call) RunAndReturn(run func(ctx context.Context, level float64) error) *MockWebView_SetZoomLevel_Call {
3381 _c.Call.Return(run)
3382 return _c
3383}
3384
3385// State provides a mock function for the type MockWebView
3386func (_mock *MockWebView) State() port.WebViewState {
3387 ret := _mock.Called()
3388
3389 if len(ret) == 0 {
3390 panic("no return value specified for State")
3391 }
3392
3393 var r0 port.WebViewState
3394 if returnFunc, ok := ret.Get(0).(func() port.WebViewState); ok {
3395 r0 = returnFunc()
3396 } else {
3397 r0 = ret.Get(0).(port.WebViewState)
3398 }
3399 return r0
3400}
3401
3402// MockWebView_State_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'State'
3403type MockWebView_State_Call struct {
3404 *mock.Call
3405}
3406
3407// State is a helper method to define mock.On call
3408func (_e *MockWebView_Expecter) State() *MockWebView_State_Call {
3409 return &MockWebView_State_Call{Call: _e.mock.On("State")}
3410}
3411
3412func (_c *MockWebView_State_Call) Run(run func()) *MockWebView_State_Call {
3413 _c.Call.Run(func(args mock.Arguments) {
3414 run()
3415 })
3416 return _c
3417}
3418
3419func (_c *MockWebView_State_Call) Return(webViewState port.WebViewState) *MockWebView_State_Call {
3420 _c.Call.Return(webViewState)
3421 return _c
3422}
3423
3424func (_c *MockWebView_State_Call) RunAndReturn(run func() port.WebViewState) *MockWebView_State_Call {
3425 _c.Call.Return(run)
3426 return _c
3427}
3428
3429// Stop provides a mock function for the type MockWebView
3430func (_mock *MockWebView) Stop(ctx context.Context) error {
3431 ret := _mock.Called(ctx)
3432
3433 if len(ret) == 0 {
3434 panic("no return value specified for Stop")
3435 }
3436
3437 var r0 error
3438 if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
3439 r0 = returnFunc(ctx)
3440 } else {
3441 r0 = ret.Error(0)
3442 }
3443 return r0
3444}
3445
3446// MockWebView_Stop_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Stop'
3447type MockWebView_Stop_Call struct {
3448 *mock.Call
3449}
3450
3451// Stop is a helper method to define mock.On call
3452// - ctx context.Context
3453func (_e *MockWebView_Expecter) Stop(ctx interface{}) *MockWebView_Stop_Call {
3454 return &MockWebView_Stop_Call{Call: _e.mock.On("Stop", ctx)}
3455}
3456
3457func (_c *MockWebView_Stop_Call) Run(run func(ctx context.Context)) *MockWebView_Stop_Call {
3458 _c.Call.Run(func(args mock.Arguments) {
3459 var arg0 context.Context
3460 if args[0] != nil {
3461 arg0 = args[0].(context.Context)
3462 }
3463 run(
3464 arg0,
3465 )
3466 })
3467 return _c
3468}
3469
3470func (_c *MockWebView_Stop_Call) Return(err error) *MockWebView_Stop_Call {
3471 _c.Call.Return(err)
3472 return _c
3473}
3474
3475func (_c *MockWebView_Stop_Call) RunAndReturn(run func(ctx context.Context) error) *MockWebView_Stop_Call {
3476 _c.Call.Return(run)
3477 return _c
3478}
3479
3480// Title provides a mock function for the type MockWebView
3481func (_mock *MockWebView) Title() string {
3482 ret := _mock.Called()
3483
3484 if len(ret) == 0 {
3485 panic("no return value specified for Title")
3486 }
3487
3488 var r0 string
3489 if returnFunc, ok := ret.Get(0).(func() string); ok {
3490 r0 = returnFunc()
3491 } else {
3492 r0 = ret.Get(0).(string)
3493 }
3494 return r0
3495}
3496
3497// MockWebView_Title_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Title'
3498type MockWebView_Title_Call struct {
3499 *mock.Call
3500}
3501
3502// Title is a helper method to define mock.On call
3503func (_e *MockWebView_Expecter) Title() *MockWebView_Title_Call {
3504 return &MockWebView_Title_Call{Call: _e.mock.On("Title")}
3505}
3506
3507func (_c *MockWebView_Title_Call) Run(run func()) *MockWebView_Title_Call {
3508 _c.Call.Run(func(args mock.Arguments) {
3509 run()
3510 })
3511 return _c
3512}
3513
3514func (_c *MockWebView_Title_Call) Return(s string) *MockWebView_Title_Call {
3515 _c.Call.Return(s)
3516 return _c
3517}
3518
3519func (_c *MockWebView_Title_Call) RunAndReturn(run func() string) *MockWebView_Title_Call {
3520 _c.Call.Return(run)
3521 return _c
3522}
3523
3524// URI provides a mock function for the type MockWebView
3525func (_mock *MockWebView) URI() string {
3526 ret := _mock.Called()
3527
3528 if len(ret) == 0 {
3529 panic("no return value specified for URI")
3530 }
3531
3532 var r0 string
3533 if returnFunc, ok := ret.Get(0).(func() string); ok {
3534 r0 = returnFunc()
3535 } else {
3536 r0 = ret.Get(0).(string)
3537 }
3538 return r0
3539}
3540
3541// MockWebView_URI_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'URI'
3542type MockWebView_URI_Call struct {
3543 *mock.Call
3544}
3545
3546// URI is a helper method to define mock.On call
3547func (_e *MockWebView_Expecter) URI() *MockWebView_URI_Call {
3548 return &MockWebView_URI_Call{Call: _e.mock.On("URI")}
3549}
3550
3551func (_c *MockWebView_URI_Call) Run(run func()) *MockWebView_URI_Call {
3552 _c.Call.Run(func(args mock.Arguments) {
3553 run()
3554 })
3555 return _c
3556}
3557
3558func (_c *MockWebView_URI_Call) Return(s string) *MockWebView_URI_Call {
3559 _c.Call.Return(s)
3560 return _c
3561}
3562
3563func (_c *MockWebView_URI_Call) RunAndReturn(run func() string) *MockWebView_URI_Call {
3564 _c.Call.Return(run)
3565 return _c
3566}
3567
3568// 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.
3569// The first argument is typically a *testing.T value.
3570func NewMockWebViewPool(t interface {
3571 mock.TestingT
3572 Cleanup(func())
3573}) *MockWebViewPool {
3574 mock := &MockWebViewPool{}
3575 mock.Mock.Test(t)
3576
3577 t.Cleanup(func() { mock.AssertExpectations(t) })
3578
3579 return mock
3580}
3581
3582// MockWebViewPool is an autogenerated mock type for the WebViewPool type
3583type MockWebViewPool struct {
3584 mock.Mock
3585}
3586
3587type MockWebViewPool_Expecter struct {
3588 mock *mock.Mock
3589}
3590
3591func (_m *MockWebViewPool) EXPECT() *MockWebViewPool_Expecter {
3592 return &MockWebViewPool_Expecter{mock: &_m.Mock}
3593}
3594
3595// Acquire provides a mock function for the type MockWebViewPool
3596func (_mock *MockWebViewPool) Acquire(ctx context.Context) (port.WebView, error) {
3597 ret := _mock.Called(ctx)
3598
3599 if len(ret) == 0 {
3600 panic("no return value specified for Acquire")
3601 }
3602
3603 var r0 port.WebView
3604 var r1 error
3605 if returnFunc, ok := ret.Get(0).(func(context.Context) (port.WebView, error)); ok {
3606 return returnFunc(ctx)
3607 }
3608 if returnFunc, ok := ret.Get(0).(func(context.Context) port.WebView); ok {
3609 r0 = returnFunc(ctx)
3610 } else {
3611 if ret.Get(0) != nil {
3612 r0 = ret.Get(0).(port.WebView)
3613 }
3614 }
3615 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
3616 r1 = returnFunc(ctx)
3617 } else {
3618 r1 = ret.Error(1)
3619 }
3620 return r0, r1
3621}
3622
3623// MockWebViewPool_Acquire_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Acquire'
3624type MockWebViewPool_Acquire_Call struct {
3625 *mock.Call
3626}
3627
3628// Acquire is a helper method to define mock.On call
3629// - ctx context.Context
3630func (_e *MockWebViewPool_Expecter) Acquire(ctx interface{}) *MockWebViewPool_Acquire_Call {
3631 return &MockWebViewPool_Acquire_Call{Call: _e.mock.On("Acquire", ctx)}
3632}
3633
3634func (_c *MockWebViewPool_Acquire_Call) Run(run func(ctx context.Context)) *MockWebViewPool_Acquire_Call {
3635 _c.Call.Run(func(args mock.Arguments) {
3636 var arg0 context.Context
3637 if args[0] != nil {
3638 arg0 = args[0].(context.Context)
3639 }
3640 run(
3641 arg0,
3642 )
3643 })
3644 return _c
3645}
3646
3647func (_c *MockWebViewPool_Acquire_Call) Return(webView port.WebView, err error) *MockWebViewPool_Acquire_Call {
3648 _c.Call.Return(webView, err)
3649 return _c
3650}
3651
3652func (_c *MockWebViewPool_Acquire_Call) RunAndReturn(run func(ctx context.Context) (port.WebView, error)) *MockWebViewPool_Acquire_Call {
3653 _c.Call.Return(run)
3654 return _c
3655}
3656
3657// Close provides a mock function for the type MockWebViewPool
3658func (_mock *MockWebViewPool) Close() {
3659 _mock.Called()
3660 return
3661}
3662
3663// MockWebViewPool_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
3664type MockWebViewPool_Close_Call struct {
3665 *mock.Call
3666}
3667
3668// Close is a helper method to define mock.On call
3669func (_e *MockWebViewPool_Expecter) Close() *MockWebViewPool_Close_Call {
3670 return &MockWebViewPool_Close_Call{Call: _e.mock.On("Close")}
3671}
3672
3673func (_c *MockWebViewPool_Close_Call) Run(run func()) *MockWebViewPool_Close_Call {
3674 _c.Call.Run(func(args mock.Arguments) {
3675 run()
3676 })
3677 return _c
3678}
3679
3680func (_c *MockWebViewPool_Close_Call) Return() *MockWebViewPool_Close_Call {
3681 _c.Call.Return()
3682 return _c
3683}
3684
3685func (_c *MockWebViewPool_Close_Call) RunAndReturn(run func()) *MockWebViewPool_Close_Call {
3686 _c.Run(run)
3687 return _c
3688}
3689
3690// Prewarm provides a mock function for the type MockWebViewPool
3691func (_mock *MockWebViewPool) Prewarm(count int) {
3692 _mock.Called(count)
3693 return
3694}
3695
3696// MockWebViewPool_Prewarm_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Prewarm'
3697type MockWebViewPool_Prewarm_Call struct {
3698 *mock.Call
3699}
3700
3701// Prewarm is a helper method to define mock.On call
3702// - count int
3703func (_e *MockWebViewPool_Expecter) Prewarm(count interface{}) *MockWebViewPool_Prewarm_Call {
3704 return &MockWebViewPool_Prewarm_Call{Call: _e.mock.On("Prewarm", count)}
3705}
3706
3707func (_c *MockWebViewPool_Prewarm_Call) Run(run func(count int)) *MockWebViewPool_Prewarm_Call {
3708 _c.Call.Run(func(args mock.Arguments) {
3709 var arg0 int
3710 if args[0] != nil {
3711 arg0 = args[0].(int)
3712 }
3713 run(
3714 arg0,
3715 )
3716 })
3717 return _c
3718}
3719
3720func (_c *MockWebViewPool_Prewarm_Call) Return() *MockWebViewPool_Prewarm_Call {
3721 _c.Call.Return()
3722 return _c
3723}
3724
3725func (_c *MockWebViewPool_Prewarm_Call) RunAndReturn(run func(count int)) *MockWebViewPool_Prewarm_Call {
3726 _c.Run(run)
3727 return _c
3728}
3729
3730// Release provides a mock function for the type MockWebViewPool
3731func (_mock *MockWebViewPool) Release(wv port.WebView) {
3732 _mock.Called(wv)
3733 return
3734}
3735
3736// MockWebViewPool_Release_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Release'
3737type MockWebViewPool_Release_Call struct {
3738 *mock.Call
3739}
3740
3741// Release is a helper method to define mock.On call
3742// - wv port.WebView
3743func (_e *MockWebViewPool_Expecter) Release(wv interface{}) *MockWebViewPool_Release_Call {
3744 return &MockWebViewPool_Release_Call{Call: _e.mock.On("Release", wv)}
3745}
3746
3747func (_c *MockWebViewPool_Release_Call) Run(run func(wv port.WebView)) *MockWebViewPool_Release_Call {
3748 _c.Call.Run(func(args mock.Arguments) {
3749 var arg0 port.WebView
3750 if args[0] != nil {
3751 arg0 = args[0].(port.WebView)
3752 }
3753 run(
3754 arg0,
3755 )
3756 })
3757 return _c
3758}
3759
3760func (_c *MockWebViewPool_Release_Call) Return() *MockWebViewPool_Release_Call {
3761 _c.Call.Return()
3762 return _c
3763}
3764
3765func (_c *MockWebViewPool_Release_Call) RunAndReturn(run func(wv port.WebView)) *MockWebViewPool_Release_Call {
3766 _c.Run(run)
3767 return _c
3768}
3769
3770// Size provides a mock function for the type MockWebViewPool
3771func (_mock *MockWebViewPool) Size() int {
3772 ret := _mock.Called()
3773
3774 if len(ret) == 0 {
3775 panic("no return value specified for Size")
3776 }
3777
3778 var r0 int
3779 if returnFunc, ok := ret.Get(0).(func() int); ok {
3780 r0 = returnFunc()
3781 } else {
3782 r0 = ret.Get(0).(int)
3783 }
3784 return r0
3785}
3786
3787// MockWebViewPool_Size_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Size'
3788type MockWebViewPool_Size_Call struct {
3789 *mock.Call
3790}
3791
3792// Size is a helper method to define mock.On call
3793func (_e *MockWebViewPool_Expecter) Size() *MockWebViewPool_Size_Call {
3794 return &MockWebViewPool_Size_Call{Call: _e.mock.On("Size")}
3795}
3796
3797func (_c *MockWebViewPool_Size_Call) Run(run func()) *MockWebViewPool_Size_Call {
3798 _c.Call.Run(func(args mock.Arguments) {
3799 run()
3800 })
3801 return _c
3802}
3803
3804func (_c *MockWebViewPool_Size_Call) Return(n int) *MockWebViewPool_Size_Call {
3805 _c.Call.Return(n)
3806 return _c
3807}
3808
3809func (_c *MockWebViewPool_Size_Call) RunAndReturn(run func() int) *MockWebViewPool_Size_Call {
3810 _c.Call.Return(run)
3811 return _c
3812}
3813
3814// 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.
3815// The first argument is typically a *testing.T value.
3816func NewMockWebViewFactory(t interface {
3817 mock.TestingT
3818 Cleanup(func())
3819}) *MockWebViewFactory {
3820 mock := &MockWebViewFactory{}
3821 mock.Mock.Test(t)
3822
3823 t.Cleanup(func() { mock.AssertExpectations(t) })
3824
3825 return mock
3826}
3827
3828// MockWebViewFactory is an autogenerated mock type for the WebViewFactory type
3829type MockWebViewFactory struct {
3830 mock.Mock
3831}
3832
3833type MockWebViewFactory_Expecter struct {
3834 mock *mock.Mock
3835}
3836
3837func (_m *MockWebViewFactory) EXPECT() *MockWebViewFactory_Expecter {
3838 return &MockWebViewFactory_Expecter{mock: &_m.Mock}
3839}
3840
3841// Create provides a mock function for the type MockWebViewFactory
3842func (_mock *MockWebViewFactory) Create(ctx context.Context) (port.WebView, error) {
3843 ret := _mock.Called(ctx)
3844
3845 if len(ret) == 0 {
3846 panic("no return value specified for Create")
3847 }
3848
3849 var r0 port.WebView
3850 var r1 error
3851 if returnFunc, ok := ret.Get(0).(func(context.Context) (port.WebView, error)); ok {
3852 return returnFunc(ctx)
3853 }
3854 if returnFunc, ok := ret.Get(0).(func(context.Context) port.WebView); ok {
3855 r0 = returnFunc(ctx)
3856 } else {
3857 if ret.Get(0) != nil {
3858 r0 = ret.Get(0).(port.WebView)
3859 }
3860 }
3861 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
3862 r1 = returnFunc(ctx)
3863 } else {
3864 r1 = ret.Error(1)
3865 }
3866 return r0, r1
3867}
3868
3869// MockWebViewFactory_Create_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Create'
3870type MockWebViewFactory_Create_Call struct {
3871 *mock.Call
3872}
3873
3874// Create is a helper method to define mock.On call
3875// - ctx context.Context
3876func (_e *MockWebViewFactory_Expecter) Create(ctx interface{}) *MockWebViewFactory_Create_Call {
3877 return &MockWebViewFactory_Create_Call{Call: _e.mock.On("Create", ctx)}
3878}
3879
3880func (_c *MockWebViewFactory_Create_Call) Run(run func(ctx context.Context)) *MockWebViewFactory_Create_Call {
3881 _c.Call.Run(func(args mock.Arguments) {
3882 var arg0 context.Context
3883 if args[0] != nil {
3884 arg0 = args[0].(context.Context)
3885 }
3886 run(
3887 arg0,
3888 )
3889 })
3890 return _c
3891}
3892
3893func (_c *MockWebViewFactory_Create_Call) Return(webView port.WebView, err error) *MockWebViewFactory_Create_Call {
3894 _c.Call.Return(webView, err)
3895 return _c
3896}
3897
3898func (_c *MockWebViewFactory_Create_Call) RunAndReturn(run func(ctx context.Context) (port.WebView, error)) *MockWebViewFactory_Create_Call {
3899 _c.Call.Return(run)
3900 return _c
3901}
3902
3903// CreateRelated provides a mock function for the type MockWebViewFactory
3904func (_mock *MockWebViewFactory) CreateRelated(ctx context.Context, parentID port.WebViewID) (port.WebView, error) {
3905 ret := _mock.Called(ctx, parentID)
3906
3907 if len(ret) == 0 {
3908 panic("no return value specified for CreateRelated")
3909 }
3910
3911 var r0 port.WebView
3912 var r1 error
3913 if returnFunc, ok := ret.Get(0).(func(context.Context, port.WebViewID) (port.WebView, error)); ok {
3914 return returnFunc(ctx, parentID)
3915 }
3916 if returnFunc, ok := ret.Get(0).(func(context.Context, port.WebViewID) port.WebView); ok {
3917 r0 = returnFunc(ctx, parentID)
3918 } else {
3919 if ret.Get(0) != nil {
3920 r0 = ret.Get(0).(port.WebView)
3921 }
3922 }
3923 if returnFunc, ok := ret.Get(1).(func(context.Context, port.WebViewID) error); ok {
3924 r1 = returnFunc(ctx, parentID)
3925 } else {
3926 r1 = ret.Error(1)
3927 }
3928 return r0, r1
3929}
3930
3931// MockWebViewFactory_CreateRelated_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateRelated'
3932type MockWebViewFactory_CreateRelated_Call struct {
3933 *mock.Call
3934}
3935
3936// CreateRelated is a helper method to define mock.On call
3937// - ctx context.Context
3938// - parentID port.WebViewID
3939func (_e *MockWebViewFactory_Expecter) CreateRelated(ctx interface{}, parentID interface{}) *MockWebViewFactory_CreateRelated_Call {
3940 return &MockWebViewFactory_CreateRelated_Call{Call: _e.mock.On("CreateRelated", ctx, parentID)}
3941}
3942
3943func (_c *MockWebViewFactory_CreateRelated_Call) Run(run func(ctx context.Context, parentID port.WebViewID)) *MockWebViewFactory_CreateRelated_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 var arg1 port.WebViewID
3950 if args[1] != nil {
3951 arg1 = args[1].(port.WebViewID)
3952 }
3953 run(
3954 arg0,
3955 arg1,
3956 )
3957 })
3958 return _c
3959}
3960
3961func (_c *MockWebViewFactory_CreateRelated_Call) Return(webView port.WebView, err error) *MockWebViewFactory_CreateRelated_Call {
3962 _c.Call.Return(webView, err)
3963 return _c
3964}
3965
3966func (_c *MockWebViewFactory_CreateRelated_Call) RunAndReturn(run func(ctx context.Context, parentID port.WebViewID) (port.WebView, error)) *MockWebViewFactory_CreateRelated_Call {
3967 _c.Call.Return(run)
3968 return _c
3969}