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