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