Codex: Add RTMP protocol fakes.
This commit is contained in:
winlin
parent
9b9b91c7a6
commit
9ea08e9509
7
internal/rtmp/gen.go
Normal file
7
internal/rtmp/gen.go
Normal file
|
|
@ -0,0 +1,7 @@
|
|||
// Copyright (c) 2026 Winlin
|
||||
//
|
||||
// SPDX-License-Identifier: MIT
|
||||
package rtmp
|
||||
|
||||
//go:generate go tool counterfeiter -o rtmpfakes/fake_handshake.go . Handshake
|
||||
//go:generate go tool counterfeiter -o rtmpfakes/fake_protocol.go . Protocol
|
||||
554
internal/rtmp/rtmpfakes/fake_handshake.go
Normal file
554
internal/rtmp/rtmpfakes/fake_handshake.go
Normal file
|
|
@ -0,0 +1,554 @@
|
|||
// Code generated by counterfeiter. DO NOT EDIT.
|
||||
package rtmpfakes
|
||||
|
||||
import (
|
||||
"io"
|
||||
"srsx/internal/rtmp"
|
||||
"sync"
|
||||
)
|
||||
|
||||
type FakeHandshake struct {
|
||||
C1S1Stub func() []byte
|
||||
c1S1Mutex sync.RWMutex
|
||||
c1S1ArgsForCall []struct {
|
||||
}
|
||||
c1S1Returns struct {
|
||||
result1 []byte
|
||||
}
|
||||
c1S1ReturnsOnCall map[int]struct {
|
||||
result1 []byte
|
||||
}
|
||||
ReadC0S0Stub func(io.Reader) ([]byte, error)
|
||||
readC0S0Mutex sync.RWMutex
|
||||
readC0S0ArgsForCall []struct {
|
||||
arg1 io.Reader
|
||||
}
|
||||
readC0S0Returns struct {
|
||||
result1 []byte
|
||||
result2 error
|
||||
}
|
||||
readC0S0ReturnsOnCall map[int]struct {
|
||||
result1 []byte
|
||||
result2 error
|
||||
}
|
||||
ReadC1S1Stub func(io.Reader) ([]byte, error)
|
||||
readC1S1Mutex sync.RWMutex
|
||||
readC1S1ArgsForCall []struct {
|
||||
arg1 io.Reader
|
||||
}
|
||||
readC1S1Returns struct {
|
||||
result1 []byte
|
||||
result2 error
|
||||
}
|
||||
readC1S1ReturnsOnCall map[int]struct {
|
||||
result1 []byte
|
||||
result2 error
|
||||
}
|
||||
ReadC2S2Stub func(io.Reader) ([]byte, error)
|
||||
readC2S2Mutex sync.RWMutex
|
||||
readC2S2ArgsForCall []struct {
|
||||
arg1 io.Reader
|
||||
}
|
||||
readC2S2Returns struct {
|
||||
result1 []byte
|
||||
result2 error
|
||||
}
|
||||
readC2S2ReturnsOnCall map[int]struct {
|
||||
result1 []byte
|
||||
result2 error
|
||||
}
|
||||
WriteC0S0Stub func(io.Writer) error
|
||||
writeC0S0Mutex sync.RWMutex
|
||||
writeC0S0ArgsForCall []struct {
|
||||
arg1 io.Writer
|
||||
}
|
||||
writeC0S0Returns struct {
|
||||
result1 error
|
||||
}
|
||||
writeC0S0ReturnsOnCall map[int]struct {
|
||||
result1 error
|
||||
}
|
||||
WriteC1S1Stub func(io.Writer) error
|
||||
writeC1S1Mutex sync.RWMutex
|
||||
writeC1S1ArgsForCall []struct {
|
||||
arg1 io.Writer
|
||||
}
|
||||
writeC1S1Returns struct {
|
||||
result1 error
|
||||
}
|
||||
writeC1S1ReturnsOnCall map[int]struct {
|
||||
result1 error
|
||||
}
|
||||
WriteC2S2Stub func(io.Writer, []byte) error
|
||||
writeC2S2Mutex sync.RWMutex
|
||||
writeC2S2ArgsForCall []struct {
|
||||
arg1 io.Writer
|
||||
arg2 []byte
|
||||
}
|
||||
writeC2S2Returns struct {
|
||||
result1 error
|
||||
}
|
||||
writeC2S2ReturnsOnCall map[int]struct {
|
||||
result1 error
|
||||
}
|
||||
invocations map[string][][]interface{}
|
||||
invocationsMutex sync.RWMutex
|
||||
}
|
||||
|
||||
func (fake *FakeHandshake) C1S1() []byte {
|
||||
fake.c1S1Mutex.Lock()
|
||||
ret, specificReturn := fake.c1S1ReturnsOnCall[len(fake.c1S1ArgsForCall)]
|
||||
fake.c1S1ArgsForCall = append(fake.c1S1ArgsForCall, struct {
|
||||
}{})
|
||||
stub := fake.C1S1Stub
|
||||
fakeReturns := fake.c1S1Returns
|
||||
fake.recordInvocation("C1S1", []interface{}{})
|
||||
fake.c1S1Mutex.Unlock()
|
||||
if stub != nil {
|
||||
return stub()
|
||||
}
|
||||
if specificReturn {
|
||||
return ret.result1
|
||||
}
|
||||
return fakeReturns.result1
|
||||
}
|
||||
|
||||
func (fake *FakeHandshake) C1S1CallCount() int {
|
||||
fake.c1S1Mutex.RLock()
|
||||
defer fake.c1S1Mutex.RUnlock()
|
||||
return len(fake.c1S1ArgsForCall)
|
||||
}
|
||||
|
||||
func (fake *FakeHandshake) C1S1Calls(stub func() []byte) {
|
||||
fake.c1S1Mutex.Lock()
|
||||
defer fake.c1S1Mutex.Unlock()
|
||||
fake.C1S1Stub = stub
|
||||
}
|
||||
|
||||
func (fake *FakeHandshake) C1S1Returns(result1 []byte) {
|
||||
fake.c1S1Mutex.Lock()
|
||||
defer fake.c1S1Mutex.Unlock()
|
||||
fake.C1S1Stub = nil
|
||||
fake.c1S1Returns = struct {
|
||||
result1 []byte
|
||||
}{result1}
|
||||
}
|
||||
|
||||
func (fake *FakeHandshake) C1S1ReturnsOnCall(i int, result1 []byte) {
|
||||
fake.c1S1Mutex.Lock()
|
||||
defer fake.c1S1Mutex.Unlock()
|
||||
fake.C1S1Stub = nil
|
||||
if fake.c1S1ReturnsOnCall == nil {
|
||||
fake.c1S1ReturnsOnCall = make(map[int]struct {
|
||||
result1 []byte
|
||||
})
|
||||
}
|
||||
fake.c1S1ReturnsOnCall[i] = struct {
|
||||
result1 []byte
|
||||
}{result1}
|
||||
}
|
||||
|
||||
func (fake *FakeHandshake) ReadC0S0(arg1 io.Reader) ([]byte, error) {
|
||||
fake.readC0S0Mutex.Lock()
|
||||
ret, specificReturn := fake.readC0S0ReturnsOnCall[len(fake.readC0S0ArgsForCall)]
|
||||
fake.readC0S0ArgsForCall = append(fake.readC0S0ArgsForCall, struct {
|
||||
arg1 io.Reader
|
||||
}{arg1})
|
||||
stub := fake.ReadC0S0Stub
|
||||
fakeReturns := fake.readC0S0Returns
|
||||
fake.recordInvocation("ReadC0S0", []interface{}{arg1})
|
||||
fake.readC0S0Mutex.Unlock()
|
||||
if stub != nil {
|
||||
return stub(arg1)
|
||||
}
|
||||
if specificReturn {
|
||||
return ret.result1, ret.result2
|
||||
}
|
||||
return fakeReturns.result1, fakeReturns.result2
|
||||
}
|
||||
|
||||
func (fake *FakeHandshake) ReadC0S0CallCount() int {
|
||||
fake.readC0S0Mutex.RLock()
|
||||
defer fake.readC0S0Mutex.RUnlock()
|
||||
return len(fake.readC0S0ArgsForCall)
|
||||
}
|
||||
|
||||
func (fake *FakeHandshake) ReadC0S0Calls(stub func(io.Reader) ([]byte, error)) {
|
||||
fake.readC0S0Mutex.Lock()
|
||||
defer fake.readC0S0Mutex.Unlock()
|
||||
fake.ReadC0S0Stub = stub
|
||||
}
|
||||
|
||||
func (fake *FakeHandshake) ReadC0S0ArgsForCall(i int) io.Reader {
|
||||
fake.readC0S0Mutex.RLock()
|
||||
defer fake.readC0S0Mutex.RUnlock()
|
||||
argsForCall := fake.readC0S0ArgsForCall[i]
|
||||
return argsForCall.arg1
|
||||
}
|
||||
|
||||
func (fake *FakeHandshake) ReadC0S0Returns(result1 []byte, result2 error) {
|
||||
fake.readC0S0Mutex.Lock()
|
||||
defer fake.readC0S0Mutex.Unlock()
|
||||
fake.ReadC0S0Stub = nil
|
||||
fake.readC0S0Returns = struct {
|
||||
result1 []byte
|
||||
result2 error
|
||||
}{result1, result2}
|
||||
}
|
||||
|
||||
func (fake *FakeHandshake) ReadC0S0ReturnsOnCall(i int, result1 []byte, result2 error) {
|
||||
fake.readC0S0Mutex.Lock()
|
||||
defer fake.readC0S0Mutex.Unlock()
|
||||
fake.ReadC0S0Stub = nil
|
||||
if fake.readC0S0ReturnsOnCall == nil {
|
||||
fake.readC0S0ReturnsOnCall = make(map[int]struct {
|
||||
result1 []byte
|
||||
result2 error
|
||||
})
|
||||
}
|
||||
fake.readC0S0ReturnsOnCall[i] = struct {
|
||||
result1 []byte
|
||||
result2 error
|
||||
}{result1, result2}
|
||||
}
|
||||
|
||||
func (fake *FakeHandshake) ReadC1S1(arg1 io.Reader) ([]byte, error) {
|
||||
fake.readC1S1Mutex.Lock()
|
||||
ret, specificReturn := fake.readC1S1ReturnsOnCall[len(fake.readC1S1ArgsForCall)]
|
||||
fake.readC1S1ArgsForCall = append(fake.readC1S1ArgsForCall, struct {
|
||||
arg1 io.Reader
|
||||
}{arg1})
|
||||
stub := fake.ReadC1S1Stub
|
||||
fakeReturns := fake.readC1S1Returns
|
||||
fake.recordInvocation("ReadC1S1", []interface{}{arg1})
|
||||
fake.readC1S1Mutex.Unlock()
|
||||
if stub != nil {
|
||||
return stub(arg1)
|
||||
}
|
||||
if specificReturn {
|
||||
return ret.result1, ret.result2
|
||||
}
|
||||
return fakeReturns.result1, fakeReturns.result2
|
||||
}
|
||||
|
||||
func (fake *FakeHandshake) ReadC1S1CallCount() int {
|
||||
fake.readC1S1Mutex.RLock()
|
||||
defer fake.readC1S1Mutex.RUnlock()
|
||||
return len(fake.readC1S1ArgsForCall)
|
||||
}
|
||||
|
||||
func (fake *FakeHandshake) ReadC1S1Calls(stub func(io.Reader) ([]byte, error)) {
|
||||
fake.readC1S1Mutex.Lock()
|
||||
defer fake.readC1S1Mutex.Unlock()
|
||||
fake.ReadC1S1Stub = stub
|
||||
}
|
||||
|
||||
func (fake *FakeHandshake) ReadC1S1ArgsForCall(i int) io.Reader {
|
||||
fake.readC1S1Mutex.RLock()
|
||||
defer fake.readC1S1Mutex.RUnlock()
|
||||
argsForCall := fake.readC1S1ArgsForCall[i]
|
||||
return argsForCall.arg1
|
||||
}
|
||||
|
||||
func (fake *FakeHandshake) ReadC1S1Returns(result1 []byte, result2 error) {
|
||||
fake.readC1S1Mutex.Lock()
|
||||
defer fake.readC1S1Mutex.Unlock()
|
||||
fake.ReadC1S1Stub = nil
|
||||
fake.readC1S1Returns = struct {
|
||||
result1 []byte
|
||||
result2 error
|
||||
}{result1, result2}
|
||||
}
|
||||
|
||||
func (fake *FakeHandshake) ReadC1S1ReturnsOnCall(i int, result1 []byte, result2 error) {
|
||||
fake.readC1S1Mutex.Lock()
|
||||
defer fake.readC1S1Mutex.Unlock()
|
||||
fake.ReadC1S1Stub = nil
|
||||
if fake.readC1S1ReturnsOnCall == nil {
|
||||
fake.readC1S1ReturnsOnCall = make(map[int]struct {
|
||||
result1 []byte
|
||||
result2 error
|
||||
})
|
||||
}
|
||||
fake.readC1S1ReturnsOnCall[i] = struct {
|
||||
result1 []byte
|
||||
result2 error
|
||||
}{result1, result2}
|
||||
}
|
||||
|
||||
func (fake *FakeHandshake) ReadC2S2(arg1 io.Reader) ([]byte, error) {
|
||||
fake.readC2S2Mutex.Lock()
|
||||
ret, specificReturn := fake.readC2S2ReturnsOnCall[len(fake.readC2S2ArgsForCall)]
|
||||
fake.readC2S2ArgsForCall = append(fake.readC2S2ArgsForCall, struct {
|
||||
arg1 io.Reader
|
||||
}{arg1})
|
||||
stub := fake.ReadC2S2Stub
|
||||
fakeReturns := fake.readC2S2Returns
|
||||
fake.recordInvocation("ReadC2S2", []interface{}{arg1})
|
||||
fake.readC2S2Mutex.Unlock()
|
||||
if stub != nil {
|
||||
return stub(arg1)
|
||||
}
|
||||
if specificReturn {
|
||||
return ret.result1, ret.result2
|
||||
}
|
||||
return fakeReturns.result1, fakeReturns.result2
|
||||
}
|
||||
|
||||
func (fake *FakeHandshake) ReadC2S2CallCount() int {
|
||||
fake.readC2S2Mutex.RLock()
|
||||
defer fake.readC2S2Mutex.RUnlock()
|
||||
return len(fake.readC2S2ArgsForCall)
|
||||
}
|
||||
|
||||
func (fake *FakeHandshake) ReadC2S2Calls(stub func(io.Reader) ([]byte, error)) {
|
||||
fake.readC2S2Mutex.Lock()
|
||||
defer fake.readC2S2Mutex.Unlock()
|
||||
fake.ReadC2S2Stub = stub
|
||||
}
|
||||
|
||||
func (fake *FakeHandshake) ReadC2S2ArgsForCall(i int) io.Reader {
|
||||
fake.readC2S2Mutex.RLock()
|
||||
defer fake.readC2S2Mutex.RUnlock()
|
||||
argsForCall := fake.readC2S2ArgsForCall[i]
|
||||
return argsForCall.arg1
|
||||
}
|
||||
|
||||
func (fake *FakeHandshake) ReadC2S2Returns(result1 []byte, result2 error) {
|
||||
fake.readC2S2Mutex.Lock()
|
||||
defer fake.readC2S2Mutex.Unlock()
|
||||
fake.ReadC2S2Stub = nil
|
||||
fake.readC2S2Returns = struct {
|
||||
result1 []byte
|
||||
result2 error
|
||||
}{result1, result2}
|
||||
}
|
||||
|
||||
func (fake *FakeHandshake) ReadC2S2ReturnsOnCall(i int, result1 []byte, result2 error) {
|
||||
fake.readC2S2Mutex.Lock()
|
||||
defer fake.readC2S2Mutex.Unlock()
|
||||
fake.ReadC2S2Stub = nil
|
||||
if fake.readC2S2ReturnsOnCall == nil {
|
||||
fake.readC2S2ReturnsOnCall = make(map[int]struct {
|
||||
result1 []byte
|
||||
result2 error
|
||||
})
|
||||
}
|
||||
fake.readC2S2ReturnsOnCall[i] = struct {
|
||||
result1 []byte
|
||||
result2 error
|
||||
}{result1, result2}
|
||||
}
|
||||
|
||||
func (fake *FakeHandshake) WriteC0S0(arg1 io.Writer) error {
|
||||
fake.writeC0S0Mutex.Lock()
|
||||
ret, specificReturn := fake.writeC0S0ReturnsOnCall[len(fake.writeC0S0ArgsForCall)]
|
||||
fake.writeC0S0ArgsForCall = append(fake.writeC0S0ArgsForCall, struct {
|
||||
arg1 io.Writer
|
||||
}{arg1})
|
||||
stub := fake.WriteC0S0Stub
|
||||
fakeReturns := fake.writeC0S0Returns
|
||||
fake.recordInvocation("WriteC0S0", []interface{}{arg1})
|
||||
fake.writeC0S0Mutex.Unlock()
|
||||
if stub != nil {
|
||||
return stub(arg1)
|
||||
}
|
||||
if specificReturn {
|
||||
return ret.result1
|
||||
}
|
||||
return fakeReturns.result1
|
||||
}
|
||||
|
||||
func (fake *FakeHandshake) WriteC0S0CallCount() int {
|
||||
fake.writeC0S0Mutex.RLock()
|
||||
defer fake.writeC0S0Mutex.RUnlock()
|
||||
return len(fake.writeC0S0ArgsForCall)
|
||||
}
|
||||
|
||||
func (fake *FakeHandshake) WriteC0S0Calls(stub func(io.Writer) error) {
|
||||
fake.writeC0S0Mutex.Lock()
|
||||
defer fake.writeC0S0Mutex.Unlock()
|
||||
fake.WriteC0S0Stub = stub
|
||||
}
|
||||
|
||||
func (fake *FakeHandshake) WriteC0S0ArgsForCall(i int) io.Writer {
|
||||
fake.writeC0S0Mutex.RLock()
|
||||
defer fake.writeC0S0Mutex.RUnlock()
|
||||
argsForCall := fake.writeC0S0ArgsForCall[i]
|
||||
return argsForCall.arg1
|
||||
}
|
||||
|
||||
func (fake *FakeHandshake) WriteC0S0Returns(result1 error) {
|
||||
fake.writeC0S0Mutex.Lock()
|
||||
defer fake.writeC0S0Mutex.Unlock()
|
||||
fake.WriteC0S0Stub = nil
|
||||
fake.writeC0S0Returns = struct {
|
||||
result1 error
|
||||
}{result1}
|
||||
}
|
||||
|
||||
func (fake *FakeHandshake) WriteC0S0ReturnsOnCall(i int, result1 error) {
|
||||
fake.writeC0S0Mutex.Lock()
|
||||
defer fake.writeC0S0Mutex.Unlock()
|
||||
fake.WriteC0S0Stub = nil
|
||||
if fake.writeC0S0ReturnsOnCall == nil {
|
||||
fake.writeC0S0ReturnsOnCall = make(map[int]struct {
|
||||
result1 error
|
||||
})
|
||||
}
|
||||
fake.writeC0S0ReturnsOnCall[i] = struct {
|
||||
result1 error
|
||||
}{result1}
|
||||
}
|
||||
|
||||
func (fake *FakeHandshake) WriteC1S1(arg1 io.Writer) error {
|
||||
fake.writeC1S1Mutex.Lock()
|
||||
ret, specificReturn := fake.writeC1S1ReturnsOnCall[len(fake.writeC1S1ArgsForCall)]
|
||||
fake.writeC1S1ArgsForCall = append(fake.writeC1S1ArgsForCall, struct {
|
||||
arg1 io.Writer
|
||||
}{arg1})
|
||||
stub := fake.WriteC1S1Stub
|
||||
fakeReturns := fake.writeC1S1Returns
|
||||
fake.recordInvocation("WriteC1S1", []interface{}{arg1})
|
||||
fake.writeC1S1Mutex.Unlock()
|
||||
if stub != nil {
|
||||
return stub(arg1)
|
||||
}
|
||||
if specificReturn {
|
||||
return ret.result1
|
||||
}
|
||||
return fakeReturns.result1
|
||||
}
|
||||
|
||||
func (fake *FakeHandshake) WriteC1S1CallCount() int {
|
||||
fake.writeC1S1Mutex.RLock()
|
||||
defer fake.writeC1S1Mutex.RUnlock()
|
||||
return len(fake.writeC1S1ArgsForCall)
|
||||
}
|
||||
|
||||
func (fake *FakeHandshake) WriteC1S1Calls(stub func(io.Writer) error) {
|
||||
fake.writeC1S1Mutex.Lock()
|
||||
defer fake.writeC1S1Mutex.Unlock()
|
||||
fake.WriteC1S1Stub = stub
|
||||
}
|
||||
|
||||
func (fake *FakeHandshake) WriteC1S1ArgsForCall(i int) io.Writer {
|
||||
fake.writeC1S1Mutex.RLock()
|
||||
defer fake.writeC1S1Mutex.RUnlock()
|
||||
argsForCall := fake.writeC1S1ArgsForCall[i]
|
||||
return argsForCall.arg1
|
||||
}
|
||||
|
||||
func (fake *FakeHandshake) WriteC1S1Returns(result1 error) {
|
||||
fake.writeC1S1Mutex.Lock()
|
||||
defer fake.writeC1S1Mutex.Unlock()
|
||||
fake.WriteC1S1Stub = nil
|
||||
fake.writeC1S1Returns = struct {
|
||||
result1 error
|
||||
}{result1}
|
||||
}
|
||||
|
||||
func (fake *FakeHandshake) WriteC1S1ReturnsOnCall(i int, result1 error) {
|
||||
fake.writeC1S1Mutex.Lock()
|
||||
defer fake.writeC1S1Mutex.Unlock()
|
||||
fake.WriteC1S1Stub = nil
|
||||
if fake.writeC1S1ReturnsOnCall == nil {
|
||||
fake.writeC1S1ReturnsOnCall = make(map[int]struct {
|
||||
result1 error
|
||||
})
|
||||
}
|
||||
fake.writeC1S1ReturnsOnCall[i] = struct {
|
||||
result1 error
|
||||
}{result1}
|
||||
}
|
||||
|
||||
func (fake *FakeHandshake) WriteC2S2(arg1 io.Writer, arg2 []byte) error {
|
||||
var arg2Copy []byte
|
||||
if arg2 != nil {
|
||||
arg2Copy = make([]byte, len(arg2))
|
||||
copy(arg2Copy, arg2)
|
||||
}
|
||||
fake.writeC2S2Mutex.Lock()
|
||||
ret, specificReturn := fake.writeC2S2ReturnsOnCall[len(fake.writeC2S2ArgsForCall)]
|
||||
fake.writeC2S2ArgsForCall = append(fake.writeC2S2ArgsForCall, struct {
|
||||
arg1 io.Writer
|
||||
arg2 []byte
|
||||
}{arg1, arg2Copy})
|
||||
stub := fake.WriteC2S2Stub
|
||||
fakeReturns := fake.writeC2S2Returns
|
||||
fake.recordInvocation("WriteC2S2", []interface{}{arg1, arg2Copy})
|
||||
fake.writeC2S2Mutex.Unlock()
|
||||
if stub != nil {
|
||||
return stub(arg1, arg2)
|
||||
}
|
||||
if specificReturn {
|
||||
return ret.result1
|
||||
}
|
||||
return fakeReturns.result1
|
||||
}
|
||||
|
||||
func (fake *FakeHandshake) WriteC2S2CallCount() int {
|
||||
fake.writeC2S2Mutex.RLock()
|
||||
defer fake.writeC2S2Mutex.RUnlock()
|
||||
return len(fake.writeC2S2ArgsForCall)
|
||||
}
|
||||
|
||||
func (fake *FakeHandshake) WriteC2S2Calls(stub func(io.Writer, []byte) error) {
|
||||
fake.writeC2S2Mutex.Lock()
|
||||
defer fake.writeC2S2Mutex.Unlock()
|
||||
fake.WriteC2S2Stub = stub
|
||||
}
|
||||
|
||||
func (fake *FakeHandshake) WriteC2S2ArgsForCall(i int) (io.Writer, []byte) {
|
||||
fake.writeC2S2Mutex.RLock()
|
||||
defer fake.writeC2S2Mutex.RUnlock()
|
||||
argsForCall := fake.writeC2S2ArgsForCall[i]
|
||||
return argsForCall.arg1, argsForCall.arg2
|
||||
}
|
||||
|
||||
func (fake *FakeHandshake) WriteC2S2Returns(result1 error) {
|
||||
fake.writeC2S2Mutex.Lock()
|
||||
defer fake.writeC2S2Mutex.Unlock()
|
||||
fake.WriteC2S2Stub = nil
|
||||
fake.writeC2S2Returns = struct {
|
||||
result1 error
|
||||
}{result1}
|
||||
}
|
||||
|
||||
func (fake *FakeHandshake) WriteC2S2ReturnsOnCall(i int, result1 error) {
|
||||
fake.writeC2S2Mutex.Lock()
|
||||
defer fake.writeC2S2Mutex.Unlock()
|
||||
fake.WriteC2S2Stub = nil
|
||||
if fake.writeC2S2ReturnsOnCall == nil {
|
||||
fake.writeC2S2ReturnsOnCall = make(map[int]struct {
|
||||
result1 error
|
||||
})
|
||||
}
|
||||
fake.writeC2S2ReturnsOnCall[i] = struct {
|
||||
result1 error
|
||||
}{result1}
|
||||
}
|
||||
|
||||
func (fake *FakeHandshake) Invocations() map[string][][]interface{} {
|
||||
fake.invocationsMutex.RLock()
|
||||
defer fake.invocationsMutex.RUnlock()
|
||||
copiedInvocations := map[string][][]interface{}{}
|
||||
for key, value := range fake.invocations {
|
||||
copiedInvocations[key] = value
|
||||
}
|
||||
return copiedInvocations
|
||||
}
|
||||
|
||||
func (fake *FakeHandshake) recordInvocation(key string, args []interface{}) {
|
||||
fake.invocationsMutex.Lock()
|
||||
defer fake.invocationsMutex.Unlock()
|
||||
if fake.invocations == nil {
|
||||
fake.invocations = map[string][][]interface{}{}
|
||||
}
|
||||
if fake.invocations[key] == nil {
|
||||
fake.invocations[key] = [][]interface{}{}
|
||||
}
|
||||
fake.invocations[key] = append(fake.invocations[key], args)
|
||||
}
|
||||
|
||||
var _ rtmp.Handshake = new(FakeHandshake)
|
||||
499
internal/rtmp/rtmpfakes/fake_protocol.go
Normal file
499
internal/rtmp/rtmpfakes/fake_protocol.go
Normal file
|
|
@ -0,0 +1,499 @@
|
|||
// Code generated by counterfeiter. DO NOT EDIT.
|
||||
package rtmpfakes
|
||||
|
||||
import (
|
||||
"context"
|
||||
"srsx/internal/rtmp"
|
||||
"sync"
|
||||
)
|
||||
|
||||
type FakeProtocol struct {
|
||||
DecodeMessageStub func(rtmp.Message) (rtmp.Packet, error)
|
||||
decodeMessageMutex sync.RWMutex
|
||||
decodeMessageArgsForCall []struct {
|
||||
arg1 rtmp.Message
|
||||
}
|
||||
decodeMessageReturns struct {
|
||||
result1 rtmp.Packet
|
||||
result2 error
|
||||
}
|
||||
decodeMessageReturnsOnCall map[int]struct {
|
||||
result1 rtmp.Packet
|
||||
result2 error
|
||||
}
|
||||
ExpectMessageStub func(context.Context, ...rtmp.MessageType) (rtmp.Message, error)
|
||||
expectMessageMutex sync.RWMutex
|
||||
expectMessageArgsForCall []struct {
|
||||
arg1 context.Context
|
||||
arg2 []rtmp.MessageType
|
||||
}
|
||||
expectMessageReturns struct {
|
||||
result1 rtmp.Message
|
||||
result2 error
|
||||
}
|
||||
expectMessageReturnsOnCall map[int]struct {
|
||||
result1 rtmp.Message
|
||||
result2 error
|
||||
}
|
||||
ExpectPacketStub func(context.Context, any) (rtmp.Message, error)
|
||||
expectPacketMutex sync.RWMutex
|
||||
expectPacketArgsForCall []struct {
|
||||
arg1 context.Context
|
||||
arg2 any
|
||||
}
|
||||
expectPacketReturns struct {
|
||||
result1 rtmp.Message
|
||||
result2 error
|
||||
}
|
||||
expectPacketReturnsOnCall map[int]struct {
|
||||
result1 rtmp.Message
|
||||
result2 error
|
||||
}
|
||||
ReadMessageStub func(context.Context) (rtmp.Message, error)
|
||||
readMessageMutex sync.RWMutex
|
||||
readMessageArgsForCall []struct {
|
||||
arg1 context.Context
|
||||
}
|
||||
readMessageReturns struct {
|
||||
result1 rtmp.Message
|
||||
result2 error
|
||||
}
|
||||
readMessageReturnsOnCall map[int]struct {
|
||||
result1 rtmp.Message
|
||||
result2 error
|
||||
}
|
||||
WriteMessageStub func(context.Context, rtmp.Message) error
|
||||
writeMessageMutex sync.RWMutex
|
||||
writeMessageArgsForCall []struct {
|
||||
arg1 context.Context
|
||||
arg2 rtmp.Message
|
||||
}
|
||||
writeMessageReturns struct {
|
||||
result1 error
|
||||
}
|
||||
writeMessageReturnsOnCall map[int]struct {
|
||||
result1 error
|
||||
}
|
||||
WritePacketStub func(context.Context, rtmp.Packet, int) error
|
||||
writePacketMutex sync.RWMutex
|
||||
writePacketArgsForCall []struct {
|
||||
arg1 context.Context
|
||||
arg2 rtmp.Packet
|
||||
arg3 int
|
||||
}
|
||||
writePacketReturns struct {
|
||||
result1 error
|
||||
}
|
||||
writePacketReturnsOnCall map[int]struct {
|
||||
result1 error
|
||||
}
|
||||
invocations map[string][][]interface{}
|
||||
invocationsMutex sync.RWMutex
|
||||
}
|
||||
|
||||
func (fake *FakeProtocol) DecodeMessage(arg1 rtmp.Message) (rtmp.Packet, error) {
|
||||
fake.decodeMessageMutex.Lock()
|
||||
ret, specificReturn := fake.decodeMessageReturnsOnCall[len(fake.decodeMessageArgsForCall)]
|
||||
fake.decodeMessageArgsForCall = append(fake.decodeMessageArgsForCall, struct {
|
||||
arg1 rtmp.Message
|
||||
}{arg1})
|
||||
stub := fake.DecodeMessageStub
|
||||
fakeReturns := fake.decodeMessageReturns
|
||||
fake.recordInvocation("DecodeMessage", []interface{}{arg1})
|
||||
fake.decodeMessageMutex.Unlock()
|
||||
if stub != nil {
|
||||
return stub(arg1)
|
||||
}
|
||||
if specificReturn {
|
||||
return ret.result1, ret.result2
|
||||
}
|
||||
return fakeReturns.result1, fakeReturns.result2
|
||||
}
|
||||
|
||||
func (fake *FakeProtocol) DecodeMessageCallCount() int {
|
||||
fake.decodeMessageMutex.RLock()
|
||||
defer fake.decodeMessageMutex.RUnlock()
|
||||
return len(fake.decodeMessageArgsForCall)
|
||||
}
|
||||
|
||||
func (fake *FakeProtocol) DecodeMessageCalls(stub func(rtmp.Message) (rtmp.Packet, error)) {
|
||||
fake.decodeMessageMutex.Lock()
|
||||
defer fake.decodeMessageMutex.Unlock()
|
||||
fake.DecodeMessageStub = stub
|
||||
}
|
||||
|
||||
func (fake *FakeProtocol) DecodeMessageArgsForCall(i int) rtmp.Message {
|
||||
fake.decodeMessageMutex.RLock()
|
||||
defer fake.decodeMessageMutex.RUnlock()
|
||||
argsForCall := fake.decodeMessageArgsForCall[i]
|
||||
return argsForCall.arg1
|
||||
}
|
||||
|
||||
func (fake *FakeProtocol) DecodeMessageReturns(result1 rtmp.Packet, result2 error) {
|
||||
fake.decodeMessageMutex.Lock()
|
||||
defer fake.decodeMessageMutex.Unlock()
|
||||
fake.DecodeMessageStub = nil
|
||||
fake.decodeMessageReturns = struct {
|
||||
result1 rtmp.Packet
|
||||
result2 error
|
||||
}{result1, result2}
|
||||
}
|
||||
|
||||
func (fake *FakeProtocol) DecodeMessageReturnsOnCall(i int, result1 rtmp.Packet, result2 error) {
|
||||
fake.decodeMessageMutex.Lock()
|
||||
defer fake.decodeMessageMutex.Unlock()
|
||||
fake.DecodeMessageStub = nil
|
||||
if fake.decodeMessageReturnsOnCall == nil {
|
||||
fake.decodeMessageReturnsOnCall = make(map[int]struct {
|
||||
result1 rtmp.Packet
|
||||
result2 error
|
||||
})
|
||||
}
|
||||
fake.decodeMessageReturnsOnCall[i] = struct {
|
||||
result1 rtmp.Packet
|
||||
result2 error
|
||||
}{result1, result2}
|
||||
}
|
||||
|
||||
func (fake *FakeProtocol) ExpectMessage(arg1 context.Context, arg2 ...rtmp.MessageType) (rtmp.Message, error) {
|
||||
fake.expectMessageMutex.Lock()
|
||||
ret, specificReturn := fake.expectMessageReturnsOnCall[len(fake.expectMessageArgsForCall)]
|
||||
fake.expectMessageArgsForCall = append(fake.expectMessageArgsForCall, struct {
|
||||
arg1 context.Context
|
||||
arg2 []rtmp.MessageType
|
||||
}{arg1, arg2})
|
||||
stub := fake.ExpectMessageStub
|
||||
fakeReturns := fake.expectMessageReturns
|
||||
fake.recordInvocation("ExpectMessage", []interface{}{arg1, arg2})
|
||||
fake.expectMessageMutex.Unlock()
|
||||
if stub != nil {
|
||||
return stub(arg1, arg2...)
|
||||
}
|
||||
if specificReturn {
|
||||
return ret.result1, ret.result2
|
||||
}
|
||||
return fakeReturns.result1, fakeReturns.result2
|
||||
}
|
||||
|
||||
func (fake *FakeProtocol) ExpectMessageCallCount() int {
|
||||
fake.expectMessageMutex.RLock()
|
||||
defer fake.expectMessageMutex.RUnlock()
|
||||
return len(fake.expectMessageArgsForCall)
|
||||
}
|
||||
|
||||
func (fake *FakeProtocol) ExpectMessageCalls(stub func(context.Context, ...rtmp.MessageType) (rtmp.Message, error)) {
|
||||
fake.expectMessageMutex.Lock()
|
||||
defer fake.expectMessageMutex.Unlock()
|
||||
fake.ExpectMessageStub = stub
|
||||
}
|
||||
|
||||
func (fake *FakeProtocol) ExpectMessageArgsForCall(i int) (context.Context, []rtmp.MessageType) {
|
||||
fake.expectMessageMutex.RLock()
|
||||
defer fake.expectMessageMutex.RUnlock()
|
||||
argsForCall := fake.expectMessageArgsForCall[i]
|
||||
return argsForCall.arg1, argsForCall.arg2
|
||||
}
|
||||
|
||||
func (fake *FakeProtocol) ExpectMessageReturns(result1 rtmp.Message, result2 error) {
|
||||
fake.expectMessageMutex.Lock()
|
||||
defer fake.expectMessageMutex.Unlock()
|
||||
fake.ExpectMessageStub = nil
|
||||
fake.expectMessageReturns = struct {
|
||||
result1 rtmp.Message
|
||||
result2 error
|
||||
}{result1, result2}
|
||||
}
|
||||
|
||||
func (fake *FakeProtocol) ExpectMessageReturnsOnCall(i int, result1 rtmp.Message, result2 error) {
|
||||
fake.expectMessageMutex.Lock()
|
||||
defer fake.expectMessageMutex.Unlock()
|
||||
fake.ExpectMessageStub = nil
|
||||
if fake.expectMessageReturnsOnCall == nil {
|
||||
fake.expectMessageReturnsOnCall = make(map[int]struct {
|
||||
result1 rtmp.Message
|
||||
result2 error
|
||||
})
|
||||
}
|
||||
fake.expectMessageReturnsOnCall[i] = struct {
|
||||
result1 rtmp.Message
|
||||
result2 error
|
||||
}{result1, result2}
|
||||
}
|
||||
|
||||
func (fake *FakeProtocol) ExpectPacket(arg1 context.Context, arg2 any) (rtmp.Message, error) {
|
||||
fake.expectPacketMutex.Lock()
|
||||
ret, specificReturn := fake.expectPacketReturnsOnCall[len(fake.expectPacketArgsForCall)]
|
||||
fake.expectPacketArgsForCall = append(fake.expectPacketArgsForCall, struct {
|
||||
arg1 context.Context
|
||||
arg2 any
|
||||
}{arg1, arg2})
|
||||
stub := fake.ExpectPacketStub
|
||||
fakeReturns := fake.expectPacketReturns
|
||||
fake.recordInvocation("ExpectPacket", []interface{}{arg1, arg2})
|
||||
fake.expectPacketMutex.Unlock()
|
||||
if stub != nil {
|
||||
return stub(arg1, arg2)
|
||||
}
|
||||
if specificReturn {
|
||||
return ret.result1, ret.result2
|
||||
}
|
||||
return fakeReturns.result1, fakeReturns.result2
|
||||
}
|
||||
|
||||
func (fake *FakeProtocol) ExpectPacketCallCount() int {
|
||||
fake.expectPacketMutex.RLock()
|
||||
defer fake.expectPacketMutex.RUnlock()
|
||||
return len(fake.expectPacketArgsForCall)
|
||||
}
|
||||
|
||||
func (fake *FakeProtocol) ExpectPacketCalls(stub func(context.Context, any) (rtmp.Message, error)) {
|
||||
fake.expectPacketMutex.Lock()
|
||||
defer fake.expectPacketMutex.Unlock()
|
||||
fake.ExpectPacketStub = stub
|
||||
}
|
||||
|
||||
func (fake *FakeProtocol) ExpectPacketArgsForCall(i int) (context.Context, any) {
|
||||
fake.expectPacketMutex.RLock()
|
||||
defer fake.expectPacketMutex.RUnlock()
|
||||
argsForCall := fake.expectPacketArgsForCall[i]
|
||||
return argsForCall.arg1, argsForCall.arg2
|
||||
}
|
||||
|
||||
func (fake *FakeProtocol) ExpectPacketReturns(result1 rtmp.Message, result2 error) {
|
||||
fake.expectPacketMutex.Lock()
|
||||
defer fake.expectPacketMutex.Unlock()
|
||||
fake.ExpectPacketStub = nil
|
||||
fake.expectPacketReturns = struct {
|
||||
result1 rtmp.Message
|
||||
result2 error
|
||||
}{result1, result2}
|
||||
}
|
||||
|
||||
func (fake *FakeProtocol) ExpectPacketReturnsOnCall(i int, result1 rtmp.Message, result2 error) {
|
||||
fake.expectPacketMutex.Lock()
|
||||
defer fake.expectPacketMutex.Unlock()
|
||||
fake.ExpectPacketStub = nil
|
||||
if fake.expectPacketReturnsOnCall == nil {
|
||||
fake.expectPacketReturnsOnCall = make(map[int]struct {
|
||||
result1 rtmp.Message
|
||||
result2 error
|
||||
})
|
||||
}
|
||||
fake.expectPacketReturnsOnCall[i] = struct {
|
||||
result1 rtmp.Message
|
||||
result2 error
|
||||
}{result1, result2}
|
||||
}
|
||||
|
||||
func (fake *FakeProtocol) ReadMessage(arg1 context.Context) (rtmp.Message, error) {
|
||||
fake.readMessageMutex.Lock()
|
||||
ret, specificReturn := fake.readMessageReturnsOnCall[len(fake.readMessageArgsForCall)]
|
||||
fake.readMessageArgsForCall = append(fake.readMessageArgsForCall, struct {
|
||||
arg1 context.Context
|
||||
}{arg1})
|
||||
stub := fake.ReadMessageStub
|
||||
fakeReturns := fake.readMessageReturns
|
||||
fake.recordInvocation("ReadMessage", []interface{}{arg1})
|
||||
fake.readMessageMutex.Unlock()
|
||||
if stub != nil {
|
||||
return stub(arg1)
|
||||
}
|
||||
if specificReturn {
|
||||
return ret.result1, ret.result2
|
||||
}
|
||||
return fakeReturns.result1, fakeReturns.result2
|
||||
}
|
||||
|
||||
func (fake *FakeProtocol) ReadMessageCallCount() int {
|
||||
fake.readMessageMutex.RLock()
|
||||
defer fake.readMessageMutex.RUnlock()
|
||||
return len(fake.readMessageArgsForCall)
|
||||
}
|
||||
|
||||
func (fake *FakeProtocol) ReadMessageCalls(stub func(context.Context) (rtmp.Message, error)) {
|
||||
fake.readMessageMutex.Lock()
|
||||
defer fake.readMessageMutex.Unlock()
|
||||
fake.ReadMessageStub = stub
|
||||
}
|
||||
|
||||
func (fake *FakeProtocol) ReadMessageArgsForCall(i int) context.Context {
|
||||
fake.readMessageMutex.RLock()
|
||||
defer fake.readMessageMutex.RUnlock()
|
||||
argsForCall := fake.readMessageArgsForCall[i]
|
||||
return argsForCall.arg1
|
||||
}
|
||||
|
||||
func (fake *FakeProtocol) ReadMessageReturns(result1 rtmp.Message, result2 error) {
|
||||
fake.readMessageMutex.Lock()
|
||||
defer fake.readMessageMutex.Unlock()
|
||||
fake.ReadMessageStub = nil
|
||||
fake.readMessageReturns = struct {
|
||||
result1 rtmp.Message
|
||||
result2 error
|
||||
}{result1, result2}
|
||||
}
|
||||
|
||||
func (fake *FakeProtocol) ReadMessageReturnsOnCall(i int, result1 rtmp.Message, result2 error) {
|
||||
fake.readMessageMutex.Lock()
|
||||
defer fake.readMessageMutex.Unlock()
|
||||
fake.ReadMessageStub = nil
|
||||
if fake.readMessageReturnsOnCall == nil {
|
||||
fake.readMessageReturnsOnCall = make(map[int]struct {
|
||||
result1 rtmp.Message
|
||||
result2 error
|
||||
})
|
||||
}
|
||||
fake.readMessageReturnsOnCall[i] = struct {
|
||||
result1 rtmp.Message
|
||||
result2 error
|
||||
}{result1, result2}
|
||||
}
|
||||
|
||||
func (fake *FakeProtocol) WriteMessage(arg1 context.Context, arg2 rtmp.Message) error {
|
||||
fake.writeMessageMutex.Lock()
|
||||
ret, specificReturn := fake.writeMessageReturnsOnCall[len(fake.writeMessageArgsForCall)]
|
||||
fake.writeMessageArgsForCall = append(fake.writeMessageArgsForCall, struct {
|
||||
arg1 context.Context
|
||||
arg2 rtmp.Message
|
||||
}{arg1, arg2})
|
||||
stub := fake.WriteMessageStub
|
||||
fakeReturns := fake.writeMessageReturns
|
||||
fake.recordInvocation("WriteMessage", []interface{}{arg1, arg2})
|
||||
fake.writeMessageMutex.Unlock()
|
||||
if stub != nil {
|
||||
return stub(arg1, arg2)
|
||||
}
|
||||
if specificReturn {
|
||||
return ret.result1
|
||||
}
|
||||
return fakeReturns.result1
|
||||
}
|
||||
|
||||
func (fake *FakeProtocol) WriteMessageCallCount() int {
|
||||
fake.writeMessageMutex.RLock()
|
||||
defer fake.writeMessageMutex.RUnlock()
|
||||
return len(fake.writeMessageArgsForCall)
|
||||
}
|
||||
|
||||
func (fake *FakeProtocol) WriteMessageCalls(stub func(context.Context, rtmp.Message) error) {
|
||||
fake.writeMessageMutex.Lock()
|
||||
defer fake.writeMessageMutex.Unlock()
|
||||
fake.WriteMessageStub = stub
|
||||
}
|
||||
|
||||
func (fake *FakeProtocol) WriteMessageArgsForCall(i int) (context.Context, rtmp.Message) {
|
||||
fake.writeMessageMutex.RLock()
|
||||
defer fake.writeMessageMutex.RUnlock()
|
||||
argsForCall := fake.writeMessageArgsForCall[i]
|
||||
return argsForCall.arg1, argsForCall.arg2
|
||||
}
|
||||
|
||||
func (fake *FakeProtocol) WriteMessageReturns(result1 error) {
|
||||
fake.writeMessageMutex.Lock()
|
||||
defer fake.writeMessageMutex.Unlock()
|
||||
fake.WriteMessageStub = nil
|
||||
fake.writeMessageReturns = struct {
|
||||
result1 error
|
||||
}{result1}
|
||||
}
|
||||
|
||||
func (fake *FakeProtocol) WriteMessageReturnsOnCall(i int, result1 error) {
|
||||
fake.writeMessageMutex.Lock()
|
||||
defer fake.writeMessageMutex.Unlock()
|
||||
fake.WriteMessageStub = nil
|
||||
if fake.writeMessageReturnsOnCall == nil {
|
||||
fake.writeMessageReturnsOnCall = make(map[int]struct {
|
||||
result1 error
|
||||
})
|
||||
}
|
||||
fake.writeMessageReturnsOnCall[i] = struct {
|
||||
result1 error
|
||||
}{result1}
|
||||
}
|
||||
|
||||
func (fake *FakeProtocol) WritePacket(arg1 context.Context, arg2 rtmp.Packet, arg3 int) error {
|
||||
fake.writePacketMutex.Lock()
|
||||
ret, specificReturn := fake.writePacketReturnsOnCall[len(fake.writePacketArgsForCall)]
|
||||
fake.writePacketArgsForCall = append(fake.writePacketArgsForCall, struct {
|
||||
arg1 context.Context
|
||||
arg2 rtmp.Packet
|
||||
arg3 int
|
||||
}{arg1, arg2, arg3})
|
||||
stub := fake.WritePacketStub
|
||||
fakeReturns := fake.writePacketReturns
|
||||
fake.recordInvocation("WritePacket", []interface{}{arg1, arg2, arg3})
|
||||
fake.writePacketMutex.Unlock()
|
||||
if stub != nil {
|
||||
return stub(arg1, arg2, arg3)
|
||||
}
|
||||
if specificReturn {
|
||||
return ret.result1
|
||||
}
|
||||
return fakeReturns.result1
|
||||
}
|
||||
|
||||
func (fake *FakeProtocol) WritePacketCallCount() int {
|
||||
fake.writePacketMutex.RLock()
|
||||
defer fake.writePacketMutex.RUnlock()
|
||||
return len(fake.writePacketArgsForCall)
|
||||
}
|
||||
|
||||
func (fake *FakeProtocol) WritePacketCalls(stub func(context.Context, rtmp.Packet, int) error) {
|
||||
fake.writePacketMutex.Lock()
|
||||
defer fake.writePacketMutex.Unlock()
|
||||
fake.WritePacketStub = stub
|
||||
}
|
||||
|
||||
func (fake *FakeProtocol) WritePacketArgsForCall(i int) (context.Context, rtmp.Packet, int) {
|
||||
fake.writePacketMutex.RLock()
|
||||
defer fake.writePacketMutex.RUnlock()
|
||||
argsForCall := fake.writePacketArgsForCall[i]
|
||||
return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
|
||||
}
|
||||
|
||||
func (fake *FakeProtocol) WritePacketReturns(result1 error) {
|
||||
fake.writePacketMutex.Lock()
|
||||
defer fake.writePacketMutex.Unlock()
|
||||
fake.WritePacketStub = nil
|
||||
fake.writePacketReturns = struct {
|
||||
result1 error
|
||||
}{result1}
|
||||
}
|
||||
|
||||
func (fake *FakeProtocol) WritePacketReturnsOnCall(i int, result1 error) {
|
||||
fake.writePacketMutex.Lock()
|
||||
defer fake.writePacketMutex.Unlock()
|
||||
fake.WritePacketStub = nil
|
||||
if fake.writePacketReturnsOnCall == nil {
|
||||
fake.writePacketReturnsOnCall = make(map[int]struct {
|
||||
result1 error
|
||||
})
|
||||
}
|
||||
fake.writePacketReturnsOnCall[i] = struct {
|
||||
result1 error
|
||||
}{result1}
|
||||
}
|
||||
|
||||
func (fake *FakeProtocol) Invocations() map[string][][]interface{} {
|
||||
fake.invocationsMutex.RLock()
|
||||
defer fake.invocationsMutex.RUnlock()
|
||||
copiedInvocations := map[string][][]interface{}{}
|
||||
for key, value := range fake.invocations {
|
||||
copiedInvocations[key] = value
|
||||
}
|
||||
return copiedInvocations
|
||||
}
|
||||
|
||||
func (fake *FakeProtocol) recordInvocation(key string, args []interface{}) {
|
||||
fake.invocationsMutex.Lock()
|
||||
defer fake.invocationsMutex.Unlock()
|
||||
if fake.invocations == nil {
|
||||
fake.invocations = map[string][][]interface{}{}
|
||||
}
|
||||
if fake.invocations[key] == nil {
|
||||
fake.invocations[key] = [][]interface{}{}
|
||||
}
|
||||
fake.invocations[key] = append(fake.invocations[key], args)
|
||||
}
|
||||
|
||||
var _ rtmp.Protocol = new(FakeProtocol)
|
||||
Loading…
Reference in New Issue
Block a user