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 mock "github.com/stretchr/testify/mock"
11)
12
13// NewMockVideoStreamAPI creates a new instance of MockVideoStreamAPI. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
14// The first argument is typically a *testing.T value.
15func NewMockVideoStreamAPI(t interface {
16 mock.TestingT
17 Cleanup(func())
18}) *MockVideoStreamAPI {
19 if helper, ok := t.(interface{ Helper() }); ok {
20 helper.Helper()
21 }
22
23 mock := &MockVideoStreamAPI{}
24 mock.Mock.Test(t)
25
26 t.Cleanup(func() {
27 if helper, ok := t.(interface{ Helper() }); ok {
28 helper.Helper()
29 }
30 mock.AssertExpectations(t)
31 })
32
33 return mock
34}
35
36// MockVideoStreamAPI is an autogenerated mock type for the VideoStreamAPI type
37type MockVideoStreamAPI struct {
38 mock.Mock
39}
40
41type MockVideoStreamAPI_Expecter struct {
42 mock *mock.Mock
43}
44
45func (_m *MockVideoStreamAPI) EXPECT() *MockVideoStreamAPI_Expecter {
46 return &MockVideoStreamAPI_Expecter{mock: &_m.Mock}
47}
48
49// PWContextConnect provides a mock function for the type MockVideoStreamAPI
50func (_mock *MockVideoStreamAPI) PWContextConnect(context unsafe.Pointer, props unsafe.Pointer, user_data_size uintptr) unsafe.Pointer {
51 ret := _mock.Called(context, props, user_data_size)
52
53 if len(ret) == 0 {
54 panic("no return value specified for PWContextConnect")
55 }
56
57 var r0 unsafe.Pointer
58 if returnFunc, ok := ret.Get(0).(func(unsafe.Pointer, unsafe.Pointer, uintptr) unsafe.Pointer); ok {
59 r0 = returnFunc(context, props, user_data_size)
60 } else {
61 r0 = ret.Get(0).(unsafe.Pointer)
62 }
63 return r0
64}
65
66// MockVideoStreamAPI_PWContextConnect_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PWContextConnect'
67type MockVideoStreamAPI_PWContextConnect_Call struct {
68 *mock.Call
69}
70
71// PWContextConnect is a helper method to define mock.On call
72// - context unsafe.Pointer
73// - props unsafe.Pointer
74// - user_data_size uintptr
75func (_e *MockVideoStreamAPI_Expecter) PWContextConnect(context any, props any, user_data_size any) *MockVideoStreamAPI_PWContextConnect_Call {
76 return &MockVideoStreamAPI_PWContextConnect_Call{Call: _e.mock.On("PWContextConnect", context, props, user_data_size)}
77}
78
79func (_c *MockVideoStreamAPI_PWContextConnect_Call) Run(run func(context unsafe.Pointer, props unsafe.Pointer, user_data_size uintptr)) *MockVideoStreamAPI_PWContextConnect_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 unsafe.Pointer
86 if args[1] != nil {
87 arg1 = args[1].(unsafe.Pointer)
88 }
89 var arg2 uintptr
90 if args[2] != nil {
91 arg2 = args[2].(uintptr)
92 }
93 run(
94 arg0,
95 arg1,
96 arg2,
97 )
98 })
99 return _c
100}
101
102func (_c *MockVideoStreamAPI_PWContextConnect_Call) Return(v unsafe.Pointer) *MockVideoStreamAPI_PWContextConnect_Call {
103 _c.Call.Return(v)
104 return _c
105}
106
107func (_c *MockVideoStreamAPI_PWContextConnect_Call) RunAndReturn(run func(context unsafe.Pointer, props unsafe.Pointer, user_data_size uintptr) unsafe.Pointer) *MockVideoStreamAPI_PWContextConnect_Call {
108 _c.Call.Return(run)
109 return _c
110}
111
112// PWContextDestroy provides a mock function for the type MockVideoStreamAPI
113func (_mock *MockVideoStreamAPI) PWContextDestroy(context unsafe.Pointer) {
114 _mock.Called(context)
115 return
116}
117
118// MockVideoStreamAPI_PWContextDestroy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PWContextDestroy'
119type MockVideoStreamAPI_PWContextDestroy_Call struct {
120 *mock.Call
121}
122
123// PWContextDestroy is a helper method to define mock.On call
124// - context unsafe.Pointer
125func (_e *MockVideoStreamAPI_Expecter) PWContextDestroy(context any) *MockVideoStreamAPI_PWContextDestroy_Call {
126 return &MockVideoStreamAPI_PWContextDestroy_Call{Call: _e.mock.On("PWContextDestroy", context)}
127}
128
129func (_c *MockVideoStreamAPI_PWContextDestroy_Call) Run(run func(context unsafe.Pointer)) *MockVideoStreamAPI_PWContextDestroy_Call {
130 _c.Call.Run(func(args mock.Arguments) {
131 var arg0 unsafe.Pointer
132 if args[0] != nil {
133 arg0 = args[0].(unsafe.Pointer)
134 }
135 run(
136 arg0,
137 )
138 })
139 return _c
140}
141
142func (_c *MockVideoStreamAPI_PWContextDestroy_Call) Return() *MockVideoStreamAPI_PWContextDestroy_Call {
143 _c.Call.Return()
144 return _c
145}
146
147func (_c *MockVideoStreamAPI_PWContextDestroy_Call) RunAndReturn(run func(context unsafe.Pointer)) *MockVideoStreamAPI_PWContextDestroy_Call {
148 _c.Run(run)
149 return _c
150}
151
152// PWContextNew provides a mock function for the type MockVideoStreamAPI
153func (_mock *MockVideoStreamAPI) PWContextNew(loop unsafe.Pointer, props unsafe.Pointer, user_data_size uintptr) unsafe.Pointer {
154 ret := _mock.Called(loop, props, user_data_size)
155
156 if len(ret) == 0 {
157 panic("no return value specified for PWContextNew")
158 }
159
160 var r0 unsafe.Pointer
161 if returnFunc, ok := ret.Get(0).(func(unsafe.Pointer, unsafe.Pointer, uintptr) unsafe.Pointer); ok {
162 r0 = returnFunc(loop, props, user_data_size)
163 } else {
164 r0 = ret.Get(0).(unsafe.Pointer)
165 }
166 return r0
167}
168
169// MockVideoStreamAPI_PWContextNew_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PWContextNew'
170type MockVideoStreamAPI_PWContextNew_Call struct {
171 *mock.Call
172}
173
174// PWContextNew is a helper method to define mock.On call
175// - loop unsafe.Pointer
176// - props unsafe.Pointer
177// - user_data_size uintptr
178func (_e *MockVideoStreamAPI_Expecter) PWContextNew(loop any, props any, user_data_size any) *MockVideoStreamAPI_PWContextNew_Call {
179 return &MockVideoStreamAPI_PWContextNew_Call{Call: _e.mock.On("PWContextNew", loop, props, user_data_size)}
180}
181
182func (_c *MockVideoStreamAPI_PWContextNew_Call) Run(run func(loop unsafe.Pointer, props unsafe.Pointer, user_data_size uintptr)) *MockVideoStreamAPI_PWContextNew_Call {
183 _c.Call.Run(func(args mock.Arguments) {
184 var arg0 unsafe.Pointer
185 if args[0] != nil {
186 arg0 = args[0].(unsafe.Pointer)
187 }
188 var arg1 unsafe.Pointer
189 if args[1] != nil {
190 arg1 = args[1].(unsafe.Pointer)
191 }
192 var arg2 uintptr
193 if args[2] != nil {
194 arg2 = args[2].(uintptr)
195 }
196 run(
197 arg0,
198 arg1,
199 arg2,
200 )
201 })
202 return _c
203}
204
205func (_c *MockVideoStreamAPI_PWContextNew_Call) Return(v unsafe.Pointer) *MockVideoStreamAPI_PWContextNew_Call {
206 _c.Call.Return(v)
207 return _c
208}
209
210func (_c *MockVideoStreamAPI_PWContextNew_Call) RunAndReturn(run func(loop unsafe.Pointer, props unsafe.Pointer, user_data_size uintptr) unsafe.Pointer) *MockVideoStreamAPI_PWContextNew_Call {
211 _c.Call.Return(run)
212 return _c
213}
214
215// PWCoreDisconnect provides a mock function for the type MockVideoStreamAPI
216func (_mock *MockVideoStreamAPI) PWCoreDisconnect(core unsafe.Pointer) int32 {
217 ret := _mock.Called(core)
218
219 if len(ret) == 0 {
220 panic("no return value specified for PWCoreDisconnect")
221 }
222
223 var r0 int32
224 if returnFunc, ok := ret.Get(0).(func(unsafe.Pointer) int32); ok {
225 r0 = returnFunc(core)
226 } else {
227 r0 = ret.Get(0).(int32)
228 }
229 return r0
230}
231
232// MockVideoStreamAPI_PWCoreDisconnect_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PWCoreDisconnect'
233type MockVideoStreamAPI_PWCoreDisconnect_Call struct {
234 *mock.Call
235}
236
237// PWCoreDisconnect is a helper method to define mock.On call
238// - core unsafe.Pointer
239func (_e *MockVideoStreamAPI_Expecter) PWCoreDisconnect(core any) *MockVideoStreamAPI_PWCoreDisconnect_Call {
240 return &MockVideoStreamAPI_PWCoreDisconnect_Call{Call: _e.mock.On("PWCoreDisconnect", core)}
241}
242
243func (_c *MockVideoStreamAPI_PWCoreDisconnect_Call) Run(run func(core unsafe.Pointer)) *MockVideoStreamAPI_PWCoreDisconnect_Call {
244 _c.Call.Run(func(args mock.Arguments) {
245 var arg0 unsafe.Pointer
246 if args[0] != nil {
247 arg0 = args[0].(unsafe.Pointer)
248 }
249 run(
250 arg0,
251 )
252 })
253 return _c
254}
255
256func (_c *MockVideoStreamAPI_PWCoreDisconnect_Call) Return(n int32) *MockVideoStreamAPI_PWCoreDisconnect_Call {
257 _c.Call.Return(n)
258 return _c
259}
260
261func (_c *MockVideoStreamAPI_PWCoreDisconnect_Call) RunAndReturn(run func(core unsafe.Pointer) int32) *MockVideoStreamAPI_PWCoreDisconnect_Call {
262 _c.Call.Return(run)
263 return _c
264}
265
266// PWLoopDestroy provides a mock function for the type MockVideoStreamAPI
267func (_mock *MockVideoStreamAPI) PWLoopDestroy(loop unsafe.Pointer) {
268 _mock.Called(loop)
269 return
270}
271
272// MockVideoStreamAPI_PWLoopDestroy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PWLoopDestroy'
273type MockVideoStreamAPI_PWLoopDestroy_Call struct {
274 *mock.Call
275}
276
277// PWLoopDestroy is a helper method to define mock.On call
278// - loop unsafe.Pointer
279func (_e *MockVideoStreamAPI_Expecter) PWLoopDestroy(loop any) *MockVideoStreamAPI_PWLoopDestroy_Call {
280 return &MockVideoStreamAPI_PWLoopDestroy_Call{Call: _e.mock.On("PWLoopDestroy", loop)}
281}
282
283func (_c *MockVideoStreamAPI_PWLoopDestroy_Call) Run(run func(loop unsafe.Pointer)) *MockVideoStreamAPI_PWLoopDestroy_Call {
284 _c.Call.Run(func(args mock.Arguments) {
285 var arg0 unsafe.Pointer
286 if args[0] != nil {
287 arg0 = args[0].(unsafe.Pointer)
288 }
289 run(
290 arg0,
291 )
292 })
293 return _c
294}
295
296func (_c *MockVideoStreamAPI_PWLoopDestroy_Call) Return() *MockVideoStreamAPI_PWLoopDestroy_Call {
297 _c.Call.Return()
298 return _c
299}
300
301func (_c *MockVideoStreamAPI_PWLoopDestroy_Call) RunAndReturn(run func(loop unsafe.Pointer)) *MockVideoStreamAPI_PWLoopDestroy_Call {
302 _c.Run(run)
303 return _c
304}
305
306// PWLoopEnter provides a mock function for the type MockVideoStreamAPI
307func (_mock *MockVideoStreamAPI) PWLoopEnter(loop unsafe.Pointer) {
308 _mock.Called(loop)
309 return
310}
311
312// MockVideoStreamAPI_PWLoopEnter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PWLoopEnter'
313type MockVideoStreamAPI_PWLoopEnter_Call struct {
314 *mock.Call
315}
316
317// PWLoopEnter is a helper method to define mock.On call
318// - loop unsafe.Pointer
319func (_e *MockVideoStreamAPI_Expecter) PWLoopEnter(loop any) *MockVideoStreamAPI_PWLoopEnter_Call {
320 return &MockVideoStreamAPI_PWLoopEnter_Call{Call: _e.mock.On("PWLoopEnter", loop)}
321}
322
323func (_c *MockVideoStreamAPI_PWLoopEnter_Call) Run(run func(loop unsafe.Pointer)) *MockVideoStreamAPI_PWLoopEnter_Call {
324 _c.Call.Run(func(args mock.Arguments) {
325 var arg0 unsafe.Pointer
326 if args[0] != nil {
327 arg0 = args[0].(unsafe.Pointer)
328 }
329 run(
330 arg0,
331 )
332 })
333 return _c
334}
335
336func (_c *MockVideoStreamAPI_PWLoopEnter_Call) Return() *MockVideoStreamAPI_PWLoopEnter_Call {
337 _c.Call.Return()
338 return _c
339}
340
341func (_c *MockVideoStreamAPI_PWLoopEnter_Call) RunAndReturn(run func(loop unsafe.Pointer)) *MockVideoStreamAPI_PWLoopEnter_Call {
342 _c.Run(run)
343 return _c
344}
345
346// PWLoopGetFd provides a mock function for the type MockVideoStreamAPI
347func (_mock *MockVideoStreamAPI) PWLoopGetFd(loop unsafe.Pointer) int32 {
348 ret := _mock.Called(loop)
349
350 if len(ret) == 0 {
351 panic("no return value specified for PWLoopGetFd")
352 }
353
354 var r0 int32
355 if returnFunc, ok := ret.Get(0).(func(unsafe.Pointer) int32); ok {
356 r0 = returnFunc(loop)
357 } else {
358 r0 = ret.Get(0).(int32)
359 }
360 return r0
361}
362
363// MockVideoStreamAPI_PWLoopGetFd_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PWLoopGetFd'
364type MockVideoStreamAPI_PWLoopGetFd_Call struct {
365 *mock.Call
366}
367
368// PWLoopGetFd is a helper method to define mock.On call
369// - loop unsafe.Pointer
370func (_e *MockVideoStreamAPI_Expecter) PWLoopGetFd(loop any) *MockVideoStreamAPI_PWLoopGetFd_Call {
371 return &MockVideoStreamAPI_PWLoopGetFd_Call{Call: _e.mock.On("PWLoopGetFd", loop)}
372}
373
374func (_c *MockVideoStreamAPI_PWLoopGetFd_Call) Run(run func(loop unsafe.Pointer)) *MockVideoStreamAPI_PWLoopGetFd_Call {
375 _c.Call.Run(func(args mock.Arguments) {
376 var arg0 unsafe.Pointer
377 if args[0] != nil {
378 arg0 = args[0].(unsafe.Pointer)
379 }
380 run(
381 arg0,
382 )
383 })
384 return _c
385}
386
387func (_c *MockVideoStreamAPI_PWLoopGetFd_Call) Return(n int32) *MockVideoStreamAPI_PWLoopGetFd_Call {
388 _c.Call.Return(n)
389 return _c
390}
391
392func (_c *MockVideoStreamAPI_PWLoopGetFd_Call) RunAndReturn(run func(loop unsafe.Pointer) int32) *MockVideoStreamAPI_PWLoopGetFd_Call {
393 _c.Call.Return(run)
394 return _c
395}
396
397// PWLoopIterate provides a mock function for the type MockVideoStreamAPI
398func (_mock *MockVideoStreamAPI) PWLoopIterate(loop unsafe.Pointer, timeout int32) int32 {
399 ret := _mock.Called(loop, timeout)
400
401 if len(ret) == 0 {
402 panic("no return value specified for PWLoopIterate")
403 }
404
405 var r0 int32
406 if returnFunc, ok := ret.Get(0).(func(unsafe.Pointer, int32) int32); ok {
407 r0 = returnFunc(loop, timeout)
408 } else {
409 r0 = ret.Get(0).(int32)
410 }
411 return r0
412}
413
414// MockVideoStreamAPI_PWLoopIterate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PWLoopIterate'
415type MockVideoStreamAPI_PWLoopIterate_Call struct {
416 *mock.Call
417}
418
419// PWLoopIterate is a helper method to define mock.On call
420// - loop unsafe.Pointer
421// - timeout int32
422func (_e *MockVideoStreamAPI_Expecter) PWLoopIterate(loop any, timeout any) *MockVideoStreamAPI_PWLoopIterate_Call {
423 return &MockVideoStreamAPI_PWLoopIterate_Call{Call: _e.mock.On("PWLoopIterate", loop, timeout)}
424}
425
426func (_c *MockVideoStreamAPI_PWLoopIterate_Call) Run(run func(loop unsafe.Pointer, timeout int32)) *MockVideoStreamAPI_PWLoopIterate_Call {
427 _c.Call.Run(func(args mock.Arguments) {
428 var arg0 unsafe.Pointer
429 if args[0] != nil {
430 arg0 = args[0].(unsafe.Pointer)
431 }
432 var arg1 int32
433 if args[1] != nil {
434 arg1 = args[1].(int32)
435 }
436 run(
437 arg0,
438 arg1,
439 )
440 })
441 return _c
442}
443
444func (_c *MockVideoStreamAPI_PWLoopIterate_Call) Return(n int32) *MockVideoStreamAPI_PWLoopIterate_Call {
445 _c.Call.Return(n)
446 return _c
447}
448
449func (_c *MockVideoStreamAPI_PWLoopIterate_Call) RunAndReturn(run func(loop unsafe.Pointer, timeout int32) int32) *MockVideoStreamAPI_PWLoopIterate_Call {
450 _c.Call.Return(run)
451 return _c
452}
453
454// PWLoopLeave provides a mock function for the type MockVideoStreamAPI
455func (_mock *MockVideoStreamAPI) PWLoopLeave(loop unsafe.Pointer) {
456 _mock.Called(loop)
457 return
458}
459
460// MockVideoStreamAPI_PWLoopLeave_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PWLoopLeave'
461type MockVideoStreamAPI_PWLoopLeave_Call struct {
462 *mock.Call
463}
464
465// PWLoopLeave is a helper method to define mock.On call
466// - loop unsafe.Pointer
467func (_e *MockVideoStreamAPI_Expecter) PWLoopLeave(loop any) *MockVideoStreamAPI_PWLoopLeave_Call {
468 return &MockVideoStreamAPI_PWLoopLeave_Call{Call: _e.mock.On("PWLoopLeave", loop)}
469}
470
471func (_c *MockVideoStreamAPI_PWLoopLeave_Call) Run(run func(loop unsafe.Pointer)) *MockVideoStreamAPI_PWLoopLeave_Call {
472 _c.Call.Run(func(args mock.Arguments) {
473 var arg0 unsafe.Pointer
474 if args[0] != nil {
475 arg0 = args[0].(unsafe.Pointer)
476 }
477 run(
478 arg0,
479 )
480 })
481 return _c
482}
483
484func (_c *MockVideoStreamAPI_PWLoopLeave_Call) Return() *MockVideoStreamAPI_PWLoopLeave_Call {
485 _c.Call.Return()
486 return _c
487}
488
489func (_c *MockVideoStreamAPI_PWLoopLeave_Call) RunAndReturn(run func(loop unsafe.Pointer)) *MockVideoStreamAPI_PWLoopLeave_Call {
490 _c.Run(run)
491 return _c
492}
493
494// PWLoopNew provides a mock function for the type MockVideoStreamAPI
495func (_mock *MockVideoStreamAPI) PWLoopNew(props unsafe.Pointer) unsafe.Pointer {
496 ret := _mock.Called(props)
497
498 if len(ret) == 0 {
499 panic("no return value specified for PWLoopNew")
500 }
501
502 var r0 unsafe.Pointer
503 if returnFunc, ok := ret.Get(0).(func(unsafe.Pointer) unsafe.Pointer); ok {
504 r0 = returnFunc(props)
505 } else {
506 r0 = ret.Get(0).(unsafe.Pointer)
507 }
508 return r0
509}
510
511// MockVideoStreamAPI_PWLoopNew_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PWLoopNew'
512type MockVideoStreamAPI_PWLoopNew_Call struct {
513 *mock.Call
514}
515
516// PWLoopNew is a helper method to define mock.On call
517// - props unsafe.Pointer
518func (_e *MockVideoStreamAPI_Expecter) PWLoopNew(props any) *MockVideoStreamAPI_PWLoopNew_Call {
519 return &MockVideoStreamAPI_PWLoopNew_Call{Call: _e.mock.On("PWLoopNew", props)}
520}
521
522func (_c *MockVideoStreamAPI_PWLoopNew_Call) Run(run func(props unsafe.Pointer)) *MockVideoStreamAPI_PWLoopNew_Call {
523 _c.Call.Run(func(args mock.Arguments) {
524 var arg0 unsafe.Pointer
525 if args[0] != nil {
526 arg0 = args[0].(unsafe.Pointer)
527 }
528 run(
529 arg0,
530 )
531 })
532 return _c
533}
534
535func (_c *MockVideoStreamAPI_PWLoopNew_Call) Return(v unsafe.Pointer) *MockVideoStreamAPI_PWLoopNew_Call {
536 _c.Call.Return(v)
537 return _c
538}
539
540func (_c *MockVideoStreamAPI_PWLoopNew_Call) RunAndReturn(run func(props unsafe.Pointer) unsafe.Pointer) *MockVideoStreamAPI_PWLoopNew_Call {
541 _c.Call.Return(run)
542 return _c
543}
544
545// PWPropertiesNewString provides a mock function for the type MockVideoStreamAPI
546func (_mock *MockVideoStreamAPI) PWPropertiesNewString(args *byte) unsafe.Pointer {
547 ret := _mock.Called(args)
548
549 if len(ret) == 0 {
550 panic("no return value specified for PWPropertiesNewString")
551 }
552
553 var r0 unsafe.Pointer
554 if returnFunc, ok := ret.Get(0).(func(*byte) unsafe.Pointer); ok {
555 r0 = returnFunc(args)
556 } else {
557 r0 = ret.Get(0).(unsafe.Pointer)
558 }
559 return r0
560}
561
562// MockVideoStreamAPI_PWPropertiesNewString_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PWPropertiesNewString'
563type MockVideoStreamAPI_PWPropertiesNewString_Call struct {
564 *mock.Call
565}
566
567// PWPropertiesNewString is a helper method to define mock.On call
568// - args *byte
569func (_e *MockVideoStreamAPI_Expecter) PWPropertiesNewString(args any) *MockVideoStreamAPI_PWPropertiesNewString_Call {
570 return &MockVideoStreamAPI_PWPropertiesNewString_Call{Call: _e.mock.On("PWPropertiesNewString", args)}
571}
572
573func (_c *MockVideoStreamAPI_PWPropertiesNewString_Call) Run(run func(args *byte)) *MockVideoStreamAPI_PWPropertiesNewString_Call {
574 _c.Call.Run(func(args mock.Arguments) {
575 var arg0 *byte
576 if args[0] != nil {
577 arg0 = args[0].(*byte)
578 }
579 run(
580 arg0,
581 )
582 })
583 return _c
584}
585
586func (_c *MockVideoStreamAPI_PWPropertiesNewString_Call) Return(v unsafe.Pointer) *MockVideoStreamAPI_PWPropertiesNewString_Call {
587 _c.Call.Return(v)
588 return _c
589}
590
591func (_c *MockVideoStreamAPI_PWPropertiesNewString_Call) RunAndReturn(run func(args *byte) unsafe.Pointer) *MockVideoStreamAPI_PWPropertiesNewString_Call {
592 _c.Call.Return(run)
593 return _c
594}
595
596// PWStreamAddListener provides a mock function for the type MockVideoStreamAPI
597func (_mock *MockVideoStreamAPI) PWStreamAddListener(stream unsafe.Pointer, listener unsafe.Pointer, events unsafe.Pointer, data unsafe.Pointer) int32 {
598 ret := _mock.Called(stream, listener, events, data)
599
600 if len(ret) == 0 {
601 panic("no return value specified for PWStreamAddListener")
602 }
603
604 var r0 int32
605 if returnFunc, ok := ret.Get(0).(func(unsafe.Pointer, unsafe.Pointer, unsafe.Pointer, unsafe.Pointer) int32); ok {
606 r0 = returnFunc(stream, listener, events, data)
607 } else {
608 r0 = ret.Get(0).(int32)
609 }
610 return r0
611}
612
613// MockVideoStreamAPI_PWStreamAddListener_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PWStreamAddListener'
614type MockVideoStreamAPI_PWStreamAddListener_Call struct {
615 *mock.Call
616}
617
618// PWStreamAddListener is a helper method to define mock.On call
619// - stream unsafe.Pointer
620// - listener unsafe.Pointer
621// - events unsafe.Pointer
622// - data unsafe.Pointer
623func (_e *MockVideoStreamAPI_Expecter) PWStreamAddListener(stream any, listener any, events any, data any) *MockVideoStreamAPI_PWStreamAddListener_Call {
624 return &MockVideoStreamAPI_PWStreamAddListener_Call{Call: _e.mock.On("PWStreamAddListener", stream, listener, events, data)}
625}
626
627func (_c *MockVideoStreamAPI_PWStreamAddListener_Call) Run(run func(stream unsafe.Pointer, listener unsafe.Pointer, events unsafe.Pointer, data unsafe.Pointer)) *MockVideoStreamAPI_PWStreamAddListener_Call {
628 _c.Call.Run(func(args mock.Arguments) {
629 var arg0 unsafe.Pointer
630 if args[0] != nil {
631 arg0 = args[0].(unsafe.Pointer)
632 }
633 var arg1 unsafe.Pointer
634 if args[1] != nil {
635 arg1 = args[1].(unsafe.Pointer)
636 }
637 var arg2 unsafe.Pointer
638 if args[2] != nil {
639 arg2 = args[2].(unsafe.Pointer)
640 }
641 var arg3 unsafe.Pointer
642 if args[3] != nil {
643 arg3 = args[3].(unsafe.Pointer)
644 }
645 run(
646 arg0,
647 arg1,
648 arg2,
649 arg3,
650 )
651 })
652 return _c
653}
654
655func (_c *MockVideoStreamAPI_PWStreamAddListener_Call) Return(n int32) *MockVideoStreamAPI_PWStreamAddListener_Call {
656 _c.Call.Return(n)
657 return _c
658}
659
660func (_c *MockVideoStreamAPI_PWStreamAddListener_Call) RunAndReturn(run func(stream unsafe.Pointer, listener unsafe.Pointer, events unsafe.Pointer, data unsafe.Pointer) int32) *MockVideoStreamAPI_PWStreamAddListener_Call {
661 _c.Call.Return(run)
662 return _c
663}
664
665// PWStreamConnect provides a mock function for the type MockVideoStreamAPI
666func (_mock *MockVideoStreamAPI) PWStreamConnect(stream unsafe.Pointer, direction int32, id uint32, flags uint32, ports unsafe.Pointer, n_ports uint32) int32 {
667 ret := _mock.Called(stream, direction, id, flags, ports, n_ports)
668
669 if len(ret) == 0 {
670 panic("no return value specified for PWStreamConnect")
671 }
672
673 var r0 int32
674 if returnFunc, ok := ret.Get(0).(func(unsafe.Pointer, int32, uint32, uint32, unsafe.Pointer, uint32) int32); ok {
675 r0 = returnFunc(stream, direction, id, flags, ports, n_ports)
676 } else {
677 r0 = ret.Get(0).(int32)
678 }
679 return r0
680}
681
682// MockVideoStreamAPI_PWStreamConnect_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PWStreamConnect'
683type MockVideoStreamAPI_PWStreamConnect_Call struct {
684 *mock.Call
685}
686
687// PWStreamConnect is a helper method to define mock.On call
688// - stream unsafe.Pointer
689// - direction int32
690// - id uint32
691// - flags uint32
692// - ports unsafe.Pointer
693// - n_ports uint32
694func (_e *MockVideoStreamAPI_Expecter) PWStreamConnect(stream any, direction any, id any, flags any, ports any, n_ports any) *MockVideoStreamAPI_PWStreamConnect_Call {
695 return &MockVideoStreamAPI_PWStreamConnect_Call{Call: _e.mock.On("PWStreamConnect", stream, direction, id, flags, ports, n_ports)}
696}
697
698func (_c *MockVideoStreamAPI_PWStreamConnect_Call) Run(run func(stream unsafe.Pointer, direction int32, id uint32, flags uint32, ports unsafe.Pointer, n_ports uint32)) *MockVideoStreamAPI_PWStreamConnect_Call {
699 _c.Call.Run(func(args mock.Arguments) {
700 var arg0 unsafe.Pointer
701 if args[0] != nil {
702 arg0 = args[0].(unsafe.Pointer)
703 }
704 var arg1 int32
705 if args[1] != nil {
706 arg1 = args[1].(int32)
707 }
708 var arg2 uint32
709 if args[2] != nil {
710 arg2 = args[2].(uint32)
711 }
712 var arg3 uint32
713 if args[3] != nil {
714 arg3 = args[3].(uint32)
715 }
716 var arg4 unsafe.Pointer
717 if args[4] != nil {
718 arg4 = args[4].(unsafe.Pointer)
719 }
720 var arg5 uint32
721 if args[5] != nil {
722 arg5 = args[5].(uint32)
723 }
724 run(
725 arg0,
726 arg1,
727 arg2,
728 arg3,
729 arg4,
730 arg5,
731 )
732 })
733 return _c
734}
735
736func (_c *MockVideoStreamAPI_PWStreamConnect_Call) Return(n int32) *MockVideoStreamAPI_PWStreamConnect_Call {
737 _c.Call.Return(n)
738 return _c
739}
740
741func (_c *MockVideoStreamAPI_PWStreamConnect_Call) RunAndReturn(run func(stream unsafe.Pointer, direction int32, id uint32, flags uint32, ports unsafe.Pointer, n_ports uint32) int32) *MockVideoStreamAPI_PWStreamConnect_Call {
742 _c.Call.Return(run)
743 return _c
744}
745
746// PWStreamDequeueBuffer provides a mock function for the type MockVideoStreamAPI
747func (_mock *MockVideoStreamAPI) PWStreamDequeueBuffer(stream unsafe.Pointer) unsafe.Pointer {
748 ret := _mock.Called(stream)
749
750 if len(ret) == 0 {
751 panic("no return value specified for PWStreamDequeueBuffer")
752 }
753
754 var r0 unsafe.Pointer
755 if returnFunc, ok := ret.Get(0).(func(unsafe.Pointer) unsafe.Pointer); ok {
756 r0 = returnFunc(stream)
757 } else {
758 r0 = ret.Get(0).(unsafe.Pointer)
759 }
760 return r0
761}
762
763// MockVideoStreamAPI_PWStreamDequeueBuffer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PWStreamDequeueBuffer'
764type MockVideoStreamAPI_PWStreamDequeueBuffer_Call struct {
765 *mock.Call
766}
767
768// PWStreamDequeueBuffer is a helper method to define mock.On call
769// - stream unsafe.Pointer
770func (_e *MockVideoStreamAPI_Expecter) PWStreamDequeueBuffer(stream any) *MockVideoStreamAPI_PWStreamDequeueBuffer_Call {
771 return &MockVideoStreamAPI_PWStreamDequeueBuffer_Call{Call: _e.mock.On("PWStreamDequeueBuffer", stream)}
772}
773
774func (_c *MockVideoStreamAPI_PWStreamDequeueBuffer_Call) Run(run func(stream unsafe.Pointer)) *MockVideoStreamAPI_PWStreamDequeueBuffer_Call {
775 _c.Call.Run(func(args mock.Arguments) {
776 var arg0 unsafe.Pointer
777 if args[0] != nil {
778 arg0 = args[0].(unsafe.Pointer)
779 }
780 run(
781 arg0,
782 )
783 })
784 return _c
785}
786
787func (_c *MockVideoStreamAPI_PWStreamDequeueBuffer_Call) Return(v unsafe.Pointer) *MockVideoStreamAPI_PWStreamDequeueBuffer_Call {
788 _c.Call.Return(v)
789 return _c
790}
791
792func (_c *MockVideoStreamAPI_PWStreamDequeueBuffer_Call) RunAndReturn(run func(stream unsafe.Pointer) unsafe.Pointer) *MockVideoStreamAPI_PWStreamDequeueBuffer_Call {
793 _c.Call.Return(run)
794 return _c
795}
796
797// PWStreamDestroy provides a mock function for the type MockVideoStreamAPI
798func (_mock *MockVideoStreamAPI) PWStreamDestroy(stream unsafe.Pointer) {
799 _mock.Called(stream)
800 return
801}
802
803// MockVideoStreamAPI_PWStreamDestroy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PWStreamDestroy'
804type MockVideoStreamAPI_PWStreamDestroy_Call struct {
805 *mock.Call
806}
807
808// PWStreamDestroy is a helper method to define mock.On call
809// - stream unsafe.Pointer
810func (_e *MockVideoStreamAPI_Expecter) PWStreamDestroy(stream any) *MockVideoStreamAPI_PWStreamDestroy_Call {
811 return &MockVideoStreamAPI_PWStreamDestroy_Call{Call: _e.mock.On("PWStreamDestroy", stream)}
812}
813
814func (_c *MockVideoStreamAPI_PWStreamDestroy_Call) Run(run func(stream unsafe.Pointer)) *MockVideoStreamAPI_PWStreamDestroy_Call {
815 _c.Call.Run(func(args mock.Arguments) {
816 var arg0 unsafe.Pointer
817 if args[0] != nil {
818 arg0 = args[0].(unsafe.Pointer)
819 }
820 run(
821 arg0,
822 )
823 })
824 return _c
825}
826
827func (_c *MockVideoStreamAPI_PWStreamDestroy_Call) Return() *MockVideoStreamAPI_PWStreamDestroy_Call {
828 _c.Call.Return()
829 return _c
830}
831
832func (_c *MockVideoStreamAPI_PWStreamDestroy_Call) RunAndReturn(run func(stream unsafe.Pointer)) *MockVideoStreamAPI_PWStreamDestroy_Call {
833 _c.Run(run)
834 return _c
835}
836
837// PWStreamDisconnect provides a mock function for the type MockVideoStreamAPI
838func (_mock *MockVideoStreamAPI) PWStreamDisconnect(stream unsafe.Pointer) int32 {
839 ret := _mock.Called(stream)
840
841 if len(ret) == 0 {
842 panic("no return value specified for PWStreamDisconnect")
843 }
844
845 var r0 int32
846 if returnFunc, ok := ret.Get(0).(func(unsafe.Pointer) int32); ok {
847 r0 = returnFunc(stream)
848 } else {
849 r0 = ret.Get(0).(int32)
850 }
851 return r0
852}
853
854// MockVideoStreamAPI_PWStreamDisconnect_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PWStreamDisconnect'
855type MockVideoStreamAPI_PWStreamDisconnect_Call struct {
856 *mock.Call
857}
858
859// PWStreamDisconnect is a helper method to define mock.On call
860// - stream unsafe.Pointer
861func (_e *MockVideoStreamAPI_Expecter) PWStreamDisconnect(stream any) *MockVideoStreamAPI_PWStreamDisconnect_Call {
862 return &MockVideoStreamAPI_PWStreamDisconnect_Call{Call: _e.mock.On("PWStreamDisconnect", stream)}
863}
864
865func (_c *MockVideoStreamAPI_PWStreamDisconnect_Call) Run(run func(stream unsafe.Pointer)) *MockVideoStreamAPI_PWStreamDisconnect_Call {
866 _c.Call.Run(func(args mock.Arguments) {
867 var arg0 unsafe.Pointer
868 if args[0] != nil {
869 arg0 = args[0].(unsafe.Pointer)
870 }
871 run(
872 arg0,
873 )
874 })
875 return _c
876}
877
878func (_c *MockVideoStreamAPI_PWStreamDisconnect_Call) Return(n int32) *MockVideoStreamAPI_PWStreamDisconnect_Call {
879 _c.Call.Return(n)
880 return _c
881}
882
883func (_c *MockVideoStreamAPI_PWStreamDisconnect_Call) RunAndReturn(run func(stream unsafe.Pointer) int32) *MockVideoStreamAPI_PWStreamDisconnect_Call {
884 _c.Call.Return(run)
885 return _c
886}
887
888// PWStreamGetNodeId provides a mock function for the type MockVideoStreamAPI
889func (_mock *MockVideoStreamAPI) PWStreamGetNodeId(stream unsafe.Pointer) uint32 {
890 ret := _mock.Called(stream)
891
892 if len(ret) == 0 {
893 panic("no return value specified for PWStreamGetNodeId")
894 }
895
896 var r0 uint32
897 if returnFunc, ok := ret.Get(0).(func(unsafe.Pointer) uint32); ok {
898 r0 = returnFunc(stream)
899 } else {
900 r0 = ret.Get(0).(uint32)
901 }
902 return r0
903}
904
905// MockVideoStreamAPI_PWStreamGetNodeId_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PWStreamGetNodeId'
906type MockVideoStreamAPI_PWStreamGetNodeId_Call struct {
907 *mock.Call
908}
909
910// PWStreamGetNodeId is a helper method to define mock.On call
911// - stream unsafe.Pointer
912func (_e *MockVideoStreamAPI_Expecter) PWStreamGetNodeId(stream any) *MockVideoStreamAPI_PWStreamGetNodeId_Call {
913 return &MockVideoStreamAPI_PWStreamGetNodeId_Call{Call: _e.mock.On("PWStreamGetNodeId", stream)}
914}
915
916func (_c *MockVideoStreamAPI_PWStreamGetNodeId_Call) Run(run func(stream unsafe.Pointer)) *MockVideoStreamAPI_PWStreamGetNodeId_Call {
917 _c.Call.Run(func(args mock.Arguments) {
918 var arg0 unsafe.Pointer
919 if args[0] != nil {
920 arg0 = args[0].(unsafe.Pointer)
921 }
922 run(
923 arg0,
924 )
925 })
926 return _c
927}
928
929func (_c *MockVideoStreamAPI_PWStreamGetNodeId_Call) Return(v uint32) *MockVideoStreamAPI_PWStreamGetNodeId_Call {
930 _c.Call.Return(v)
931 return _c
932}
933
934func (_c *MockVideoStreamAPI_PWStreamGetNodeId_Call) RunAndReturn(run func(stream unsafe.Pointer) uint32) *MockVideoStreamAPI_PWStreamGetNodeId_Call {
935 _c.Call.Return(run)
936 return _c
937}
938
939// PWStreamIsDriving provides a mock function for the type MockVideoStreamAPI
940func (_mock *MockVideoStreamAPI) PWStreamIsDriving(stream unsafe.Pointer) bool {
941 ret := _mock.Called(stream)
942
943 if len(ret) == 0 {
944 panic("no return value specified for PWStreamIsDriving")
945 }
946
947 var r0 bool
948 if returnFunc, ok := ret.Get(0).(func(unsafe.Pointer) bool); ok {
949 r0 = returnFunc(stream)
950 } else {
951 r0 = ret.Get(0).(bool)
952 }
953 return r0
954}
955
956// MockVideoStreamAPI_PWStreamIsDriving_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PWStreamIsDriving'
957type MockVideoStreamAPI_PWStreamIsDriving_Call struct {
958 *mock.Call
959}
960
961// PWStreamIsDriving is a helper method to define mock.On call
962// - stream unsafe.Pointer
963func (_e *MockVideoStreamAPI_Expecter) PWStreamIsDriving(stream any) *MockVideoStreamAPI_PWStreamIsDriving_Call {
964 return &MockVideoStreamAPI_PWStreamIsDriving_Call{Call: _e.mock.On("PWStreamIsDriving", stream)}
965}
966
967func (_c *MockVideoStreamAPI_PWStreamIsDriving_Call) Run(run func(stream unsafe.Pointer)) *MockVideoStreamAPI_PWStreamIsDriving_Call {
968 _c.Call.Run(func(args mock.Arguments) {
969 var arg0 unsafe.Pointer
970 if args[0] != nil {
971 arg0 = args[0].(unsafe.Pointer)
972 }
973 run(
974 arg0,
975 )
976 })
977 return _c
978}
979
980func (_c *MockVideoStreamAPI_PWStreamIsDriving_Call) Return(b bool) *MockVideoStreamAPI_PWStreamIsDriving_Call {
981 _c.Call.Return(b)
982 return _c
983}
984
985func (_c *MockVideoStreamAPI_PWStreamIsDriving_Call) RunAndReturn(run func(stream unsafe.Pointer) bool) *MockVideoStreamAPI_PWStreamIsDriving_Call {
986 _c.Call.Return(run)
987 return _c
988}
989
990// PWStreamNew provides a mock function for the type MockVideoStreamAPI
991func (_mock *MockVideoStreamAPI) PWStreamNew(core unsafe.Pointer, name *byte, props unsafe.Pointer) unsafe.Pointer {
992 ret := _mock.Called(core, name, props)
993
994 if len(ret) == 0 {
995 panic("no return value specified for PWStreamNew")
996 }
997
998 var r0 unsafe.Pointer
999 if returnFunc, ok := ret.Get(0).(func(unsafe.Pointer, *byte, unsafe.Pointer) unsafe.Pointer); ok {
1000 r0 = returnFunc(core, name, props)
1001 } else {
1002 r0 = ret.Get(0).(unsafe.Pointer)
1003 }
1004 return r0
1005}
1006
1007// MockVideoStreamAPI_PWStreamNew_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PWStreamNew'
1008type MockVideoStreamAPI_PWStreamNew_Call struct {
1009 *mock.Call
1010}
1011
1012// PWStreamNew is a helper method to define mock.On call
1013// - core unsafe.Pointer
1014// - name *byte
1015// - props unsafe.Pointer
1016func (_e *MockVideoStreamAPI_Expecter) PWStreamNew(core any, name any, props any) *MockVideoStreamAPI_PWStreamNew_Call {
1017 return &MockVideoStreamAPI_PWStreamNew_Call{Call: _e.mock.On("PWStreamNew", core, name, props)}
1018}
1019
1020func (_c *MockVideoStreamAPI_PWStreamNew_Call) Run(run func(core unsafe.Pointer, name *byte, props unsafe.Pointer)) *MockVideoStreamAPI_PWStreamNew_Call {
1021 _c.Call.Run(func(args mock.Arguments) {
1022 var arg0 unsafe.Pointer
1023 if args[0] != nil {
1024 arg0 = args[0].(unsafe.Pointer)
1025 }
1026 var arg1 *byte
1027 if args[1] != nil {
1028 arg1 = args[1].(*byte)
1029 }
1030 var arg2 unsafe.Pointer
1031 if args[2] != nil {
1032 arg2 = args[2].(unsafe.Pointer)
1033 }
1034 run(
1035 arg0,
1036 arg1,
1037 arg2,
1038 )
1039 })
1040 return _c
1041}
1042
1043func (_c *MockVideoStreamAPI_PWStreamNew_Call) Return(v unsafe.Pointer) *MockVideoStreamAPI_PWStreamNew_Call {
1044 _c.Call.Return(v)
1045 return _c
1046}
1047
1048func (_c *MockVideoStreamAPI_PWStreamNew_Call) RunAndReturn(run func(core unsafe.Pointer, name *byte, props unsafe.Pointer) unsafe.Pointer) *MockVideoStreamAPI_PWStreamNew_Call {
1049 _c.Call.Return(run)
1050 return _c
1051}
1052
1053// PWStreamNewSimple provides a mock function for the type MockVideoStreamAPI
1054func (_mock *MockVideoStreamAPI) PWStreamNewSimple(context unsafe.Pointer, name *byte, props unsafe.Pointer, events unsafe.Pointer, data unsafe.Pointer) unsafe.Pointer {
1055 ret := _mock.Called(context, name, props, events, data)
1056
1057 if len(ret) == 0 {
1058 panic("no return value specified for PWStreamNewSimple")
1059 }
1060
1061 var r0 unsafe.Pointer
1062 if returnFunc, ok := ret.Get(0).(func(unsafe.Pointer, *byte, unsafe.Pointer, unsafe.Pointer, unsafe.Pointer) unsafe.Pointer); ok {
1063 r0 = returnFunc(context, name, props, events, data)
1064 } else {
1065 r0 = ret.Get(0).(unsafe.Pointer)
1066 }
1067 return r0
1068}
1069
1070// MockVideoStreamAPI_PWStreamNewSimple_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PWStreamNewSimple'
1071type MockVideoStreamAPI_PWStreamNewSimple_Call struct {
1072 *mock.Call
1073}
1074
1075// PWStreamNewSimple is a helper method to define mock.On call
1076// - context unsafe.Pointer
1077// - name *byte
1078// - props unsafe.Pointer
1079// - events unsafe.Pointer
1080// - data unsafe.Pointer
1081func (_e *MockVideoStreamAPI_Expecter) PWStreamNewSimple(context any, name any, props any, events any, data any) *MockVideoStreamAPI_PWStreamNewSimple_Call {
1082 return &MockVideoStreamAPI_PWStreamNewSimple_Call{Call: _e.mock.On("PWStreamNewSimple", context, name, props, events, data)}
1083}
1084
1085func (_c *MockVideoStreamAPI_PWStreamNewSimple_Call) Run(run func(context unsafe.Pointer, name *byte, props unsafe.Pointer, events unsafe.Pointer, data unsafe.Pointer)) *MockVideoStreamAPI_PWStreamNewSimple_Call {
1086 _c.Call.Run(func(args mock.Arguments) {
1087 var arg0 unsafe.Pointer
1088 if args[0] != nil {
1089 arg0 = args[0].(unsafe.Pointer)
1090 }
1091 var arg1 *byte
1092 if args[1] != nil {
1093 arg1 = args[1].(*byte)
1094 }
1095 var arg2 unsafe.Pointer
1096 if args[2] != nil {
1097 arg2 = args[2].(unsafe.Pointer)
1098 }
1099 var arg3 unsafe.Pointer
1100 if args[3] != nil {
1101 arg3 = args[3].(unsafe.Pointer)
1102 }
1103 var arg4 unsafe.Pointer
1104 if args[4] != nil {
1105 arg4 = args[4].(unsafe.Pointer)
1106 }
1107 run(
1108 arg0,
1109 arg1,
1110 arg2,
1111 arg3,
1112 arg4,
1113 )
1114 })
1115 return _c
1116}
1117
1118func (_c *MockVideoStreamAPI_PWStreamNewSimple_Call) Return(v unsafe.Pointer) *MockVideoStreamAPI_PWStreamNewSimple_Call {
1119 _c.Call.Return(v)
1120 return _c
1121}
1122
1123func (_c *MockVideoStreamAPI_PWStreamNewSimple_Call) RunAndReturn(run func(context unsafe.Pointer, name *byte, props unsafe.Pointer, events unsafe.Pointer, data unsafe.Pointer) unsafe.Pointer) *MockVideoStreamAPI_PWStreamNewSimple_Call {
1124 _c.Call.Return(run)
1125 return _c
1126}
1127
1128// PWStreamQueueBuffer provides a mock function for the type MockVideoStreamAPI
1129func (_mock *MockVideoStreamAPI) PWStreamQueueBuffer(stream unsafe.Pointer, buffer unsafe.Pointer) int32 {
1130 ret := _mock.Called(stream, buffer)
1131
1132 if len(ret) == 0 {
1133 panic("no return value specified for PWStreamQueueBuffer")
1134 }
1135
1136 var r0 int32
1137 if returnFunc, ok := ret.Get(0).(func(unsafe.Pointer, unsafe.Pointer) int32); ok {
1138 r0 = returnFunc(stream, buffer)
1139 } else {
1140 r0 = ret.Get(0).(int32)
1141 }
1142 return r0
1143}
1144
1145// MockVideoStreamAPI_PWStreamQueueBuffer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PWStreamQueueBuffer'
1146type MockVideoStreamAPI_PWStreamQueueBuffer_Call struct {
1147 *mock.Call
1148}
1149
1150// PWStreamQueueBuffer is a helper method to define mock.On call
1151// - stream unsafe.Pointer
1152// - buffer unsafe.Pointer
1153func (_e *MockVideoStreamAPI_Expecter) PWStreamQueueBuffer(stream any, buffer any) *MockVideoStreamAPI_PWStreamQueueBuffer_Call {
1154 return &MockVideoStreamAPI_PWStreamQueueBuffer_Call{Call: _e.mock.On("PWStreamQueueBuffer", stream, buffer)}
1155}
1156
1157func (_c *MockVideoStreamAPI_PWStreamQueueBuffer_Call) Run(run func(stream unsafe.Pointer, buffer unsafe.Pointer)) *MockVideoStreamAPI_PWStreamQueueBuffer_Call {
1158 _c.Call.Run(func(args mock.Arguments) {
1159 var arg0 unsafe.Pointer
1160 if args[0] != nil {
1161 arg0 = args[0].(unsafe.Pointer)
1162 }
1163 var arg1 unsafe.Pointer
1164 if args[1] != nil {
1165 arg1 = args[1].(unsafe.Pointer)
1166 }
1167 run(
1168 arg0,
1169 arg1,
1170 )
1171 })
1172 return _c
1173}
1174
1175func (_c *MockVideoStreamAPI_PWStreamQueueBuffer_Call) Return(n int32) *MockVideoStreamAPI_PWStreamQueueBuffer_Call {
1176 _c.Call.Return(n)
1177 return _c
1178}
1179
1180func (_c *MockVideoStreamAPI_PWStreamQueueBuffer_Call) RunAndReturn(run func(stream unsafe.Pointer, buffer unsafe.Pointer) int32) *MockVideoStreamAPI_PWStreamQueueBuffer_Call {
1181 _c.Call.Return(run)
1182 return _c
1183}
1184
1185// PWStreamReturnBuffer provides a mock function for the type MockVideoStreamAPI
1186func (_mock *MockVideoStreamAPI) PWStreamReturnBuffer(stream unsafe.Pointer, buffer unsafe.Pointer) int32 {
1187 ret := _mock.Called(stream, buffer)
1188
1189 if len(ret) == 0 {
1190 panic("no return value specified for PWStreamReturnBuffer")
1191 }
1192
1193 var r0 int32
1194 if returnFunc, ok := ret.Get(0).(func(unsafe.Pointer, unsafe.Pointer) int32); ok {
1195 r0 = returnFunc(stream, buffer)
1196 } else {
1197 r0 = ret.Get(0).(int32)
1198 }
1199 return r0
1200}
1201
1202// MockVideoStreamAPI_PWStreamReturnBuffer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PWStreamReturnBuffer'
1203type MockVideoStreamAPI_PWStreamReturnBuffer_Call struct {
1204 *mock.Call
1205}
1206
1207// PWStreamReturnBuffer is a helper method to define mock.On call
1208// - stream unsafe.Pointer
1209// - buffer unsafe.Pointer
1210func (_e *MockVideoStreamAPI_Expecter) PWStreamReturnBuffer(stream any, buffer any) *MockVideoStreamAPI_PWStreamReturnBuffer_Call {
1211 return &MockVideoStreamAPI_PWStreamReturnBuffer_Call{Call: _e.mock.On("PWStreamReturnBuffer", stream, buffer)}
1212}
1213
1214func (_c *MockVideoStreamAPI_PWStreamReturnBuffer_Call) Run(run func(stream unsafe.Pointer, buffer unsafe.Pointer)) *MockVideoStreamAPI_PWStreamReturnBuffer_Call {
1215 _c.Call.Run(func(args mock.Arguments) {
1216 var arg0 unsafe.Pointer
1217 if args[0] != nil {
1218 arg0 = args[0].(unsafe.Pointer)
1219 }
1220 var arg1 unsafe.Pointer
1221 if args[1] != nil {
1222 arg1 = args[1].(unsafe.Pointer)
1223 }
1224 run(
1225 arg0,
1226 arg1,
1227 )
1228 })
1229 return _c
1230}
1231
1232func (_c *MockVideoStreamAPI_PWStreamReturnBuffer_Call) Return(n int32) *MockVideoStreamAPI_PWStreamReturnBuffer_Call {
1233 _c.Call.Return(n)
1234 return _c
1235}
1236
1237func (_c *MockVideoStreamAPI_PWStreamReturnBuffer_Call) RunAndReturn(run func(stream unsafe.Pointer, buffer unsafe.Pointer) int32) *MockVideoStreamAPI_PWStreamReturnBuffer_Call {
1238 _c.Call.Return(run)
1239 return _c
1240}
1241
1242// PWStreamSetActive provides a mock function for the type MockVideoStreamAPI
1243func (_mock *MockVideoStreamAPI) PWStreamSetActive(stream unsafe.Pointer, active bool) int32 {
1244 ret := _mock.Called(stream, active)
1245
1246 if len(ret) == 0 {
1247 panic("no return value specified for PWStreamSetActive")
1248 }
1249
1250 var r0 int32
1251 if returnFunc, ok := ret.Get(0).(func(unsafe.Pointer, bool) int32); ok {
1252 r0 = returnFunc(stream, active)
1253 } else {
1254 r0 = ret.Get(0).(int32)
1255 }
1256 return r0
1257}
1258
1259// MockVideoStreamAPI_PWStreamSetActive_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PWStreamSetActive'
1260type MockVideoStreamAPI_PWStreamSetActive_Call struct {
1261 *mock.Call
1262}
1263
1264// PWStreamSetActive is a helper method to define mock.On call
1265// - stream unsafe.Pointer
1266// - active bool
1267func (_e *MockVideoStreamAPI_Expecter) PWStreamSetActive(stream any, active any) *MockVideoStreamAPI_PWStreamSetActive_Call {
1268 return &MockVideoStreamAPI_PWStreamSetActive_Call{Call: _e.mock.On("PWStreamSetActive", stream, active)}
1269}
1270
1271func (_c *MockVideoStreamAPI_PWStreamSetActive_Call) Run(run func(stream unsafe.Pointer, active bool)) *MockVideoStreamAPI_PWStreamSetActive_Call {
1272 _c.Call.Run(func(args mock.Arguments) {
1273 var arg0 unsafe.Pointer
1274 if args[0] != nil {
1275 arg0 = args[0].(unsafe.Pointer)
1276 }
1277 var arg1 bool
1278 if args[1] != nil {
1279 arg1 = args[1].(bool)
1280 }
1281 run(
1282 arg0,
1283 arg1,
1284 )
1285 })
1286 return _c
1287}
1288
1289func (_c *MockVideoStreamAPI_PWStreamSetActive_Call) Return(n int32) *MockVideoStreamAPI_PWStreamSetActive_Call {
1290 _c.Call.Return(n)
1291 return _c
1292}
1293
1294func (_c *MockVideoStreamAPI_PWStreamSetActive_Call) RunAndReturn(run func(stream unsafe.Pointer, active bool) int32) *MockVideoStreamAPI_PWStreamSetActive_Call {
1295 _c.Call.Return(run)
1296 return _c
1297}
1298
1299// PWStreamTriggerProcess provides a mock function for the type MockVideoStreamAPI
1300func (_mock *MockVideoStreamAPI) PWStreamTriggerProcess(stream unsafe.Pointer) int32 {
1301 ret := _mock.Called(stream)
1302
1303 if len(ret) == 0 {
1304 panic("no return value specified for PWStreamTriggerProcess")
1305 }
1306
1307 var r0 int32
1308 if returnFunc, ok := ret.Get(0).(func(unsafe.Pointer) int32); ok {
1309 r0 = returnFunc(stream)
1310 } else {
1311 r0 = ret.Get(0).(int32)
1312 }
1313 return r0
1314}
1315
1316// MockVideoStreamAPI_PWStreamTriggerProcess_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PWStreamTriggerProcess'
1317type MockVideoStreamAPI_PWStreamTriggerProcess_Call struct {
1318 *mock.Call
1319}
1320
1321// PWStreamTriggerProcess is a helper method to define mock.On call
1322// - stream unsafe.Pointer
1323func (_e *MockVideoStreamAPI_Expecter) PWStreamTriggerProcess(stream any) *MockVideoStreamAPI_PWStreamTriggerProcess_Call {
1324 return &MockVideoStreamAPI_PWStreamTriggerProcess_Call{Call: _e.mock.On("PWStreamTriggerProcess", stream)}
1325}
1326
1327func (_c *MockVideoStreamAPI_PWStreamTriggerProcess_Call) Run(run func(stream unsafe.Pointer)) *MockVideoStreamAPI_PWStreamTriggerProcess_Call {
1328 _c.Call.Run(func(args mock.Arguments) {
1329 var arg0 unsafe.Pointer
1330 if args[0] != nil {
1331 arg0 = args[0].(unsafe.Pointer)
1332 }
1333 run(
1334 arg0,
1335 )
1336 })
1337 return _c
1338}
1339
1340func (_c *MockVideoStreamAPI_PWStreamTriggerProcess_Call) Return(n int32) *MockVideoStreamAPI_PWStreamTriggerProcess_Call {
1341 _c.Call.Return(n)
1342 return _c
1343}
1344
1345func (_c *MockVideoStreamAPI_PWStreamTriggerProcess_Call) RunAndReturn(run func(stream unsafe.Pointer) int32) *MockVideoStreamAPI_PWStreamTriggerProcess_Call {
1346 _c.Call.Return(run)
1347 return _c
1348}
1349
1350// PWStreamUpdateParams provides a mock function for the type MockVideoStreamAPI
1351func (_mock *MockVideoStreamAPI) PWStreamUpdateParams(stream unsafe.Pointer, params unsafe.Pointer, n_params uint32) int32 {
1352 ret := _mock.Called(stream, params, n_params)
1353
1354 if len(ret) == 0 {
1355 panic("no return value specified for PWStreamUpdateParams")
1356 }
1357
1358 var r0 int32
1359 if returnFunc, ok := ret.Get(0).(func(unsafe.Pointer, unsafe.Pointer, uint32) int32); ok {
1360 r0 = returnFunc(stream, params, n_params)
1361 } else {
1362 r0 = ret.Get(0).(int32)
1363 }
1364 return r0
1365}
1366
1367// MockVideoStreamAPI_PWStreamUpdateParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PWStreamUpdateParams'
1368type MockVideoStreamAPI_PWStreamUpdateParams_Call struct {
1369 *mock.Call
1370}
1371
1372// PWStreamUpdateParams is a helper method to define mock.On call
1373// - stream unsafe.Pointer
1374// - params unsafe.Pointer
1375// - n_params uint32
1376func (_e *MockVideoStreamAPI_Expecter) PWStreamUpdateParams(stream any, params any, n_params any) *MockVideoStreamAPI_PWStreamUpdateParams_Call {
1377 return &MockVideoStreamAPI_PWStreamUpdateParams_Call{Call: _e.mock.On("PWStreamUpdateParams", stream, params, n_params)}
1378}
1379
1380func (_c *MockVideoStreamAPI_PWStreamUpdateParams_Call) Run(run func(stream unsafe.Pointer, params unsafe.Pointer, n_params uint32)) *MockVideoStreamAPI_PWStreamUpdateParams_Call {
1381 _c.Call.Run(func(args mock.Arguments) {
1382 var arg0 unsafe.Pointer
1383 if args[0] != nil {
1384 arg0 = args[0].(unsafe.Pointer)
1385 }
1386 var arg1 unsafe.Pointer
1387 if args[1] != nil {
1388 arg1 = args[1].(unsafe.Pointer)
1389 }
1390 var arg2 uint32
1391 if args[2] != nil {
1392 arg2 = args[2].(uint32)
1393 }
1394 run(
1395 arg0,
1396 arg1,
1397 arg2,
1398 )
1399 })
1400 return _c
1401}
1402
1403func (_c *MockVideoStreamAPI_PWStreamUpdateParams_Call) Return(n int32) *MockVideoStreamAPI_PWStreamUpdateParams_Call {
1404 _c.Call.Return(n)
1405 return _c
1406}
1407
1408func (_c *MockVideoStreamAPI_PWStreamUpdateParams_Call) RunAndReturn(run func(stream unsafe.Pointer, params unsafe.Pointer, n_params uint32) int32) *MockVideoStreamAPI_PWStreamUpdateParams_Call {
1409 _c.Call.Return(run)
1410 return _c
1411}