1// Code generated by mockery; DO NOT EDIT.
2// github.com/vektra/mockery
3// template: testify
4
5package portsmocks
6
7import (
8 "context"
9
10 "github.com/bnema/vev/internal/ports"
11 mock "github.com/stretchr/testify/mock"
12)
13
14// NewMockTransport creates a new instance of MockTransport. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
15// The first argument is typically a *testing.T value.
16func NewMockTransport(t interface {
17 mock.TestingT
18 Cleanup(func())
19}) *MockTransport {
20 mock := &MockTransport{}
21 mock.Mock.Test(t)
22
23 t.Cleanup(func() { mock.AssertExpectations(t) })
24
25 return mock
26}
27
28// MockTransport is an autogenerated mock type for the Transport type
29type MockTransport struct {
30 mock.Mock
31}
32
33type MockTransport_Expecter struct {
34 mock *mock.Mock
35}
36
37func (_m *MockTransport) EXPECT() *MockTransport_Expecter {
38 return &MockTransport_Expecter{mock: &_m.Mock}
39}
40
41// Close provides a mock function for the type MockTransport
42func (_mock *MockTransport) Close() error {
43 ret := _mock.Called()
44
45 if len(ret) == 0 {
46 panic("no return value specified for Close")
47 }
48
49 var r0 error
50 if returnFunc, ok := ret.Get(0).(func() error); ok {
51 r0 = returnFunc()
52 } else {
53 r0 = ret.Error(0)
54 }
55 return r0
56}
57
58// MockTransport_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
59type MockTransport_Close_Call struct {
60 *mock.Call
61}
62
63// Close is a helper method to define mock.On call
64func (_e *MockTransport_Expecter) Close() *MockTransport_Close_Call {
65 return &MockTransport_Close_Call{Call: _e.mock.On("Close")}
66}
67
68func (_c *MockTransport_Close_Call) Run(run func()) *MockTransport_Close_Call {
69 _c.Call.Run(func(args mock.Arguments) {
70 run()
71 })
72 return _c
73}
74
75func (_c *MockTransport_Close_Call) Return(err error) *MockTransport_Close_Call {
76 _c.Call.Return(err)
77 return _c
78}
79
80func (_c *MockTransport_Close_Call) RunAndReturn(run func() error) *MockTransport_Close_Call {
81 _c.Call.Return(run)
82 return _c
83}
84
85// Recv provides a mock function for the type MockTransport
86func (_mock *MockTransport) Recv() (ports.Frame, error) {
87 ret := _mock.Called()
88
89 if len(ret) == 0 {
90 panic("no return value specified for Recv")
91 }
92
93 var r0 ports.Frame
94 var r1 error
95 if returnFunc, ok := ret.Get(0).(func() (ports.Frame, error)); ok {
96 return returnFunc()
97 }
98 if returnFunc, ok := ret.Get(0).(func() ports.Frame); ok {
99 r0 = returnFunc()
100 } else {
101 r0 = ret.Get(0).(ports.Frame)
102 }
103 if returnFunc, ok := ret.Get(1).(func() error); ok {
104 r1 = returnFunc()
105 } else {
106 r1 = ret.Error(1)
107 }
108 return r0, r1
109}
110
111// MockTransport_Recv_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Recv'
112type MockTransport_Recv_Call struct {
113 *mock.Call
114}
115
116// Recv is a helper method to define mock.On call
117func (_e *MockTransport_Expecter) Recv() *MockTransport_Recv_Call {
118 return &MockTransport_Recv_Call{Call: _e.mock.On("Recv")}
119}
120
121func (_c *MockTransport_Recv_Call) Run(run func()) *MockTransport_Recv_Call {
122 _c.Call.Run(func(args mock.Arguments) {
123 run()
124 })
125 return _c
126}
127
128func (_c *MockTransport_Recv_Call) Return(frame ports.Frame, err error) *MockTransport_Recv_Call {
129 _c.Call.Return(frame, err)
130 return _c
131}
132
133func (_c *MockTransport_Recv_Call) RunAndReturn(run func() (ports.Frame, error)) *MockTransport_Recv_Call {
134 _c.Call.Return(run)
135 return _c
136}
137
138// Send provides a mock function for the type MockTransport
139func (_mock *MockTransport) Send(frame ports.Frame) error {
140 ret := _mock.Called(frame)
141
142 if len(ret) == 0 {
143 panic("no return value specified for Send")
144 }
145
146 var r0 error
147 if returnFunc, ok := ret.Get(0).(func(ports.Frame) error); ok {
148 r0 = returnFunc(frame)
149 } else {
150 r0 = ret.Error(0)
151 }
152 return r0
153}
154
155// MockTransport_Send_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Send'
156type MockTransport_Send_Call struct {
157 *mock.Call
158}
159
160// Send is a helper method to define mock.On call
161// - frame ports.Frame
162func (_e *MockTransport_Expecter) Send(frame any) *MockTransport_Send_Call {
163 return &MockTransport_Send_Call{Call: _e.mock.On("Send", frame)}
164}
165
166func (_c *MockTransport_Send_Call) Run(run func(frame ports.Frame)) *MockTransport_Send_Call {
167 _c.Call.Run(func(args mock.Arguments) {
168 var arg0 ports.Frame
169 if args[0] != nil {
170 arg0 = args[0].(ports.Frame)
171 }
172 run(
173 arg0,
174 )
175 })
176 return _c
177}
178
179func (_c *MockTransport_Send_Call) Return(err error) *MockTransport_Send_Call {
180 _c.Call.Return(err)
181 return _c
182}
183
184func (_c *MockTransport_Send_Call) RunAndReturn(run func(frame ports.Frame) error) *MockTransport_Send_Call {
185 _c.Call.Return(run)
186 return _c
187}
188
189// NewMockDatagramTransport creates a new instance of MockDatagramTransport. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
190// The first argument is typically a *testing.T value.
191func NewMockDatagramTransport(t interface {
192 mock.TestingT
193 Cleanup(func())
194}) *MockDatagramTransport {
195 mock := &MockDatagramTransport{}
196 mock.Mock.Test(t)
197
198 t.Cleanup(func() { mock.AssertExpectations(t) })
199
200 return mock
201}
202
203// MockDatagramTransport is an autogenerated mock type for the DatagramTransport type
204type MockDatagramTransport struct {
205 mock.Mock
206}
207
208type MockDatagramTransport_Expecter struct {
209 mock *mock.Mock
210}
211
212func (_m *MockDatagramTransport) EXPECT() *MockDatagramTransport_Expecter {
213 return &MockDatagramTransport_Expecter{mock: &_m.Mock}
214}
215
216// Close provides a mock function for the type MockDatagramTransport
217func (_mock *MockDatagramTransport) Close() error {
218 ret := _mock.Called()
219
220 if len(ret) == 0 {
221 panic("no return value specified for Close")
222 }
223
224 var r0 error
225 if returnFunc, ok := ret.Get(0).(func() error); ok {
226 r0 = returnFunc()
227 } else {
228 r0 = ret.Error(0)
229 }
230 return r0
231}
232
233// MockDatagramTransport_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
234type MockDatagramTransport_Close_Call struct {
235 *mock.Call
236}
237
238// Close is a helper method to define mock.On call
239func (_e *MockDatagramTransport_Expecter) Close() *MockDatagramTransport_Close_Call {
240 return &MockDatagramTransport_Close_Call{Call: _e.mock.On("Close")}
241}
242
243func (_c *MockDatagramTransport_Close_Call) Run(run func()) *MockDatagramTransport_Close_Call {
244 _c.Call.Run(func(args mock.Arguments) {
245 run()
246 })
247 return _c
248}
249
250func (_c *MockDatagramTransport_Close_Call) Return(err error) *MockDatagramTransport_Close_Call {
251 _c.Call.Return(err)
252 return _c
253}
254
255func (_c *MockDatagramTransport_Close_Call) RunAndReturn(run func() error) *MockDatagramTransport_Close_Call {
256 _c.Call.Return(run)
257 return _c
258}
259
260// DatagramTransport provides a mock function for the type MockDatagramTransport
261func (_mock *MockDatagramTransport) DatagramTransport() {
262 _mock.Called()
263 return
264}
265
266// MockDatagramTransport_DatagramTransport_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DatagramTransport'
267type MockDatagramTransport_DatagramTransport_Call struct {
268 *mock.Call
269}
270
271// DatagramTransport is a helper method to define mock.On call
272func (_e *MockDatagramTransport_Expecter) DatagramTransport() *MockDatagramTransport_DatagramTransport_Call {
273 return &MockDatagramTransport_DatagramTransport_Call{Call: _e.mock.On("DatagramTransport")}
274}
275
276func (_c *MockDatagramTransport_DatagramTransport_Call) Run(run func()) *MockDatagramTransport_DatagramTransport_Call {
277 _c.Call.Run(func(args mock.Arguments) {
278 run()
279 })
280 return _c
281}
282
283func (_c *MockDatagramTransport_DatagramTransport_Call) Return() *MockDatagramTransport_DatagramTransport_Call {
284 _c.Call.Return()
285 return _c
286}
287
288func (_c *MockDatagramTransport_DatagramTransport_Call) RunAndReturn(run func()) *MockDatagramTransport_DatagramTransport_Call {
289 _c.Run(run)
290 return _c
291}
292
293// Recv provides a mock function for the type MockDatagramTransport
294func (_mock *MockDatagramTransport) Recv() (ports.Frame, error) {
295 ret := _mock.Called()
296
297 if len(ret) == 0 {
298 panic("no return value specified for Recv")
299 }
300
301 var r0 ports.Frame
302 var r1 error
303 if returnFunc, ok := ret.Get(0).(func() (ports.Frame, error)); ok {
304 return returnFunc()
305 }
306 if returnFunc, ok := ret.Get(0).(func() ports.Frame); ok {
307 r0 = returnFunc()
308 } else {
309 r0 = ret.Get(0).(ports.Frame)
310 }
311 if returnFunc, ok := ret.Get(1).(func() error); ok {
312 r1 = returnFunc()
313 } else {
314 r1 = ret.Error(1)
315 }
316 return r0, r1
317}
318
319// MockDatagramTransport_Recv_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Recv'
320type MockDatagramTransport_Recv_Call struct {
321 *mock.Call
322}
323
324// Recv is a helper method to define mock.On call
325func (_e *MockDatagramTransport_Expecter) Recv() *MockDatagramTransport_Recv_Call {
326 return &MockDatagramTransport_Recv_Call{Call: _e.mock.On("Recv")}
327}
328
329func (_c *MockDatagramTransport_Recv_Call) Run(run func()) *MockDatagramTransport_Recv_Call {
330 _c.Call.Run(func(args mock.Arguments) {
331 run()
332 })
333 return _c
334}
335
336func (_c *MockDatagramTransport_Recv_Call) Return(frame ports.Frame, err error) *MockDatagramTransport_Recv_Call {
337 _c.Call.Return(frame, err)
338 return _c
339}
340
341func (_c *MockDatagramTransport_Recv_Call) RunAndReturn(run func() (ports.Frame, error)) *MockDatagramTransport_Recv_Call {
342 _c.Call.Return(run)
343 return _c
344}
345
346// Send provides a mock function for the type MockDatagramTransport
347func (_mock *MockDatagramTransport) Send(frame ports.Frame) error {
348 ret := _mock.Called(frame)
349
350 if len(ret) == 0 {
351 panic("no return value specified for Send")
352 }
353
354 var r0 error
355 if returnFunc, ok := ret.Get(0).(func(ports.Frame) error); ok {
356 r0 = returnFunc(frame)
357 } else {
358 r0 = ret.Error(0)
359 }
360 return r0
361}
362
363// MockDatagramTransport_Send_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Send'
364type MockDatagramTransport_Send_Call struct {
365 *mock.Call
366}
367
368// Send is a helper method to define mock.On call
369// - frame ports.Frame
370func (_e *MockDatagramTransport_Expecter) Send(frame any) *MockDatagramTransport_Send_Call {
371 return &MockDatagramTransport_Send_Call{Call: _e.mock.On("Send", frame)}
372}
373
374func (_c *MockDatagramTransport_Send_Call) Run(run func(frame ports.Frame)) *MockDatagramTransport_Send_Call {
375 _c.Call.Run(func(args mock.Arguments) {
376 var arg0 ports.Frame
377 if args[0] != nil {
378 arg0 = args[0].(ports.Frame)
379 }
380 run(
381 arg0,
382 )
383 })
384 return _c
385}
386
387func (_c *MockDatagramTransport_Send_Call) Return(err error) *MockDatagramTransport_Send_Call {
388 _c.Call.Return(err)
389 return _c
390}
391
392func (_c *MockDatagramTransport_Send_Call) RunAndReturn(run func(frame ports.Frame) error) *MockDatagramTransport_Send_Call {
393 _c.Call.Return(run)
394 return _c
395}
396
397// NewMockAsyncTransport creates a new instance of MockAsyncTransport. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
398// The first argument is typically a *testing.T value.
399func NewMockAsyncTransport(t interface {
400 mock.TestingT
401 Cleanup(func())
402}) *MockAsyncTransport {
403 mock := &MockAsyncTransport{}
404 mock.Mock.Test(t)
405
406 t.Cleanup(func() { mock.AssertExpectations(t) })
407
408 return mock
409}
410
411// MockAsyncTransport is an autogenerated mock type for the AsyncTransport type
412type MockAsyncTransport struct {
413 mock.Mock
414}
415
416type MockAsyncTransport_Expecter struct {
417 mock *mock.Mock
418}
419
420func (_m *MockAsyncTransport) EXPECT() *MockAsyncTransport_Expecter {
421 return &MockAsyncTransport_Expecter{mock: &_m.Mock}
422}
423
424// SendAsync provides a mock function for the type MockAsyncTransport
425func (_mock *MockAsyncTransport) SendAsync(frame ports.Frame) error {
426 ret := _mock.Called(frame)
427
428 if len(ret) == 0 {
429 panic("no return value specified for SendAsync")
430 }
431
432 var r0 error
433 if returnFunc, ok := ret.Get(0).(func(ports.Frame) error); ok {
434 r0 = returnFunc(frame)
435 } else {
436 r0 = ret.Error(0)
437 }
438 return r0
439}
440
441// MockAsyncTransport_SendAsync_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendAsync'
442type MockAsyncTransport_SendAsync_Call struct {
443 *mock.Call
444}
445
446// SendAsync is a helper method to define mock.On call
447// - frame ports.Frame
448func (_e *MockAsyncTransport_Expecter) SendAsync(frame any) *MockAsyncTransport_SendAsync_Call {
449 return &MockAsyncTransport_SendAsync_Call{Call: _e.mock.On("SendAsync", frame)}
450}
451
452func (_c *MockAsyncTransport_SendAsync_Call) Run(run func(frame ports.Frame)) *MockAsyncTransport_SendAsync_Call {
453 _c.Call.Run(func(args mock.Arguments) {
454 var arg0 ports.Frame
455 if args[0] != nil {
456 arg0 = args[0].(ports.Frame)
457 }
458 run(
459 arg0,
460 )
461 })
462 return _c
463}
464
465func (_c *MockAsyncTransport_SendAsync_Call) Return(err error) *MockAsyncTransport_SendAsync_Call {
466 _c.Call.Return(err)
467 return _c
468}
469
470func (_c *MockAsyncTransport_SendAsync_Call) RunAndReturn(run func(frame ports.Frame) error) *MockAsyncTransport_SendAsync_Call {
471 _c.Call.Return(run)
472 return _c
473}
474
475// NewMockOwnedSynchronousTransport creates a new instance of MockOwnedSynchronousTransport. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
476// The first argument is typically a *testing.T value.
477func NewMockOwnedSynchronousTransport(t interface {
478 mock.TestingT
479 Cleanup(func())
480}) *MockOwnedSynchronousTransport {
481 mock := &MockOwnedSynchronousTransport{}
482 mock.Mock.Test(t)
483
484 t.Cleanup(func() { mock.AssertExpectations(t) })
485
486 return mock
487}
488
489// MockOwnedSynchronousTransport is an autogenerated mock type for the OwnedSynchronousTransport type
490type MockOwnedSynchronousTransport struct {
491 mock.Mock
492}
493
494type MockOwnedSynchronousTransport_Expecter struct {
495 mock *mock.Mock
496}
497
498func (_m *MockOwnedSynchronousTransport) EXPECT() *MockOwnedSynchronousTransport_Expecter {
499 return &MockOwnedSynchronousTransport_Expecter{mock: &_m.Mock}
500}
501
502// SendSynchronous provides a mock function for the type MockOwnedSynchronousTransport
503func (_mock *MockOwnedSynchronousTransport) SendSynchronous(frame ports.Frame) error {
504 ret := _mock.Called(frame)
505
506 if len(ret) == 0 {
507 panic("no return value specified for SendSynchronous")
508 }
509
510 var r0 error
511 if returnFunc, ok := ret.Get(0).(func(ports.Frame) error); ok {
512 r0 = returnFunc(frame)
513 } else {
514 r0 = ret.Error(0)
515 }
516 return r0
517}
518
519// MockOwnedSynchronousTransport_SendSynchronous_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendSynchronous'
520type MockOwnedSynchronousTransport_SendSynchronous_Call struct {
521 *mock.Call
522}
523
524// SendSynchronous is a helper method to define mock.On call
525// - frame ports.Frame
526func (_e *MockOwnedSynchronousTransport_Expecter) SendSynchronous(frame any) *MockOwnedSynchronousTransport_SendSynchronous_Call {
527 return &MockOwnedSynchronousTransport_SendSynchronous_Call{Call: _e.mock.On("SendSynchronous", frame)}
528}
529
530func (_c *MockOwnedSynchronousTransport_SendSynchronous_Call) Run(run func(frame ports.Frame)) *MockOwnedSynchronousTransport_SendSynchronous_Call {
531 _c.Call.Run(func(args mock.Arguments) {
532 var arg0 ports.Frame
533 if args[0] != nil {
534 arg0 = args[0].(ports.Frame)
535 }
536 run(
537 arg0,
538 )
539 })
540 return _c
541}
542
543func (_c *MockOwnedSynchronousTransport_SendSynchronous_Call) Return(err error) *MockOwnedSynchronousTransport_SendSynchronous_Call {
544 _c.Call.Return(err)
545 return _c
546}
547
548func (_c *MockOwnedSynchronousTransport_SendSynchronous_Call) RunAndReturn(run func(frame ports.Frame) error) *MockOwnedSynchronousTransport_SendSynchronous_Call {
549 _c.Call.Return(run)
550 return _c
551}
552
553// NewMockDialer creates a new instance of MockDialer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
554// The first argument is typically a *testing.T value.
555func NewMockDialer(t interface {
556 mock.TestingT
557 Cleanup(func())
558}) *MockDialer {
559 mock := &MockDialer{}
560 mock.Mock.Test(t)
561
562 t.Cleanup(func() { mock.AssertExpectations(t) })
563
564 return mock
565}
566
567// MockDialer is an autogenerated mock type for the Dialer type
568type MockDialer struct {
569 mock.Mock
570}
571
572type MockDialer_Expecter struct {
573 mock *mock.Mock
574}
575
576func (_m *MockDialer) EXPECT() *MockDialer_Expecter {
577 return &MockDialer_Expecter{mock: &_m.Mock}
578}
579
580// Dial provides a mock function for the type MockDialer
581func (_mock *MockDialer) Dial(ctx context.Context) (ports.Transport, error) {
582 ret := _mock.Called(ctx)
583
584 if len(ret) == 0 {
585 panic("no return value specified for Dial")
586 }
587
588 var r0 ports.Transport
589 var r1 error
590 if returnFunc, ok := ret.Get(0).(func(context.Context) (ports.Transport, error)); ok {
591 return returnFunc(ctx)
592 }
593 if returnFunc, ok := ret.Get(0).(func(context.Context) ports.Transport); ok {
594 r0 = returnFunc(ctx)
595 } else {
596 if ret.Get(0) != nil {
597 r0 = ret.Get(0).(ports.Transport)
598 }
599 }
600 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
601 r1 = returnFunc(ctx)
602 } else {
603 r1 = ret.Error(1)
604 }
605 return r0, r1
606}
607
608// MockDialer_Dial_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Dial'
609type MockDialer_Dial_Call struct {
610 *mock.Call
611}
612
613// Dial is a helper method to define mock.On call
614// - ctx context.Context
615func (_e *MockDialer_Expecter) Dial(ctx any) *MockDialer_Dial_Call {
616 return &MockDialer_Dial_Call{Call: _e.mock.On("Dial", ctx)}
617}
618
619func (_c *MockDialer_Dial_Call) Run(run func(ctx context.Context)) *MockDialer_Dial_Call {
620 _c.Call.Run(func(args mock.Arguments) {
621 var arg0 context.Context
622 if args[0] != nil {
623 arg0 = args[0].(context.Context)
624 }
625 run(
626 arg0,
627 )
628 })
629 return _c
630}
631
632func (_c *MockDialer_Dial_Call) Return(transport ports.Transport, err error) *MockDialer_Dial_Call {
633 _c.Call.Return(transport, err)
634 return _c
635}
636
637func (_c *MockDialer_Dial_Call) RunAndReturn(run func(ctx context.Context) (ports.Transport, error)) *MockDialer_Dial_Call {
638 _c.Call.Return(run)
639 return _c
640}
641
642// NewMockListener creates a new instance of MockListener. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
643// The first argument is typically a *testing.T value.
644func NewMockListener(t interface {
645 mock.TestingT
646 Cleanup(func())
647}) *MockListener {
648 mock := &MockListener{}
649 mock.Mock.Test(t)
650
651 t.Cleanup(func() { mock.AssertExpectations(t) })
652
653 return mock
654}
655
656// MockListener is an autogenerated mock type for the Listener type
657type MockListener struct {
658 mock.Mock
659}
660
661type MockListener_Expecter struct {
662 mock *mock.Mock
663}
664
665func (_m *MockListener) EXPECT() *MockListener_Expecter {
666 return &MockListener_Expecter{mock: &_m.Mock}
667}
668
669// Accept provides a mock function for the type MockListener
670func (_mock *MockListener) Accept() (ports.Transport, error) {
671 ret := _mock.Called()
672
673 if len(ret) == 0 {
674 panic("no return value specified for Accept")
675 }
676
677 var r0 ports.Transport
678 var r1 error
679 if returnFunc, ok := ret.Get(0).(func() (ports.Transport, error)); ok {
680 return returnFunc()
681 }
682 if returnFunc, ok := ret.Get(0).(func() ports.Transport); ok {
683 r0 = returnFunc()
684 } else {
685 if ret.Get(0) != nil {
686 r0 = ret.Get(0).(ports.Transport)
687 }
688 }
689 if returnFunc, ok := ret.Get(1).(func() error); ok {
690 r1 = returnFunc()
691 } else {
692 r1 = ret.Error(1)
693 }
694 return r0, r1
695}
696
697// MockListener_Accept_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Accept'
698type MockListener_Accept_Call struct {
699 *mock.Call
700}
701
702// Accept is a helper method to define mock.On call
703func (_e *MockListener_Expecter) Accept() *MockListener_Accept_Call {
704 return &MockListener_Accept_Call{Call: _e.mock.On("Accept")}
705}
706
707func (_c *MockListener_Accept_Call) Run(run func()) *MockListener_Accept_Call {
708 _c.Call.Run(func(args mock.Arguments) {
709 run()
710 })
711 return _c
712}
713
714func (_c *MockListener_Accept_Call) Return(transport ports.Transport, err error) *MockListener_Accept_Call {
715 _c.Call.Return(transport, err)
716 return _c
717}
718
719func (_c *MockListener_Accept_Call) RunAndReturn(run func() (ports.Transport, error)) *MockListener_Accept_Call {
720 _c.Call.Return(run)
721 return _c
722}
723
724// Addr provides a mock function for the type MockListener
725func (_mock *MockListener) Addr() string {
726 ret := _mock.Called()
727
728 if len(ret) == 0 {
729 panic("no return value specified for Addr")
730 }
731
732 var r0 string
733 if returnFunc, ok := ret.Get(0).(func() string); ok {
734 r0 = returnFunc()
735 } else {
736 r0 = ret.Get(0).(string)
737 }
738 return r0
739}
740
741// MockListener_Addr_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Addr'
742type MockListener_Addr_Call struct {
743 *mock.Call
744}
745
746// Addr is a helper method to define mock.On call
747func (_e *MockListener_Expecter) Addr() *MockListener_Addr_Call {
748 return &MockListener_Addr_Call{Call: _e.mock.On("Addr")}
749}
750
751func (_c *MockListener_Addr_Call) Run(run func()) *MockListener_Addr_Call {
752 _c.Call.Run(func(args mock.Arguments) {
753 run()
754 })
755 return _c
756}
757
758func (_c *MockListener_Addr_Call) Return(s string) *MockListener_Addr_Call {
759 _c.Call.Return(s)
760 return _c
761}
762
763func (_c *MockListener_Addr_Call) RunAndReturn(run func() string) *MockListener_Addr_Call {
764 _c.Call.Return(run)
765 return _c
766}
767
768// Close provides a mock function for the type MockListener
769func (_mock *MockListener) Close() error {
770 ret := _mock.Called()
771
772 if len(ret) == 0 {
773 panic("no return value specified for Close")
774 }
775
776 var r0 error
777 if returnFunc, ok := ret.Get(0).(func() error); ok {
778 r0 = returnFunc()
779 } else {
780 r0 = ret.Error(0)
781 }
782 return r0
783}
784
785// MockListener_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
786type MockListener_Close_Call struct {
787 *mock.Call
788}
789
790// Close is a helper method to define mock.On call
791func (_e *MockListener_Expecter) Close() *MockListener_Close_Call {
792 return &MockListener_Close_Call{Call: _e.mock.On("Close")}
793}
794
795func (_c *MockListener_Close_Call) Run(run func()) *MockListener_Close_Call {
796 _c.Call.Run(func(args mock.Arguments) {
797 run()
798 })
799 return _c
800}
801
802func (_c *MockListener_Close_Call) Return(err error) *MockListener_Close_Call {
803 _c.Call.Return(err)
804 return _c
805}
806
807func (_c *MockListener_Close_Call) RunAndReturn(run func() error) *MockListener_Close_Call {
808 _c.Call.Return(run)
809 return _c
810}