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 "github.com/bnema/dumber/internal/domain/entity"
12 "github.com/rs/zerolog"
13 mock "github.com/stretchr/testify/mock"
14)
15
16// NewMockSessionLogger creates a new instance of MockSessionLogger. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
17// The first argument is typically a *testing.T value.
18func NewMockSessionLogger(t interface {
19 mock.TestingT
20 Cleanup(func())
21}) *MockSessionLogger {
22 mock := &MockSessionLogger{}
23 mock.Mock.Test(t)
24
25 t.Cleanup(func() { mock.AssertExpectations(t) })
26
27 return mock
28}
29
30// MockSessionLogger is an autogenerated mock type for the SessionLogger type
31type MockSessionLogger struct {
32 mock.Mock
33}
34
35type MockSessionLogger_Expecter struct {
36 mock *mock.Mock
37}
38
39func (_m *MockSessionLogger) EXPECT() *MockSessionLogger_Expecter {
40 return &MockSessionLogger_Expecter{mock: &_m.Mock}
41}
42
43// CreateLogger provides a mock function for the type MockSessionLogger
44func (_mock *MockSessionLogger) CreateLogger(ctx context.Context, sessionID entity.SessionID, cfg port.SessionLogConfig) (zerolog.Logger, func(), error) {
45 ret := _mock.Called(ctx, sessionID, cfg)
46
47 if len(ret) == 0 {
48 panic("no return value specified for CreateLogger")
49 }
50
51 var r0 zerolog.Logger
52 var r1 func()
53 var r2 error
54 if returnFunc, ok := ret.Get(0).(func(context.Context, entity.SessionID, port.SessionLogConfig) (zerolog.Logger, func(), error)); ok {
55 return returnFunc(ctx, sessionID, cfg)
56 }
57 if returnFunc, ok := ret.Get(0).(func(context.Context, entity.SessionID, port.SessionLogConfig) zerolog.Logger); ok {
58 r0 = returnFunc(ctx, sessionID, cfg)
59 } else {
60 r0 = ret.Get(0).(zerolog.Logger)
61 }
62 if returnFunc, ok := ret.Get(1).(func(context.Context, entity.SessionID, port.SessionLogConfig) func()); ok {
63 r1 = returnFunc(ctx, sessionID, cfg)
64 } else {
65 if ret.Get(1) != nil {
66 r1 = ret.Get(1).(func())
67 }
68 }
69 if returnFunc, ok := ret.Get(2).(func(context.Context, entity.SessionID, port.SessionLogConfig) error); ok {
70 r2 = returnFunc(ctx, sessionID, cfg)
71 } else {
72 r2 = ret.Error(2)
73 }
74 return r0, r1, r2
75}
76
77// MockSessionLogger_CreateLogger_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateLogger'
78type MockSessionLogger_CreateLogger_Call struct {
79 *mock.Call
80}
81
82// CreateLogger is a helper method to define mock.On call
83// - ctx context.Context
84// - sessionID entity.SessionID
85// - cfg port.SessionLogConfig
86func (_e *MockSessionLogger_Expecter) CreateLogger(ctx interface{}, sessionID interface{}, cfg interface{}) *MockSessionLogger_CreateLogger_Call {
87 return &MockSessionLogger_CreateLogger_Call{Call: _e.mock.On("CreateLogger", ctx, sessionID, cfg)}
88}
89
90func (_c *MockSessionLogger_CreateLogger_Call) Run(run func(ctx context.Context, sessionID entity.SessionID, cfg port.SessionLogConfig)) *MockSessionLogger_CreateLogger_Call {
91 _c.Call.Run(func(args mock.Arguments) {
92 var arg0 context.Context
93 if args[0] != nil {
94 arg0 = args[0].(context.Context)
95 }
96 var arg1 entity.SessionID
97 if args[1] != nil {
98 arg1 = args[1].(entity.SessionID)
99 }
100 var arg2 port.SessionLogConfig
101 if args[2] != nil {
102 arg2 = args[2].(port.SessionLogConfig)
103 }
104 run(
105 arg0,
106 arg1,
107 arg2,
108 )
109 })
110 return _c
111}
112
113func (_c *MockSessionLogger_CreateLogger_Call) Return(logger zerolog.Logger, fn func(), err error) *MockSessionLogger_CreateLogger_Call {
114 _c.Call.Return(logger, fn, err)
115 return _c
116}
117
118func (_c *MockSessionLogger_CreateLogger_Call) RunAndReturn(run func(ctx context.Context, sessionID entity.SessionID, cfg port.SessionLogConfig) (zerolog.Logger, func(), error)) *MockSessionLogger_CreateLogger_Call {
119 _c.Call.Return(run)
120 return _c
121}
122
123// NewMockTabListProvider creates a new instance of MockTabListProvider. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
124// The first argument is typically a *testing.T value.
125func NewMockTabListProvider(t interface {
126 mock.TestingT
127 Cleanup(func())
128}) *MockTabListProvider {
129 mock := &MockTabListProvider{}
130 mock.Mock.Test(t)
131
132 t.Cleanup(func() { mock.AssertExpectations(t) })
133
134 return mock
135}
136
137// MockTabListProvider is an autogenerated mock type for the TabListProvider type
138type MockTabListProvider struct {
139 mock.Mock
140}
141
142type MockTabListProvider_Expecter struct {
143 mock *mock.Mock
144}
145
146func (_m *MockTabListProvider) EXPECT() *MockTabListProvider_Expecter {
147 return &MockTabListProvider_Expecter{mock: &_m.Mock}
148}
149
150// GetSessionID provides a mock function for the type MockTabListProvider
151func (_mock *MockTabListProvider) GetSessionID() entity.SessionID {
152 ret := _mock.Called()
153
154 if len(ret) == 0 {
155 panic("no return value specified for GetSessionID")
156 }
157
158 var r0 entity.SessionID
159 if returnFunc, ok := ret.Get(0).(func() entity.SessionID); ok {
160 r0 = returnFunc()
161 } else {
162 r0 = ret.Get(0).(entity.SessionID)
163 }
164 return r0
165}
166
167// MockTabListProvider_GetSessionID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSessionID'
168type MockTabListProvider_GetSessionID_Call struct {
169 *mock.Call
170}
171
172// GetSessionID is a helper method to define mock.On call
173func (_e *MockTabListProvider_Expecter) GetSessionID() *MockTabListProvider_GetSessionID_Call {
174 return &MockTabListProvider_GetSessionID_Call{Call: _e.mock.On("GetSessionID")}
175}
176
177func (_c *MockTabListProvider_GetSessionID_Call) Run(run func()) *MockTabListProvider_GetSessionID_Call {
178 _c.Call.Run(func(args mock.Arguments) {
179 run()
180 })
181 return _c
182}
183
184func (_c *MockTabListProvider_GetSessionID_Call) Return(sessionID entity.SessionID) *MockTabListProvider_GetSessionID_Call {
185 _c.Call.Return(sessionID)
186 return _c
187}
188
189func (_c *MockTabListProvider_GetSessionID_Call) RunAndReturn(run func() entity.SessionID) *MockTabListProvider_GetSessionID_Call {
190 _c.Call.Return(run)
191 return _c
192}
193
194// GetTabList provides a mock function for the type MockTabListProvider
195func (_mock *MockTabListProvider) GetTabList() *entity.TabList {
196 ret := _mock.Called()
197
198 if len(ret) == 0 {
199 panic("no return value specified for GetTabList")
200 }
201
202 var r0 *entity.TabList
203 if returnFunc, ok := ret.Get(0).(func() *entity.TabList); ok {
204 r0 = returnFunc()
205 } else {
206 if ret.Get(0) != nil {
207 r0 = ret.Get(0).(*entity.TabList)
208 }
209 }
210 return r0
211}
212
213// MockTabListProvider_GetTabList_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTabList'
214type MockTabListProvider_GetTabList_Call struct {
215 *mock.Call
216}
217
218// GetTabList is a helper method to define mock.On call
219func (_e *MockTabListProvider_Expecter) GetTabList() *MockTabListProvider_GetTabList_Call {
220 return &MockTabListProvider_GetTabList_Call{Call: _e.mock.On("GetTabList")}
221}
222
223func (_c *MockTabListProvider_GetTabList_Call) Run(run func()) *MockTabListProvider_GetTabList_Call {
224 _c.Call.Run(func(args mock.Arguments) {
225 run()
226 })
227 return _c
228}
229
230func (_c *MockTabListProvider_GetTabList_Call) Return(tabList *entity.TabList) *MockTabListProvider_GetTabList_Call {
231 _c.Call.Return(tabList)
232 return _c
233}
234
235func (_c *MockTabListProvider_GetTabList_Call) RunAndReturn(run func() *entity.TabList) *MockTabListProvider_GetTabList_Call {
236 _c.Call.Return(run)
237 return _c
238}
239
240// NewMockSessionSpawner creates a new instance of MockSessionSpawner. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
241// The first argument is typically a *testing.T value.
242func NewMockSessionSpawner(t interface {
243 mock.TestingT
244 Cleanup(func())
245}) *MockSessionSpawner {
246 mock := &MockSessionSpawner{}
247 mock.Mock.Test(t)
248
249 t.Cleanup(func() { mock.AssertExpectations(t) })
250
251 return mock
252}
253
254// MockSessionSpawner is an autogenerated mock type for the SessionSpawner type
255type MockSessionSpawner struct {
256 mock.Mock
257}
258
259type MockSessionSpawner_Expecter struct {
260 mock *mock.Mock
261}
262
263func (_m *MockSessionSpawner) EXPECT() *MockSessionSpawner_Expecter {
264 return &MockSessionSpawner_Expecter{mock: &_m.Mock}
265}
266
267// SpawnWithSession provides a mock function for the type MockSessionSpawner
268func (_mock *MockSessionSpawner) SpawnWithSession(sessionID entity.SessionID) error {
269 ret := _mock.Called(sessionID)
270
271 if len(ret) == 0 {
272 panic("no return value specified for SpawnWithSession")
273 }
274
275 var r0 error
276 if returnFunc, ok := ret.Get(0).(func(entity.SessionID) error); ok {
277 r0 = returnFunc(sessionID)
278 } else {
279 r0 = ret.Error(0)
280 }
281 return r0
282}
283
284// MockSessionSpawner_SpawnWithSession_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SpawnWithSession'
285type MockSessionSpawner_SpawnWithSession_Call struct {
286 *mock.Call
287}
288
289// SpawnWithSession is a helper method to define mock.On call
290// - sessionID entity.SessionID
291func (_e *MockSessionSpawner_Expecter) SpawnWithSession(sessionID interface{}) *MockSessionSpawner_SpawnWithSession_Call {
292 return &MockSessionSpawner_SpawnWithSession_Call{Call: _e.mock.On("SpawnWithSession", sessionID)}
293}
294
295func (_c *MockSessionSpawner_SpawnWithSession_Call) Run(run func(sessionID entity.SessionID)) *MockSessionSpawner_SpawnWithSession_Call {
296 _c.Call.Run(func(args mock.Arguments) {
297 var arg0 entity.SessionID
298 if args[0] != nil {
299 arg0 = args[0].(entity.SessionID)
300 }
301 run(
302 arg0,
303 )
304 })
305 return _c
306}
307
308func (_c *MockSessionSpawner_SpawnWithSession_Call) Return(err error) *MockSessionSpawner_SpawnWithSession_Call {
309 _c.Call.Return(err)
310 return _c
311}
312
313func (_c *MockSessionSpawner_SpawnWithSession_Call) RunAndReturn(run func(sessionID entity.SessionID) error) *MockSessionSpawner_SpawnWithSession_Call {
314 _c.Call.Return(run)
315 return _c
316}
317
318// 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.
319// The first argument is typically a *testing.T value.
320func NewMockWebView(t interface {
321 mock.TestingT
322 Cleanup(func())
323}) *MockWebView {
324 mock := &MockWebView{}
325 mock.Mock.Test(t)
326
327 t.Cleanup(func() { mock.AssertExpectations(t) })
328
329 return mock
330}
331
332// MockWebView is an autogenerated mock type for the WebView type
333type MockWebView struct {
334 mock.Mock
335}
336
337type MockWebView_Expecter struct {
338 mock *mock.Mock
339}
340
341func (_m *MockWebView) EXPECT() *MockWebView_Expecter {
342 return &MockWebView_Expecter{mock: &_m.Mock}
343}
344
345// CanGoBack provides a mock function for the type MockWebView
346func (_mock *MockWebView) CanGoBack() bool {
347 ret := _mock.Called()
348
349 if len(ret) == 0 {
350 panic("no return value specified for CanGoBack")
351 }
352
353 var r0 bool
354 if returnFunc, ok := ret.Get(0).(func() bool); ok {
355 r0 = returnFunc()
356 } else {
357 r0 = ret.Get(0).(bool)
358 }
359 return r0
360}
361
362// MockWebView_CanGoBack_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CanGoBack'
363type MockWebView_CanGoBack_Call struct {
364 *mock.Call
365}
366
367// CanGoBack is a helper method to define mock.On call
368func (_e *MockWebView_Expecter) CanGoBack() *MockWebView_CanGoBack_Call {
369 return &MockWebView_CanGoBack_Call{Call: _e.mock.On("CanGoBack")}
370}
371
372func (_c *MockWebView_CanGoBack_Call) Run(run func()) *MockWebView_CanGoBack_Call {
373 _c.Call.Run(func(args mock.Arguments) {
374 run()
375 })
376 return _c
377}
378
379func (_c *MockWebView_CanGoBack_Call) Return(b bool) *MockWebView_CanGoBack_Call {
380 _c.Call.Return(b)
381 return _c
382}
383
384func (_c *MockWebView_CanGoBack_Call) RunAndReturn(run func() bool) *MockWebView_CanGoBack_Call {
385 _c.Call.Return(run)
386 return _c
387}
388
389// CanGoForward provides a mock function for the type MockWebView
390func (_mock *MockWebView) CanGoForward() bool {
391 ret := _mock.Called()
392
393 if len(ret) == 0 {
394 panic("no return value specified for CanGoForward")
395 }
396
397 var r0 bool
398 if returnFunc, ok := ret.Get(0).(func() bool); ok {
399 r0 = returnFunc()
400 } else {
401 r0 = ret.Get(0).(bool)
402 }
403 return r0
404}
405
406// MockWebView_CanGoForward_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CanGoForward'
407type MockWebView_CanGoForward_Call struct {
408 *mock.Call
409}
410
411// CanGoForward is a helper method to define mock.On call
412func (_e *MockWebView_Expecter) CanGoForward() *MockWebView_CanGoForward_Call {
413 return &MockWebView_CanGoForward_Call{Call: _e.mock.On("CanGoForward")}
414}
415
416func (_c *MockWebView_CanGoForward_Call) Run(run func()) *MockWebView_CanGoForward_Call {
417 _c.Call.Run(func(args mock.Arguments) {
418 run()
419 })
420 return _c
421}
422
423func (_c *MockWebView_CanGoForward_Call) Return(b bool) *MockWebView_CanGoForward_Call {
424 _c.Call.Return(b)
425 return _c
426}
427
428func (_c *MockWebView_CanGoForward_Call) RunAndReturn(run func() bool) *MockWebView_CanGoForward_Call {
429 _c.Call.Return(run)
430 return _c
431}
432
433// Destroy provides a mock function for the type MockWebView
434func (_mock *MockWebView) Destroy() {
435 _mock.Called()
436 return
437}
438
439// MockWebView_Destroy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Destroy'
440type MockWebView_Destroy_Call struct {
441 *mock.Call
442}
443
444// Destroy is a helper method to define mock.On call
445func (_e *MockWebView_Expecter) Destroy() *MockWebView_Destroy_Call {
446 return &MockWebView_Destroy_Call{Call: _e.mock.On("Destroy")}
447}
448
449func (_c *MockWebView_Destroy_Call) Run(run func()) *MockWebView_Destroy_Call {
450 _c.Call.Run(func(args mock.Arguments) {
451 run()
452 })
453 return _c
454}
455
456func (_c *MockWebView_Destroy_Call) Return() *MockWebView_Destroy_Call {
457 _c.Call.Return()
458 return _c
459}
460
461func (_c *MockWebView_Destroy_Call) RunAndReturn(run func()) *MockWebView_Destroy_Call {
462 _c.Run(run)
463 return _c
464}
465
466// EstimatedProgress provides a mock function for the type MockWebView
467func (_mock *MockWebView) EstimatedProgress() float64 {
468 ret := _mock.Called()
469
470 if len(ret) == 0 {
471 panic("no return value specified for EstimatedProgress")
472 }
473
474 var r0 float64
475 if returnFunc, ok := ret.Get(0).(func() float64); ok {
476 r0 = returnFunc()
477 } else {
478 r0 = ret.Get(0).(float64)
479 }
480 return r0
481}
482
483// MockWebView_EstimatedProgress_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EstimatedProgress'
484type MockWebView_EstimatedProgress_Call struct {
485 *mock.Call
486}
487
488// EstimatedProgress is a helper method to define mock.On call
489func (_e *MockWebView_Expecter) EstimatedProgress() *MockWebView_EstimatedProgress_Call {
490 return &MockWebView_EstimatedProgress_Call{Call: _e.mock.On("EstimatedProgress")}
491}
492
493func (_c *MockWebView_EstimatedProgress_Call) Run(run func()) *MockWebView_EstimatedProgress_Call {
494 _c.Call.Run(func(args mock.Arguments) {
495 run()
496 })
497 return _c
498}
499
500func (_c *MockWebView_EstimatedProgress_Call) Return(f float64) *MockWebView_EstimatedProgress_Call {
501 _c.Call.Return(f)
502 return _c
503}
504
505func (_c *MockWebView_EstimatedProgress_Call) RunAndReturn(run func() float64) *MockWebView_EstimatedProgress_Call {
506 _c.Call.Return(run)
507 return _c
508}
509
510// GetFindController provides a mock function for the type MockWebView
511func (_mock *MockWebView) GetFindController() port.FindController {
512 ret := _mock.Called()
513
514 if len(ret) == 0 {
515 panic("no return value specified for GetFindController")
516 }
517
518 var r0 port.FindController
519 if returnFunc, ok := ret.Get(0).(func() port.FindController); ok {
520 r0 = returnFunc()
521 } else {
522 if ret.Get(0) != nil {
523 r0 = ret.Get(0).(port.FindController)
524 }
525 }
526 return r0
527}
528
529// MockWebView_GetFindController_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetFindController'
530type MockWebView_GetFindController_Call struct {
531 *mock.Call
532}
533
534// GetFindController is a helper method to define mock.On call
535func (_e *MockWebView_Expecter) GetFindController() *MockWebView_GetFindController_Call {
536 return &MockWebView_GetFindController_Call{Call: _e.mock.On("GetFindController")}
537}
538
539func (_c *MockWebView_GetFindController_Call) Run(run func()) *MockWebView_GetFindController_Call {
540 _c.Call.Run(func(args mock.Arguments) {
541 run()
542 })
543 return _c
544}
545
546func (_c *MockWebView_GetFindController_Call) Return(findController port.FindController) *MockWebView_GetFindController_Call {
547 _c.Call.Return(findController)
548 return _c
549}
550
551func (_c *MockWebView_GetFindController_Call) RunAndReturn(run func() port.FindController) *MockWebView_GetFindController_Call {
552 _c.Call.Return(run)
553 return _c
554}
555
556// GetZoomLevel provides a mock function for the type MockWebView
557func (_mock *MockWebView) GetZoomLevel() float64 {
558 ret := _mock.Called()
559
560 if len(ret) == 0 {
561 panic("no return value specified for GetZoomLevel")
562 }
563
564 var r0 float64
565 if returnFunc, ok := ret.Get(0).(func() float64); ok {
566 r0 = returnFunc()
567 } else {
568 r0 = ret.Get(0).(float64)
569 }
570 return r0
571}
572
573// MockWebView_GetZoomLevel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetZoomLevel'
574type MockWebView_GetZoomLevel_Call struct {
575 *mock.Call
576}
577
578// GetZoomLevel is a helper method to define mock.On call
579func (_e *MockWebView_Expecter) GetZoomLevel() *MockWebView_GetZoomLevel_Call {
580 return &MockWebView_GetZoomLevel_Call{Call: _e.mock.On("GetZoomLevel")}
581}
582
583func (_c *MockWebView_GetZoomLevel_Call) Run(run func()) *MockWebView_GetZoomLevel_Call {
584 _c.Call.Run(func(args mock.Arguments) {
585 run()
586 })
587 return _c
588}
589
590func (_c *MockWebView_GetZoomLevel_Call) Return(f float64) *MockWebView_GetZoomLevel_Call {
591 _c.Call.Return(f)
592 return _c
593}
594
595func (_c *MockWebView_GetZoomLevel_Call) RunAndReturn(run func() float64) *MockWebView_GetZoomLevel_Call {
596 _c.Call.Return(run)
597 return _c
598}
599
600// GoBack provides a mock function for the type MockWebView
601func (_mock *MockWebView) GoBack(ctx context.Context) error {
602 ret := _mock.Called(ctx)
603
604 if len(ret) == 0 {
605 panic("no return value specified for GoBack")
606 }
607
608 var r0 error
609 if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
610 r0 = returnFunc(ctx)
611 } else {
612 r0 = ret.Error(0)
613 }
614 return r0
615}
616
617// MockWebView_GoBack_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GoBack'
618type MockWebView_GoBack_Call struct {
619 *mock.Call
620}
621
622// GoBack is a helper method to define mock.On call
623// - ctx context.Context
624func (_e *MockWebView_Expecter) GoBack(ctx interface{}) *MockWebView_GoBack_Call {
625 return &MockWebView_GoBack_Call{Call: _e.mock.On("GoBack", ctx)}
626}
627
628func (_c *MockWebView_GoBack_Call) Run(run func(ctx context.Context)) *MockWebView_GoBack_Call {
629 _c.Call.Run(func(args mock.Arguments) {
630 var arg0 context.Context
631 if args[0] != nil {
632 arg0 = args[0].(context.Context)
633 }
634 run(
635 arg0,
636 )
637 })
638 return _c
639}
640
641func (_c *MockWebView_GoBack_Call) Return(err error) *MockWebView_GoBack_Call {
642 _c.Call.Return(err)
643 return _c
644}
645
646func (_c *MockWebView_GoBack_Call) RunAndReturn(run func(ctx context.Context) error) *MockWebView_GoBack_Call {
647 _c.Call.Return(run)
648 return _c
649}
650
651// GoForward provides a mock function for the type MockWebView
652func (_mock *MockWebView) GoForward(ctx context.Context) error {
653 ret := _mock.Called(ctx)
654
655 if len(ret) == 0 {
656 panic("no return value specified for GoForward")
657 }
658
659 var r0 error
660 if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
661 r0 = returnFunc(ctx)
662 } else {
663 r0 = ret.Error(0)
664 }
665 return r0
666}
667
668// MockWebView_GoForward_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GoForward'
669type MockWebView_GoForward_Call struct {
670 *mock.Call
671}
672
673// GoForward is a helper method to define mock.On call
674// - ctx context.Context
675func (_e *MockWebView_Expecter) GoForward(ctx interface{}) *MockWebView_GoForward_Call {
676 return &MockWebView_GoForward_Call{Call: _e.mock.On("GoForward", ctx)}
677}
678
679func (_c *MockWebView_GoForward_Call) Run(run func(ctx context.Context)) *MockWebView_GoForward_Call {
680 _c.Call.Run(func(args mock.Arguments) {
681 var arg0 context.Context
682 if args[0] != nil {
683 arg0 = args[0].(context.Context)
684 }
685 run(
686 arg0,
687 )
688 })
689 return _c
690}
691
692func (_c *MockWebView_GoForward_Call) Return(err error) *MockWebView_GoForward_Call {
693 _c.Call.Return(err)
694 return _c
695}
696
697func (_c *MockWebView_GoForward_Call) RunAndReturn(run func(ctx context.Context) error) *MockWebView_GoForward_Call {
698 _c.Call.Return(run)
699 return _c
700}
701
702// ID provides a mock function for the type MockWebView
703func (_mock *MockWebView) ID() port.WebViewID {
704 ret := _mock.Called()
705
706 if len(ret) == 0 {
707 panic("no return value specified for ID")
708 }
709
710 var r0 port.WebViewID
711 if returnFunc, ok := ret.Get(0).(func() port.WebViewID); ok {
712 r0 = returnFunc()
713 } else {
714 r0 = ret.Get(0).(port.WebViewID)
715 }
716 return r0
717}
718
719// MockWebView_ID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ID'
720type MockWebView_ID_Call struct {
721 *mock.Call
722}
723
724// ID is a helper method to define mock.On call
725func (_e *MockWebView_Expecter) ID() *MockWebView_ID_Call {
726 return &MockWebView_ID_Call{Call: _e.mock.On("ID")}
727}
728
729func (_c *MockWebView_ID_Call) Run(run func()) *MockWebView_ID_Call {
730 _c.Call.Run(func(args mock.Arguments) {
731 run()
732 })
733 return _c
734}
735
736func (_c *MockWebView_ID_Call) Return(webViewID port.WebViewID) *MockWebView_ID_Call {
737 _c.Call.Return(webViewID)
738 return _c
739}
740
741func (_c *MockWebView_ID_Call) RunAndReturn(run func() port.WebViewID) *MockWebView_ID_Call {
742 _c.Call.Return(run)
743 return _c
744}
745
746// IsDestroyed provides a mock function for the type MockWebView
747func (_mock *MockWebView) IsDestroyed() bool {
748 ret := _mock.Called()
749
750 if len(ret) == 0 {
751 panic("no return value specified for IsDestroyed")
752 }
753
754 var r0 bool
755 if returnFunc, ok := ret.Get(0).(func() bool); ok {
756 r0 = returnFunc()
757 } else {
758 r0 = ret.Get(0).(bool)
759 }
760 return r0
761}
762
763// MockWebView_IsDestroyed_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsDestroyed'
764type MockWebView_IsDestroyed_Call struct {
765 *mock.Call
766}
767
768// IsDestroyed is a helper method to define mock.On call
769func (_e *MockWebView_Expecter) IsDestroyed() *MockWebView_IsDestroyed_Call {
770 return &MockWebView_IsDestroyed_Call{Call: _e.mock.On("IsDestroyed")}
771}
772
773func (_c *MockWebView_IsDestroyed_Call) Run(run func()) *MockWebView_IsDestroyed_Call {
774 _c.Call.Run(func(args mock.Arguments) {
775 run()
776 })
777 return _c
778}
779
780func (_c *MockWebView_IsDestroyed_Call) Return(b bool) *MockWebView_IsDestroyed_Call {
781 _c.Call.Return(b)
782 return _c
783}
784
785func (_c *MockWebView_IsDestroyed_Call) RunAndReturn(run func() bool) *MockWebView_IsDestroyed_Call {
786 _c.Call.Return(run)
787 return _c
788}
789
790// IsFullscreen provides a mock function for the type MockWebView
791func (_mock *MockWebView) IsFullscreen() bool {
792 ret := _mock.Called()
793
794 if len(ret) == 0 {
795 panic("no return value specified for IsFullscreen")
796 }
797
798 var r0 bool
799 if returnFunc, ok := ret.Get(0).(func() bool); ok {
800 r0 = returnFunc()
801 } else {
802 r0 = ret.Get(0).(bool)
803 }
804 return r0
805}
806
807// MockWebView_IsFullscreen_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsFullscreen'
808type MockWebView_IsFullscreen_Call struct {
809 *mock.Call
810}
811
812// IsFullscreen is a helper method to define mock.On call
813func (_e *MockWebView_Expecter) IsFullscreen() *MockWebView_IsFullscreen_Call {
814 return &MockWebView_IsFullscreen_Call{Call: _e.mock.On("IsFullscreen")}
815}
816
817func (_c *MockWebView_IsFullscreen_Call) Run(run func()) *MockWebView_IsFullscreen_Call {
818 _c.Call.Run(func(args mock.Arguments) {
819 run()
820 })
821 return _c
822}
823
824func (_c *MockWebView_IsFullscreen_Call) Return(b bool) *MockWebView_IsFullscreen_Call {
825 _c.Call.Return(b)
826 return _c
827}
828
829func (_c *MockWebView_IsFullscreen_Call) RunAndReturn(run func() bool) *MockWebView_IsFullscreen_Call {
830 _c.Call.Return(run)
831 return _c
832}
833
834// IsLoading provides a mock function for the type MockWebView
835func (_mock *MockWebView) IsLoading() bool {
836 ret := _mock.Called()
837
838 if len(ret) == 0 {
839 panic("no return value specified for IsLoading")
840 }
841
842 var r0 bool
843 if returnFunc, ok := ret.Get(0).(func() bool); ok {
844 r0 = returnFunc()
845 } else {
846 r0 = ret.Get(0).(bool)
847 }
848 return r0
849}
850
851// MockWebView_IsLoading_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsLoading'
852type MockWebView_IsLoading_Call struct {
853 *mock.Call
854}
855
856// IsLoading is a helper method to define mock.On call
857func (_e *MockWebView_Expecter) IsLoading() *MockWebView_IsLoading_Call {
858 return &MockWebView_IsLoading_Call{Call: _e.mock.On("IsLoading")}
859}
860
861func (_c *MockWebView_IsLoading_Call) Run(run func()) *MockWebView_IsLoading_Call {
862 _c.Call.Run(func(args mock.Arguments) {
863 run()
864 })
865 return _c
866}
867
868func (_c *MockWebView_IsLoading_Call) Return(b bool) *MockWebView_IsLoading_Call {
869 _c.Call.Return(b)
870 return _c
871}
872
873func (_c *MockWebView_IsLoading_Call) RunAndReturn(run func() bool) *MockWebView_IsLoading_Call {
874 _c.Call.Return(run)
875 return _c
876}
877
878// IsPlayingAudio provides a mock function for the type MockWebView
879func (_mock *MockWebView) IsPlayingAudio() bool {
880 ret := _mock.Called()
881
882 if len(ret) == 0 {
883 panic("no return value specified for IsPlayingAudio")
884 }
885
886 var r0 bool
887 if returnFunc, ok := ret.Get(0).(func() bool); ok {
888 r0 = returnFunc()
889 } else {
890 r0 = ret.Get(0).(bool)
891 }
892 return r0
893}
894
895// MockWebView_IsPlayingAudio_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsPlayingAudio'
896type MockWebView_IsPlayingAudio_Call struct {
897 *mock.Call
898}
899
900// IsPlayingAudio is a helper method to define mock.On call
901func (_e *MockWebView_Expecter) IsPlayingAudio() *MockWebView_IsPlayingAudio_Call {
902 return &MockWebView_IsPlayingAudio_Call{Call: _e.mock.On("IsPlayingAudio")}
903}
904
905func (_c *MockWebView_IsPlayingAudio_Call) Run(run func()) *MockWebView_IsPlayingAudio_Call {
906 _c.Call.Run(func(args mock.Arguments) {
907 run()
908 })
909 return _c
910}
911
912func (_c *MockWebView_IsPlayingAudio_Call) Return(b bool) *MockWebView_IsPlayingAudio_Call {
913 _c.Call.Return(b)
914 return _c
915}
916
917func (_c *MockWebView_IsPlayingAudio_Call) RunAndReturn(run func() bool) *MockWebView_IsPlayingAudio_Call {
918 _c.Call.Return(run)
919 return _c
920}
921
922// LoadHTML provides a mock function for the type MockWebView
923func (_mock *MockWebView) LoadHTML(ctx context.Context, content string, baseURI string) error {
924 ret := _mock.Called(ctx, content, baseURI)
925
926 if len(ret) == 0 {
927 panic("no return value specified for LoadHTML")
928 }
929
930 var r0 error
931 if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) error); ok {
932 r0 = returnFunc(ctx, content, baseURI)
933 } else {
934 r0 = ret.Error(0)
935 }
936 return r0
937}
938
939// MockWebView_LoadHTML_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LoadHTML'
940type MockWebView_LoadHTML_Call struct {
941 *mock.Call
942}
943
944// LoadHTML is a helper method to define mock.On call
945// - ctx context.Context
946// - content string
947// - baseURI string
948func (_e *MockWebView_Expecter) LoadHTML(ctx interface{}, content interface{}, baseURI interface{}) *MockWebView_LoadHTML_Call {
949 return &MockWebView_LoadHTML_Call{Call: _e.mock.On("LoadHTML", ctx, content, baseURI)}
950}
951
952func (_c *MockWebView_LoadHTML_Call) Run(run func(ctx context.Context, content string, baseURI string)) *MockWebView_LoadHTML_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 var arg1 string
959 if args[1] != nil {
960 arg1 = args[1].(string)
961 }
962 var arg2 string
963 if args[2] != nil {
964 arg2 = args[2].(string)
965 }
966 run(
967 arg0,
968 arg1,
969 arg2,
970 )
971 })
972 return _c
973}
974
975func (_c *MockWebView_LoadHTML_Call) Return(err error) *MockWebView_LoadHTML_Call {
976 _c.Call.Return(err)
977 return _c
978}
979
980func (_c *MockWebView_LoadHTML_Call) RunAndReturn(run func(ctx context.Context, content string, baseURI string) error) *MockWebView_LoadHTML_Call {
981 _c.Call.Return(run)
982 return _c
983}
984
985// LoadURI provides a mock function for the type MockWebView
986func (_mock *MockWebView) LoadURI(ctx context.Context, uri string) error {
987 ret := _mock.Called(ctx, uri)
988
989 if len(ret) == 0 {
990 panic("no return value specified for LoadURI")
991 }
992
993 var r0 error
994 if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
995 r0 = returnFunc(ctx, uri)
996 } else {
997 r0 = ret.Error(0)
998 }
999 return r0
1000}
1001
1002// MockWebView_LoadURI_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LoadURI'
1003type MockWebView_LoadURI_Call struct {
1004 *mock.Call
1005}
1006
1007// LoadURI is a helper method to define mock.On call
1008// - ctx context.Context
1009// - uri string
1010func (_e *MockWebView_Expecter) LoadURI(ctx interface{}, uri interface{}) *MockWebView_LoadURI_Call {
1011 return &MockWebView_LoadURI_Call{Call: _e.mock.On("LoadURI", ctx, uri)}
1012}
1013
1014func (_c *MockWebView_LoadURI_Call) Run(run func(ctx context.Context, uri string)) *MockWebView_LoadURI_Call {
1015 _c.Call.Run(func(args mock.Arguments) {
1016 var arg0 context.Context
1017 if args[0] != nil {
1018 arg0 = args[0].(context.Context)
1019 }
1020 var arg1 string
1021 if args[1] != nil {
1022 arg1 = args[1].(string)
1023 }
1024 run(
1025 arg0,
1026 arg1,
1027 )
1028 })
1029 return _c
1030}
1031
1032func (_c *MockWebView_LoadURI_Call) Return(err error) *MockWebView_LoadURI_Call {
1033 _c.Call.Return(err)
1034 return _c
1035}
1036
1037func (_c *MockWebView_LoadURI_Call) RunAndReturn(run func(ctx context.Context, uri string) error) *MockWebView_LoadURI_Call {
1038 _c.Call.Return(run)
1039 return _c
1040}
1041
1042// Reload provides a mock function for the type MockWebView
1043func (_mock *MockWebView) Reload(ctx context.Context) error {
1044 ret := _mock.Called(ctx)
1045
1046 if len(ret) == 0 {
1047 panic("no return value specified for Reload")
1048 }
1049
1050 var r0 error
1051 if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
1052 r0 = returnFunc(ctx)
1053 } else {
1054 r0 = ret.Error(0)
1055 }
1056 return r0
1057}
1058
1059// MockWebView_Reload_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Reload'
1060type MockWebView_Reload_Call struct {
1061 *mock.Call
1062}
1063
1064// Reload is a helper method to define mock.On call
1065// - ctx context.Context
1066func (_e *MockWebView_Expecter) Reload(ctx interface{}) *MockWebView_Reload_Call {
1067 return &MockWebView_Reload_Call{Call: _e.mock.On("Reload", ctx)}
1068}
1069
1070func (_c *MockWebView_Reload_Call) Run(run func(ctx context.Context)) *MockWebView_Reload_Call {
1071 _c.Call.Run(func(args mock.Arguments) {
1072 var arg0 context.Context
1073 if args[0] != nil {
1074 arg0 = args[0].(context.Context)
1075 }
1076 run(
1077 arg0,
1078 )
1079 })
1080 return _c
1081}
1082
1083func (_c *MockWebView_Reload_Call) Return(err error) *MockWebView_Reload_Call {
1084 _c.Call.Return(err)
1085 return _c
1086}
1087
1088func (_c *MockWebView_Reload_Call) RunAndReturn(run func(ctx context.Context) error) *MockWebView_Reload_Call {
1089 _c.Call.Return(run)
1090 return _c
1091}
1092
1093// ReloadBypassCache provides a mock function for the type MockWebView
1094func (_mock *MockWebView) ReloadBypassCache(ctx context.Context) error {
1095 ret := _mock.Called(ctx)
1096
1097 if len(ret) == 0 {
1098 panic("no return value specified for ReloadBypassCache")
1099 }
1100
1101 var r0 error
1102 if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
1103 r0 = returnFunc(ctx)
1104 } else {
1105 r0 = ret.Error(0)
1106 }
1107 return r0
1108}
1109
1110// MockWebView_ReloadBypassCache_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReloadBypassCache'
1111type MockWebView_ReloadBypassCache_Call struct {
1112 *mock.Call
1113}
1114
1115// ReloadBypassCache is a helper method to define mock.On call
1116// - ctx context.Context
1117func (_e *MockWebView_Expecter) ReloadBypassCache(ctx interface{}) *MockWebView_ReloadBypassCache_Call {
1118 return &MockWebView_ReloadBypassCache_Call{Call: _e.mock.On("ReloadBypassCache", ctx)}
1119}
1120
1121func (_c *MockWebView_ReloadBypassCache_Call) Run(run func(ctx context.Context)) *MockWebView_ReloadBypassCache_Call {
1122 _c.Call.Run(func(args mock.Arguments) {
1123 var arg0 context.Context
1124 if args[0] != nil {
1125 arg0 = args[0].(context.Context)
1126 }
1127 run(
1128 arg0,
1129 )
1130 })
1131 return _c
1132}
1133
1134func (_c *MockWebView_ReloadBypassCache_Call) Return(err error) *MockWebView_ReloadBypassCache_Call {
1135 _c.Call.Return(err)
1136 return _c
1137}
1138
1139func (_c *MockWebView_ReloadBypassCache_Call) RunAndReturn(run func(ctx context.Context) error) *MockWebView_ReloadBypassCache_Call {
1140 _c.Call.Return(run)
1141 return _c
1142}
1143
1144// SetCallbacks provides a mock function for the type MockWebView
1145func (_mock *MockWebView) SetCallbacks(callbacks *port.WebViewCallbacks) {
1146 _mock.Called(callbacks)
1147 return
1148}
1149
1150// MockWebView_SetCallbacks_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetCallbacks'
1151type MockWebView_SetCallbacks_Call struct {
1152 *mock.Call
1153}
1154
1155// SetCallbacks is a helper method to define mock.On call
1156// - callbacks *port.WebViewCallbacks
1157func (_e *MockWebView_Expecter) SetCallbacks(callbacks interface{}) *MockWebView_SetCallbacks_Call {
1158 return &MockWebView_SetCallbacks_Call{Call: _e.mock.On("SetCallbacks", callbacks)}
1159}
1160
1161func (_c *MockWebView_SetCallbacks_Call) Run(run func(callbacks *port.WebViewCallbacks)) *MockWebView_SetCallbacks_Call {
1162 _c.Call.Run(func(args mock.Arguments) {
1163 var arg0 *port.WebViewCallbacks
1164 if args[0] != nil {
1165 arg0 = args[0].(*port.WebViewCallbacks)
1166 }
1167 run(
1168 arg0,
1169 )
1170 })
1171 return _c
1172}
1173
1174func (_c *MockWebView_SetCallbacks_Call) Return() *MockWebView_SetCallbacks_Call {
1175 _c.Call.Return()
1176 return _c
1177}
1178
1179func (_c *MockWebView_SetCallbacks_Call) RunAndReturn(run func(callbacks *port.WebViewCallbacks)) *MockWebView_SetCallbacks_Call {
1180 _c.Run(run)
1181 return _c
1182}
1183
1184// SetZoomLevel provides a mock function for the type MockWebView
1185func (_mock *MockWebView) SetZoomLevel(ctx context.Context, level float64) error {
1186 ret := _mock.Called(ctx, level)
1187
1188 if len(ret) == 0 {
1189 panic("no return value specified for SetZoomLevel")
1190 }
1191
1192 var r0 error
1193 if returnFunc, ok := ret.Get(0).(func(context.Context, float64) error); ok {
1194 r0 = returnFunc(ctx, level)
1195 } else {
1196 r0 = ret.Error(0)
1197 }
1198 return r0
1199}
1200
1201// MockWebView_SetZoomLevel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetZoomLevel'
1202type MockWebView_SetZoomLevel_Call struct {
1203 *mock.Call
1204}
1205
1206// SetZoomLevel is a helper method to define mock.On call
1207// - ctx context.Context
1208// - level float64
1209func (_e *MockWebView_Expecter) SetZoomLevel(ctx interface{}, level interface{}) *MockWebView_SetZoomLevel_Call {
1210 return &MockWebView_SetZoomLevel_Call{Call: _e.mock.On("SetZoomLevel", ctx, level)}
1211}
1212
1213func (_c *MockWebView_SetZoomLevel_Call) Run(run func(ctx context.Context, level float64)) *MockWebView_SetZoomLevel_Call {
1214 _c.Call.Run(func(args mock.Arguments) {
1215 var arg0 context.Context
1216 if args[0] != nil {
1217 arg0 = args[0].(context.Context)
1218 }
1219 var arg1 float64
1220 if args[1] != nil {
1221 arg1 = args[1].(float64)
1222 }
1223 run(
1224 arg0,
1225 arg1,
1226 )
1227 })
1228 return _c
1229}
1230
1231func (_c *MockWebView_SetZoomLevel_Call) Return(err error) *MockWebView_SetZoomLevel_Call {
1232 _c.Call.Return(err)
1233 return _c
1234}
1235
1236func (_c *MockWebView_SetZoomLevel_Call) RunAndReturn(run func(ctx context.Context, level float64) error) *MockWebView_SetZoomLevel_Call {
1237 _c.Call.Return(run)
1238 return _c
1239}
1240
1241// State provides a mock function for the type MockWebView
1242func (_mock *MockWebView) State() port.WebViewState {
1243 ret := _mock.Called()
1244
1245 if len(ret) == 0 {
1246 panic("no return value specified for State")
1247 }
1248
1249 var r0 port.WebViewState
1250 if returnFunc, ok := ret.Get(0).(func() port.WebViewState); ok {
1251 r0 = returnFunc()
1252 } else {
1253 r0 = ret.Get(0).(port.WebViewState)
1254 }
1255 return r0
1256}
1257
1258// MockWebView_State_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'State'
1259type MockWebView_State_Call struct {
1260 *mock.Call
1261}
1262
1263// State is a helper method to define mock.On call
1264func (_e *MockWebView_Expecter) State() *MockWebView_State_Call {
1265 return &MockWebView_State_Call{Call: _e.mock.On("State")}
1266}
1267
1268func (_c *MockWebView_State_Call) Run(run func()) *MockWebView_State_Call {
1269 _c.Call.Run(func(args mock.Arguments) {
1270 run()
1271 })
1272 return _c
1273}
1274
1275func (_c *MockWebView_State_Call) Return(webViewState port.WebViewState) *MockWebView_State_Call {
1276 _c.Call.Return(webViewState)
1277 return _c
1278}
1279
1280func (_c *MockWebView_State_Call) RunAndReturn(run func() port.WebViewState) *MockWebView_State_Call {
1281 _c.Call.Return(run)
1282 return _c
1283}
1284
1285// Stop provides a mock function for the type MockWebView
1286func (_mock *MockWebView) Stop(ctx context.Context) error {
1287 ret := _mock.Called(ctx)
1288
1289 if len(ret) == 0 {
1290 panic("no return value specified for Stop")
1291 }
1292
1293 var r0 error
1294 if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
1295 r0 = returnFunc(ctx)
1296 } else {
1297 r0 = ret.Error(0)
1298 }
1299 return r0
1300}
1301
1302// MockWebView_Stop_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Stop'
1303type MockWebView_Stop_Call struct {
1304 *mock.Call
1305}
1306
1307// Stop is a helper method to define mock.On call
1308// - ctx context.Context
1309func (_e *MockWebView_Expecter) Stop(ctx interface{}) *MockWebView_Stop_Call {
1310 return &MockWebView_Stop_Call{Call: _e.mock.On("Stop", ctx)}
1311}
1312
1313func (_c *MockWebView_Stop_Call) Run(run func(ctx context.Context)) *MockWebView_Stop_Call {
1314 _c.Call.Run(func(args mock.Arguments) {
1315 var arg0 context.Context
1316 if args[0] != nil {
1317 arg0 = args[0].(context.Context)
1318 }
1319 run(
1320 arg0,
1321 )
1322 })
1323 return _c
1324}
1325
1326func (_c *MockWebView_Stop_Call) Return(err error) *MockWebView_Stop_Call {
1327 _c.Call.Return(err)
1328 return _c
1329}
1330
1331func (_c *MockWebView_Stop_Call) RunAndReturn(run func(ctx context.Context) error) *MockWebView_Stop_Call {
1332 _c.Call.Return(run)
1333 return _c
1334}
1335
1336// Title provides a mock function for the type MockWebView
1337func (_mock *MockWebView) Title() string {
1338 ret := _mock.Called()
1339
1340 if len(ret) == 0 {
1341 panic("no return value specified for Title")
1342 }
1343
1344 var r0 string
1345 if returnFunc, ok := ret.Get(0).(func() string); ok {
1346 r0 = returnFunc()
1347 } else {
1348 r0 = ret.Get(0).(string)
1349 }
1350 return r0
1351}
1352
1353// MockWebView_Title_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Title'
1354type MockWebView_Title_Call struct {
1355 *mock.Call
1356}
1357
1358// Title is a helper method to define mock.On call
1359func (_e *MockWebView_Expecter) Title() *MockWebView_Title_Call {
1360 return &MockWebView_Title_Call{Call: _e.mock.On("Title")}
1361}
1362
1363func (_c *MockWebView_Title_Call) Run(run func()) *MockWebView_Title_Call {
1364 _c.Call.Run(func(args mock.Arguments) {
1365 run()
1366 })
1367 return _c
1368}
1369
1370func (_c *MockWebView_Title_Call) Return(s string) *MockWebView_Title_Call {
1371 _c.Call.Return(s)
1372 return _c
1373}
1374
1375func (_c *MockWebView_Title_Call) RunAndReturn(run func() string) *MockWebView_Title_Call {
1376 _c.Call.Return(run)
1377 return _c
1378}
1379
1380// URI provides a mock function for the type MockWebView
1381func (_mock *MockWebView) URI() string {
1382 ret := _mock.Called()
1383
1384 if len(ret) == 0 {
1385 panic("no return value specified for URI")
1386 }
1387
1388 var r0 string
1389 if returnFunc, ok := ret.Get(0).(func() string); ok {
1390 r0 = returnFunc()
1391 } else {
1392 r0 = ret.Get(0).(string)
1393 }
1394 return r0
1395}
1396
1397// MockWebView_URI_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'URI'
1398type MockWebView_URI_Call struct {
1399 *mock.Call
1400}
1401
1402// URI is a helper method to define mock.On call
1403func (_e *MockWebView_Expecter) URI() *MockWebView_URI_Call {
1404 return &MockWebView_URI_Call{Call: _e.mock.On("URI")}
1405}
1406
1407func (_c *MockWebView_URI_Call) Run(run func()) *MockWebView_URI_Call {
1408 _c.Call.Run(func(args mock.Arguments) {
1409 run()
1410 })
1411 return _c
1412}
1413
1414func (_c *MockWebView_URI_Call) Return(s string) *MockWebView_URI_Call {
1415 _c.Call.Return(s)
1416 return _c
1417}
1418
1419func (_c *MockWebView_URI_Call) RunAndReturn(run func() string) *MockWebView_URI_Call {
1420 _c.Call.Return(run)
1421 return _c
1422}
1423
1424// 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.
1425// The first argument is typically a *testing.T value.
1426func NewMockWebViewPool(t interface {
1427 mock.TestingT
1428 Cleanup(func())
1429}) *MockWebViewPool {
1430 mock := &MockWebViewPool{}
1431 mock.Mock.Test(t)
1432
1433 t.Cleanup(func() { mock.AssertExpectations(t) })
1434
1435 return mock
1436}
1437
1438// MockWebViewPool is an autogenerated mock type for the WebViewPool type
1439type MockWebViewPool struct {
1440 mock.Mock
1441}
1442
1443type MockWebViewPool_Expecter struct {
1444 mock *mock.Mock
1445}
1446
1447func (_m *MockWebViewPool) EXPECT() *MockWebViewPool_Expecter {
1448 return &MockWebViewPool_Expecter{mock: &_m.Mock}
1449}
1450
1451// Acquire provides a mock function for the type MockWebViewPool
1452func (_mock *MockWebViewPool) Acquire(ctx context.Context) (port.WebView, error) {
1453 ret := _mock.Called(ctx)
1454
1455 if len(ret) == 0 {
1456 panic("no return value specified for Acquire")
1457 }
1458
1459 var r0 port.WebView
1460 var r1 error
1461 if returnFunc, ok := ret.Get(0).(func(context.Context) (port.WebView, error)); ok {
1462 return returnFunc(ctx)
1463 }
1464 if returnFunc, ok := ret.Get(0).(func(context.Context) port.WebView); ok {
1465 r0 = returnFunc(ctx)
1466 } else {
1467 if ret.Get(0) != nil {
1468 r0 = ret.Get(0).(port.WebView)
1469 }
1470 }
1471 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
1472 r1 = returnFunc(ctx)
1473 } else {
1474 r1 = ret.Error(1)
1475 }
1476 return r0, r1
1477}
1478
1479// MockWebViewPool_Acquire_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Acquire'
1480type MockWebViewPool_Acquire_Call struct {
1481 *mock.Call
1482}
1483
1484// Acquire is a helper method to define mock.On call
1485// - ctx context.Context
1486func (_e *MockWebViewPool_Expecter) Acquire(ctx interface{}) *MockWebViewPool_Acquire_Call {
1487 return &MockWebViewPool_Acquire_Call{Call: _e.mock.On("Acquire", ctx)}
1488}
1489
1490func (_c *MockWebViewPool_Acquire_Call) Run(run func(ctx context.Context)) *MockWebViewPool_Acquire_Call {
1491 _c.Call.Run(func(args mock.Arguments) {
1492 var arg0 context.Context
1493 if args[0] != nil {
1494 arg0 = args[0].(context.Context)
1495 }
1496 run(
1497 arg0,
1498 )
1499 })
1500 return _c
1501}
1502
1503func (_c *MockWebViewPool_Acquire_Call) Return(webView port.WebView, err error) *MockWebViewPool_Acquire_Call {
1504 _c.Call.Return(webView, err)
1505 return _c
1506}
1507
1508func (_c *MockWebViewPool_Acquire_Call) RunAndReturn(run func(ctx context.Context) (port.WebView, error)) *MockWebViewPool_Acquire_Call {
1509 _c.Call.Return(run)
1510 return _c
1511}
1512
1513// Close provides a mock function for the type MockWebViewPool
1514func (_mock *MockWebViewPool) Close() {
1515 _mock.Called()
1516 return
1517}
1518
1519// MockWebViewPool_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
1520type MockWebViewPool_Close_Call struct {
1521 *mock.Call
1522}
1523
1524// Close is a helper method to define mock.On call
1525func (_e *MockWebViewPool_Expecter) Close() *MockWebViewPool_Close_Call {
1526 return &MockWebViewPool_Close_Call{Call: _e.mock.On("Close")}
1527}
1528
1529func (_c *MockWebViewPool_Close_Call) Run(run func()) *MockWebViewPool_Close_Call {
1530 _c.Call.Run(func(args mock.Arguments) {
1531 run()
1532 })
1533 return _c
1534}
1535
1536func (_c *MockWebViewPool_Close_Call) Return() *MockWebViewPool_Close_Call {
1537 _c.Call.Return()
1538 return _c
1539}
1540
1541func (_c *MockWebViewPool_Close_Call) RunAndReturn(run func()) *MockWebViewPool_Close_Call {
1542 _c.Run(run)
1543 return _c
1544}
1545
1546// Prewarm provides a mock function for the type MockWebViewPool
1547func (_mock *MockWebViewPool) Prewarm(count int) {
1548 _mock.Called(count)
1549 return
1550}
1551
1552// MockWebViewPool_Prewarm_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Prewarm'
1553type MockWebViewPool_Prewarm_Call struct {
1554 *mock.Call
1555}
1556
1557// Prewarm is a helper method to define mock.On call
1558// - count int
1559func (_e *MockWebViewPool_Expecter) Prewarm(count interface{}) *MockWebViewPool_Prewarm_Call {
1560 return &MockWebViewPool_Prewarm_Call{Call: _e.mock.On("Prewarm", count)}
1561}
1562
1563func (_c *MockWebViewPool_Prewarm_Call) Run(run func(count int)) *MockWebViewPool_Prewarm_Call {
1564 _c.Call.Run(func(args mock.Arguments) {
1565 var arg0 int
1566 if args[0] != nil {
1567 arg0 = args[0].(int)
1568 }
1569 run(
1570 arg0,
1571 )
1572 })
1573 return _c
1574}
1575
1576func (_c *MockWebViewPool_Prewarm_Call) Return() *MockWebViewPool_Prewarm_Call {
1577 _c.Call.Return()
1578 return _c
1579}
1580
1581func (_c *MockWebViewPool_Prewarm_Call) RunAndReturn(run func(count int)) *MockWebViewPool_Prewarm_Call {
1582 _c.Run(run)
1583 return _c
1584}
1585
1586// Release provides a mock function for the type MockWebViewPool
1587func (_mock *MockWebViewPool) Release(wv port.WebView) {
1588 _mock.Called(wv)
1589 return
1590}
1591
1592// MockWebViewPool_Release_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Release'
1593type MockWebViewPool_Release_Call struct {
1594 *mock.Call
1595}
1596
1597// Release is a helper method to define mock.On call
1598// - wv port.WebView
1599func (_e *MockWebViewPool_Expecter) Release(wv interface{}) *MockWebViewPool_Release_Call {
1600 return &MockWebViewPool_Release_Call{Call: _e.mock.On("Release", wv)}
1601}
1602
1603func (_c *MockWebViewPool_Release_Call) Run(run func(wv port.WebView)) *MockWebViewPool_Release_Call {
1604 _c.Call.Run(func(args mock.Arguments) {
1605 var arg0 port.WebView
1606 if args[0] != nil {
1607 arg0 = args[0].(port.WebView)
1608 }
1609 run(
1610 arg0,
1611 )
1612 })
1613 return _c
1614}
1615
1616func (_c *MockWebViewPool_Release_Call) Return() *MockWebViewPool_Release_Call {
1617 _c.Call.Return()
1618 return _c
1619}
1620
1621func (_c *MockWebViewPool_Release_Call) RunAndReturn(run func(wv port.WebView)) *MockWebViewPool_Release_Call {
1622 _c.Run(run)
1623 return _c
1624}
1625
1626// Size provides a mock function for the type MockWebViewPool
1627func (_mock *MockWebViewPool) Size() int {
1628 ret := _mock.Called()
1629
1630 if len(ret) == 0 {
1631 panic("no return value specified for Size")
1632 }
1633
1634 var r0 int
1635 if returnFunc, ok := ret.Get(0).(func() int); ok {
1636 r0 = returnFunc()
1637 } else {
1638 r0 = ret.Get(0).(int)
1639 }
1640 return r0
1641}
1642
1643// MockWebViewPool_Size_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Size'
1644type MockWebViewPool_Size_Call struct {
1645 *mock.Call
1646}
1647
1648// Size is a helper method to define mock.On call
1649func (_e *MockWebViewPool_Expecter) Size() *MockWebViewPool_Size_Call {
1650 return &MockWebViewPool_Size_Call{Call: _e.mock.On("Size")}
1651}
1652
1653func (_c *MockWebViewPool_Size_Call) Run(run func()) *MockWebViewPool_Size_Call {
1654 _c.Call.Run(func(args mock.Arguments) {
1655 run()
1656 })
1657 return _c
1658}
1659
1660func (_c *MockWebViewPool_Size_Call) Return(n int) *MockWebViewPool_Size_Call {
1661 _c.Call.Return(n)
1662 return _c
1663}
1664
1665func (_c *MockWebViewPool_Size_Call) RunAndReturn(run func() int) *MockWebViewPool_Size_Call {
1666 _c.Call.Return(run)
1667 return _c
1668}
1669
1670// 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.
1671// The first argument is typically a *testing.T value.
1672func NewMockWebViewFactory(t interface {
1673 mock.TestingT
1674 Cleanup(func())
1675}) *MockWebViewFactory {
1676 mock := &MockWebViewFactory{}
1677 mock.Mock.Test(t)
1678
1679 t.Cleanup(func() { mock.AssertExpectations(t) })
1680
1681 return mock
1682}
1683
1684// MockWebViewFactory is an autogenerated mock type for the WebViewFactory type
1685type MockWebViewFactory struct {
1686 mock.Mock
1687}
1688
1689type MockWebViewFactory_Expecter struct {
1690 mock *mock.Mock
1691}
1692
1693func (_m *MockWebViewFactory) EXPECT() *MockWebViewFactory_Expecter {
1694 return &MockWebViewFactory_Expecter{mock: &_m.Mock}
1695}
1696
1697// Create provides a mock function for the type MockWebViewFactory
1698func (_mock *MockWebViewFactory) Create(ctx context.Context) (port.WebView, error) {
1699 ret := _mock.Called(ctx)
1700
1701 if len(ret) == 0 {
1702 panic("no return value specified for Create")
1703 }
1704
1705 var r0 port.WebView
1706 var r1 error
1707 if returnFunc, ok := ret.Get(0).(func(context.Context) (port.WebView, error)); ok {
1708 return returnFunc(ctx)
1709 }
1710 if returnFunc, ok := ret.Get(0).(func(context.Context) port.WebView); ok {
1711 r0 = returnFunc(ctx)
1712 } else {
1713 if ret.Get(0) != nil {
1714 r0 = ret.Get(0).(port.WebView)
1715 }
1716 }
1717 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
1718 r1 = returnFunc(ctx)
1719 } else {
1720 r1 = ret.Error(1)
1721 }
1722 return r0, r1
1723}
1724
1725// MockWebViewFactory_Create_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Create'
1726type MockWebViewFactory_Create_Call struct {
1727 *mock.Call
1728}
1729
1730// Create is a helper method to define mock.On call
1731// - ctx context.Context
1732func (_e *MockWebViewFactory_Expecter) Create(ctx interface{}) *MockWebViewFactory_Create_Call {
1733 return &MockWebViewFactory_Create_Call{Call: _e.mock.On("Create", ctx)}
1734}
1735
1736func (_c *MockWebViewFactory_Create_Call) Run(run func(ctx context.Context)) *MockWebViewFactory_Create_Call {
1737 _c.Call.Run(func(args mock.Arguments) {
1738 var arg0 context.Context
1739 if args[0] != nil {
1740 arg0 = args[0].(context.Context)
1741 }
1742 run(
1743 arg0,
1744 )
1745 })
1746 return _c
1747}
1748
1749func (_c *MockWebViewFactory_Create_Call) Return(webView port.WebView, err error) *MockWebViewFactory_Create_Call {
1750 _c.Call.Return(webView, err)
1751 return _c
1752}
1753
1754func (_c *MockWebViewFactory_Create_Call) RunAndReturn(run func(ctx context.Context) (port.WebView, error)) *MockWebViewFactory_Create_Call {
1755 _c.Call.Return(run)
1756 return _c
1757}
1758
1759// CreateRelated provides a mock function for the type MockWebViewFactory
1760func (_mock *MockWebViewFactory) CreateRelated(ctx context.Context, parentID port.WebViewID) (port.WebView, error) {
1761 ret := _mock.Called(ctx, parentID)
1762
1763 if len(ret) == 0 {
1764 panic("no return value specified for CreateRelated")
1765 }
1766
1767 var r0 port.WebView
1768 var r1 error
1769 if returnFunc, ok := ret.Get(0).(func(context.Context, port.WebViewID) (port.WebView, error)); ok {
1770 return returnFunc(ctx, parentID)
1771 }
1772 if returnFunc, ok := ret.Get(0).(func(context.Context, port.WebViewID) port.WebView); ok {
1773 r0 = returnFunc(ctx, parentID)
1774 } else {
1775 if ret.Get(0) != nil {
1776 r0 = ret.Get(0).(port.WebView)
1777 }
1778 }
1779 if returnFunc, ok := ret.Get(1).(func(context.Context, port.WebViewID) error); ok {
1780 r1 = returnFunc(ctx, parentID)
1781 } else {
1782 r1 = ret.Error(1)
1783 }
1784 return r0, r1
1785}
1786
1787// MockWebViewFactory_CreateRelated_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateRelated'
1788type MockWebViewFactory_CreateRelated_Call struct {
1789 *mock.Call
1790}
1791
1792// CreateRelated is a helper method to define mock.On call
1793// - ctx context.Context
1794// - parentID port.WebViewID
1795func (_e *MockWebViewFactory_Expecter) CreateRelated(ctx interface{}, parentID interface{}) *MockWebViewFactory_CreateRelated_Call {
1796 return &MockWebViewFactory_CreateRelated_Call{Call: _e.mock.On("CreateRelated", ctx, parentID)}
1797}
1798
1799func (_c *MockWebViewFactory_CreateRelated_Call) Run(run func(ctx context.Context, parentID port.WebViewID)) *MockWebViewFactory_CreateRelated_Call {
1800 _c.Call.Run(func(args mock.Arguments) {
1801 var arg0 context.Context
1802 if args[0] != nil {
1803 arg0 = args[0].(context.Context)
1804 }
1805 var arg1 port.WebViewID
1806 if args[1] != nil {
1807 arg1 = args[1].(port.WebViewID)
1808 }
1809 run(
1810 arg0,
1811 arg1,
1812 )
1813 })
1814 return _c
1815}
1816
1817func (_c *MockWebViewFactory_CreateRelated_Call) Return(webView port.WebView, err error) *MockWebViewFactory_CreateRelated_Call {
1818 _c.Call.Return(webView, err)
1819 return _c
1820}
1821
1822func (_c *MockWebViewFactory_CreateRelated_Call) RunAndReturn(run func(ctx context.Context, parentID port.WebViewID) (port.WebView, error)) *MockWebViewFactory_CreateRelated_Call {
1823 _c.Call.Return(run)
1824 return _c
1825}