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