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