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