// 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)