webview.go RawHistoryFolder

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