1// Code generated by mockery; DO NOT EDIT.
2// github.com/vektra/mockery
3// template: testify
4
5package mocks
6
7import (
8 "unsafe"
9
10 "github.com/bnema/purego-pipewire/internal/ports/out"
11 mock "github.com/stretchr/testify/mock"
12)
13
14// NewMockStreamOps creates a new instance of MockStreamOps. 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 NewMockStreamOps(t interface {
17 mock.TestingT
18 Cleanup(func())
19}) *MockStreamOps {
20 if helper, ok := t.(interface{ Helper() }); ok {
21 helper.Helper()
22 }
23
24 mock := &MockStreamOps{}
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// MockStreamOps is an autogenerated mock type for the StreamOps type
38type MockStreamOps struct {
39 mock.Mock
40}
41
42type MockStreamOps_Expecter struct {
43 mock *mock.Mock
44}
45
46func (_m *MockStreamOps) EXPECT() *MockStreamOps_Expecter {
47 return &MockStreamOps_Expecter{mock: &_m.Mock}
48}
49
50// ConnectPlaybackStream provides a mock function for the type MockStreamOps
51func (_mock *MockStreamOps) ConnectPlaybackStream(streamPtr unsafe.Pointer, format out.PlaybackFormat) error {
52 ret := _mock.Called(streamPtr, format)
53
54 if len(ret) == 0 {
55 panic("no return value specified for ConnectPlaybackStream")
56 }
57
58 var r0 error
59 if returnFunc, ok := ret.Get(0).(func(unsafe.Pointer, out.PlaybackFormat) error); ok {
60 r0 = returnFunc(streamPtr, format)
61 } else {
62 r0 = ret.Error(0)
63 }
64 return r0
65}
66
67// MockStreamOps_ConnectPlaybackStream_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ConnectPlaybackStream'
68type MockStreamOps_ConnectPlaybackStream_Call struct {
69 *mock.Call
70}
71
72// ConnectPlaybackStream is a helper method to define mock.On call
73// - streamPtr unsafe.Pointer
74// - format out.PlaybackFormat
75func (_e *MockStreamOps_Expecter) ConnectPlaybackStream(streamPtr any, format any) *MockStreamOps_ConnectPlaybackStream_Call {
76 return &MockStreamOps_ConnectPlaybackStream_Call{Call: _e.mock.On("ConnectPlaybackStream", streamPtr, format)}
77}
78
79func (_c *MockStreamOps_ConnectPlaybackStream_Call) Run(run func(streamPtr unsafe.Pointer, format out.PlaybackFormat)) *MockStreamOps_ConnectPlaybackStream_Call {
80 _c.Call.Run(func(args mock.Arguments) {
81 var arg0 unsafe.Pointer
82 if args[0] != nil {
83 arg0 = args[0].(unsafe.Pointer)
84 }
85 var arg1 out.PlaybackFormat
86 if args[1] != nil {
87 arg1 = args[1].(out.PlaybackFormat)
88 }
89 run(
90 arg0,
91 arg1,
92 )
93 })
94 return _c
95}
96
97func (_c *MockStreamOps_ConnectPlaybackStream_Call) Return(err error) *MockStreamOps_ConnectPlaybackStream_Call {
98 _c.Call.Return(err)
99 return _c
100}
101
102func (_c *MockStreamOps_ConnectPlaybackStream_Call) RunAndReturn(run func(streamPtr unsafe.Pointer, format out.PlaybackFormat) error) *MockStreamOps_ConnectPlaybackStream_Call {
103 _c.Call.Return(run)
104 return _c
105}
106
107// CreateMainLoop provides a mock function for the type MockStreamOps
108func (_mock *MockStreamOps) CreateMainLoop() (unsafe.Pointer, error) {
109 ret := _mock.Called()
110
111 if len(ret) == 0 {
112 panic("no return value specified for CreateMainLoop")
113 }
114
115 var r0 unsafe.Pointer
116 var r1 error
117 if returnFunc, ok := ret.Get(0).(func() (unsafe.Pointer, error)); ok {
118 return returnFunc()
119 }
120 if returnFunc, ok := ret.Get(0).(func() unsafe.Pointer); ok {
121 r0 = returnFunc()
122 } else {
123 r0 = ret.Get(0).(unsafe.Pointer)
124 }
125 if returnFunc, ok := ret.Get(1).(func() error); ok {
126 r1 = returnFunc()
127 } else {
128 r1 = ret.Error(1)
129 }
130 return r0, r1
131}
132
133// MockStreamOps_CreateMainLoop_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateMainLoop'
134type MockStreamOps_CreateMainLoop_Call struct {
135 *mock.Call
136}
137
138// CreateMainLoop is a helper method to define mock.On call
139func (_e *MockStreamOps_Expecter) CreateMainLoop() *MockStreamOps_CreateMainLoop_Call {
140 return &MockStreamOps_CreateMainLoop_Call{Call: _e.mock.On("CreateMainLoop")}
141}
142
143func (_c *MockStreamOps_CreateMainLoop_Call) Run(run func()) *MockStreamOps_CreateMainLoop_Call {
144 _c.Call.Run(func(args mock.Arguments) {
145 run()
146 })
147 return _c
148}
149
150func (_c *MockStreamOps_CreateMainLoop_Call) Return(loopPtr unsafe.Pointer, err error) *MockStreamOps_CreateMainLoop_Call {
151 _c.Call.Return(loopPtr, err)
152 return _c
153}
154
155func (_c *MockStreamOps_CreateMainLoop_Call) RunAndReturn(run func() (unsafe.Pointer, error)) *MockStreamOps_CreateMainLoop_Call {
156 _c.Call.Return(run)
157 return _c
158}
159
160// CreatePlaybackStream provides a mock function for the type MockStreamOps
161func (_mock *MockStreamOps) CreatePlaybackStream(loopPtr unsafe.Pointer, name string, onProcess func()) (unsafe.Pointer, error) {
162 ret := _mock.Called(loopPtr, name, onProcess)
163
164 if len(ret) == 0 {
165 panic("no return value specified for CreatePlaybackStream")
166 }
167
168 var r0 unsafe.Pointer
169 var r1 error
170 if returnFunc, ok := ret.Get(0).(func(unsafe.Pointer, string, func()) (unsafe.Pointer, error)); ok {
171 return returnFunc(loopPtr, name, onProcess)
172 }
173 if returnFunc, ok := ret.Get(0).(func(unsafe.Pointer, string, func()) unsafe.Pointer); ok {
174 r0 = returnFunc(loopPtr, name, onProcess)
175 } else {
176 r0 = ret.Get(0).(unsafe.Pointer)
177 }
178 if returnFunc, ok := ret.Get(1).(func(unsafe.Pointer, string, func()) error); ok {
179 r1 = returnFunc(loopPtr, name, onProcess)
180 } else {
181 r1 = ret.Error(1)
182 }
183 return r0, r1
184}
185
186// MockStreamOps_CreatePlaybackStream_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreatePlaybackStream'
187type MockStreamOps_CreatePlaybackStream_Call struct {
188 *mock.Call
189}
190
191// CreatePlaybackStream is a helper method to define mock.On call
192// - loopPtr unsafe.Pointer
193// - name string
194// - onProcess func()
195func (_e *MockStreamOps_Expecter) CreatePlaybackStream(loopPtr any, name any, onProcess any) *MockStreamOps_CreatePlaybackStream_Call {
196 return &MockStreamOps_CreatePlaybackStream_Call{Call: _e.mock.On("CreatePlaybackStream", loopPtr, name, onProcess)}
197}
198
199func (_c *MockStreamOps_CreatePlaybackStream_Call) Run(run func(loopPtr unsafe.Pointer, name string, onProcess func())) *MockStreamOps_CreatePlaybackStream_Call {
200 _c.Call.Run(func(args mock.Arguments) {
201 var arg0 unsafe.Pointer
202 if args[0] != nil {
203 arg0 = args[0].(unsafe.Pointer)
204 }
205 var arg1 string
206 if args[1] != nil {
207 arg1 = args[1].(string)
208 }
209 var arg2 func()
210 if args[2] != nil {
211 arg2 = args[2].(func())
212 }
213 run(
214 arg0,
215 arg1,
216 arg2,
217 )
218 })
219 return _c
220}
221
222func (_c *MockStreamOps_CreatePlaybackStream_Call) Return(streamPtr unsafe.Pointer, err error) *MockStreamOps_CreatePlaybackStream_Call {
223 _c.Call.Return(streamPtr, err)
224 return _c
225}
226
227func (_c *MockStreamOps_CreatePlaybackStream_Call) RunAndReturn(run func(loopPtr unsafe.Pointer, name string, onProcess func()) (unsafe.Pointer, error)) *MockStreamOps_CreatePlaybackStream_Call {
228 _c.Call.Return(run)
229 return _c
230}
231
232// DequeueBuffer provides a mock function for the type MockStreamOps
233func (_mock *MockStreamOps) DequeueBuffer(streamPtr unsafe.Pointer) unsafe.Pointer {
234 ret := _mock.Called(streamPtr)
235
236 if len(ret) == 0 {
237 panic("no return value specified for DequeueBuffer")
238 }
239
240 var r0 unsafe.Pointer
241 if returnFunc, ok := ret.Get(0).(func(unsafe.Pointer) unsafe.Pointer); ok {
242 r0 = returnFunc(streamPtr)
243 } else {
244 r0 = ret.Get(0).(unsafe.Pointer)
245 }
246 return r0
247}
248
249// MockStreamOps_DequeueBuffer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DequeueBuffer'
250type MockStreamOps_DequeueBuffer_Call struct {
251 *mock.Call
252}
253
254// DequeueBuffer is a helper method to define mock.On call
255// - streamPtr unsafe.Pointer
256func (_e *MockStreamOps_Expecter) DequeueBuffer(streamPtr any) *MockStreamOps_DequeueBuffer_Call {
257 return &MockStreamOps_DequeueBuffer_Call{Call: _e.mock.On("DequeueBuffer", streamPtr)}
258}
259
260func (_c *MockStreamOps_DequeueBuffer_Call) Run(run func(streamPtr unsafe.Pointer)) *MockStreamOps_DequeueBuffer_Call {
261 _c.Call.Run(func(args mock.Arguments) {
262 var arg0 unsafe.Pointer
263 if args[0] != nil {
264 arg0 = args[0].(unsafe.Pointer)
265 }
266 run(
267 arg0,
268 )
269 })
270 return _c
271}
272
273func (_c *MockStreamOps_DequeueBuffer_Call) Return(v unsafe.Pointer) *MockStreamOps_DequeueBuffer_Call {
274 _c.Call.Return(v)
275 return _c
276}
277
278func (_c *MockStreamOps_DequeueBuffer_Call) RunAndReturn(run func(streamPtr unsafe.Pointer) unsafe.Pointer) *MockStreamOps_DequeueBuffer_Call {
279 _c.Call.Return(run)
280 return _c
281}
282
283// DestroyMainLoop provides a mock function for the type MockStreamOps
284func (_mock *MockStreamOps) DestroyMainLoop(loopPtr unsafe.Pointer) {
285 _mock.Called(loopPtr)
286 return
287}
288
289// MockStreamOps_DestroyMainLoop_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DestroyMainLoop'
290type MockStreamOps_DestroyMainLoop_Call struct {
291 *mock.Call
292}
293
294// DestroyMainLoop is a helper method to define mock.On call
295// - loopPtr unsafe.Pointer
296func (_e *MockStreamOps_Expecter) DestroyMainLoop(loopPtr any) *MockStreamOps_DestroyMainLoop_Call {
297 return &MockStreamOps_DestroyMainLoop_Call{Call: _e.mock.On("DestroyMainLoop", loopPtr)}
298}
299
300func (_c *MockStreamOps_DestroyMainLoop_Call) Run(run func(loopPtr unsafe.Pointer)) *MockStreamOps_DestroyMainLoop_Call {
301 _c.Call.Run(func(args mock.Arguments) {
302 var arg0 unsafe.Pointer
303 if args[0] != nil {
304 arg0 = args[0].(unsafe.Pointer)
305 }
306 run(
307 arg0,
308 )
309 })
310 return _c
311}
312
313func (_c *MockStreamOps_DestroyMainLoop_Call) Return() *MockStreamOps_DestroyMainLoop_Call {
314 _c.Call.Return()
315 return _c
316}
317
318func (_c *MockStreamOps_DestroyMainLoop_Call) RunAndReturn(run func(loopPtr unsafe.Pointer)) *MockStreamOps_DestroyMainLoop_Call {
319 _c.Run(run)
320 return _c
321}
322
323// DestroyStream provides a mock function for the type MockStreamOps
324func (_mock *MockStreamOps) DestroyStream(streamPtr unsafe.Pointer) {
325 _mock.Called(streamPtr)
326 return
327}
328
329// MockStreamOps_DestroyStream_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DestroyStream'
330type MockStreamOps_DestroyStream_Call struct {
331 *mock.Call
332}
333
334// DestroyStream is a helper method to define mock.On call
335// - streamPtr unsafe.Pointer
336func (_e *MockStreamOps_Expecter) DestroyStream(streamPtr any) *MockStreamOps_DestroyStream_Call {
337 return &MockStreamOps_DestroyStream_Call{Call: _e.mock.On("DestroyStream", streamPtr)}
338}
339
340func (_c *MockStreamOps_DestroyStream_Call) Run(run func(streamPtr unsafe.Pointer)) *MockStreamOps_DestroyStream_Call {
341 _c.Call.Run(func(args mock.Arguments) {
342 var arg0 unsafe.Pointer
343 if args[0] != nil {
344 arg0 = args[0].(unsafe.Pointer)
345 }
346 run(
347 arg0,
348 )
349 })
350 return _c
351}
352
353func (_c *MockStreamOps_DestroyStream_Call) Return() *MockStreamOps_DestroyStream_Call {
354 _c.Call.Return()
355 return _c
356}
357
358func (_c *MockStreamOps_DestroyStream_Call) RunAndReturn(run func(streamPtr unsafe.Pointer)) *MockStreamOps_DestroyStream_Call {
359 _c.Run(run)
360 return _c
361}
362
363// DisconnectStream provides a mock function for the type MockStreamOps
364func (_mock *MockStreamOps) DisconnectStream(streamPtr unsafe.Pointer) error {
365 ret := _mock.Called(streamPtr)
366
367 if len(ret) == 0 {
368 panic("no return value specified for DisconnectStream")
369 }
370
371 var r0 error
372 if returnFunc, ok := ret.Get(0).(func(unsafe.Pointer) error); ok {
373 r0 = returnFunc(streamPtr)
374 } else {
375 r0 = ret.Error(0)
376 }
377 return r0
378}
379
380// MockStreamOps_DisconnectStream_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DisconnectStream'
381type MockStreamOps_DisconnectStream_Call struct {
382 *mock.Call
383}
384
385// DisconnectStream is a helper method to define mock.On call
386// - streamPtr unsafe.Pointer
387func (_e *MockStreamOps_Expecter) DisconnectStream(streamPtr any) *MockStreamOps_DisconnectStream_Call {
388 return &MockStreamOps_DisconnectStream_Call{Call: _e.mock.On("DisconnectStream", streamPtr)}
389}
390
391func (_c *MockStreamOps_DisconnectStream_Call) Run(run func(streamPtr unsafe.Pointer)) *MockStreamOps_DisconnectStream_Call {
392 _c.Call.Run(func(args mock.Arguments) {
393 var arg0 unsafe.Pointer
394 if args[0] != nil {
395 arg0 = args[0].(unsafe.Pointer)
396 }
397 run(
398 arg0,
399 )
400 })
401 return _c
402}
403
404func (_c *MockStreamOps_DisconnectStream_Call) Return(err error) *MockStreamOps_DisconnectStream_Call {
405 _c.Call.Return(err)
406 return _c
407}
408
409func (_c *MockStreamOps_DisconnectStream_Call) RunAndReturn(run func(streamPtr unsafe.Pointer) error) *MockStreamOps_DisconnectStream_Call {
410 _c.Call.Return(run)
411 return _c
412}
413
414// QueueBuffer provides a mock function for the type MockStreamOps
415func (_mock *MockStreamOps) QueueBuffer(streamPtr unsafe.Pointer, bufPtr unsafe.Pointer) error {
416 ret := _mock.Called(streamPtr, bufPtr)
417
418 if len(ret) == 0 {
419 panic("no return value specified for QueueBuffer")
420 }
421
422 var r0 error
423 if returnFunc, ok := ret.Get(0).(func(unsafe.Pointer, unsafe.Pointer) error); ok {
424 r0 = returnFunc(streamPtr, bufPtr)
425 } else {
426 r0 = ret.Error(0)
427 }
428 return r0
429}
430
431// MockStreamOps_QueueBuffer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'QueueBuffer'
432type MockStreamOps_QueueBuffer_Call struct {
433 *mock.Call
434}
435
436// QueueBuffer is a helper method to define mock.On call
437// - streamPtr unsafe.Pointer
438// - bufPtr unsafe.Pointer
439func (_e *MockStreamOps_Expecter) QueueBuffer(streamPtr any, bufPtr any) *MockStreamOps_QueueBuffer_Call {
440 return &MockStreamOps_QueueBuffer_Call{Call: _e.mock.On("QueueBuffer", streamPtr, bufPtr)}
441}
442
443func (_c *MockStreamOps_QueueBuffer_Call) Run(run func(streamPtr unsafe.Pointer, bufPtr unsafe.Pointer)) *MockStreamOps_QueueBuffer_Call {
444 _c.Call.Run(func(args mock.Arguments) {
445 var arg0 unsafe.Pointer
446 if args[0] != nil {
447 arg0 = args[0].(unsafe.Pointer)
448 }
449 var arg1 unsafe.Pointer
450 if args[1] != nil {
451 arg1 = args[1].(unsafe.Pointer)
452 }
453 run(
454 arg0,
455 arg1,
456 )
457 })
458 return _c
459}
460
461func (_c *MockStreamOps_QueueBuffer_Call) Return(err error) *MockStreamOps_QueueBuffer_Call {
462 _c.Call.Return(err)
463 return _c
464}
465
466func (_c *MockStreamOps_QueueBuffer_Call) RunAndReturn(run func(streamPtr unsafe.Pointer, bufPtr unsafe.Pointer) error) *MockStreamOps_QueueBuffer_Call {
467 _c.Call.Return(run)
468 return _c
469}
470
471// QuitMainLoop provides a mock function for the type MockStreamOps
472func (_mock *MockStreamOps) QuitMainLoop(loopPtr unsafe.Pointer) {
473 _mock.Called(loopPtr)
474 return
475}
476
477// MockStreamOps_QuitMainLoop_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'QuitMainLoop'
478type MockStreamOps_QuitMainLoop_Call struct {
479 *mock.Call
480}
481
482// QuitMainLoop is a helper method to define mock.On call
483// - loopPtr unsafe.Pointer
484func (_e *MockStreamOps_Expecter) QuitMainLoop(loopPtr any) *MockStreamOps_QuitMainLoop_Call {
485 return &MockStreamOps_QuitMainLoop_Call{Call: _e.mock.On("QuitMainLoop", loopPtr)}
486}
487
488func (_c *MockStreamOps_QuitMainLoop_Call) Run(run func(loopPtr unsafe.Pointer)) *MockStreamOps_QuitMainLoop_Call {
489 _c.Call.Run(func(args mock.Arguments) {
490 var arg0 unsafe.Pointer
491 if args[0] != nil {
492 arg0 = args[0].(unsafe.Pointer)
493 }
494 run(
495 arg0,
496 )
497 })
498 return _c
499}
500
501func (_c *MockStreamOps_QuitMainLoop_Call) Return() *MockStreamOps_QuitMainLoop_Call {
502 _c.Call.Return()
503 return _c
504}
505
506func (_c *MockStreamOps_QuitMainLoop_Call) RunAndReturn(run func(loopPtr unsafe.Pointer)) *MockStreamOps_QuitMainLoop_Call {
507 _c.Run(run)
508 return _c
509}
510
511// RunMainLoop provides a mock function for the type MockStreamOps
512func (_mock *MockStreamOps) RunMainLoop(loopPtr unsafe.Pointer) error {
513 ret := _mock.Called(loopPtr)
514
515 if len(ret) == 0 {
516 panic("no return value specified for RunMainLoop")
517 }
518
519 var r0 error
520 if returnFunc, ok := ret.Get(0).(func(unsafe.Pointer) error); ok {
521 r0 = returnFunc(loopPtr)
522 } else {
523 r0 = ret.Error(0)
524 }
525 return r0
526}
527
528// MockStreamOps_RunMainLoop_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RunMainLoop'
529type MockStreamOps_RunMainLoop_Call struct {
530 *mock.Call
531}
532
533// RunMainLoop is a helper method to define mock.On call
534// - loopPtr unsafe.Pointer
535func (_e *MockStreamOps_Expecter) RunMainLoop(loopPtr any) *MockStreamOps_RunMainLoop_Call {
536 return &MockStreamOps_RunMainLoop_Call{Call: _e.mock.On("RunMainLoop", loopPtr)}
537}
538
539func (_c *MockStreamOps_RunMainLoop_Call) Run(run func(loopPtr unsafe.Pointer)) *MockStreamOps_RunMainLoop_Call {
540 _c.Call.Run(func(args mock.Arguments) {
541 var arg0 unsafe.Pointer
542 if args[0] != nil {
543 arg0 = args[0].(unsafe.Pointer)
544 }
545 run(
546 arg0,
547 )
548 })
549 return _c
550}
551
552func (_c *MockStreamOps_RunMainLoop_Call) Return(err error) *MockStreamOps_RunMainLoop_Call {
553 _c.Call.Return(err)
554 return _c
555}
556
557func (_c *MockStreamOps_RunMainLoop_Call) RunAndReturn(run func(loopPtr unsafe.Pointer) error) *MockStreamOps_RunMainLoop_Call {
558 _c.Call.Return(run)
559 return _c
560}
561
562// SetStreamActive provides a mock function for the type MockStreamOps
563func (_mock *MockStreamOps) SetStreamActive(streamPtr unsafe.Pointer, active bool) error {
564 ret := _mock.Called(streamPtr, active)
565
566 if len(ret) == 0 {
567 panic("no return value specified for SetStreamActive")
568 }
569
570 var r0 error
571 if returnFunc, ok := ret.Get(0).(func(unsafe.Pointer, bool) error); ok {
572 r0 = returnFunc(streamPtr, active)
573 } else {
574 r0 = ret.Error(0)
575 }
576 return r0
577}
578
579// MockStreamOps_SetStreamActive_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetStreamActive'
580type MockStreamOps_SetStreamActive_Call struct {
581 *mock.Call
582}
583
584// SetStreamActive is a helper method to define mock.On call
585// - streamPtr unsafe.Pointer
586// - active bool
587func (_e *MockStreamOps_Expecter) SetStreamActive(streamPtr any, active any) *MockStreamOps_SetStreamActive_Call {
588 return &MockStreamOps_SetStreamActive_Call{Call: _e.mock.On("SetStreamActive", streamPtr, active)}
589}
590
591func (_c *MockStreamOps_SetStreamActive_Call) Run(run func(streamPtr unsafe.Pointer, active bool)) *MockStreamOps_SetStreamActive_Call {
592 _c.Call.Run(func(args mock.Arguments) {
593 var arg0 unsafe.Pointer
594 if args[0] != nil {
595 arg0 = args[0].(unsafe.Pointer)
596 }
597 var arg1 bool
598 if args[1] != nil {
599 arg1 = args[1].(bool)
600 }
601 run(
602 arg0,
603 arg1,
604 )
605 })
606 return _c
607}
608
609func (_c *MockStreamOps_SetStreamActive_Call) Return(err error) *MockStreamOps_SetStreamActive_Call {
610 _c.Call.Return(err)
611 return _c
612}
613
614func (_c *MockStreamOps_SetStreamActive_Call) RunAndReturn(run func(streamPtr unsafe.Pointer, active bool) error) *MockStreamOps_SetStreamActive_Call {
615 _c.Call.Return(run)
616 return _c
617}