1// Code generated by mockery; DO NOT EDIT.
2// github.com/vektra/mockery
3// template: testify
4
5package mocks
6
7import (
8 "context"
9
10 "github.com/bnema/dumber/internal/application/dto"
11 "github.com/bnema/dumber/internal/application/port"
12 mock "github.com/stretchr/testify/mock"
13)
14
15// NewMockTexture creates a new instance of MockTexture. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
16// The first argument is typically a *testing.T value.
17func NewMockTexture(t interface {
18 mock.TestingT
19 Cleanup(func())
20}) *MockTexture {
21 if helper, ok := t.(interface{ Helper() }); ok {
22 helper.Helper()
23 }
24
25 mock := &MockTexture{}
26 mock.Mock.Test(t)
27
28 t.Cleanup(func() {
29 if helper, ok := t.(interface{ Helper() }); ok {
30 helper.Helper()
31 }
32 mock.AssertExpectations(t)
33 })
34
35 return mock
36}
37
38// MockTexture is an autogenerated mock type for the Texture type
39type MockTexture struct {
40 mock.Mock
41}
42
43type MockTexture_Expecter struct {
44 mock *mock.Mock
45}
46
47func (_m *MockTexture) EXPECT() *MockTexture_Expecter {
48 return &MockTexture_Expecter{mock: &_m.Mock}
49}
50
51// GoPointer provides a mock function for the type MockTexture
52func (_mock *MockTexture) GoPointer() uintptr {
53 ret := _mock.Called()
54
55 if len(ret) == 0 {
56 panic("no return value specified for GoPointer")
57 }
58
59 var r0 uintptr
60 if returnFunc, ok := ret.Get(0).(func() uintptr); ok {
61 r0 = returnFunc()
62 } else {
63 r0 = ret.Get(0).(uintptr)
64 }
65 return r0
66}
67
68// MockTexture_GoPointer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GoPointer'
69type MockTexture_GoPointer_Call struct {
70 *mock.Call
71}
72
73// GoPointer is a helper method to define mock.On call
74func (_e *MockTexture_Expecter) GoPointer() *MockTexture_GoPointer_Call {
75 return &MockTexture_GoPointer_Call{Call: _e.mock.On("GoPointer")}
76}
77
78func (_c *MockTexture_GoPointer_Call) Run(run func()) *MockTexture_GoPointer_Call {
79 _c.Call.Run(func(args mock.Arguments) {
80 run()
81 })
82 return _c
83}
84
85func (_c *MockTexture_GoPointer_Call) Return(v uintptr) *MockTexture_GoPointer_Call {
86 _c.Call.Return(v)
87 return _c
88}
89
90func (_c *MockTexture_GoPointer_Call) RunAndReturn(run func() uintptr) *MockTexture_GoPointer_Call {
91 _c.Call.Return(run)
92 return _c
93}
94
95// NewMockFindController creates a new instance of MockFindController. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
96// The first argument is typically a *testing.T value.
97func NewMockFindController(t interface {
98 mock.TestingT
99 Cleanup(func())
100}) *MockFindController {
101 if helper, ok := t.(interface{ Helper() }); ok {
102 helper.Helper()
103 }
104
105 mock := &MockFindController{}
106 mock.Mock.Test(t)
107
108 t.Cleanup(func() {
109 if helper, ok := t.(interface{ Helper() }); ok {
110 helper.Helper()
111 }
112 mock.AssertExpectations(t)
113 })
114
115 return mock
116}
117
118// MockFindController is an autogenerated mock type for the FindController type
119type MockFindController struct {
120 mock.Mock
121}
122
123type MockFindController_Expecter struct {
124 mock *mock.Mock
125}
126
127func (_m *MockFindController) EXPECT() *MockFindController_Expecter {
128 return &MockFindController_Expecter{mock: &_m.Mock}
129}
130
131// CountMatches provides a mock function for the type MockFindController
132func (_mock *MockFindController) CountMatches(text string, options port.FindOptions, maxMatches uint) {
133 _mock.Called(text, options, maxMatches)
134 return
135}
136
137// MockFindController_CountMatches_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CountMatches'
138type MockFindController_CountMatches_Call struct {
139 *mock.Call
140}
141
142// CountMatches is a helper method to define mock.On call
143// - text string
144// - options port.FindOptions
145// - maxMatches uint
146func (_e *MockFindController_Expecter) CountMatches(text any, options any, maxMatches any) *MockFindController_CountMatches_Call {
147 return &MockFindController_CountMatches_Call{Call: _e.mock.On("CountMatches", text, options, maxMatches)}
148}
149
150func (_c *MockFindController_CountMatches_Call) Run(run func(text string, options port.FindOptions, maxMatches uint)) *MockFindController_CountMatches_Call {
151 _c.Call.Run(func(args mock.Arguments) {
152 var arg0 string
153 if args[0] != nil {
154 arg0 = args[0].(string)
155 }
156 var arg1 port.FindOptions
157 if args[1] != nil {
158 arg1 = args[1].(port.FindOptions)
159 }
160 var arg2 uint
161 if args[2] != nil {
162 arg2 = args[2].(uint)
163 }
164 run(
165 arg0,
166 arg1,
167 arg2,
168 )
169 })
170 return _c
171}
172
173func (_c *MockFindController_CountMatches_Call) Return() *MockFindController_CountMatches_Call {
174 _c.Call.Return()
175 return _c
176}
177
178func (_c *MockFindController_CountMatches_Call) RunAndReturn(run func(text string, options port.FindOptions, maxMatches uint)) *MockFindController_CountMatches_Call {
179 _c.Run(run)
180 return _c
181}
182
183// DisconnectSignal provides a mock function for the type MockFindController
184func (_mock *MockFindController) DisconnectSignal(id uint) {
185 _mock.Called(id)
186 return
187}
188
189// MockFindController_DisconnectSignal_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DisconnectSignal'
190type MockFindController_DisconnectSignal_Call struct {
191 *mock.Call
192}
193
194// DisconnectSignal is a helper method to define mock.On call
195// - id uint
196func (_e *MockFindController_Expecter) DisconnectSignal(id any) *MockFindController_DisconnectSignal_Call {
197 return &MockFindController_DisconnectSignal_Call{Call: _e.mock.On("DisconnectSignal", id)}
198}
199
200func (_c *MockFindController_DisconnectSignal_Call) Run(run func(id uint)) *MockFindController_DisconnectSignal_Call {
201 _c.Call.Run(func(args mock.Arguments) {
202 var arg0 uint
203 if args[0] != nil {
204 arg0 = args[0].(uint)
205 }
206 run(
207 arg0,
208 )
209 })
210 return _c
211}
212
213func (_c *MockFindController_DisconnectSignal_Call) Return() *MockFindController_DisconnectSignal_Call {
214 _c.Call.Return()
215 return _c
216}
217
218func (_c *MockFindController_DisconnectSignal_Call) RunAndReturn(run func(id uint)) *MockFindController_DisconnectSignal_Call {
219 _c.Run(run)
220 return _c
221}
222
223// GetSearchText provides a mock function for the type MockFindController
224func (_mock *MockFindController) GetSearchText() string {
225 ret := _mock.Called()
226
227 if len(ret) == 0 {
228 panic("no return value specified for GetSearchText")
229 }
230
231 var r0 string
232 if returnFunc, ok := ret.Get(0).(func() string); ok {
233 r0 = returnFunc()
234 } else {
235 r0 = ret.Get(0).(string)
236 }
237 return r0
238}
239
240// MockFindController_GetSearchText_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSearchText'
241type MockFindController_GetSearchText_Call struct {
242 *mock.Call
243}
244
245// GetSearchText is a helper method to define mock.On call
246func (_e *MockFindController_Expecter) GetSearchText() *MockFindController_GetSearchText_Call {
247 return &MockFindController_GetSearchText_Call{Call: _e.mock.On("GetSearchText")}
248}
249
250func (_c *MockFindController_GetSearchText_Call) Run(run func()) *MockFindController_GetSearchText_Call {
251 _c.Call.Run(func(args mock.Arguments) {
252 run()
253 })
254 return _c
255}
256
257func (_c *MockFindController_GetSearchText_Call) Return(s string) *MockFindController_GetSearchText_Call {
258 _c.Call.Return(s)
259 return _c
260}
261
262func (_c *MockFindController_GetSearchText_Call) RunAndReturn(run func() string) *MockFindController_GetSearchText_Call {
263 _c.Call.Return(run)
264 return _c
265}
266
267// OnCountedMatches provides a mock function for the type MockFindController
268func (_mock *MockFindController) OnCountedMatches(callback func(matchCount uint)) uint {
269 ret := _mock.Called(callback)
270
271 if len(ret) == 0 {
272 panic("no return value specified for OnCountedMatches")
273 }
274
275 var r0 uint
276 if returnFunc, ok := ret.Get(0).(func(func(matchCount uint)) uint); ok {
277 r0 = returnFunc(callback)
278 } else {
279 r0 = ret.Get(0).(uint)
280 }
281 return r0
282}
283
284// MockFindController_OnCountedMatches_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OnCountedMatches'
285type MockFindController_OnCountedMatches_Call struct {
286 *mock.Call
287}
288
289// OnCountedMatches is a helper method to define mock.On call
290// - callback func(matchCount uint)
291func (_e *MockFindController_Expecter) OnCountedMatches(callback any) *MockFindController_OnCountedMatches_Call {
292 return &MockFindController_OnCountedMatches_Call{Call: _e.mock.On("OnCountedMatches", callback)}
293}
294
295func (_c *MockFindController_OnCountedMatches_Call) Run(run func(callback func(matchCount uint))) *MockFindController_OnCountedMatches_Call {
296 _c.Call.Run(func(args mock.Arguments) {
297 var arg0 func(matchCount uint)
298 if args[0] != nil {
299 arg0 = args[0].(func(matchCount uint))
300 }
301 run(
302 arg0,
303 )
304 })
305 return _c
306}
307
308func (_c *MockFindController_OnCountedMatches_Call) Return(v uint) *MockFindController_OnCountedMatches_Call {
309 _c.Call.Return(v)
310 return _c
311}
312
313func (_c *MockFindController_OnCountedMatches_Call) RunAndReturn(run func(callback func(matchCount uint)) uint) *MockFindController_OnCountedMatches_Call {
314 _c.Call.Return(run)
315 return _c
316}
317
318// OnFailedToFindText provides a mock function for the type MockFindController
319func (_mock *MockFindController) OnFailedToFindText(callback func()) uint {
320 ret := _mock.Called(callback)
321
322 if len(ret) == 0 {
323 panic("no return value specified for OnFailedToFindText")
324 }
325
326 var r0 uint
327 if returnFunc, ok := ret.Get(0).(func(func()) uint); ok {
328 r0 = returnFunc(callback)
329 } else {
330 r0 = ret.Get(0).(uint)
331 }
332 return r0
333}
334
335// MockFindController_OnFailedToFindText_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OnFailedToFindText'
336type MockFindController_OnFailedToFindText_Call struct {
337 *mock.Call
338}
339
340// OnFailedToFindText is a helper method to define mock.On call
341// - callback func()
342func (_e *MockFindController_Expecter) OnFailedToFindText(callback any) *MockFindController_OnFailedToFindText_Call {
343 return &MockFindController_OnFailedToFindText_Call{Call: _e.mock.On("OnFailedToFindText", callback)}
344}
345
346func (_c *MockFindController_OnFailedToFindText_Call) Run(run func(callback func())) *MockFindController_OnFailedToFindText_Call {
347 _c.Call.Run(func(args mock.Arguments) {
348 var arg0 func()
349 if args[0] != nil {
350 arg0 = args[0].(func())
351 }
352 run(
353 arg0,
354 )
355 })
356 return _c
357}
358
359func (_c *MockFindController_OnFailedToFindText_Call) Return(v uint) *MockFindController_OnFailedToFindText_Call {
360 _c.Call.Return(v)
361 return _c
362}
363
364func (_c *MockFindController_OnFailedToFindText_Call) RunAndReturn(run func(callback func()) uint) *MockFindController_OnFailedToFindText_Call {
365 _c.Call.Return(run)
366 return _c
367}
368
369// OnFoundText provides a mock function for the type MockFindController
370func (_mock *MockFindController) OnFoundText(callback func(matchCount uint)) uint {
371 ret := _mock.Called(callback)
372
373 if len(ret) == 0 {
374 panic("no return value specified for OnFoundText")
375 }
376
377 var r0 uint
378 if returnFunc, ok := ret.Get(0).(func(func(matchCount uint)) uint); ok {
379 r0 = returnFunc(callback)
380 } else {
381 r0 = ret.Get(0).(uint)
382 }
383 return r0
384}
385
386// MockFindController_OnFoundText_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OnFoundText'
387type MockFindController_OnFoundText_Call struct {
388 *mock.Call
389}
390
391// OnFoundText is a helper method to define mock.On call
392// - callback func(matchCount uint)
393func (_e *MockFindController_Expecter) OnFoundText(callback any) *MockFindController_OnFoundText_Call {
394 return &MockFindController_OnFoundText_Call{Call: _e.mock.On("OnFoundText", callback)}
395}
396
397func (_c *MockFindController_OnFoundText_Call) Run(run func(callback func(matchCount uint))) *MockFindController_OnFoundText_Call {
398 _c.Call.Run(func(args mock.Arguments) {
399 var arg0 func(matchCount uint)
400 if args[0] != nil {
401 arg0 = args[0].(func(matchCount uint))
402 }
403 run(
404 arg0,
405 )
406 })
407 return _c
408}
409
410func (_c *MockFindController_OnFoundText_Call) Return(v uint) *MockFindController_OnFoundText_Call {
411 _c.Call.Return(v)
412 return _c
413}
414
415func (_c *MockFindController_OnFoundText_Call) RunAndReturn(run func(callback func(matchCount uint)) uint) *MockFindController_OnFoundText_Call {
416 _c.Call.Return(run)
417 return _c
418}
419
420// Search provides a mock function for the type MockFindController
421func (_mock *MockFindController) Search(text string, options port.FindOptions, maxMatches uint) {
422 _mock.Called(text, options, maxMatches)
423 return
424}
425
426// MockFindController_Search_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Search'
427type MockFindController_Search_Call struct {
428 *mock.Call
429}
430
431// Search is a helper method to define mock.On call
432// - text string
433// - options port.FindOptions
434// - maxMatches uint
435func (_e *MockFindController_Expecter) Search(text any, options any, maxMatches any) *MockFindController_Search_Call {
436 return &MockFindController_Search_Call{Call: _e.mock.On("Search", text, options, maxMatches)}
437}
438
439func (_c *MockFindController_Search_Call) Run(run func(text string, options port.FindOptions, maxMatches uint)) *MockFindController_Search_Call {
440 _c.Call.Run(func(args mock.Arguments) {
441 var arg0 string
442 if args[0] != nil {
443 arg0 = args[0].(string)
444 }
445 var arg1 port.FindOptions
446 if args[1] != nil {
447 arg1 = args[1].(port.FindOptions)
448 }
449 var arg2 uint
450 if args[2] != nil {
451 arg2 = args[2].(uint)
452 }
453 run(
454 arg0,
455 arg1,
456 arg2,
457 )
458 })
459 return _c
460}
461
462func (_c *MockFindController_Search_Call) Return() *MockFindController_Search_Call {
463 _c.Call.Return()
464 return _c
465}
466
467func (_c *MockFindController_Search_Call) RunAndReturn(run func(text string, options port.FindOptions, maxMatches uint)) *MockFindController_Search_Call {
468 _c.Run(run)
469 return _c
470}
471
472// SearchFinish provides a mock function for the type MockFindController
473func (_mock *MockFindController) SearchFinish() {
474 _mock.Called()
475 return
476}
477
478// MockFindController_SearchFinish_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SearchFinish'
479type MockFindController_SearchFinish_Call struct {
480 *mock.Call
481}
482
483// SearchFinish is a helper method to define mock.On call
484func (_e *MockFindController_Expecter) SearchFinish() *MockFindController_SearchFinish_Call {
485 return &MockFindController_SearchFinish_Call{Call: _e.mock.On("SearchFinish")}
486}
487
488func (_c *MockFindController_SearchFinish_Call) Run(run func()) *MockFindController_SearchFinish_Call {
489 _c.Call.Run(func(args mock.Arguments) {
490 run()
491 })
492 return _c
493}
494
495func (_c *MockFindController_SearchFinish_Call) Return() *MockFindController_SearchFinish_Call {
496 _c.Call.Return()
497 return _c
498}
499
500func (_c *MockFindController_SearchFinish_Call) RunAndReturn(run func()) *MockFindController_SearchFinish_Call {
501 _c.Run(run)
502 return _c
503}
504
505// SearchNext provides a mock function for the type MockFindController
506func (_mock *MockFindController) SearchNext() {
507 _mock.Called()
508 return
509}
510
511// MockFindController_SearchNext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SearchNext'
512type MockFindController_SearchNext_Call struct {
513 *mock.Call
514}
515
516// SearchNext is a helper method to define mock.On call
517func (_e *MockFindController_Expecter) SearchNext() *MockFindController_SearchNext_Call {
518 return &MockFindController_SearchNext_Call{Call: _e.mock.On("SearchNext")}
519}
520
521func (_c *MockFindController_SearchNext_Call) Run(run func()) *MockFindController_SearchNext_Call {
522 _c.Call.Run(func(args mock.Arguments) {
523 run()
524 })
525 return _c
526}
527
528func (_c *MockFindController_SearchNext_Call) Return() *MockFindController_SearchNext_Call {
529 _c.Call.Return()
530 return _c
531}
532
533func (_c *MockFindController_SearchNext_Call) RunAndReturn(run func()) *MockFindController_SearchNext_Call {
534 _c.Run(run)
535 return _c
536}
537
538// SearchPrevious provides a mock function for the type MockFindController
539func (_mock *MockFindController) SearchPrevious() {
540 _mock.Called()
541 return
542}
543
544// MockFindController_SearchPrevious_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SearchPrevious'
545type MockFindController_SearchPrevious_Call struct {
546 *mock.Call
547}
548
549// SearchPrevious is a helper method to define mock.On call
550func (_e *MockFindController_Expecter) SearchPrevious() *MockFindController_SearchPrevious_Call {
551 return &MockFindController_SearchPrevious_Call{Call: _e.mock.On("SearchPrevious")}
552}
553
554func (_c *MockFindController_SearchPrevious_Call) Run(run func()) *MockFindController_SearchPrevious_Call {
555 _c.Call.Run(func(args mock.Arguments) {
556 run()
557 })
558 return _c
559}
560
561func (_c *MockFindController_SearchPrevious_Call) Return() *MockFindController_SearchPrevious_Call {
562 _c.Call.Return()
563 return _c
564}
565
566func (_c *MockFindController_SearchPrevious_Call) RunAndReturn(run func()) *MockFindController_SearchPrevious_Call {
567 _c.Run(run)
568 return _c
569}
570
571// NewMockPageNavigator creates a new instance of MockPageNavigator. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
572// The first argument is typically a *testing.T value.
573func NewMockPageNavigator(t interface {
574 mock.TestingT
575 Cleanup(func())
576}) *MockPageNavigator {
577 if helper, ok := t.(interface{ Helper() }); ok {
578 helper.Helper()
579 }
580
581 mock := &MockPageNavigator{}
582 mock.Mock.Test(t)
583
584 t.Cleanup(func() {
585 if helper, ok := t.(interface{ Helper() }); ok {
586 helper.Helper()
587 }
588 mock.AssertExpectations(t)
589 })
590
591 return mock
592}
593
594// MockPageNavigator is an autogenerated mock type for the PageNavigator type
595type MockPageNavigator struct {
596 mock.Mock
597}
598
599type MockPageNavigator_Expecter struct {
600 mock *mock.Mock
601}
602
603func (_m *MockPageNavigator) EXPECT() *MockPageNavigator_Expecter {
604 return &MockPageNavigator_Expecter{mock: &_m.Mock}
605}
606
607// GoBack provides a mock function for the type MockPageNavigator
608func (_mock *MockPageNavigator) GoBack(ctx context.Context) error {
609 ret := _mock.Called(ctx)
610
611 if len(ret) == 0 {
612 panic("no return value specified for GoBack")
613 }
614
615 var r0 error
616 if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
617 r0 = returnFunc(ctx)
618 } else {
619 r0 = ret.Error(0)
620 }
621 return r0
622}
623
624// MockPageNavigator_GoBack_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GoBack'
625type MockPageNavigator_GoBack_Call struct {
626 *mock.Call
627}
628
629// GoBack is a helper method to define mock.On call
630// - ctx context.Context
631func (_e *MockPageNavigator_Expecter) GoBack(ctx any) *MockPageNavigator_GoBack_Call {
632 return &MockPageNavigator_GoBack_Call{Call: _e.mock.On("GoBack", ctx)}
633}
634
635func (_c *MockPageNavigator_GoBack_Call) Run(run func(ctx context.Context)) *MockPageNavigator_GoBack_Call {
636 _c.Call.Run(func(args mock.Arguments) {
637 var arg0 context.Context
638 if args[0] != nil {
639 arg0 = args[0].(context.Context)
640 }
641 run(
642 arg0,
643 )
644 })
645 return _c
646}
647
648func (_c *MockPageNavigator_GoBack_Call) Return(err error) *MockPageNavigator_GoBack_Call {
649 _c.Call.Return(err)
650 return _c
651}
652
653func (_c *MockPageNavigator_GoBack_Call) RunAndReturn(run func(ctx context.Context) error) *MockPageNavigator_GoBack_Call {
654 _c.Call.Return(run)
655 return _c
656}
657
658// GoForward provides a mock function for the type MockPageNavigator
659func (_mock *MockPageNavigator) GoForward(ctx context.Context) error {
660 ret := _mock.Called(ctx)
661
662 if len(ret) == 0 {
663 panic("no return value specified for GoForward")
664 }
665
666 var r0 error
667 if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
668 r0 = returnFunc(ctx)
669 } else {
670 r0 = ret.Error(0)
671 }
672 return r0
673}
674
675// MockPageNavigator_GoForward_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GoForward'
676type MockPageNavigator_GoForward_Call struct {
677 *mock.Call
678}
679
680// GoForward is a helper method to define mock.On call
681// - ctx context.Context
682func (_e *MockPageNavigator_Expecter) GoForward(ctx any) *MockPageNavigator_GoForward_Call {
683 return &MockPageNavigator_GoForward_Call{Call: _e.mock.On("GoForward", ctx)}
684}
685
686func (_c *MockPageNavigator_GoForward_Call) Run(run func(ctx context.Context)) *MockPageNavigator_GoForward_Call {
687 _c.Call.Run(func(args mock.Arguments) {
688 var arg0 context.Context
689 if args[0] != nil {
690 arg0 = args[0].(context.Context)
691 }
692 run(
693 arg0,
694 )
695 })
696 return _c
697}
698
699func (_c *MockPageNavigator_GoForward_Call) Return(err error) *MockPageNavigator_GoForward_Call {
700 _c.Call.Return(err)
701 return _c
702}
703
704func (_c *MockPageNavigator_GoForward_Call) RunAndReturn(run func(ctx context.Context) error) *MockPageNavigator_GoForward_Call {
705 _c.Call.Return(run)
706 return _c
707}
708
709// LoadHTML provides a mock function for the type MockPageNavigator
710func (_mock *MockPageNavigator) LoadHTML(ctx context.Context, content string, baseURI string) error {
711 ret := _mock.Called(ctx, content, baseURI)
712
713 if len(ret) == 0 {
714 panic("no return value specified for LoadHTML")
715 }
716
717 var r0 error
718 if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) error); ok {
719 r0 = returnFunc(ctx, content, baseURI)
720 } else {
721 r0 = ret.Error(0)
722 }
723 return r0
724}
725
726// MockPageNavigator_LoadHTML_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LoadHTML'
727type MockPageNavigator_LoadHTML_Call struct {
728 *mock.Call
729}
730
731// LoadHTML is a helper method to define mock.On call
732// - ctx context.Context
733// - content string
734// - baseURI string
735func (_e *MockPageNavigator_Expecter) LoadHTML(ctx any, content any, baseURI any) *MockPageNavigator_LoadHTML_Call {
736 return &MockPageNavigator_LoadHTML_Call{Call: _e.mock.On("LoadHTML", ctx, content, baseURI)}
737}
738
739func (_c *MockPageNavigator_LoadHTML_Call) Run(run func(ctx context.Context, content string, baseURI string)) *MockPageNavigator_LoadHTML_Call {
740 _c.Call.Run(func(args mock.Arguments) {
741 var arg0 context.Context
742 if args[0] != nil {
743 arg0 = args[0].(context.Context)
744 }
745 var arg1 string
746 if args[1] != nil {
747 arg1 = args[1].(string)
748 }
749 var arg2 string
750 if args[2] != nil {
751 arg2 = args[2].(string)
752 }
753 run(
754 arg0,
755 arg1,
756 arg2,
757 )
758 })
759 return _c
760}
761
762func (_c *MockPageNavigator_LoadHTML_Call) Return(err error) *MockPageNavigator_LoadHTML_Call {
763 _c.Call.Return(err)
764 return _c
765}
766
767func (_c *MockPageNavigator_LoadHTML_Call) RunAndReturn(run func(ctx context.Context, content string, baseURI string) error) *MockPageNavigator_LoadHTML_Call {
768 _c.Call.Return(run)
769 return _c
770}
771
772// LoadURI provides a mock function for the type MockPageNavigator
773func (_mock *MockPageNavigator) LoadURI(ctx context.Context, uri string) error {
774 ret := _mock.Called(ctx, uri)
775
776 if len(ret) == 0 {
777 panic("no return value specified for LoadURI")
778 }
779
780 var r0 error
781 if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
782 r0 = returnFunc(ctx, uri)
783 } else {
784 r0 = ret.Error(0)
785 }
786 return r0
787}
788
789// MockPageNavigator_LoadURI_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LoadURI'
790type MockPageNavigator_LoadURI_Call struct {
791 *mock.Call
792}
793
794// LoadURI is a helper method to define mock.On call
795// - ctx context.Context
796// - uri string
797func (_e *MockPageNavigator_Expecter) LoadURI(ctx any, uri any) *MockPageNavigator_LoadURI_Call {
798 return &MockPageNavigator_LoadURI_Call{Call: _e.mock.On("LoadURI", ctx, uri)}
799}
800
801func (_c *MockPageNavigator_LoadURI_Call) Run(run func(ctx context.Context, uri string)) *MockPageNavigator_LoadURI_Call {
802 _c.Call.Run(func(args mock.Arguments) {
803 var arg0 context.Context
804 if args[0] != nil {
805 arg0 = args[0].(context.Context)
806 }
807 var arg1 string
808 if args[1] != nil {
809 arg1 = args[1].(string)
810 }
811 run(
812 arg0,
813 arg1,
814 )
815 })
816 return _c
817}
818
819func (_c *MockPageNavigator_LoadURI_Call) Return(err error) *MockPageNavigator_LoadURI_Call {
820 _c.Call.Return(err)
821 return _c
822}
823
824func (_c *MockPageNavigator_LoadURI_Call) RunAndReturn(run func(ctx context.Context, uri string) error) *MockPageNavigator_LoadURI_Call {
825 _c.Call.Return(run)
826 return _c
827}
828
829// Reload provides a mock function for the type MockPageNavigator
830func (_mock *MockPageNavigator) Reload(ctx context.Context) error {
831 ret := _mock.Called(ctx)
832
833 if len(ret) == 0 {
834 panic("no return value specified for Reload")
835 }
836
837 var r0 error
838 if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
839 r0 = returnFunc(ctx)
840 } else {
841 r0 = ret.Error(0)
842 }
843 return r0
844}
845
846// MockPageNavigator_Reload_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Reload'
847type MockPageNavigator_Reload_Call struct {
848 *mock.Call
849}
850
851// Reload is a helper method to define mock.On call
852// - ctx context.Context
853func (_e *MockPageNavigator_Expecter) Reload(ctx any) *MockPageNavigator_Reload_Call {
854 return &MockPageNavigator_Reload_Call{Call: _e.mock.On("Reload", ctx)}
855}
856
857func (_c *MockPageNavigator_Reload_Call) Run(run func(ctx context.Context)) *MockPageNavigator_Reload_Call {
858 _c.Call.Run(func(args mock.Arguments) {
859 var arg0 context.Context
860 if args[0] != nil {
861 arg0 = args[0].(context.Context)
862 }
863 run(
864 arg0,
865 )
866 })
867 return _c
868}
869
870func (_c *MockPageNavigator_Reload_Call) Return(err error) *MockPageNavigator_Reload_Call {
871 _c.Call.Return(err)
872 return _c
873}
874
875func (_c *MockPageNavigator_Reload_Call) RunAndReturn(run func(ctx context.Context) error) *MockPageNavigator_Reload_Call {
876 _c.Call.Return(run)
877 return _c
878}
879
880// ReloadBypassCache provides a mock function for the type MockPageNavigator
881func (_mock *MockPageNavigator) ReloadBypassCache(ctx context.Context) error {
882 ret := _mock.Called(ctx)
883
884 if len(ret) == 0 {
885 panic("no return value specified for ReloadBypassCache")
886 }
887
888 var r0 error
889 if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
890 r0 = returnFunc(ctx)
891 } else {
892 r0 = ret.Error(0)
893 }
894 return r0
895}
896
897// MockPageNavigator_ReloadBypassCache_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReloadBypassCache'
898type MockPageNavigator_ReloadBypassCache_Call struct {
899 *mock.Call
900}
901
902// ReloadBypassCache is a helper method to define mock.On call
903// - ctx context.Context
904func (_e *MockPageNavigator_Expecter) ReloadBypassCache(ctx any) *MockPageNavigator_ReloadBypassCache_Call {
905 return &MockPageNavigator_ReloadBypassCache_Call{Call: _e.mock.On("ReloadBypassCache", ctx)}
906}
907
908func (_c *MockPageNavigator_ReloadBypassCache_Call) Run(run func(ctx context.Context)) *MockPageNavigator_ReloadBypassCache_Call {
909 _c.Call.Run(func(args mock.Arguments) {
910 var arg0 context.Context
911 if args[0] != nil {
912 arg0 = args[0].(context.Context)
913 }
914 run(
915 arg0,
916 )
917 })
918 return _c
919}
920
921func (_c *MockPageNavigator_ReloadBypassCache_Call) Return(err error) *MockPageNavigator_ReloadBypassCache_Call {
922 _c.Call.Return(err)
923 return _c
924}
925
926func (_c *MockPageNavigator_ReloadBypassCache_Call) RunAndReturn(run func(ctx context.Context) error) *MockPageNavigator_ReloadBypassCache_Call {
927 _c.Call.Return(run)
928 return _c
929}
930
931// Stop provides a mock function for the type MockPageNavigator
932func (_mock *MockPageNavigator) Stop(ctx context.Context) error {
933 ret := _mock.Called(ctx)
934
935 if len(ret) == 0 {
936 panic("no return value specified for Stop")
937 }
938
939 var r0 error
940 if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
941 r0 = returnFunc(ctx)
942 } else {
943 r0 = ret.Error(0)
944 }
945 return r0
946}
947
948// MockPageNavigator_Stop_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Stop'
949type MockPageNavigator_Stop_Call struct {
950 *mock.Call
951}
952
953// Stop is a helper method to define mock.On call
954// - ctx context.Context
955func (_e *MockPageNavigator_Expecter) Stop(ctx any) *MockPageNavigator_Stop_Call {
956 return &MockPageNavigator_Stop_Call{Call: _e.mock.On("Stop", ctx)}
957}
958
959func (_c *MockPageNavigator_Stop_Call) Run(run func(ctx context.Context)) *MockPageNavigator_Stop_Call {
960 _c.Call.Run(func(args mock.Arguments) {
961 var arg0 context.Context
962 if args[0] != nil {
963 arg0 = args[0].(context.Context)
964 }
965 run(
966 arg0,
967 )
968 })
969 return _c
970}
971
972func (_c *MockPageNavigator_Stop_Call) Return(err error) *MockPageNavigator_Stop_Call {
973 _c.Call.Return(err)
974 return _c
975}
976
977func (_c *MockPageNavigator_Stop_Call) RunAndReturn(run func(ctx context.Context) error) *MockPageNavigator_Stop_Call {
978 _c.Call.Return(run)
979 return _c
980}
981
982// 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.
983// The first argument is typically a *testing.T value.
984func NewMockWebView(t interface {
985 mock.TestingT
986 Cleanup(func())
987}) *MockWebView {
988 if helper, ok := t.(interface{ Helper() }); ok {
989 helper.Helper()
990 }
991
992 mock := &MockWebView{}
993 mock.Mock.Test(t)
994
995 t.Cleanup(func() {
996 if helper, ok := t.(interface{ Helper() }); ok {
997 helper.Helper()
998 }
999 mock.AssertExpectations(t)
1000 })
1001
1002 return mock
1003}
1004
1005// MockWebView is an autogenerated mock type for the WebView type
1006type MockWebView struct {
1007 mock.Mock
1008}
1009
1010type MockWebView_Expecter struct {
1011 mock *mock.Mock
1012}
1013
1014func (_m *MockWebView) EXPECT() *MockWebView_Expecter {
1015 return &MockWebView_Expecter{mock: &_m.Mock}
1016}
1017
1018// CanGoBack provides a mock function for the type MockWebView
1019func (_mock *MockWebView) CanGoBack() bool {
1020 ret := _mock.Called()
1021
1022 if len(ret) == 0 {
1023 panic("no return value specified for CanGoBack")
1024 }
1025
1026 var r0 bool
1027 if returnFunc, ok := ret.Get(0).(func() bool); ok {
1028 r0 = returnFunc()
1029 } else {
1030 r0 = ret.Get(0).(bool)
1031 }
1032 return r0
1033}
1034
1035// MockWebView_CanGoBack_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CanGoBack'
1036type MockWebView_CanGoBack_Call struct {
1037 *mock.Call
1038}
1039
1040// CanGoBack is a helper method to define mock.On call
1041func (_e *MockWebView_Expecter) CanGoBack() *MockWebView_CanGoBack_Call {
1042 return &MockWebView_CanGoBack_Call{Call: _e.mock.On("CanGoBack")}
1043}
1044
1045func (_c *MockWebView_CanGoBack_Call) Run(run func()) *MockWebView_CanGoBack_Call {
1046 _c.Call.Run(func(args mock.Arguments) {
1047 run()
1048 })
1049 return _c
1050}
1051
1052func (_c *MockWebView_CanGoBack_Call) Return(b bool) *MockWebView_CanGoBack_Call {
1053 _c.Call.Return(b)
1054 return _c
1055}
1056
1057func (_c *MockWebView_CanGoBack_Call) RunAndReturn(run func() bool) *MockWebView_CanGoBack_Call {
1058 _c.Call.Return(run)
1059 return _c
1060}
1061
1062// CanGoForward provides a mock function for the type MockWebView
1063func (_mock *MockWebView) CanGoForward() bool {
1064 ret := _mock.Called()
1065
1066 if len(ret) == 0 {
1067 panic("no return value specified for CanGoForward")
1068 }
1069
1070 var r0 bool
1071 if returnFunc, ok := ret.Get(0).(func() bool); ok {
1072 r0 = returnFunc()
1073 } else {
1074 r0 = ret.Get(0).(bool)
1075 }
1076 return r0
1077}
1078
1079// MockWebView_CanGoForward_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CanGoForward'
1080type MockWebView_CanGoForward_Call struct {
1081 *mock.Call
1082}
1083
1084// CanGoForward is a helper method to define mock.On call
1085func (_e *MockWebView_Expecter) CanGoForward() *MockWebView_CanGoForward_Call {
1086 return &MockWebView_CanGoForward_Call{Call: _e.mock.On("CanGoForward")}
1087}
1088
1089func (_c *MockWebView_CanGoForward_Call) Run(run func()) *MockWebView_CanGoForward_Call {
1090 _c.Call.Run(func(args mock.Arguments) {
1091 run()
1092 })
1093 return _c
1094}
1095
1096func (_c *MockWebView_CanGoForward_Call) Return(b bool) *MockWebView_CanGoForward_Call {
1097 _c.Call.Return(b)
1098 return _c
1099}
1100
1101func (_c *MockWebView_CanGoForward_Call) RunAndReturn(run func() bool) *MockWebView_CanGoForward_Call {
1102 _c.Call.Return(run)
1103 return _c
1104}
1105
1106// Destroy provides a mock function for the type MockWebView
1107func (_mock *MockWebView) Destroy() {
1108 _mock.Called()
1109 return
1110}
1111
1112// MockWebView_Destroy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Destroy'
1113type MockWebView_Destroy_Call struct {
1114 *mock.Call
1115}
1116
1117// Destroy is a helper method to define mock.On call
1118func (_e *MockWebView_Expecter) Destroy() *MockWebView_Destroy_Call {
1119 return &MockWebView_Destroy_Call{Call: _e.mock.On("Destroy")}
1120}
1121
1122func (_c *MockWebView_Destroy_Call) Run(run func()) *MockWebView_Destroy_Call {
1123 _c.Call.Run(func(args mock.Arguments) {
1124 run()
1125 })
1126 return _c
1127}
1128
1129func (_c *MockWebView_Destroy_Call) Return() *MockWebView_Destroy_Call {
1130 _c.Call.Return()
1131 return _c
1132}
1133
1134func (_c *MockWebView_Destroy_Call) RunAndReturn(run func()) *MockWebView_Destroy_Call {
1135 _c.Run(run)
1136 return _c
1137}
1138
1139// EstimatedProgress provides a mock function for the type MockWebView
1140func (_mock *MockWebView) EstimatedProgress() float64 {
1141 ret := _mock.Called()
1142
1143 if len(ret) == 0 {
1144 panic("no return value specified for EstimatedProgress")
1145 }
1146
1147 var r0 float64
1148 if returnFunc, ok := ret.Get(0).(func() float64); ok {
1149 r0 = returnFunc()
1150 } else {
1151 r0 = ret.Get(0).(float64)
1152 }
1153 return r0
1154}
1155
1156// MockWebView_EstimatedProgress_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EstimatedProgress'
1157type MockWebView_EstimatedProgress_Call struct {
1158 *mock.Call
1159}
1160
1161// EstimatedProgress is a helper method to define mock.On call
1162func (_e *MockWebView_Expecter) EstimatedProgress() *MockWebView_EstimatedProgress_Call {
1163 return &MockWebView_EstimatedProgress_Call{Call: _e.mock.On("EstimatedProgress")}
1164}
1165
1166func (_c *MockWebView_EstimatedProgress_Call) Run(run func()) *MockWebView_EstimatedProgress_Call {
1167 _c.Call.Run(func(args mock.Arguments) {
1168 run()
1169 })
1170 return _c
1171}
1172
1173func (_c *MockWebView_EstimatedProgress_Call) Return(f float64) *MockWebView_EstimatedProgress_Call {
1174 _c.Call.Return(f)
1175 return _c
1176}
1177
1178func (_c *MockWebView_EstimatedProgress_Call) RunAndReturn(run func() float64) *MockWebView_EstimatedProgress_Call {
1179 _c.Call.Return(run)
1180 return _c
1181}
1182
1183// Favicon provides a mock function for the type MockWebView
1184func (_mock *MockWebView) Favicon() port.Texture {
1185 ret := _mock.Called()
1186
1187 if len(ret) == 0 {
1188 panic("no return value specified for Favicon")
1189 }
1190
1191 var r0 port.Texture
1192 if returnFunc, ok := ret.Get(0).(func() port.Texture); ok {
1193 r0 = returnFunc()
1194 } else {
1195 if ret.Get(0) != nil {
1196 r0 = ret.Get(0).(port.Texture)
1197 }
1198 }
1199 return r0
1200}
1201
1202// MockWebView_Favicon_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Favicon'
1203type MockWebView_Favicon_Call struct {
1204 *mock.Call
1205}
1206
1207// Favicon is a helper method to define mock.On call
1208func (_e *MockWebView_Expecter) Favicon() *MockWebView_Favicon_Call {
1209 return &MockWebView_Favicon_Call{Call: _e.mock.On("Favicon")}
1210}
1211
1212func (_c *MockWebView_Favicon_Call) Run(run func()) *MockWebView_Favicon_Call {
1213 _c.Call.Run(func(args mock.Arguments) {
1214 run()
1215 })
1216 return _c
1217}
1218
1219func (_c *MockWebView_Favicon_Call) Return(texture port.Texture) *MockWebView_Favicon_Call {
1220 _c.Call.Return(texture)
1221 return _c
1222}
1223
1224func (_c *MockWebView_Favicon_Call) RunAndReturn(run func() port.Texture) *MockWebView_Favicon_Call {
1225 _c.Call.Return(run)
1226 return _c
1227}
1228
1229// Generation provides a mock function for the type MockWebView
1230func (_mock *MockWebView) Generation() uint64 {
1231 ret := _mock.Called()
1232
1233 if len(ret) == 0 {
1234 panic("no return value specified for Generation")
1235 }
1236
1237 var r0 uint64
1238 if returnFunc, ok := ret.Get(0).(func() uint64); ok {
1239 r0 = returnFunc()
1240 } else {
1241 r0 = ret.Get(0).(uint64)
1242 }
1243 return r0
1244}
1245
1246// MockWebView_Generation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Generation'
1247type MockWebView_Generation_Call struct {
1248 *mock.Call
1249}
1250
1251// Generation is a helper method to define mock.On call
1252func (_e *MockWebView_Expecter) Generation() *MockWebView_Generation_Call {
1253 return &MockWebView_Generation_Call{Call: _e.mock.On("Generation")}
1254}
1255
1256func (_c *MockWebView_Generation_Call) Run(run func()) *MockWebView_Generation_Call {
1257 _c.Call.Run(func(args mock.Arguments) {
1258 run()
1259 })
1260 return _c
1261}
1262
1263func (_c *MockWebView_Generation_Call) Return(v uint64) *MockWebView_Generation_Call {
1264 _c.Call.Return(v)
1265 return _c
1266}
1267
1268func (_c *MockWebView_Generation_Call) RunAndReturn(run func() uint64) *MockWebView_Generation_Call {
1269 _c.Call.Return(run)
1270 return _c
1271}
1272
1273// GetFindController provides a mock function for the type MockWebView
1274func (_mock *MockWebView) GetFindController() port.FindController {
1275 ret := _mock.Called()
1276
1277 if len(ret) == 0 {
1278 panic("no return value specified for GetFindController")
1279 }
1280
1281 var r0 port.FindController
1282 if returnFunc, ok := ret.Get(0).(func() port.FindController); ok {
1283 r0 = returnFunc()
1284 } else {
1285 if ret.Get(0) != nil {
1286 r0 = ret.Get(0).(port.FindController)
1287 }
1288 }
1289 return r0
1290}
1291
1292// MockWebView_GetFindController_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetFindController'
1293type MockWebView_GetFindController_Call struct {
1294 *mock.Call
1295}
1296
1297// GetFindController is a helper method to define mock.On call
1298func (_e *MockWebView_Expecter) GetFindController() *MockWebView_GetFindController_Call {
1299 return &MockWebView_GetFindController_Call{Call: _e.mock.On("GetFindController")}
1300}
1301
1302func (_c *MockWebView_GetFindController_Call) Run(run func()) *MockWebView_GetFindController_Call {
1303 _c.Call.Run(func(args mock.Arguments) {
1304 run()
1305 })
1306 return _c
1307}
1308
1309func (_c *MockWebView_GetFindController_Call) Return(findController port.FindController) *MockWebView_GetFindController_Call {
1310 _c.Call.Return(findController)
1311 return _c
1312}
1313
1314func (_c *MockWebView_GetFindController_Call) RunAndReturn(run func() port.FindController) *MockWebView_GetFindController_Call {
1315 _c.Call.Return(run)
1316 return _c
1317}
1318
1319// GetZoomLevel provides a mock function for the type MockWebView
1320func (_mock *MockWebView) GetZoomLevel() float64 {
1321 ret := _mock.Called()
1322
1323 if len(ret) == 0 {
1324 panic("no return value specified for GetZoomLevel")
1325 }
1326
1327 var r0 float64
1328 if returnFunc, ok := ret.Get(0).(func() float64); ok {
1329 r0 = returnFunc()
1330 } else {
1331 r0 = ret.Get(0).(float64)
1332 }
1333 return r0
1334}
1335
1336// MockWebView_GetZoomLevel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetZoomLevel'
1337type MockWebView_GetZoomLevel_Call struct {
1338 *mock.Call
1339}
1340
1341// GetZoomLevel is a helper method to define mock.On call
1342func (_e *MockWebView_Expecter) GetZoomLevel() *MockWebView_GetZoomLevel_Call {
1343 return &MockWebView_GetZoomLevel_Call{Call: _e.mock.On("GetZoomLevel")}
1344}
1345
1346func (_c *MockWebView_GetZoomLevel_Call) Run(run func()) *MockWebView_GetZoomLevel_Call {
1347 _c.Call.Run(func(args mock.Arguments) {
1348 run()
1349 })
1350 return _c
1351}
1352
1353func (_c *MockWebView_GetZoomLevel_Call) Return(f float64) *MockWebView_GetZoomLevel_Call {
1354 _c.Call.Return(f)
1355 return _c
1356}
1357
1358func (_c *MockWebView_GetZoomLevel_Call) RunAndReturn(run func() float64) *MockWebView_GetZoomLevel_Call {
1359 _c.Call.Return(run)
1360 return _c
1361}
1362
1363// GoBack provides a mock function for the type MockWebView
1364func (_mock *MockWebView) GoBack(ctx context.Context) error {
1365 ret := _mock.Called(ctx)
1366
1367 if len(ret) == 0 {
1368 panic("no return value specified for GoBack")
1369 }
1370
1371 var r0 error
1372 if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
1373 r0 = returnFunc(ctx)
1374 } else {
1375 r0 = ret.Error(0)
1376 }
1377 return r0
1378}
1379
1380// MockWebView_GoBack_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GoBack'
1381type MockWebView_GoBack_Call struct {
1382 *mock.Call
1383}
1384
1385// GoBack is a helper method to define mock.On call
1386// - ctx context.Context
1387func (_e *MockWebView_Expecter) GoBack(ctx any) *MockWebView_GoBack_Call {
1388 return &MockWebView_GoBack_Call{Call: _e.mock.On("GoBack", ctx)}
1389}
1390
1391func (_c *MockWebView_GoBack_Call) Run(run func(ctx context.Context)) *MockWebView_GoBack_Call {
1392 _c.Call.Run(func(args mock.Arguments) {
1393 var arg0 context.Context
1394 if args[0] != nil {
1395 arg0 = args[0].(context.Context)
1396 }
1397 run(
1398 arg0,
1399 )
1400 })
1401 return _c
1402}
1403
1404func (_c *MockWebView_GoBack_Call) Return(err error) *MockWebView_GoBack_Call {
1405 _c.Call.Return(err)
1406 return _c
1407}
1408
1409func (_c *MockWebView_GoBack_Call) RunAndReturn(run func(ctx context.Context) error) *MockWebView_GoBack_Call {
1410 _c.Call.Return(run)
1411 return _c
1412}
1413
1414// GoForward provides a mock function for the type MockWebView
1415func (_mock *MockWebView) GoForward(ctx context.Context) error {
1416 ret := _mock.Called(ctx)
1417
1418 if len(ret) == 0 {
1419 panic("no return value specified for GoForward")
1420 }
1421
1422 var r0 error
1423 if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
1424 r0 = returnFunc(ctx)
1425 } else {
1426 r0 = ret.Error(0)
1427 }
1428 return r0
1429}
1430
1431// MockWebView_GoForward_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GoForward'
1432type MockWebView_GoForward_Call struct {
1433 *mock.Call
1434}
1435
1436// GoForward is a helper method to define mock.On call
1437// - ctx context.Context
1438func (_e *MockWebView_Expecter) GoForward(ctx any) *MockWebView_GoForward_Call {
1439 return &MockWebView_GoForward_Call{Call: _e.mock.On("GoForward", ctx)}
1440}
1441
1442func (_c *MockWebView_GoForward_Call) Run(run func(ctx context.Context)) *MockWebView_GoForward_Call {
1443 _c.Call.Run(func(args mock.Arguments) {
1444 var arg0 context.Context
1445 if args[0] != nil {
1446 arg0 = args[0].(context.Context)
1447 }
1448 run(
1449 arg0,
1450 )
1451 })
1452 return _c
1453}
1454
1455func (_c *MockWebView_GoForward_Call) Return(err error) *MockWebView_GoForward_Call {
1456 _c.Call.Return(err)
1457 return _c
1458}
1459
1460func (_c *MockWebView_GoForward_Call) RunAndReturn(run func(ctx context.Context) error) *MockWebView_GoForward_Call {
1461 _c.Call.Return(run)
1462 return _c
1463}
1464
1465// ID provides a mock function for the type MockWebView
1466func (_mock *MockWebView) ID() port.WebViewID {
1467 ret := _mock.Called()
1468
1469 if len(ret) == 0 {
1470 panic("no return value specified for ID")
1471 }
1472
1473 var r0 port.WebViewID
1474 if returnFunc, ok := ret.Get(0).(func() port.WebViewID); ok {
1475 r0 = returnFunc()
1476 } else {
1477 r0 = ret.Get(0).(port.WebViewID)
1478 }
1479 return r0
1480}
1481
1482// MockWebView_ID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ID'
1483type MockWebView_ID_Call struct {
1484 *mock.Call
1485}
1486
1487// ID is a helper method to define mock.On call
1488func (_e *MockWebView_Expecter) ID() *MockWebView_ID_Call {
1489 return &MockWebView_ID_Call{Call: _e.mock.On("ID")}
1490}
1491
1492func (_c *MockWebView_ID_Call) Run(run func()) *MockWebView_ID_Call {
1493 _c.Call.Run(func(args mock.Arguments) {
1494 run()
1495 })
1496 return _c
1497}
1498
1499func (_c *MockWebView_ID_Call) Return(webViewID port.WebViewID) *MockWebView_ID_Call {
1500 _c.Call.Return(webViewID)
1501 return _c
1502}
1503
1504func (_c *MockWebView_ID_Call) RunAndReturn(run func() port.WebViewID) *MockWebView_ID_Call {
1505 _c.Call.Return(run)
1506 return _c
1507}
1508
1509// IsDestroyed provides a mock function for the type MockWebView
1510func (_mock *MockWebView) IsDestroyed() bool {
1511 ret := _mock.Called()
1512
1513 if len(ret) == 0 {
1514 panic("no return value specified for IsDestroyed")
1515 }
1516
1517 var r0 bool
1518 if returnFunc, ok := ret.Get(0).(func() bool); ok {
1519 r0 = returnFunc()
1520 } else {
1521 r0 = ret.Get(0).(bool)
1522 }
1523 return r0
1524}
1525
1526// MockWebView_IsDestroyed_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsDestroyed'
1527type MockWebView_IsDestroyed_Call struct {
1528 *mock.Call
1529}
1530
1531// IsDestroyed is a helper method to define mock.On call
1532func (_e *MockWebView_Expecter) IsDestroyed() *MockWebView_IsDestroyed_Call {
1533 return &MockWebView_IsDestroyed_Call{Call: _e.mock.On("IsDestroyed")}
1534}
1535
1536func (_c *MockWebView_IsDestroyed_Call) Run(run func()) *MockWebView_IsDestroyed_Call {
1537 _c.Call.Run(func(args mock.Arguments) {
1538 run()
1539 })
1540 return _c
1541}
1542
1543func (_c *MockWebView_IsDestroyed_Call) Return(b bool) *MockWebView_IsDestroyed_Call {
1544 _c.Call.Return(b)
1545 return _c
1546}
1547
1548func (_c *MockWebView_IsDestroyed_Call) RunAndReturn(run func() bool) *MockWebView_IsDestroyed_Call {
1549 _c.Call.Return(run)
1550 return _c
1551}
1552
1553// IsFullscreen provides a mock function for the type MockWebView
1554func (_mock *MockWebView) IsFullscreen() bool {
1555 ret := _mock.Called()
1556
1557 if len(ret) == 0 {
1558 panic("no return value specified for IsFullscreen")
1559 }
1560
1561 var r0 bool
1562 if returnFunc, ok := ret.Get(0).(func() bool); ok {
1563 r0 = returnFunc()
1564 } else {
1565 r0 = ret.Get(0).(bool)
1566 }
1567 return r0
1568}
1569
1570// MockWebView_IsFullscreen_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsFullscreen'
1571type MockWebView_IsFullscreen_Call struct {
1572 *mock.Call
1573}
1574
1575// IsFullscreen is a helper method to define mock.On call
1576func (_e *MockWebView_Expecter) IsFullscreen() *MockWebView_IsFullscreen_Call {
1577 return &MockWebView_IsFullscreen_Call{Call: _e.mock.On("IsFullscreen")}
1578}
1579
1580func (_c *MockWebView_IsFullscreen_Call) Run(run func()) *MockWebView_IsFullscreen_Call {
1581 _c.Call.Run(func(args mock.Arguments) {
1582 run()
1583 })
1584 return _c
1585}
1586
1587func (_c *MockWebView_IsFullscreen_Call) Return(b bool) *MockWebView_IsFullscreen_Call {
1588 _c.Call.Return(b)
1589 return _c
1590}
1591
1592func (_c *MockWebView_IsFullscreen_Call) RunAndReturn(run func() bool) *MockWebView_IsFullscreen_Call {
1593 _c.Call.Return(run)
1594 return _c
1595}
1596
1597// IsLoading provides a mock function for the type MockWebView
1598func (_mock *MockWebView) IsLoading() bool {
1599 ret := _mock.Called()
1600
1601 if len(ret) == 0 {
1602 panic("no return value specified for IsLoading")
1603 }
1604
1605 var r0 bool
1606 if returnFunc, ok := ret.Get(0).(func() bool); ok {
1607 r0 = returnFunc()
1608 } else {
1609 r0 = ret.Get(0).(bool)
1610 }
1611 return r0
1612}
1613
1614// MockWebView_IsLoading_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsLoading'
1615type MockWebView_IsLoading_Call struct {
1616 *mock.Call
1617}
1618
1619// IsLoading is a helper method to define mock.On call
1620func (_e *MockWebView_Expecter) IsLoading() *MockWebView_IsLoading_Call {
1621 return &MockWebView_IsLoading_Call{Call: _e.mock.On("IsLoading")}
1622}
1623
1624func (_c *MockWebView_IsLoading_Call) Run(run func()) *MockWebView_IsLoading_Call {
1625 _c.Call.Run(func(args mock.Arguments) {
1626 run()
1627 })
1628 return _c
1629}
1630
1631func (_c *MockWebView_IsLoading_Call) Return(b bool) *MockWebView_IsLoading_Call {
1632 _c.Call.Return(b)
1633 return _c
1634}
1635
1636func (_c *MockWebView_IsLoading_Call) RunAndReturn(run func() bool) *MockWebView_IsLoading_Call {
1637 _c.Call.Return(run)
1638 return _c
1639}
1640
1641// IsPlayingAudio provides a mock function for the type MockWebView
1642func (_mock *MockWebView) IsPlayingAudio() bool {
1643 ret := _mock.Called()
1644
1645 if len(ret) == 0 {
1646 panic("no return value specified for IsPlayingAudio")
1647 }
1648
1649 var r0 bool
1650 if returnFunc, ok := ret.Get(0).(func() bool); ok {
1651 r0 = returnFunc()
1652 } else {
1653 r0 = ret.Get(0).(bool)
1654 }
1655 return r0
1656}
1657
1658// MockWebView_IsPlayingAudio_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsPlayingAudio'
1659type MockWebView_IsPlayingAudio_Call struct {
1660 *mock.Call
1661}
1662
1663// IsPlayingAudio is a helper method to define mock.On call
1664func (_e *MockWebView_Expecter) IsPlayingAudio() *MockWebView_IsPlayingAudio_Call {
1665 return &MockWebView_IsPlayingAudio_Call{Call: _e.mock.On("IsPlayingAudio")}
1666}
1667
1668func (_c *MockWebView_IsPlayingAudio_Call) Run(run func()) *MockWebView_IsPlayingAudio_Call {
1669 _c.Call.Run(func(args mock.Arguments) {
1670 run()
1671 })
1672 return _c
1673}
1674
1675func (_c *MockWebView_IsPlayingAudio_Call) Return(b bool) *MockWebView_IsPlayingAudio_Call {
1676 _c.Call.Return(b)
1677 return _c
1678}
1679
1680func (_c *MockWebView_IsPlayingAudio_Call) RunAndReturn(run func() bool) *MockWebView_IsPlayingAudio_Call {
1681 _c.Call.Return(run)
1682 return _c
1683}
1684
1685// LoadHTML provides a mock function for the type MockWebView
1686func (_mock *MockWebView) LoadHTML(ctx context.Context, content string, baseURI string) error {
1687 ret := _mock.Called(ctx, content, baseURI)
1688
1689 if len(ret) == 0 {
1690 panic("no return value specified for LoadHTML")
1691 }
1692
1693 var r0 error
1694 if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) error); ok {
1695 r0 = returnFunc(ctx, content, baseURI)
1696 } else {
1697 r0 = ret.Error(0)
1698 }
1699 return r0
1700}
1701
1702// MockWebView_LoadHTML_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LoadHTML'
1703type MockWebView_LoadHTML_Call struct {
1704 *mock.Call
1705}
1706
1707// LoadHTML is a helper method to define mock.On call
1708// - ctx context.Context
1709// - content string
1710// - baseURI string
1711func (_e *MockWebView_Expecter) LoadHTML(ctx any, content any, baseURI any) *MockWebView_LoadHTML_Call {
1712 return &MockWebView_LoadHTML_Call{Call: _e.mock.On("LoadHTML", ctx, content, baseURI)}
1713}
1714
1715func (_c *MockWebView_LoadHTML_Call) Run(run func(ctx context.Context, content string, baseURI string)) *MockWebView_LoadHTML_Call {
1716 _c.Call.Run(func(args mock.Arguments) {
1717 var arg0 context.Context
1718 if args[0] != nil {
1719 arg0 = args[0].(context.Context)
1720 }
1721 var arg1 string
1722 if args[1] != nil {
1723 arg1 = args[1].(string)
1724 }
1725 var arg2 string
1726 if args[2] != nil {
1727 arg2 = args[2].(string)
1728 }
1729 run(
1730 arg0,
1731 arg1,
1732 arg2,
1733 )
1734 })
1735 return _c
1736}
1737
1738func (_c *MockWebView_LoadHTML_Call) Return(err error) *MockWebView_LoadHTML_Call {
1739 _c.Call.Return(err)
1740 return _c
1741}
1742
1743func (_c *MockWebView_LoadHTML_Call) RunAndReturn(run func(ctx context.Context, content string, baseURI string) error) *MockWebView_LoadHTML_Call {
1744 _c.Call.Return(run)
1745 return _c
1746}
1747
1748// LoadURI provides a mock function for the type MockWebView
1749func (_mock *MockWebView) LoadURI(ctx context.Context, uri string) error {
1750 ret := _mock.Called(ctx, uri)
1751
1752 if len(ret) == 0 {
1753 panic("no return value specified for LoadURI")
1754 }
1755
1756 var r0 error
1757 if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
1758 r0 = returnFunc(ctx, uri)
1759 } else {
1760 r0 = ret.Error(0)
1761 }
1762 return r0
1763}
1764
1765// MockWebView_LoadURI_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LoadURI'
1766type MockWebView_LoadURI_Call struct {
1767 *mock.Call
1768}
1769
1770// LoadURI is a helper method to define mock.On call
1771// - ctx context.Context
1772// - uri string
1773func (_e *MockWebView_Expecter) LoadURI(ctx any, uri any) *MockWebView_LoadURI_Call {
1774 return &MockWebView_LoadURI_Call{Call: _e.mock.On("LoadURI", ctx, uri)}
1775}
1776
1777func (_c *MockWebView_LoadURI_Call) Run(run func(ctx context.Context, uri string)) *MockWebView_LoadURI_Call {
1778 _c.Call.Run(func(args mock.Arguments) {
1779 var arg0 context.Context
1780 if args[0] != nil {
1781 arg0 = args[0].(context.Context)
1782 }
1783 var arg1 string
1784 if args[1] != nil {
1785 arg1 = args[1].(string)
1786 }
1787 run(
1788 arg0,
1789 arg1,
1790 )
1791 })
1792 return _c
1793}
1794
1795func (_c *MockWebView_LoadURI_Call) Return(err error) *MockWebView_LoadURI_Call {
1796 _c.Call.Return(err)
1797 return _c
1798}
1799
1800func (_c *MockWebView_LoadURI_Call) RunAndReturn(run func(ctx context.Context, uri string) error) *MockWebView_LoadURI_Call {
1801 _c.Call.Return(run)
1802 return _c
1803}
1804
1805// Reload provides a mock function for the type MockWebView
1806func (_mock *MockWebView) Reload(ctx context.Context) error {
1807 ret := _mock.Called(ctx)
1808
1809 if len(ret) == 0 {
1810 panic("no return value specified for Reload")
1811 }
1812
1813 var r0 error
1814 if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
1815 r0 = returnFunc(ctx)
1816 } else {
1817 r0 = ret.Error(0)
1818 }
1819 return r0
1820}
1821
1822// MockWebView_Reload_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Reload'
1823type MockWebView_Reload_Call struct {
1824 *mock.Call
1825}
1826
1827// Reload is a helper method to define mock.On call
1828// - ctx context.Context
1829func (_e *MockWebView_Expecter) Reload(ctx any) *MockWebView_Reload_Call {
1830 return &MockWebView_Reload_Call{Call: _e.mock.On("Reload", ctx)}
1831}
1832
1833func (_c *MockWebView_Reload_Call) Run(run func(ctx context.Context)) *MockWebView_Reload_Call {
1834 _c.Call.Run(func(args mock.Arguments) {
1835 var arg0 context.Context
1836 if args[0] != nil {
1837 arg0 = args[0].(context.Context)
1838 }
1839 run(
1840 arg0,
1841 )
1842 })
1843 return _c
1844}
1845
1846func (_c *MockWebView_Reload_Call) Return(err error) *MockWebView_Reload_Call {
1847 _c.Call.Return(err)
1848 return _c
1849}
1850
1851func (_c *MockWebView_Reload_Call) RunAndReturn(run func(ctx context.Context) error) *MockWebView_Reload_Call {
1852 _c.Call.Return(run)
1853 return _c
1854}
1855
1856// ReloadBypassCache provides a mock function for the type MockWebView
1857func (_mock *MockWebView) ReloadBypassCache(ctx context.Context) error {
1858 ret := _mock.Called(ctx)
1859
1860 if len(ret) == 0 {
1861 panic("no return value specified for ReloadBypassCache")
1862 }
1863
1864 var r0 error
1865 if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
1866 r0 = returnFunc(ctx)
1867 } else {
1868 r0 = ret.Error(0)
1869 }
1870 return r0
1871}
1872
1873// MockWebView_ReloadBypassCache_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReloadBypassCache'
1874type MockWebView_ReloadBypassCache_Call struct {
1875 *mock.Call
1876}
1877
1878// ReloadBypassCache is a helper method to define mock.On call
1879// - ctx context.Context
1880func (_e *MockWebView_Expecter) ReloadBypassCache(ctx any) *MockWebView_ReloadBypassCache_Call {
1881 return &MockWebView_ReloadBypassCache_Call{Call: _e.mock.On("ReloadBypassCache", ctx)}
1882}
1883
1884func (_c *MockWebView_ReloadBypassCache_Call) Run(run func(ctx context.Context)) *MockWebView_ReloadBypassCache_Call {
1885 _c.Call.Run(func(args mock.Arguments) {
1886 var arg0 context.Context
1887 if args[0] != nil {
1888 arg0 = args[0].(context.Context)
1889 }
1890 run(
1891 arg0,
1892 )
1893 })
1894 return _c
1895}
1896
1897func (_c *MockWebView_ReloadBypassCache_Call) Return(err error) *MockWebView_ReloadBypassCache_Call {
1898 _c.Call.Return(err)
1899 return _c
1900}
1901
1902func (_c *MockWebView_ReloadBypassCache_Call) RunAndReturn(run func(ctx context.Context) error) *MockWebView_ReloadBypassCache_Call {
1903 _c.Call.Return(run)
1904 return _c
1905}
1906
1907// ResetBackgroundToDefault provides a mock function for the type MockWebView
1908func (_mock *MockWebView) ResetBackgroundToDefault() {
1909 _mock.Called()
1910 return
1911}
1912
1913// MockWebView_ResetBackgroundToDefault_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResetBackgroundToDefault'
1914type MockWebView_ResetBackgroundToDefault_Call struct {
1915 *mock.Call
1916}
1917
1918// ResetBackgroundToDefault is a helper method to define mock.On call
1919func (_e *MockWebView_Expecter) ResetBackgroundToDefault() *MockWebView_ResetBackgroundToDefault_Call {
1920 return &MockWebView_ResetBackgroundToDefault_Call{Call: _e.mock.On("ResetBackgroundToDefault")}
1921}
1922
1923func (_c *MockWebView_ResetBackgroundToDefault_Call) Run(run func()) *MockWebView_ResetBackgroundToDefault_Call {
1924 _c.Call.Run(func(args mock.Arguments) {
1925 run()
1926 })
1927 return _c
1928}
1929
1930func (_c *MockWebView_ResetBackgroundToDefault_Call) Return() *MockWebView_ResetBackgroundToDefault_Call {
1931 _c.Call.Return()
1932 return _c
1933}
1934
1935func (_c *MockWebView_ResetBackgroundToDefault_Call) RunAndReturn(run func()) *MockWebView_ResetBackgroundToDefault_Call {
1936 _c.Run(run)
1937 return _c
1938}
1939
1940// RunJavaScript provides a mock function for the type MockWebView
1941func (_mock *MockWebView) RunJavaScript(ctx context.Context, script string) {
1942 _mock.Called(ctx, script)
1943 return
1944}
1945
1946// MockWebView_RunJavaScript_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RunJavaScript'
1947type MockWebView_RunJavaScript_Call struct {
1948 *mock.Call
1949}
1950
1951// RunJavaScript is a helper method to define mock.On call
1952// - ctx context.Context
1953// - script string
1954func (_e *MockWebView_Expecter) RunJavaScript(ctx any, script any) *MockWebView_RunJavaScript_Call {
1955 return &MockWebView_RunJavaScript_Call{Call: _e.mock.On("RunJavaScript", ctx, script)}
1956}
1957
1958func (_c *MockWebView_RunJavaScript_Call) Run(run func(ctx context.Context, script string)) *MockWebView_RunJavaScript_Call {
1959 _c.Call.Run(func(args mock.Arguments) {
1960 var arg0 context.Context
1961 if args[0] != nil {
1962 arg0 = args[0].(context.Context)
1963 }
1964 var arg1 string
1965 if args[1] != nil {
1966 arg1 = args[1].(string)
1967 }
1968 run(
1969 arg0,
1970 arg1,
1971 )
1972 })
1973 return _c
1974}
1975
1976func (_c *MockWebView_RunJavaScript_Call) Return() *MockWebView_RunJavaScript_Call {
1977 _c.Call.Return()
1978 return _c
1979}
1980
1981func (_c *MockWebView_RunJavaScript_Call) RunAndReturn(run func(ctx context.Context, script string)) *MockWebView_RunJavaScript_Call {
1982 _c.Run(run)
1983 return _c
1984}
1985
1986// SetBackgroundColor provides a mock function for the type MockWebView
1987func (_mock *MockWebView) SetBackgroundColor(r float64, g float64, b float64, a float64) {
1988 _mock.Called(r, g, b, a)
1989 return
1990}
1991
1992// MockWebView_SetBackgroundColor_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetBackgroundColor'
1993type MockWebView_SetBackgroundColor_Call struct {
1994 *mock.Call
1995}
1996
1997// SetBackgroundColor is a helper method to define mock.On call
1998// - r float64
1999// - g float64
2000// - b float64
2001// - a float64
2002func (_e *MockWebView_Expecter) SetBackgroundColor(r any, g any, b any, a any) *MockWebView_SetBackgroundColor_Call {
2003 return &MockWebView_SetBackgroundColor_Call{Call: _e.mock.On("SetBackgroundColor", r, g, b, a)}
2004}
2005
2006func (_c *MockWebView_SetBackgroundColor_Call) Run(run func(r float64, g float64, b float64, a float64)) *MockWebView_SetBackgroundColor_Call {
2007 _c.Call.Run(func(args mock.Arguments) {
2008 var arg0 float64
2009 if args[0] != nil {
2010 arg0 = args[0].(float64)
2011 }
2012 var arg1 float64
2013 if args[1] != nil {
2014 arg1 = args[1].(float64)
2015 }
2016 var arg2 float64
2017 if args[2] != nil {
2018 arg2 = args[2].(float64)
2019 }
2020 var arg3 float64
2021 if args[3] != nil {
2022 arg3 = args[3].(float64)
2023 }
2024 run(
2025 arg0,
2026 arg1,
2027 arg2,
2028 arg3,
2029 )
2030 })
2031 return _c
2032}
2033
2034func (_c *MockWebView_SetBackgroundColor_Call) Return() *MockWebView_SetBackgroundColor_Call {
2035 _c.Call.Return()
2036 return _c
2037}
2038
2039func (_c *MockWebView_SetBackgroundColor_Call) RunAndReturn(run func(r float64, g float64, b float64, a float64)) *MockWebView_SetBackgroundColor_Call {
2040 _c.Run(run)
2041 return _c
2042}
2043
2044// SetCallbacks provides a mock function for the type MockWebView
2045func (_mock *MockWebView) SetCallbacks(callbacks *port.WebViewCallbacks) {
2046 _mock.Called(callbacks)
2047 return
2048}
2049
2050// MockWebView_SetCallbacks_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetCallbacks'
2051type MockWebView_SetCallbacks_Call struct {
2052 *mock.Call
2053}
2054
2055// SetCallbacks is a helper method to define mock.On call
2056// - callbacks *port.WebViewCallbacks
2057func (_e *MockWebView_Expecter) SetCallbacks(callbacks any) *MockWebView_SetCallbacks_Call {
2058 return &MockWebView_SetCallbacks_Call{Call: _e.mock.On("SetCallbacks", callbacks)}
2059}
2060
2061func (_c *MockWebView_SetCallbacks_Call) Run(run func(callbacks *port.WebViewCallbacks)) *MockWebView_SetCallbacks_Call {
2062 _c.Call.Run(func(args mock.Arguments) {
2063 var arg0 *port.WebViewCallbacks
2064 if args[0] != nil {
2065 arg0 = args[0].(*port.WebViewCallbacks)
2066 }
2067 run(
2068 arg0,
2069 )
2070 })
2071 return _c
2072}
2073
2074func (_c *MockWebView_SetCallbacks_Call) Return() *MockWebView_SetCallbacks_Call {
2075 _c.Call.Return()
2076 return _c
2077}
2078
2079func (_c *MockWebView_SetCallbacks_Call) RunAndReturn(run func(callbacks *port.WebViewCallbacks)) *MockWebView_SetCallbacks_Call {
2080 _c.Run(run)
2081 return _c
2082}
2083
2084// SetZoomLevel provides a mock function for the type MockWebView
2085func (_mock *MockWebView) SetZoomLevel(ctx context.Context, level float64) error {
2086 ret := _mock.Called(ctx, level)
2087
2088 if len(ret) == 0 {
2089 panic("no return value specified for SetZoomLevel")
2090 }
2091
2092 var r0 error
2093 if returnFunc, ok := ret.Get(0).(func(context.Context, float64) error); ok {
2094 r0 = returnFunc(ctx, level)
2095 } else {
2096 r0 = ret.Error(0)
2097 }
2098 return r0
2099}
2100
2101// MockWebView_SetZoomLevel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetZoomLevel'
2102type MockWebView_SetZoomLevel_Call struct {
2103 *mock.Call
2104}
2105
2106// SetZoomLevel is a helper method to define mock.On call
2107// - ctx context.Context
2108// - level float64
2109func (_e *MockWebView_Expecter) SetZoomLevel(ctx any, level any) *MockWebView_SetZoomLevel_Call {
2110 return &MockWebView_SetZoomLevel_Call{Call: _e.mock.On("SetZoomLevel", ctx, level)}
2111}
2112
2113func (_c *MockWebView_SetZoomLevel_Call) Run(run func(ctx context.Context, level float64)) *MockWebView_SetZoomLevel_Call {
2114 _c.Call.Run(func(args mock.Arguments) {
2115 var arg0 context.Context
2116 if args[0] != nil {
2117 arg0 = args[0].(context.Context)
2118 }
2119 var arg1 float64
2120 if args[1] != nil {
2121 arg1 = args[1].(float64)
2122 }
2123 run(
2124 arg0,
2125 arg1,
2126 )
2127 })
2128 return _c
2129}
2130
2131func (_c *MockWebView_SetZoomLevel_Call) Return(err error) *MockWebView_SetZoomLevel_Call {
2132 _c.Call.Return(err)
2133 return _c
2134}
2135
2136func (_c *MockWebView_SetZoomLevel_Call) RunAndReturn(run func(ctx context.Context, level float64) error) *MockWebView_SetZoomLevel_Call {
2137 _c.Call.Return(run)
2138 return _c
2139}
2140
2141// State provides a mock function for the type MockWebView
2142func (_mock *MockWebView) State() port.WebViewState {
2143 ret := _mock.Called()
2144
2145 if len(ret) == 0 {
2146 panic("no return value specified for State")
2147 }
2148
2149 var r0 port.WebViewState
2150 if returnFunc, ok := ret.Get(0).(func() port.WebViewState); ok {
2151 r0 = returnFunc()
2152 } else {
2153 r0 = ret.Get(0).(port.WebViewState)
2154 }
2155 return r0
2156}
2157
2158// MockWebView_State_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'State'
2159type MockWebView_State_Call struct {
2160 *mock.Call
2161}
2162
2163// State is a helper method to define mock.On call
2164func (_e *MockWebView_Expecter) State() *MockWebView_State_Call {
2165 return &MockWebView_State_Call{Call: _e.mock.On("State")}
2166}
2167
2168func (_c *MockWebView_State_Call) Run(run func()) *MockWebView_State_Call {
2169 _c.Call.Run(func(args mock.Arguments) {
2170 run()
2171 })
2172 return _c
2173}
2174
2175func (_c *MockWebView_State_Call) Return(webViewState port.WebViewState) *MockWebView_State_Call {
2176 _c.Call.Return(webViewState)
2177 return _c
2178}
2179
2180func (_c *MockWebView_State_Call) RunAndReturn(run func() port.WebViewState) *MockWebView_State_Call {
2181 _c.Call.Return(run)
2182 return _c
2183}
2184
2185// Stop provides a mock function for the type MockWebView
2186func (_mock *MockWebView) Stop(ctx context.Context) error {
2187 ret := _mock.Called(ctx)
2188
2189 if len(ret) == 0 {
2190 panic("no return value specified for Stop")
2191 }
2192
2193 var r0 error
2194 if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
2195 r0 = returnFunc(ctx)
2196 } else {
2197 r0 = ret.Error(0)
2198 }
2199 return r0
2200}
2201
2202// MockWebView_Stop_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Stop'
2203type MockWebView_Stop_Call struct {
2204 *mock.Call
2205}
2206
2207// Stop is a helper method to define mock.On call
2208// - ctx context.Context
2209func (_e *MockWebView_Expecter) Stop(ctx any) *MockWebView_Stop_Call {
2210 return &MockWebView_Stop_Call{Call: _e.mock.On("Stop", ctx)}
2211}
2212
2213func (_c *MockWebView_Stop_Call) Run(run func(ctx context.Context)) *MockWebView_Stop_Call {
2214 _c.Call.Run(func(args mock.Arguments) {
2215 var arg0 context.Context
2216 if args[0] != nil {
2217 arg0 = args[0].(context.Context)
2218 }
2219 run(
2220 arg0,
2221 )
2222 })
2223 return _c
2224}
2225
2226func (_c *MockWebView_Stop_Call) Return(err error) *MockWebView_Stop_Call {
2227 _c.Call.Return(err)
2228 return _c
2229}
2230
2231func (_c *MockWebView_Stop_Call) RunAndReturn(run func(ctx context.Context) error) *MockWebView_Stop_Call {
2232 _c.Call.Return(run)
2233 return _c
2234}
2235
2236// Title provides a mock function for the type MockWebView
2237func (_mock *MockWebView) Title() string {
2238 ret := _mock.Called()
2239
2240 if len(ret) == 0 {
2241 panic("no return value specified for Title")
2242 }
2243
2244 var r0 string
2245 if returnFunc, ok := ret.Get(0).(func() string); ok {
2246 r0 = returnFunc()
2247 } else {
2248 r0 = ret.Get(0).(string)
2249 }
2250 return r0
2251}
2252
2253// MockWebView_Title_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Title'
2254type MockWebView_Title_Call struct {
2255 *mock.Call
2256}
2257
2258// Title is a helper method to define mock.On call
2259func (_e *MockWebView_Expecter) Title() *MockWebView_Title_Call {
2260 return &MockWebView_Title_Call{Call: _e.mock.On("Title")}
2261}
2262
2263func (_c *MockWebView_Title_Call) Run(run func()) *MockWebView_Title_Call {
2264 _c.Call.Run(func(args mock.Arguments) {
2265 run()
2266 })
2267 return _c
2268}
2269
2270func (_c *MockWebView_Title_Call) Return(s string) *MockWebView_Title_Call {
2271 _c.Call.Return(s)
2272 return _c
2273}
2274
2275func (_c *MockWebView_Title_Call) RunAndReturn(run func() string) *MockWebView_Title_Call {
2276 _c.Call.Return(run)
2277 return _c
2278}
2279
2280// URI provides a mock function for the type MockWebView
2281func (_mock *MockWebView) URI() string {
2282 ret := _mock.Called()
2283
2284 if len(ret) == 0 {
2285 panic("no return value specified for URI")
2286 }
2287
2288 var r0 string
2289 if returnFunc, ok := ret.Get(0).(func() string); ok {
2290 r0 = returnFunc()
2291 } else {
2292 r0 = ret.Get(0).(string)
2293 }
2294 return r0
2295}
2296
2297// MockWebView_URI_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'URI'
2298type MockWebView_URI_Call struct {
2299 *mock.Call
2300}
2301
2302// URI is a helper method to define mock.On call
2303func (_e *MockWebView_Expecter) URI() *MockWebView_URI_Call {
2304 return &MockWebView_URI_Call{Call: _e.mock.On("URI")}
2305}
2306
2307func (_c *MockWebView_URI_Call) Run(run func()) *MockWebView_URI_Call {
2308 _c.Call.Run(func(args mock.Arguments) {
2309 run()
2310 })
2311 return _c
2312}
2313
2314func (_c *MockWebView_URI_Call) Return(s string) *MockWebView_URI_Call {
2315 _c.Call.Return(s)
2316 return _c
2317}
2318
2319func (_c *MockWebView_URI_Call) RunAndReturn(run func() string) *MockWebView_URI_Call {
2320 _c.Call.Return(run)
2321 return _c
2322}
2323
2324// 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.
2325// The first argument is typically a *testing.T value.
2326func NewMockWebViewPool(t interface {
2327 mock.TestingT
2328 Cleanup(func())
2329}) *MockWebViewPool {
2330 if helper, ok := t.(interface{ Helper() }); ok {
2331 helper.Helper()
2332 }
2333
2334 mock := &MockWebViewPool{}
2335 mock.Mock.Test(t)
2336
2337 t.Cleanup(func() {
2338 if helper, ok := t.(interface{ Helper() }); ok {
2339 helper.Helper()
2340 }
2341 mock.AssertExpectations(t)
2342 })
2343
2344 return mock
2345}
2346
2347// MockWebViewPool is an autogenerated mock type for the WebViewPool type
2348type MockWebViewPool struct {
2349 mock.Mock
2350}
2351
2352type MockWebViewPool_Expecter struct {
2353 mock *mock.Mock
2354}
2355
2356func (_m *MockWebViewPool) EXPECT() *MockWebViewPool_Expecter {
2357 return &MockWebViewPool_Expecter{mock: &_m.Mock}
2358}
2359
2360// Acquire provides a mock function for the type MockWebViewPool
2361func (_mock *MockWebViewPool) Acquire(ctx context.Context) (port.WebView, error) {
2362 ret := _mock.Called(ctx)
2363
2364 if len(ret) == 0 {
2365 panic("no return value specified for Acquire")
2366 }
2367
2368 var r0 port.WebView
2369 var r1 error
2370 if returnFunc, ok := ret.Get(0).(func(context.Context) (port.WebView, error)); ok {
2371 return returnFunc(ctx)
2372 }
2373 if returnFunc, ok := ret.Get(0).(func(context.Context) port.WebView); ok {
2374 r0 = returnFunc(ctx)
2375 } else {
2376 if ret.Get(0) != nil {
2377 r0 = ret.Get(0).(port.WebView)
2378 }
2379 }
2380 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
2381 r1 = returnFunc(ctx)
2382 } else {
2383 r1 = ret.Error(1)
2384 }
2385 return r0, r1
2386}
2387
2388// MockWebViewPool_Acquire_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Acquire'
2389type MockWebViewPool_Acquire_Call struct {
2390 *mock.Call
2391}
2392
2393// Acquire is a helper method to define mock.On call
2394// - ctx context.Context
2395func (_e *MockWebViewPool_Expecter) Acquire(ctx any) *MockWebViewPool_Acquire_Call {
2396 return &MockWebViewPool_Acquire_Call{Call: _e.mock.On("Acquire", ctx)}
2397}
2398
2399func (_c *MockWebViewPool_Acquire_Call) Run(run func(ctx context.Context)) *MockWebViewPool_Acquire_Call {
2400 _c.Call.Run(func(args mock.Arguments) {
2401 var arg0 context.Context
2402 if args[0] != nil {
2403 arg0 = args[0].(context.Context)
2404 }
2405 run(
2406 arg0,
2407 )
2408 })
2409 return _c
2410}
2411
2412func (_c *MockWebViewPool_Acquire_Call) Return(webView port.WebView, err error) *MockWebViewPool_Acquire_Call {
2413 _c.Call.Return(webView, err)
2414 return _c
2415}
2416
2417func (_c *MockWebViewPool_Acquire_Call) RunAndReturn(run func(ctx context.Context) (port.WebView, error)) *MockWebViewPool_Acquire_Call {
2418 _c.Call.Return(run)
2419 return _c
2420}
2421
2422// Close provides a mock function for the type MockWebViewPool
2423func (_mock *MockWebViewPool) Close() {
2424 _mock.Called()
2425 return
2426}
2427
2428// MockWebViewPool_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
2429type MockWebViewPool_Close_Call struct {
2430 *mock.Call
2431}
2432
2433// Close is a helper method to define mock.On call
2434func (_e *MockWebViewPool_Expecter) Close() *MockWebViewPool_Close_Call {
2435 return &MockWebViewPool_Close_Call{Call: _e.mock.On("Close")}
2436}
2437
2438func (_c *MockWebViewPool_Close_Call) Run(run func()) *MockWebViewPool_Close_Call {
2439 _c.Call.Run(func(args mock.Arguments) {
2440 run()
2441 })
2442 return _c
2443}
2444
2445func (_c *MockWebViewPool_Close_Call) Return() *MockWebViewPool_Close_Call {
2446 _c.Call.Return()
2447 return _c
2448}
2449
2450func (_c *MockWebViewPool_Close_Call) RunAndReturn(run func()) *MockWebViewPool_Close_Call {
2451 _c.Run(run)
2452 return _c
2453}
2454
2455// Prewarm provides a mock function for the type MockWebViewPool
2456func (_mock *MockWebViewPool) Prewarm(count int) {
2457 _mock.Called(count)
2458 return
2459}
2460
2461// MockWebViewPool_Prewarm_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Prewarm'
2462type MockWebViewPool_Prewarm_Call struct {
2463 *mock.Call
2464}
2465
2466// Prewarm is a helper method to define mock.On call
2467// - count int
2468func (_e *MockWebViewPool_Expecter) Prewarm(count any) *MockWebViewPool_Prewarm_Call {
2469 return &MockWebViewPool_Prewarm_Call{Call: _e.mock.On("Prewarm", count)}
2470}
2471
2472func (_c *MockWebViewPool_Prewarm_Call) Run(run func(count int)) *MockWebViewPool_Prewarm_Call {
2473 _c.Call.Run(func(args mock.Arguments) {
2474 var arg0 int
2475 if args[0] != nil {
2476 arg0 = args[0].(int)
2477 }
2478 run(
2479 arg0,
2480 )
2481 })
2482 return _c
2483}
2484
2485func (_c *MockWebViewPool_Prewarm_Call) Return() *MockWebViewPool_Prewarm_Call {
2486 _c.Call.Return()
2487 return _c
2488}
2489
2490func (_c *MockWebViewPool_Prewarm_Call) RunAndReturn(run func(count int)) *MockWebViewPool_Prewarm_Call {
2491 _c.Run(run)
2492 return _c
2493}
2494
2495// PrewarmAsync provides a mock function for the type MockWebViewPool
2496func (_mock *MockWebViewPool) PrewarmAsync(ctx context.Context, count int) {
2497 _mock.Called(ctx, count)
2498 return
2499}
2500
2501// MockWebViewPool_PrewarmAsync_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PrewarmAsync'
2502type MockWebViewPool_PrewarmAsync_Call struct {
2503 *mock.Call
2504}
2505
2506// PrewarmAsync is a helper method to define mock.On call
2507// - ctx context.Context
2508// - count int
2509func (_e *MockWebViewPool_Expecter) PrewarmAsync(ctx any, count any) *MockWebViewPool_PrewarmAsync_Call {
2510 return &MockWebViewPool_PrewarmAsync_Call{Call: _e.mock.On("PrewarmAsync", ctx, count)}
2511}
2512
2513func (_c *MockWebViewPool_PrewarmAsync_Call) Run(run func(ctx context.Context, count int)) *MockWebViewPool_PrewarmAsync_Call {
2514 _c.Call.Run(func(args mock.Arguments) {
2515 var arg0 context.Context
2516 if args[0] != nil {
2517 arg0 = args[0].(context.Context)
2518 }
2519 var arg1 int
2520 if args[1] != nil {
2521 arg1 = args[1].(int)
2522 }
2523 run(
2524 arg0,
2525 arg1,
2526 )
2527 })
2528 return _c
2529}
2530
2531func (_c *MockWebViewPool_PrewarmAsync_Call) Return() *MockWebViewPool_PrewarmAsync_Call {
2532 _c.Call.Return()
2533 return _c
2534}
2535
2536func (_c *MockWebViewPool_PrewarmAsync_Call) RunAndReturn(run func(ctx context.Context, count int)) *MockWebViewPool_PrewarmAsync_Call {
2537 _c.Run(run)
2538 return _c
2539}
2540
2541// Release provides a mock function for the type MockWebViewPool
2542func (_mock *MockWebViewPool) Release(wv port.WebView) {
2543 _mock.Called(wv)
2544 return
2545}
2546
2547// MockWebViewPool_Release_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Release'
2548type MockWebViewPool_Release_Call struct {
2549 *mock.Call
2550}
2551
2552// Release is a helper method to define mock.On call
2553// - wv port.WebView
2554func (_e *MockWebViewPool_Expecter) Release(wv any) *MockWebViewPool_Release_Call {
2555 return &MockWebViewPool_Release_Call{Call: _e.mock.On("Release", wv)}
2556}
2557
2558func (_c *MockWebViewPool_Release_Call) Run(run func(wv port.WebView)) *MockWebViewPool_Release_Call {
2559 _c.Call.Run(func(args mock.Arguments) {
2560 var arg0 port.WebView
2561 if args[0] != nil {
2562 arg0 = args[0].(port.WebView)
2563 }
2564 run(
2565 arg0,
2566 )
2567 })
2568 return _c
2569}
2570
2571func (_c *MockWebViewPool_Release_Call) Return() *MockWebViewPool_Release_Call {
2572 _c.Call.Return()
2573 return _c
2574}
2575
2576func (_c *MockWebViewPool_Release_Call) RunAndReturn(run func(wv port.WebView)) *MockWebViewPool_Release_Call {
2577 _c.Run(run)
2578 return _c
2579}
2580
2581// Size provides a mock function for the type MockWebViewPool
2582func (_mock *MockWebViewPool) Size() int {
2583 ret := _mock.Called()
2584
2585 if len(ret) == 0 {
2586 panic("no return value specified for Size")
2587 }
2588
2589 var r0 int
2590 if returnFunc, ok := ret.Get(0).(func() int); ok {
2591 r0 = returnFunc()
2592 } else {
2593 r0 = ret.Get(0).(int)
2594 }
2595 return r0
2596}
2597
2598// MockWebViewPool_Size_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Size'
2599type MockWebViewPool_Size_Call struct {
2600 *mock.Call
2601}
2602
2603// Size is a helper method to define mock.On call
2604func (_e *MockWebViewPool_Expecter) Size() *MockWebViewPool_Size_Call {
2605 return &MockWebViewPool_Size_Call{Call: _e.mock.On("Size")}
2606}
2607
2608func (_c *MockWebViewPool_Size_Call) Run(run func()) *MockWebViewPool_Size_Call {
2609 _c.Call.Run(func(args mock.Arguments) {
2610 run()
2611 })
2612 return _c
2613}
2614
2615func (_c *MockWebViewPool_Size_Call) Return(n int) *MockWebViewPool_Size_Call {
2616 _c.Call.Return(n)
2617 return _c
2618}
2619
2620func (_c *MockWebViewPool_Size_Call) RunAndReturn(run func() int) *MockWebViewPool_Size_Call {
2621 _c.Call.Return(run)
2622 return _c
2623}
2624
2625// 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.
2626// The first argument is typically a *testing.T value.
2627func NewMockWebViewFactory(t interface {
2628 mock.TestingT
2629 Cleanup(func())
2630}) *MockWebViewFactory {
2631 if helper, ok := t.(interface{ Helper() }); ok {
2632 helper.Helper()
2633 }
2634
2635 mock := &MockWebViewFactory{}
2636 mock.Mock.Test(t)
2637
2638 t.Cleanup(func() {
2639 if helper, ok := t.(interface{ Helper() }); ok {
2640 helper.Helper()
2641 }
2642 mock.AssertExpectations(t)
2643 })
2644
2645 return mock
2646}
2647
2648// MockWebViewFactory is an autogenerated mock type for the WebViewFactory type
2649type MockWebViewFactory struct {
2650 mock.Mock
2651}
2652
2653type MockWebViewFactory_Expecter struct {
2654 mock *mock.Mock
2655}
2656
2657func (_m *MockWebViewFactory) EXPECT() *MockWebViewFactory_Expecter {
2658 return &MockWebViewFactory_Expecter{mock: &_m.Mock}
2659}
2660
2661// Create provides a mock function for the type MockWebViewFactory
2662func (_mock *MockWebViewFactory) Create(ctx context.Context) (port.WebView, error) {
2663 ret := _mock.Called(ctx)
2664
2665 if len(ret) == 0 {
2666 panic("no return value specified for Create")
2667 }
2668
2669 var r0 port.WebView
2670 var r1 error
2671 if returnFunc, ok := ret.Get(0).(func(context.Context) (port.WebView, error)); ok {
2672 return returnFunc(ctx)
2673 }
2674 if returnFunc, ok := ret.Get(0).(func(context.Context) port.WebView); ok {
2675 r0 = returnFunc(ctx)
2676 } else {
2677 if ret.Get(0) != nil {
2678 r0 = ret.Get(0).(port.WebView)
2679 }
2680 }
2681 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
2682 r1 = returnFunc(ctx)
2683 } else {
2684 r1 = ret.Error(1)
2685 }
2686 return r0, r1
2687}
2688
2689// MockWebViewFactory_Create_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Create'
2690type MockWebViewFactory_Create_Call struct {
2691 *mock.Call
2692}
2693
2694// Create is a helper method to define mock.On call
2695// - ctx context.Context
2696func (_e *MockWebViewFactory_Expecter) Create(ctx any) *MockWebViewFactory_Create_Call {
2697 return &MockWebViewFactory_Create_Call{Call: _e.mock.On("Create", ctx)}
2698}
2699
2700func (_c *MockWebViewFactory_Create_Call) Run(run func(ctx context.Context)) *MockWebViewFactory_Create_Call {
2701 _c.Call.Run(func(args mock.Arguments) {
2702 var arg0 context.Context
2703 if args[0] != nil {
2704 arg0 = args[0].(context.Context)
2705 }
2706 run(
2707 arg0,
2708 )
2709 })
2710 return _c
2711}
2712
2713func (_c *MockWebViewFactory_Create_Call) Return(webView port.WebView, err error) *MockWebViewFactory_Create_Call {
2714 _c.Call.Return(webView, err)
2715 return _c
2716}
2717
2718func (_c *MockWebViewFactory_Create_Call) RunAndReturn(run func(ctx context.Context) (port.WebView, error)) *MockWebViewFactory_Create_Call {
2719 _c.Call.Return(run)
2720 return _c
2721}
2722
2723// CreateRelated provides a mock function for the type MockWebViewFactory
2724func (_mock *MockWebViewFactory) CreateRelated(ctx context.Context, parentID port.WebViewID) (port.WebView, error) {
2725 ret := _mock.Called(ctx, parentID)
2726
2727 if len(ret) == 0 {
2728 panic("no return value specified for CreateRelated")
2729 }
2730
2731 var r0 port.WebView
2732 var r1 error
2733 if returnFunc, ok := ret.Get(0).(func(context.Context, port.WebViewID) (port.WebView, error)); ok {
2734 return returnFunc(ctx, parentID)
2735 }
2736 if returnFunc, ok := ret.Get(0).(func(context.Context, port.WebViewID) port.WebView); ok {
2737 r0 = returnFunc(ctx, parentID)
2738 } else {
2739 if ret.Get(0) != nil {
2740 r0 = ret.Get(0).(port.WebView)
2741 }
2742 }
2743 if returnFunc, ok := ret.Get(1).(func(context.Context, port.WebViewID) error); ok {
2744 r1 = returnFunc(ctx, parentID)
2745 } else {
2746 r1 = ret.Error(1)
2747 }
2748 return r0, r1
2749}
2750
2751// MockWebViewFactory_CreateRelated_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateRelated'
2752type MockWebViewFactory_CreateRelated_Call struct {
2753 *mock.Call
2754}
2755
2756// CreateRelated is a helper method to define mock.On call
2757// - ctx context.Context
2758// - parentID port.WebViewID
2759func (_e *MockWebViewFactory_Expecter) CreateRelated(ctx any, parentID any) *MockWebViewFactory_CreateRelated_Call {
2760 return &MockWebViewFactory_CreateRelated_Call{Call: _e.mock.On("CreateRelated", ctx, parentID)}
2761}
2762
2763func (_c *MockWebViewFactory_CreateRelated_Call) Run(run func(ctx context.Context, parentID port.WebViewID)) *MockWebViewFactory_CreateRelated_Call {
2764 _c.Call.Run(func(args mock.Arguments) {
2765 var arg0 context.Context
2766 if args[0] != nil {
2767 arg0 = args[0].(context.Context)
2768 }
2769 var arg1 port.WebViewID
2770 if args[1] != nil {
2771 arg1 = args[1].(port.WebViewID)
2772 }
2773 run(
2774 arg0,
2775 arg1,
2776 )
2777 })
2778 return _c
2779}
2780
2781func (_c *MockWebViewFactory_CreateRelated_Call) Return(webView port.WebView, err error) *MockWebViewFactory_CreateRelated_Call {
2782 _c.Call.Return(webView, err)
2783 return _c
2784}
2785
2786func (_c *MockWebViewFactory_CreateRelated_Call) RunAndReturn(run func(ctx context.Context, parentID port.WebViewID) (port.WebView, error)) *MockWebViewFactory_CreateRelated_Call {
2787 _c.Call.Return(run)
2788 return _c
2789}
2790
2791// NewMockDevToolsOpener creates a new instance of MockDevToolsOpener. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
2792// The first argument is typically a *testing.T value.
2793func NewMockDevToolsOpener(t interface {
2794 mock.TestingT
2795 Cleanup(func())
2796}) *MockDevToolsOpener {
2797 if helper, ok := t.(interface{ Helper() }); ok {
2798 helper.Helper()
2799 }
2800
2801 mock := &MockDevToolsOpener{}
2802 mock.Mock.Test(t)
2803
2804 t.Cleanup(func() {
2805 if helper, ok := t.(interface{ Helper() }); ok {
2806 helper.Helper()
2807 }
2808 mock.AssertExpectations(t)
2809 })
2810
2811 return mock
2812}
2813
2814// MockDevToolsOpener is an autogenerated mock type for the DevToolsOpener type
2815type MockDevToolsOpener struct {
2816 mock.Mock
2817}
2818
2819type MockDevToolsOpener_Expecter struct {
2820 mock *mock.Mock
2821}
2822
2823func (_m *MockDevToolsOpener) EXPECT() *MockDevToolsOpener_Expecter {
2824 return &MockDevToolsOpener_Expecter{mock: &_m.Mock}
2825}
2826
2827// OpenDevTools provides a mock function for the type MockDevToolsOpener
2828func (_mock *MockDevToolsOpener) OpenDevTools() {
2829 _mock.Called()
2830 return
2831}
2832
2833// MockDevToolsOpener_OpenDevTools_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OpenDevTools'
2834type MockDevToolsOpener_OpenDevTools_Call struct {
2835 *mock.Call
2836}
2837
2838// OpenDevTools is a helper method to define mock.On call
2839func (_e *MockDevToolsOpener_Expecter) OpenDevTools() *MockDevToolsOpener_OpenDevTools_Call {
2840 return &MockDevToolsOpener_OpenDevTools_Call{Call: _e.mock.On("OpenDevTools")}
2841}
2842
2843func (_c *MockDevToolsOpener_OpenDevTools_Call) Run(run func()) *MockDevToolsOpener_OpenDevTools_Call {
2844 _c.Call.Run(func(args mock.Arguments) {
2845 run()
2846 })
2847 return _c
2848}
2849
2850func (_c *MockDevToolsOpener_OpenDevTools_Call) Return() *MockDevToolsOpener_OpenDevTools_Call {
2851 _c.Call.Return()
2852 return _c
2853}
2854
2855func (_c *MockDevToolsOpener_OpenDevTools_Call) RunAndReturn(run func()) *MockDevToolsOpener_OpenDevTools_Call {
2856 _c.Run(run)
2857 return _c
2858}
2859
2860// NewMockPrinter creates a new instance of MockPrinter. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
2861// The first argument is typically a *testing.T value.
2862func NewMockPrinter(t interface {
2863 mock.TestingT
2864 Cleanup(func())
2865}) *MockPrinter {
2866 if helper, ok := t.(interface{ Helper() }); ok {
2867 helper.Helper()
2868 }
2869
2870 mock := &MockPrinter{}
2871 mock.Mock.Test(t)
2872
2873 t.Cleanup(func() {
2874 if helper, ok := t.(interface{ Helper() }); ok {
2875 helper.Helper()
2876 }
2877 mock.AssertExpectations(t)
2878 })
2879
2880 return mock
2881}
2882
2883// MockPrinter is an autogenerated mock type for the Printer type
2884type MockPrinter struct {
2885 mock.Mock
2886}
2887
2888type MockPrinter_Expecter struct {
2889 mock *mock.Mock
2890}
2891
2892func (_m *MockPrinter) EXPECT() *MockPrinter_Expecter {
2893 return &MockPrinter_Expecter{mock: &_m.Mock}
2894}
2895
2896// PrintPage provides a mock function for the type MockPrinter
2897func (_mock *MockPrinter) PrintPage() {
2898 _mock.Called()
2899 return
2900}
2901
2902// MockPrinter_PrintPage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PrintPage'
2903type MockPrinter_PrintPage_Call struct {
2904 *mock.Call
2905}
2906
2907// PrintPage is a helper method to define mock.On call
2908func (_e *MockPrinter_Expecter) PrintPage() *MockPrinter_PrintPage_Call {
2909 return &MockPrinter_PrintPage_Call{Call: _e.mock.On("PrintPage")}
2910}
2911
2912func (_c *MockPrinter_PrintPage_Call) Run(run func()) *MockPrinter_PrintPage_Call {
2913 _c.Call.Run(func(args mock.Arguments) {
2914 run()
2915 })
2916 return _c
2917}
2918
2919func (_c *MockPrinter_PrintPage_Call) Return() *MockPrinter_PrintPage_Call {
2920 _c.Call.Return()
2921 return _c
2922}
2923
2924func (_c *MockPrinter_PrintPage_Call) RunAndReturn(run func()) *MockPrinter_PrintPage_Call {
2925 _c.Run(run)
2926 return _c
2927}
2928
2929// NewMockPopupLifecycleCapable creates a new instance of MockPopupLifecycleCapable. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
2930// The first argument is typically a *testing.T value.
2931func NewMockPopupLifecycleCapable(t interface {
2932 mock.TestingT
2933 Cleanup(func())
2934}) *MockPopupLifecycleCapable {
2935 if helper, ok := t.(interface{ Helper() }); ok {
2936 helper.Helper()
2937 }
2938
2939 mock := &MockPopupLifecycleCapable{}
2940 mock.Mock.Test(t)
2941
2942 t.Cleanup(func() {
2943 if helper, ok := t.(interface{ Helper() }); ok {
2944 helper.Helper()
2945 }
2946 mock.AssertExpectations(t)
2947 })
2948
2949 return mock
2950}
2951
2952// MockPopupLifecycleCapable is an autogenerated mock type for the PopupLifecycleCapable type
2953type MockPopupLifecycleCapable struct {
2954 mock.Mock
2955}
2956
2957type MockPopupLifecycleCapable_Expecter struct {
2958 mock *mock.Mock
2959}
2960
2961func (_m *MockPopupLifecycleCapable) EXPECT() *MockPopupLifecycleCapable_Expecter {
2962 return &MockPopupLifecycleCapable_Expecter{mock: &_m.Mock}
2963}
2964
2965// PrimePopupNavigation provides a mock function for the type MockPopupLifecycleCapable
2966func (_mock *MockPopupLifecycleCapable) PrimePopupNavigation(uri string) {
2967 _mock.Called(uri)
2968 return
2969}
2970
2971// MockPopupLifecycleCapable_PrimePopupNavigation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PrimePopupNavigation'
2972type MockPopupLifecycleCapable_PrimePopupNavigation_Call struct {
2973 *mock.Call
2974}
2975
2976// PrimePopupNavigation is a helper method to define mock.On call
2977// - uri string
2978func (_e *MockPopupLifecycleCapable_Expecter) PrimePopupNavigation(uri any) *MockPopupLifecycleCapable_PrimePopupNavigation_Call {
2979 return &MockPopupLifecycleCapable_PrimePopupNavigation_Call{Call: _e.mock.On("PrimePopupNavigation", uri)}
2980}
2981
2982func (_c *MockPopupLifecycleCapable_PrimePopupNavigation_Call) Run(run func(uri string)) *MockPopupLifecycleCapable_PrimePopupNavigation_Call {
2983 _c.Call.Run(func(args mock.Arguments) {
2984 var arg0 string
2985 if args[0] != nil {
2986 arg0 = args[0].(string)
2987 }
2988 run(
2989 arg0,
2990 )
2991 })
2992 return _c
2993}
2994
2995func (_c *MockPopupLifecycleCapable_PrimePopupNavigation_Call) Return() *MockPopupLifecycleCapable_PrimePopupNavigation_Call {
2996 _c.Call.Return()
2997 return _c
2998}
2999
3000func (_c *MockPopupLifecycleCapable_PrimePopupNavigation_Call) RunAndReturn(run func(uri string)) *MockPopupLifecycleCapable_PrimePopupNavigation_Call {
3001 _c.Run(run)
3002 return _c
3003}
3004
3005// SetOnClose provides a mock function for the type MockPopupLifecycleCapable
3006func (_mock *MockPopupLifecycleCapable) SetOnClose(fn func()) {
3007 _mock.Called(fn)
3008 return
3009}
3010
3011// MockPopupLifecycleCapable_SetOnClose_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetOnClose'
3012type MockPopupLifecycleCapable_SetOnClose_Call struct {
3013 *mock.Call
3014}
3015
3016// SetOnClose is a helper method to define mock.On call
3017// - fn func()
3018func (_e *MockPopupLifecycleCapable_Expecter) SetOnClose(fn any) *MockPopupLifecycleCapable_SetOnClose_Call {
3019 return &MockPopupLifecycleCapable_SetOnClose_Call{Call: _e.mock.On("SetOnClose", fn)}
3020}
3021
3022func (_c *MockPopupLifecycleCapable_SetOnClose_Call) Run(run func(fn func())) *MockPopupLifecycleCapable_SetOnClose_Call {
3023 _c.Call.Run(func(args mock.Arguments) {
3024 var arg0 func()
3025 if args[0] != nil {
3026 arg0 = args[0].(func())
3027 }
3028 run(
3029 arg0,
3030 )
3031 })
3032 return _c
3033}
3034
3035func (_c *MockPopupLifecycleCapable_SetOnClose_Call) Return() *MockPopupLifecycleCapable_SetOnClose_Call {
3036 _c.Call.Return()
3037 return _c
3038}
3039
3040func (_c *MockPopupLifecycleCapable_SetOnClose_Call) RunAndReturn(run func(fn func())) *MockPopupLifecycleCapable_SetOnClose_Call {
3041 _c.Run(run)
3042 return _c
3043}
3044
3045// SetOnReadyToShow provides a mock function for the type MockPopupLifecycleCapable
3046func (_mock *MockPopupLifecycleCapable) SetOnReadyToShow(fn func()) {
3047 _mock.Called(fn)
3048 return
3049}
3050
3051// MockPopupLifecycleCapable_SetOnReadyToShow_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetOnReadyToShow'
3052type MockPopupLifecycleCapable_SetOnReadyToShow_Call struct {
3053 *mock.Call
3054}
3055
3056// SetOnReadyToShow is a helper method to define mock.On call
3057// - fn func()
3058func (_e *MockPopupLifecycleCapable_Expecter) SetOnReadyToShow(fn any) *MockPopupLifecycleCapable_SetOnReadyToShow_Call {
3059 return &MockPopupLifecycleCapable_SetOnReadyToShow_Call{Call: _e.mock.On("SetOnReadyToShow", fn)}
3060}
3061
3062func (_c *MockPopupLifecycleCapable_SetOnReadyToShow_Call) Run(run func(fn func())) *MockPopupLifecycleCapable_SetOnReadyToShow_Call {
3063 _c.Call.Run(func(args mock.Arguments) {
3064 var arg0 func()
3065 if args[0] != nil {
3066 arg0 = args[0].(func())
3067 }
3068 run(
3069 arg0,
3070 )
3071 })
3072 return _c
3073}
3074
3075func (_c *MockPopupLifecycleCapable_SetOnReadyToShow_Call) Return() *MockPopupLifecycleCapable_SetOnReadyToShow_Call {
3076 _c.Call.Return()
3077 return _c
3078}
3079
3080func (_c *MockPopupLifecycleCapable_SetOnReadyToShow_Call) RunAndReturn(run func(fn func())) *MockPopupLifecycleCapable_SetOnReadyToShow_Call {
3081 _c.Run(run)
3082 return _c
3083}
3084
3085// Show provides a mock function for the type MockPopupLifecycleCapable
3086func (_mock *MockPopupLifecycleCapable) Show() {
3087 _mock.Called()
3088 return
3089}
3090
3091// MockPopupLifecycleCapable_Show_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Show'
3092type MockPopupLifecycleCapable_Show_Call struct {
3093 *mock.Call
3094}
3095
3096// Show is a helper method to define mock.On call
3097func (_e *MockPopupLifecycleCapable_Expecter) Show() *MockPopupLifecycleCapable_Show_Call {
3098 return &MockPopupLifecycleCapable_Show_Call{Call: _e.mock.On("Show")}
3099}
3100
3101func (_c *MockPopupLifecycleCapable_Show_Call) Run(run func()) *MockPopupLifecycleCapable_Show_Call {
3102 _c.Call.Run(func(args mock.Arguments) {
3103 run()
3104 })
3105 return _c
3106}
3107
3108func (_c *MockPopupLifecycleCapable_Show_Call) Return() *MockPopupLifecycleCapable_Show_Call {
3109 _c.Call.Return()
3110 return _c
3111}
3112
3113func (_c *MockPopupLifecycleCapable_Show_Call) RunAndReturn(run func()) *MockPopupLifecycleCapable_Show_Call {
3114 _c.Run(run)
3115 return _c
3116}
3117
3118// NewMockPopupFeatureResolver creates a new instance of MockPopupFeatureResolver. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
3119// The first argument is typically a *testing.T value.
3120func NewMockPopupFeatureResolver(t interface {
3121 mock.TestingT
3122 Cleanup(func())
3123}) *MockPopupFeatureResolver {
3124 if helper, ok := t.(interface{ Helper() }); ok {
3125 helper.Helper()
3126 }
3127
3128 mock := &MockPopupFeatureResolver{}
3129 mock.Mock.Test(t)
3130
3131 t.Cleanup(func() {
3132 if helper, ok := t.(interface{ Helper() }); ok {
3133 helper.Helper()
3134 }
3135 mock.AssertExpectations(t)
3136 })
3137
3138 return mock
3139}
3140
3141// MockPopupFeatureResolver is an autogenerated mock type for the PopupFeatureResolver type
3142type MockPopupFeatureResolver struct {
3143 mock.Mock
3144}
3145
3146type MockPopupFeatureResolver_Expecter struct {
3147 mock *mock.Mock
3148}
3149
3150func (_m *MockPopupFeatureResolver) EXPECT() *MockPopupFeatureResolver_Expecter {
3151 return &MockPopupFeatureResolver_Expecter{mock: &_m.Mock}
3152}
3153
3154// ResolvePopupFeatures provides a mock function for the type MockPopupFeatureResolver
3155func (_mock *MockPopupFeatureResolver) ResolvePopupFeatures() dto.PopupFeatures {
3156 ret := _mock.Called()
3157
3158 if len(ret) == 0 {
3159 panic("no return value specified for ResolvePopupFeatures")
3160 }
3161
3162 var r0 dto.PopupFeatures
3163 if returnFunc, ok := ret.Get(0).(func() dto.PopupFeatures); ok {
3164 r0 = returnFunc()
3165 } else {
3166 r0 = ret.Get(0).(dto.PopupFeatures)
3167 }
3168 return r0
3169}
3170
3171// MockPopupFeatureResolver_ResolvePopupFeatures_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResolvePopupFeatures'
3172type MockPopupFeatureResolver_ResolvePopupFeatures_Call struct {
3173 *mock.Call
3174}
3175
3176// ResolvePopupFeatures is a helper method to define mock.On call
3177func (_e *MockPopupFeatureResolver_Expecter) ResolvePopupFeatures() *MockPopupFeatureResolver_ResolvePopupFeatures_Call {
3178 return &MockPopupFeatureResolver_ResolvePopupFeatures_Call{Call: _e.mock.On("ResolvePopupFeatures")}
3179}
3180
3181func (_c *MockPopupFeatureResolver_ResolvePopupFeatures_Call) Run(run func()) *MockPopupFeatureResolver_ResolvePopupFeatures_Call {
3182 _c.Call.Run(func(args mock.Arguments) {
3183 run()
3184 })
3185 return _c
3186}
3187
3188func (_c *MockPopupFeatureResolver_ResolvePopupFeatures_Call) Return(popupFeatures dto.PopupFeatures) *MockPopupFeatureResolver_ResolvePopupFeatures_Call {
3189 _c.Call.Return(popupFeatures)
3190 return _c
3191}
3192
3193func (_c *MockPopupFeatureResolver_ResolvePopupFeatures_Call) RunAndReturn(run func() dto.PopupFeatures) *MockPopupFeatureResolver_ResolvePopupFeatures_Call {
3194 _c.Call.Return(run)
3195 return _c
3196}
3197
3198// NewMockPopupOpenerCapable creates a new instance of MockPopupOpenerCapable. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
3199// The first argument is typically a *testing.T value.
3200func NewMockPopupOpenerCapable(t interface {
3201 mock.TestingT
3202 Cleanup(func())
3203}) *MockPopupOpenerCapable {
3204 if helper, ok := t.(interface{ Helper() }); ok {
3205 helper.Helper()
3206 }
3207
3208 mock := &MockPopupOpenerCapable{}
3209 mock.Mock.Test(t)
3210
3211 t.Cleanup(func() {
3212 if helper, ok := t.(interface{ Helper() }); ok {
3213 helper.Helper()
3214 }
3215 mock.AssertExpectations(t)
3216 })
3217
3218 return mock
3219}
3220
3221// MockPopupOpenerCapable is an autogenerated mock type for the PopupOpenerCapable type
3222type MockPopupOpenerCapable struct {
3223 mock.Mock
3224}
3225
3226type MockPopupOpenerCapable_Expecter struct {
3227 mock *mock.Mock
3228}
3229
3230func (_m *MockPopupOpenerCapable) EXPECT() *MockPopupOpenerCapable_Expecter {
3231 return &MockPopupOpenerCapable_Expecter{mock: &_m.Mock}
3232}
3233
3234// AddOpenerMessageCallback provides a mock function for the type MockPopupOpenerCapable
3235func (_mock *MockPopupOpenerCapable) AddOpenerMessageCallback(fn func()) {
3236 _mock.Called(fn)
3237 return
3238}
3239
3240// MockPopupOpenerCapable_AddOpenerMessageCallback_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddOpenerMessageCallback'
3241type MockPopupOpenerCapable_AddOpenerMessageCallback_Call struct {
3242 *mock.Call
3243}
3244
3245// AddOpenerMessageCallback is a helper method to define mock.On call
3246// - fn func()
3247func (_e *MockPopupOpenerCapable_Expecter) AddOpenerMessageCallback(fn any) *MockPopupOpenerCapable_AddOpenerMessageCallback_Call {
3248 return &MockPopupOpenerCapable_AddOpenerMessageCallback_Call{Call: _e.mock.On("AddOpenerMessageCallback", fn)}
3249}
3250
3251func (_c *MockPopupOpenerCapable_AddOpenerMessageCallback_Call) Run(run func(fn func())) *MockPopupOpenerCapable_AddOpenerMessageCallback_Call {
3252 _c.Call.Run(func(args mock.Arguments) {
3253 var arg0 func()
3254 if args[0] != nil {
3255 arg0 = args[0].(func())
3256 }
3257 run(
3258 arg0,
3259 )
3260 })
3261 return _c
3262}
3263
3264func (_c *MockPopupOpenerCapable_AddOpenerMessageCallback_Call) Return() *MockPopupOpenerCapable_AddOpenerMessageCallback_Call {
3265 _c.Call.Return()
3266 return _c
3267}
3268
3269func (_c *MockPopupOpenerCapable_AddOpenerMessageCallback_Call) RunAndReturn(run func(fn func())) *MockPopupOpenerCapable_AddOpenerMessageCallback_Call {
3270 _c.Run(run)
3271 return _c
3272}
3273
3274// AddOpenerNavigationCallback provides a mock function for the type MockPopupOpenerCapable
3275func (_mock *MockPopupOpenerCapable) AddOpenerNavigationCallback(fn func(uri string)) {
3276 _mock.Called(fn)
3277 return
3278}
3279
3280// MockPopupOpenerCapable_AddOpenerNavigationCallback_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddOpenerNavigationCallback'
3281type MockPopupOpenerCapable_AddOpenerNavigationCallback_Call struct {
3282 *mock.Call
3283}
3284
3285// AddOpenerNavigationCallback is a helper method to define mock.On call
3286// - fn func(uri string)
3287func (_e *MockPopupOpenerCapable_Expecter) AddOpenerNavigationCallback(fn any) *MockPopupOpenerCapable_AddOpenerNavigationCallback_Call {
3288 return &MockPopupOpenerCapable_AddOpenerNavigationCallback_Call{Call: _e.mock.On("AddOpenerNavigationCallback", fn)}
3289}
3290
3291func (_c *MockPopupOpenerCapable_AddOpenerNavigationCallback_Call) Run(run func(fn func(uri string))) *MockPopupOpenerCapable_AddOpenerNavigationCallback_Call {
3292 _c.Call.Run(func(args mock.Arguments) {
3293 var arg0 func(uri string)
3294 if args[0] != nil {
3295 arg0 = args[0].(func(uri string))
3296 }
3297 run(
3298 arg0,
3299 )
3300 })
3301 return _c
3302}
3303
3304func (_c *MockPopupOpenerCapable_AddOpenerNavigationCallback_Call) Return() *MockPopupOpenerCapable_AddOpenerNavigationCallback_Call {
3305 _c.Call.Return()
3306 return _c
3307}
3308
3309func (_c *MockPopupOpenerCapable_AddOpenerNavigationCallback_Call) RunAndReturn(run func(fn func(uri string))) *MockPopupOpenerCapable_AddOpenerNavigationCallback_Call {
3310 _c.Run(run)
3311 return _c
3312}
3313
3314// EnablePopupOpenerBridge provides a mock function for the type MockPopupOpenerCapable
3315func (_mock *MockPopupOpenerCapable) EnablePopupOpenerBridge(parent port.WebView, noJavaScriptAccess bool) {
3316 _mock.Called(parent, noJavaScriptAccess)
3317 return
3318}
3319
3320// MockPopupOpenerCapable_EnablePopupOpenerBridge_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EnablePopupOpenerBridge'
3321type MockPopupOpenerCapable_EnablePopupOpenerBridge_Call struct {
3322 *mock.Call
3323}
3324
3325// EnablePopupOpenerBridge is a helper method to define mock.On call
3326// - parent port.WebView
3327// - noJavaScriptAccess bool
3328func (_e *MockPopupOpenerCapable_Expecter) EnablePopupOpenerBridge(parent any, noJavaScriptAccess any) *MockPopupOpenerCapable_EnablePopupOpenerBridge_Call {
3329 return &MockPopupOpenerCapable_EnablePopupOpenerBridge_Call{Call: _e.mock.On("EnablePopupOpenerBridge", parent, noJavaScriptAccess)}
3330}
3331
3332func (_c *MockPopupOpenerCapable_EnablePopupOpenerBridge_Call) Run(run func(parent port.WebView, noJavaScriptAccess bool)) *MockPopupOpenerCapable_EnablePopupOpenerBridge_Call {
3333 _c.Call.Run(func(args mock.Arguments) {
3334 var arg0 port.WebView
3335 if args[0] != nil {
3336 arg0 = args[0].(port.WebView)
3337 }
3338 var arg1 bool
3339 if args[1] != nil {
3340 arg1 = args[1].(bool)
3341 }
3342 run(
3343 arg0,
3344 arg1,
3345 )
3346 })
3347 return _c
3348}
3349
3350func (_c *MockPopupOpenerCapable_EnablePopupOpenerBridge_Call) Return() *MockPopupOpenerCapable_EnablePopupOpenerBridge_Call {
3351 _c.Call.Return()
3352 return _c
3353}
3354
3355func (_c *MockPopupOpenerCapable_EnablePopupOpenerBridge_Call) RunAndReturn(run func(parent port.WebView, noJavaScriptAccess bool)) *MockPopupOpenerCapable_EnablePopupOpenerBridge_Call {
3356 _c.Run(run)
3357 return _c
3358}
3359
3360// HasActivePopupOpenerBridge provides a mock function for the type MockPopupOpenerCapable
3361func (_mock *MockPopupOpenerCapable) HasActivePopupOpenerBridge() bool {
3362 ret := _mock.Called()
3363
3364 if len(ret) == 0 {
3365 panic("no return value specified for HasActivePopupOpenerBridge")
3366 }
3367
3368 var r0 bool
3369 if returnFunc, ok := ret.Get(0).(func() bool); ok {
3370 r0 = returnFunc()
3371 } else {
3372 r0 = ret.Get(0).(bool)
3373 }
3374 return r0
3375}
3376
3377// MockPopupOpenerCapable_HasActivePopupOpenerBridge_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasActivePopupOpenerBridge'
3378type MockPopupOpenerCapable_HasActivePopupOpenerBridge_Call struct {
3379 *mock.Call
3380}
3381
3382// HasActivePopupOpenerBridge is a helper method to define mock.On call
3383func (_e *MockPopupOpenerCapable_Expecter) HasActivePopupOpenerBridge() *MockPopupOpenerCapable_HasActivePopupOpenerBridge_Call {
3384 return &MockPopupOpenerCapable_HasActivePopupOpenerBridge_Call{Call: _e.mock.On("HasActivePopupOpenerBridge")}
3385}
3386
3387func (_c *MockPopupOpenerCapable_HasActivePopupOpenerBridge_Call) Run(run func()) *MockPopupOpenerCapable_HasActivePopupOpenerBridge_Call {
3388 _c.Call.Run(func(args mock.Arguments) {
3389 run()
3390 })
3391 return _c
3392}
3393
3394func (_c *MockPopupOpenerCapable_HasActivePopupOpenerBridge_Call) Return(b bool) *MockPopupOpenerCapable_HasActivePopupOpenerBridge_Call {
3395 _c.Call.Return(b)
3396 return _c
3397}
3398
3399func (_c *MockPopupOpenerCapable_HasActivePopupOpenerBridge_Call) RunAndReturn(run func() bool) *MockPopupOpenerCapable_HasActivePopupOpenerBridge_Call {
3400 _c.Call.Return(run)
3401 return _c
3402}
3403
3404// NewMockOAuthCallbackCapable creates a new instance of MockOAuthCallbackCapable. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
3405// The first argument is typically a *testing.T value.
3406func NewMockOAuthCallbackCapable(t interface {
3407 mock.TestingT
3408 Cleanup(func())
3409}) *MockOAuthCallbackCapable {
3410 if helper, ok := t.(interface{ Helper() }); ok {
3411 helper.Helper()
3412 }
3413
3414 mock := &MockOAuthCallbackCapable{}
3415 mock.Mock.Test(t)
3416
3417 t.Cleanup(func() {
3418 if helper, ok := t.(interface{ Helper() }); ok {
3419 helper.Helper()
3420 }
3421 mock.AssertExpectations(t)
3422 })
3423
3424 return mock
3425}
3426
3427// MockOAuthCallbackCapable is an autogenerated mock type for the OAuthCallbackCapable type
3428type MockOAuthCallbackCapable struct {
3429 mock.Mock
3430}
3431
3432type MockOAuthCallbackCapable_Expecter struct {
3433 mock *mock.Mock
3434}
3435
3436func (_m *MockOAuthCallbackCapable) EXPECT() *MockOAuthCallbackCapable_Expecter {
3437 return &MockOAuthCallbackCapable_Expecter{mock: &_m.Mock}
3438}
3439
3440// AddCloseCallback provides a mock function for the type MockOAuthCallbackCapable
3441func (_mock *MockOAuthCallbackCapable) AddCloseCallback(fn func()) {
3442 _mock.Called(fn)
3443 return
3444}
3445
3446// MockOAuthCallbackCapable_AddCloseCallback_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddCloseCallback'
3447type MockOAuthCallbackCapable_AddCloseCallback_Call struct {
3448 *mock.Call
3449}
3450
3451// AddCloseCallback is a helper method to define mock.On call
3452// - fn func()
3453func (_e *MockOAuthCallbackCapable_Expecter) AddCloseCallback(fn any) *MockOAuthCallbackCapable_AddCloseCallback_Call {
3454 return &MockOAuthCallbackCapable_AddCloseCallback_Call{Call: _e.mock.On("AddCloseCallback", fn)}
3455}
3456
3457func (_c *MockOAuthCallbackCapable_AddCloseCallback_Call) Run(run func(fn func())) *MockOAuthCallbackCapable_AddCloseCallback_Call {
3458 _c.Call.Run(func(args mock.Arguments) {
3459 var arg0 func()
3460 if args[0] != nil {
3461 arg0 = args[0].(func())
3462 }
3463 run(
3464 arg0,
3465 )
3466 })
3467 return _c
3468}
3469
3470func (_c *MockOAuthCallbackCapable_AddCloseCallback_Call) Return() *MockOAuthCallbackCapable_AddCloseCallback_Call {
3471 _c.Call.Return()
3472 return _c
3473}
3474
3475func (_c *MockOAuthCallbackCapable_AddCloseCallback_Call) RunAndReturn(run func(fn func())) *MockOAuthCallbackCapable_AddCloseCallback_Call {
3476 _c.Run(run)
3477 return _c
3478}
3479
3480// AddNavigationCallback provides a mock function for the type MockOAuthCallbackCapable
3481func (_mock *MockOAuthCallbackCapable) AddNavigationCallback(fn func(uri string)) {
3482 _mock.Called(fn)
3483 return
3484}
3485
3486// MockOAuthCallbackCapable_AddNavigationCallback_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddNavigationCallback'
3487type MockOAuthCallbackCapable_AddNavigationCallback_Call struct {
3488 *mock.Call
3489}
3490
3491// AddNavigationCallback is a helper method to define mock.On call
3492// - fn func(uri string)
3493func (_e *MockOAuthCallbackCapable_Expecter) AddNavigationCallback(fn any) *MockOAuthCallbackCapable_AddNavigationCallback_Call {
3494 return &MockOAuthCallbackCapable_AddNavigationCallback_Call{Call: _e.mock.On("AddNavigationCallback", fn)}
3495}
3496
3497func (_c *MockOAuthCallbackCapable_AddNavigationCallback_Call) Run(run func(fn func(uri string))) *MockOAuthCallbackCapable_AddNavigationCallback_Call {
3498 _c.Call.Run(func(args mock.Arguments) {
3499 var arg0 func(uri string)
3500 if args[0] != nil {
3501 arg0 = args[0].(func(uri string))
3502 }
3503 run(
3504 arg0,
3505 )
3506 })
3507 return _c
3508}
3509
3510func (_c *MockOAuthCallbackCapable_AddNavigationCallback_Call) Return() *MockOAuthCallbackCapable_AddNavigationCallback_Call {
3511 _c.Call.Return()
3512 return _c
3513}
3514
3515func (_c *MockOAuthCallbackCapable_AddNavigationCallback_Call) RunAndReturn(run func(fn func(uri string))) *MockOAuthCallbackCapable_AddNavigationCallback_Call {
3516 _c.Run(run)
3517 return _c
3518}
3519
3520// Close provides a mock function for the type MockOAuthCallbackCapable
3521func (_mock *MockOAuthCallbackCapable) Close() {
3522 _mock.Called()
3523 return
3524}
3525
3526// MockOAuthCallbackCapable_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
3527type MockOAuthCallbackCapable_Close_Call struct {
3528 *mock.Call
3529}
3530
3531// Close is a helper method to define mock.On call
3532func (_e *MockOAuthCallbackCapable_Expecter) Close() *MockOAuthCallbackCapable_Close_Call {
3533 return &MockOAuthCallbackCapable_Close_Call{Call: _e.mock.On("Close")}
3534}
3535
3536func (_c *MockOAuthCallbackCapable_Close_Call) Run(run func()) *MockOAuthCallbackCapable_Close_Call {
3537 _c.Call.Run(func(args mock.Arguments) {
3538 run()
3539 })
3540 return _c
3541}
3542
3543func (_c *MockOAuthCallbackCapable_Close_Call) Return() *MockOAuthCallbackCapable_Close_Call {
3544 _c.Call.Return()
3545 return _c
3546}
3547
3548func (_c *MockOAuthCallbackCapable_Close_Call) RunAndReturn(run func()) *MockOAuthCallbackCapable_Close_Call {
3549 _c.Run(run)
3550 return _c
3551}
3552
3553// NewMockTextInputTargetProvider creates a new instance of MockTextInputTargetProvider. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
3554// The first argument is typically a *testing.T value.
3555func NewMockTextInputTargetProvider(t interface {
3556 mock.TestingT
3557 Cleanup(func())
3558}) *MockTextInputTargetProvider {
3559 if helper, ok := t.(interface{ Helper() }); ok {
3560 helper.Helper()
3561 }
3562
3563 mock := &MockTextInputTargetProvider{}
3564 mock.Mock.Test(t)
3565
3566 t.Cleanup(func() {
3567 if helper, ok := t.(interface{ Helper() }); ok {
3568 helper.Helper()
3569 }
3570 mock.AssertExpectations(t)
3571 })
3572
3573 return mock
3574}
3575
3576// MockTextInputTargetProvider is an autogenerated mock type for the TextInputTargetProvider type
3577type MockTextInputTargetProvider struct {
3578 mock.Mock
3579}
3580
3581type MockTextInputTargetProvider_Expecter struct {
3582 mock *mock.Mock
3583}
3584
3585func (_m *MockTextInputTargetProvider) EXPECT() *MockTextInputTargetProvider_Expecter {
3586 return &MockTextInputTargetProvider_Expecter{mock: &_m.Mock}
3587}
3588
3589// TextInputTarget provides a mock function for the type MockTextInputTargetProvider
3590func (_mock *MockTextInputTargetProvider) TextInputTarget() port.TextInputTarget {
3591 ret := _mock.Called()
3592
3593 if len(ret) == 0 {
3594 panic("no return value specified for TextInputTarget")
3595 }
3596
3597 var r0 port.TextInputTarget
3598 if returnFunc, ok := ret.Get(0).(func() port.TextInputTarget); ok {
3599 r0 = returnFunc()
3600 } else {
3601 if ret.Get(0) != nil {
3602 r0 = ret.Get(0).(port.TextInputTarget)
3603 }
3604 }
3605 return r0
3606}
3607
3608// MockTextInputTargetProvider_TextInputTarget_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TextInputTarget'
3609type MockTextInputTargetProvider_TextInputTarget_Call struct {
3610 *mock.Call
3611}
3612
3613// TextInputTarget is a helper method to define mock.On call
3614func (_e *MockTextInputTargetProvider_Expecter) TextInputTarget() *MockTextInputTargetProvider_TextInputTarget_Call {
3615 return &MockTextInputTargetProvider_TextInputTarget_Call{Call: _e.mock.On("TextInputTarget")}
3616}
3617
3618func (_c *MockTextInputTargetProvider_TextInputTarget_Call) Run(run func()) *MockTextInputTargetProvider_TextInputTarget_Call {
3619 _c.Call.Run(func(args mock.Arguments) {
3620 run()
3621 })
3622 return _c
3623}
3624
3625func (_c *MockTextInputTargetProvider_TextInputTarget_Call) Return(textInputTarget port.TextInputTarget) *MockTextInputTargetProvider_TextInputTarget_Call {
3626 _c.Call.Return(textInputTarget)
3627 return _c
3628}
3629
3630func (_c *MockTextInputTargetProvider_TextInputTarget_Call) RunAndReturn(run func() port.TextInputTarget) *MockTextInputTargetProvider_TextInputTarget_Call {
3631 _c.Call.Return(run)
3632 return _c
3633}
3634
3635// NewMockPageScrollable creates a new instance of MockPageScrollable. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
3636// The first argument is typically a *testing.T value.
3637func NewMockPageScrollable(t interface {
3638 mock.TestingT
3639 Cleanup(func())
3640}) *MockPageScrollable {
3641 if helper, ok := t.(interface{ Helper() }); ok {
3642 helper.Helper()
3643 }
3644
3645 mock := &MockPageScrollable{}
3646 mock.Mock.Test(t)
3647
3648 t.Cleanup(func() {
3649 if helper, ok := t.(interface{ Helper() }); ok {
3650 helper.Helper()
3651 }
3652 mock.AssertExpectations(t)
3653 })
3654
3655 return mock
3656}
3657
3658// MockPageScrollable is an autogenerated mock type for the PageScrollable type
3659type MockPageScrollable struct {
3660 mock.Mock
3661}
3662
3663type MockPageScrollable_Expecter struct {
3664 mock *mock.Mock
3665}
3666
3667func (_m *MockPageScrollable) EXPECT() *MockPageScrollable_Expecter {
3668 return &MockPageScrollable_Expecter{mock: &_m.Mock}
3669}
3670
3671// ScrollPage provides a mock function for the type MockPageScrollable
3672func (_mock *MockPageScrollable) ScrollPage(ctx context.Context, request port.PageScrollRequest) error {
3673 ret := _mock.Called(ctx, request)
3674
3675 if len(ret) == 0 {
3676 panic("no return value specified for ScrollPage")
3677 }
3678
3679 var r0 error
3680 if returnFunc, ok := ret.Get(0).(func(context.Context, port.PageScrollRequest) error); ok {
3681 r0 = returnFunc(ctx, request)
3682 } else {
3683 r0 = ret.Error(0)
3684 }
3685 return r0
3686}
3687
3688// MockPageScrollable_ScrollPage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ScrollPage'
3689type MockPageScrollable_ScrollPage_Call struct {
3690 *mock.Call
3691}
3692
3693// ScrollPage is a helper method to define mock.On call
3694// - ctx context.Context
3695// - request port.PageScrollRequest
3696func (_e *MockPageScrollable_Expecter) ScrollPage(ctx any, request any) *MockPageScrollable_ScrollPage_Call {
3697 return &MockPageScrollable_ScrollPage_Call{Call: _e.mock.On("ScrollPage", ctx, request)}
3698}
3699
3700func (_c *MockPageScrollable_ScrollPage_Call) Run(run func(ctx context.Context, request port.PageScrollRequest)) *MockPageScrollable_ScrollPage_Call {
3701 _c.Call.Run(func(args mock.Arguments) {
3702 var arg0 context.Context
3703 if args[0] != nil {
3704 arg0 = args[0].(context.Context)
3705 }
3706 var arg1 port.PageScrollRequest
3707 if args[1] != nil {
3708 arg1 = args[1].(port.PageScrollRequest)
3709 }
3710 run(
3711 arg0,
3712 arg1,
3713 )
3714 })
3715 return _c
3716}
3717
3718func (_c *MockPageScrollable_ScrollPage_Call) Return(err error) *MockPageScrollable_ScrollPage_Call {
3719 _c.Call.Return(err)
3720 return _c
3721}
3722
3723func (_c *MockPageScrollable_ScrollPage_Call) RunAndReturn(run func(ctx context.Context, request port.PageScrollRequest) error) *MockPageScrollable_ScrollPage_Call {
3724 _c.Call.Return(run)
3725 return _c
3726}
3727
3728// NewMockVimPageInteractor creates a new instance of MockVimPageInteractor. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
3729// The first argument is typically a *testing.T value.
3730func NewMockVimPageInteractor(t interface {
3731 mock.TestingT
3732 Cleanup(func())
3733}) *MockVimPageInteractor {
3734 if helper, ok := t.(interface{ Helper() }); ok {
3735 helper.Helper()
3736 }
3737
3738 mock := &MockVimPageInteractor{}
3739 mock.Mock.Test(t)
3740
3741 t.Cleanup(func() {
3742 if helper, ok := t.(interface{ Helper() }); ok {
3743 helper.Helper()
3744 }
3745 mock.AssertExpectations(t)
3746 })
3747
3748 return mock
3749}
3750
3751// MockVimPageInteractor is an autogenerated mock type for the VimPageInteractor type
3752type MockVimPageInteractor struct {
3753 mock.Mock
3754}
3755
3756type MockVimPageInteractor_Expecter struct {
3757 mock *mock.Mock
3758}
3759
3760func (_m *MockVimPageInteractor) EXPECT() *MockVimPageInteractor_Expecter {
3761 return &MockVimPageInteractor_Expecter{mock: &_m.Mock}
3762}
3763
3764// CancelVimPageInteraction provides a mock function for the type MockVimPageInteractor
3765func (_mock *MockVimPageInteractor) CancelVimPageInteraction(ctx context.Context) error {
3766 ret := _mock.Called(ctx)
3767
3768 if len(ret) == 0 {
3769 panic("no return value specified for CancelVimPageInteraction")
3770 }
3771
3772 var r0 error
3773 if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
3774 r0 = returnFunc(ctx)
3775 } else {
3776 r0 = ret.Error(0)
3777 }
3778 return r0
3779}
3780
3781// MockVimPageInteractor_CancelVimPageInteraction_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CancelVimPageInteraction'
3782type MockVimPageInteractor_CancelVimPageInteraction_Call struct {
3783 *mock.Call
3784}
3785
3786// CancelVimPageInteraction is a helper method to define mock.On call
3787// - ctx context.Context
3788func (_e *MockVimPageInteractor_Expecter) CancelVimPageInteraction(ctx any) *MockVimPageInteractor_CancelVimPageInteraction_Call {
3789 return &MockVimPageInteractor_CancelVimPageInteraction_Call{Call: _e.mock.On("CancelVimPageInteraction", ctx)}
3790}
3791
3792func (_c *MockVimPageInteractor_CancelVimPageInteraction_Call) Run(run func(ctx context.Context)) *MockVimPageInteractor_CancelVimPageInteraction_Call {
3793 _c.Call.Run(func(args mock.Arguments) {
3794 var arg0 context.Context
3795 if args[0] != nil {
3796 arg0 = args[0].(context.Context)
3797 }
3798 run(
3799 arg0,
3800 )
3801 })
3802 return _c
3803}
3804
3805func (_c *MockVimPageInteractor_CancelVimPageInteraction_Call) Return(err error) *MockVimPageInteractor_CancelVimPageInteraction_Call {
3806 _c.Call.Return(err)
3807 return _c
3808}
3809
3810func (_c *MockVimPageInteractor_CancelVimPageInteraction_Call) RunAndReturn(run func(ctx context.Context) error) *MockVimPageInteractor_CancelVimPageInteraction_Call {
3811 _c.Call.Return(run)
3812 return _c
3813}
3814
3815// SendVimPageKey provides a mock function for the type MockVimPageInteractor
3816func (_mock *MockVimPageInteractor) SendVimPageKey(ctx context.Context, key string) error {
3817 ret := _mock.Called(ctx, key)
3818
3819 if len(ret) == 0 {
3820 panic("no return value specified for SendVimPageKey")
3821 }
3822
3823 var r0 error
3824 if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
3825 r0 = returnFunc(ctx, key)
3826 } else {
3827 r0 = ret.Error(0)
3828 }
3829 return r0
3830}
3831
3832// MockVimPageInteractor_SendVimPageKey_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendVimPageKey'
3833type MockVimPageInteractor_SendVimPageKey_Call struct {
3834 *mock.Call
3835}
3836
3837// SendVimPageKey is a helper method to define mock.On call
3838// - ctx context.Context
3839// - key string
3840func (_e *MockVimPageInteractor_Expecter) SendVimPageKey(ctx any, key any) *MockVimPageInteractor_SendVimPageKey_Call {
3841 return &MockVimPageInteractor_SendVimPageKey_Call{Call: _e.mock.On("SendVimPageKey", ctx, key)}
3842}
3843
3844func (_c *MockVimPageInteractor_SendVimPageKey_Call) Run(run func(ctx context.Context, key string)) *MockVimPageInteractor_SendVimPageKey_Call {
3845 _c.Call.Run(func(args mock.Arguments) {
3846 var arg0 context.Context
3847 if args[0] != nil {
3848 arg0 = args[0].(context.Context)
3849 }
3850 var arg1 string
3851 if args[1] != nil {
3852 arg1 = args[1].(string)
3853 }
3854 run(
3855 arg0,
3856 arg1,
3857 )
3858 })
3859 return _c
3860}
3861
3862func (_c *MockVimPageInteractor_SendVimPageKey_Call) Return(err error) *MockVimPageInteractor_SendVimPageKey_Call {
3863 _c.Call.Return(err)
3864 return _c
3865}
3866
3867func (_c *MockVimPageInteractor_SendVimPageKey_Call) RunAndReturn(run func(ctx context.Context, key string) error) *MockVimPageInteractor_SendVimPageKey_Call {
3868 _c.Call.Return(run)
3869 return _c
3870}
3871
3872// StartVimPageInteraction provides a mock function for the type MockVimPageInteractor
3873func (_mock *MockVimPageInteractor) StartVimPageInteraction(ctx context.Context, request dto.VimPageInteractionRequest) error {
3874 ret := _mock.Called(ctx, request)
3875
3876 if len(ret) == 0 {
3877 panic("no return value specified for StartVimPageInteraction")
3878 }
3879
3880 var r0 error
3881 if returnFunc, ok := ret.Get(0).(func(context.Context, dto.VimPageInteractionRequest) error); ok {
3882 r0 = returnFunc(ctx, request)
3883 } else {
3884 r0 = ret.Error(0)
3885 }
3886 return r0
3887}
3888
3889// MockVimPageInteractor_StartVimPageInteraction_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StartVimPageInteraction'
3890type MockVimPageInteractor_StartVimPageInteraction_Call struct {
3891 *mock.Call
3892}
3893
3894// StartVimPageInteraction is a helper method to define mock.On call
3895// - ctx context.Context
3896// - request dto.VimPageInteractionRequest
3897func (_e *MockVimPageInteractor_Expecter) StartVimPageInteraction(ctx any, request any) *MockVimPageInteractor_StartVimPageInteraction_Call {
3898 return &MockVimPageInteractor_StartVimPageInteraction_Call{Call: _e.mock.On("StartVimPageInteraction", ctx, request)}
3899}
3900
3901func (_c *MockVimPageInteractor_StartVimPageInteraction_Call) Run(run func(ctx context.Context, request dto.VimPageInteractionRequest)) *MockVimPageInteractor_StartVimPageInteraction_Call {
3902 _c.Call.Run(func(args mock.Arguments) {
3903 var arg0 context.Context
3904 if args[0] != nil {
3905 arg0 = args[0].(context.Context)
3906 }
3907 var arg1 dto.VimPageInteractionRequest
3908 if args[1] != nil {
3909 arg1 = args[1].(dto.VimPageInteractionRequest)
3910 }
3911 run(
3912 arg0,
3913 arg1,
3914 )
3915 })
3916 return _c
3917}
3918
3919func (_c *MockVimPageInteractor_StartVimPageInteraction_Call) Return(err error) *MockVimPageInteractor_StartVimPageInteraction_Call {
3920 _c.Call.Return(err)
3921 return _c
3922}
3923
3924func (_c *MockVimPageInteractor_StartVimPageInteraction_Call) RunAndReturn(run func(ctx context.Context, request dto.VimPageInteractionRequest) error) *MockVimPageInteractor_StartVimPageInteraction_Call {
3925 _c.Call.Return(run)
3926 return _c
3927}