upstream-livekit/pkg/sfu/sfufakes/fake_track_sender.go

// Code generated by counterfeiter. DO NOT EDIT.
package sfufakes

import (
	"sync"

	"github.com/livekit/livekit-server/pkg/sfu"
	"github.com/livekit/livekit-server/pkg/sfu/buffer"
	"github.com/livekit/protocol/livekit"
	webrtc "github.com/pion/webrtc/v4"
)

type FakeTrackSender struct {
	CloseStub        func()
	closeMutex       sync.RWMutex
	closeArgsForCall []struct {
	}
	HandleRTCPSenderReportDataStub        func(webrtc.PayloadType, int32, *livekit.RTCPSenderReportState) error
	handleRTCPSenderReportDataMutex       sync.RWMutex
	handleRTCPSenderReportDataArgsForCall []struct {
		arg1 webrtc.PayloadType
		arg2 int32
		arg3 *livekit.RTCPSenderReportState
	}
	handleRTCPSenderReportDataReturns struct {
		result1 error
	}
	handleRTCPSenderReportDataReturnsOnCall map[int]struct {
		result1 error
	}
	IDStub        func() string
	iDMutex       sync.RWMutex
	iDArgsForCall []struct {
	}
	iDReturns struct {
		result1 string
	}
	iDReturnsOnCall map[int]struct {
		result1 string
	}
	IsClosedStub        func() bool
	isClosedMutex       sync.RWMutex
	isClosedArgsForCall []struct {
	}
	isClosedReturns struct {
		result1 bool
	}
	isClosedReturnsOnCall map[int]struct {
		result1 bool
	}
	ReceiverRestartStub        func(sfu.TrackReceiver)
	receiverRestartMutex       sync.RWMutex
	receiverRestartArgsForCall []struct {
		arg1 sfu.TrackReceiver
	}
	ResyncStub        func()
	resyncMutex       sync.RWMutex
	resyncArgsForCall []struct {
	}
	SetReceiverStub        func(sfu.TrackReceiver)
	setReceiverMutex       sync.RWMutex
	setReceiverArgsForCall []struct {
		arg1 sfu.TrackReceiver
	}
	SubscriberIDStub        func() livekit.ParticipantID
	subscriberIDMutex       sync.RWMutex
	subscriberIDArgsForCall []struct {
	}
	subscriberIDReturns struct {
		result1 livekit.ParticipantID
	}
	subscriberIDReturnsOnCall map[int]struct {
		result1 livekit.ParticipantID
	}
	UpTrackBitrateAvailabilityChangeStub        func()
	upTrackBitrateAvailabilityChangeMutex       sync.RWMutex
	upTrackBitrateAvailabilityChangeArgsForCall []struct {
	}
	UpTrackBitrateReportStub        func([]int32, sfu.Bitrates)
	upTrackBitrateReportMutex       sync.RWMutex
	upTrackBitrateReportArgsForCall []struct {
		arg1 []int32
		arg2 sfu.Bitrates
	}
	UpTrackLayersChangeStub        func()
	upTrackLayersChangeMutex       sync.RWMutex
	upTrackLayersChangeArgsForCall []struct {
	}
	UpTrackMaxPublishedLayerChangeStub        func(int32)
	upTrackMaxPublishedLayerChangeMutex       sync.RWMutex
	upTrackMaxPublishedLayerChangeArgsForCall []struct {
		arg1 int32
	}
	UpTrackMaxTemporalLayerSeenChangeStub        func(int32)
	upTrackMaxTemporalLayerSeenChangeMutex       sync.RWMutex
	upTrackMaxTemporalLayerSeenChangeArgsForCall []struct {
		arg1 int32
	}
	WriteRTPStub        func(*buffer.ExtPacket, int32) int32
	writeRTPMutex       sync.RWMutex
	writeRTPArgsForCall []struct {
		arg1 *buffer.ExtPacket
		arg2 int32
	}
	writeRTPReturns struct {
		result1 int32
	}
	writeRTPReturnsOnCall map[int]struct {
		result1 int32
	}
	invocations      map[string][][]interface{}
	invocationsMutex sync.RWMutex
}

func (fake *FakeTrackSender) Close() {
	fake.closeMutex.Lock()
	fake.closeArgsForCall = append(fake.closeArgsForCall, struct {
	}{})
	stub := fake.CloseStub
	fake.recordInvocation("Close", []interface{}{})
	fake.closeMutex.Unlock()
	if stub != nil {
		fake.CloseStub()
	}
}

func (fake *FakeTrackSender) CloseCallCount() int {
	fake.closeMutex.RLock()
	defer fake.closeMutex.RUnlock()
	return len(fake.closeArgsForCall)
}

func (fake *FakeTrackSender) CloseCalls(stub func()) {
	fake.closeMutex.Lock()
	defer fake.closeMutex.Unlock()
	fake.CloseStub = stub
}

func (fake *FakeTrackSender) HandleRTCPSenderReportData(arg1 webrtc.PayloadType, arg2 int32, arg3 *livekit.RTCPSenderReportState) error {
	fake.handleRTCPSenderReportDataMutex.Lock()
	ret, specificReturn := fake.handleRTCPSenderReportDataReturnsOnCall[len(fake.handleRTCPSenderReportDataArgsForCall)]
	fake.handleRTCPSenderReportDataArgsForCall = append(fake.handleRTCPSenderReportDataArgsForCall, struct {
		arg1 webrtc.PayloadType
		arg2 int32
		arg3 *livekit.RTCPSenderReportState
	}{arg1, arg2, arg3})
	stub := fake.HandleRTCPSenderReportDataStub
	fakeReturns := fake.handleRTCPSenderReportDataReturns
	fake.recordInvocation("HandleRTCPSenderReportData", []interface{}{arg1, arg2, arg3})
	fake.handleRTCPSenderReportDataMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeTrackSender) HandleRTCPSenderReportDataCallCount() int {
	fake.handleRTCPSenderReportDataMutex.RLock()
	defer fake.handleRTCPSenderReportDataMutex.RUnlock()
	return len(fake.handleRTCPSenderReportDataArgsForCall)
}

func (fake *FakeTrackSender) HandleRTCPSenderReportDataCalls(stub func(webrtc.PayloadType, int32, *livekit.RTCPSenderReportState) error) {
	fake.handleRTCPSenderReportDataMutex.Lock()
	defer fake.handleRTCPSenderReportDataMutex.Unlock()
	fake.HandleRTCPSenderReportDataStub = stub
}

func (fake *FakeTrackSender) HandleRTCPSenderReportDataArgsForCall(i int) (webrtc.PayloadType, int32, *livekit.RTCPSenderReportState) {
	fake.handleRTCPSenderReportDataMutex.RLock()
	defer fake.handleRTCPSenderReportDataMutex.RUnlock()
	argsForCall := fake.handleRTCPSenderReportDataArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeTrackSender) HandleRTCPSenderReportDataReturns(result1 error) {
	fake.handleRTCPSenderReportDataMutex.Lock()
	defer fake.handleRTCPSenderReportDataMutex.Unlock()
	fake.HandleRTCPSenderReportDataStub = nil
	fake.handleRTCPSenderReportDataReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeTrackSender) HandleRTCPSenderReportDataReturnsOnCall(i int, result1 error) {
	fake.handleRTCPSenderReportDataMutex.Lock()
	defer fake.handleRTCPSenderReportDataMutex.Unlock()
	fake.HandleRTCPSenderReportDataStub = nil
	if fake.handleRTCPSenderReportDataReturnsOnCall == nil {
		fake.handleRTCPSenderReportDataReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.handleRTCPSenderReportDataReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeTrackSender) ID() string {
	fake.iDMutex.Lock()
	ret, specificReturn := fake.iDReturnsOnCall[len(fake.iDArgsForCall)]
	fake.iDArgsForCall = append(fake.iDArgsForCall, struct {
	}{})
	stub := fake.IDStub
	fakeReturns := fake.iDReturns
	fake.recordInvocation("ID", []interface{}{})
	fake.iDMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeTrackSender) IDCallCount() int {
	fake.iDMutex.RLock()
	defer fake.iDMutex.RUnlock()
	return len(fake.iDArgsForCall)
}

func (fake *FakeTrackSender) IDCalls(stub func() string) {
	fake.iDMutex.Lock()
	defer fake.iDMutex.Unlock()
	fake.IDStub = stub
}

func (fake *FakeTrackSender) IDReturns(result1 string) {
	fake.iDMutex.Lock()
	defer fake.iDMutex.Unlock()
	fake.IDStub = nil
	fake.iDReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeTrackSender) IDReturnsOnCall(i int, result1 string) {
	fake.iDMutex.Lock()
	defer fake.iDMutex.Unlock()
	fake.IDStub = nil
	if fake.iDReturnsOnCall == nil {
		fake.iDReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.iDReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeTrackSender) IsClosed() bool {
	fake.isClosedMutex.Lock()
	ret, specificReturn := fake.isClosedReturnsOnCall[len(fake.isClosedArgsForCall)]
	fake.isClosedArgsForCall = append(fake.isClosedArgsForCall, struct {
	}{})
	stub := fake.IsClosedStub
	fakeReturns := fake.isClosedReturns
	fake.recordInvocation("IsClosed", []interface{}{})
	fake.isClosedMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeTrackSender) IsClosedCallCount() int {
	fake.isClosedMutex.RLock()
	defer fake.isClosedMutex.RUnlock()
	return len(fake.isClosedArgsForCall)
}

func (fake *FakeTrackSender) IsClosedCalls(stub func() bool) {
	fake.isClosedMutex.Lock()
	defer fake.isClosedMutex.Unlock()
	fake.IsClosedStub = stub
}

func (fake *FakeTrackSender) IsClosedReturns(result1 bool) {
	fake.isClosedMutex.Lock()
	defer fake.isClosedMutex.Unlock()
	fake.IsClosedStub = nil
	fake.isClosedReturns = struct {
		result1 bool
	}{result1}
}

func (fake *FakeTrackSender) IsClosedReturnsOnCall(i int, result1 bool) {
	fake.isClosedMutex.Lock()
	defer fake.isClosedMutex.Unlock()
	fake.IsClosedStub = nil
	if fake.isClosedReturnsOnCall == nil {
		fake.isClosedReturnsOnCall = make(map[int]struct {
			result1 bool
		})
	}
	fake.isClosedReturnsOnCall[i] = struct {
		result1 bool
	}{result1}
}

func (fake *FakeTrackSender) ReceiverRestart(arg1 sfu.TrackReceiver) {
	fake.receiverRestartMutex.Lock()
	fake.receiverRestartArgsForCall = append(fake.receiverRestartArgsForCall, struct {
		arg1 sfu.TrackReceiver
	}{arg1})
	stub := fake.ReceiverRestartStub
	fake.recordInvocation("ReceiverRestart", []interface{}{arg1})
	fake.receiverRestartMutex.Unlock()
	if stub != nil {
		fake.ReceiverRestartStub(arg1)
	}
}

func (fake *FakeTrackSender) ReceiverRestartCallCount() int {
	fake.receiverRestartMutex.RLock()
	defer fake.receiverRestartMutex.RUnlock()
	return len(fake.receiverRestartArgsForCall)
}

func (fake *FakeTrackSender) ReceiverRestartCalls(stub func(sfu.TrackReceiver)) {
	fake.receiverRestartMutex.Lock()
	defer fake.receiverRestartMutex.Unlock()
	fake.ReceiverRestartStub = stub
}

func (fake *FakeTrackSender) ReceiverRestartArgsForCall(i int) sfu.TrackReceiver {
	fake.receiverRestartMutex.RLock()
	defer fake.receiverRestartMutex.RUnlock()
	argsForCall := fake.receiverRestartArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeTrackSender) Resync() {
	fake.resyncMutex.Lock()
	fake.resyncArgsForCall = append(fake.resyncArgsForCall, struct {
	}{})
	stub := fake.ResyncStub
	fake.recordInvocation("Resync", []interface{}{})
	fake.resyncMutex.Unlock()
	if stub != nil {
		fake.ResyncStub()
	}
}

func (fake *FakeTrackSender) ResyncCallCount() int {
	fake.resyncMutex.RLock()
	defer fake.resyncMutex.RUnlock()
	return len(fake.resyncArgsForCall)
}

func (fake *FakeTrackSender) ResyncCalls(stub func()) {
	fake.resyncMutex.Lock()
	defer fake.resyncMutex.Unlock()
	fake.ResyncStub = stub
}

func (fake *FakeTrackSender) SetReceiver(arg1 sfu.TrackReceiver) {
	fake.setReceiverMutex.Lock()
	fake.setReceiverArgsForCall = append(fake.setReceiverArgsForCall, struct {
		arg1 sfu.TrackReceiver
	}{arg1})
	stub := fake.SetReceiverStub
	fake.recordInvocation("SetReceiver", []interface{}{arg1})
	fake.setReceiverMutex.Unlock()
	if stub != nil {
		fake.SetReceiverStub(arg1)
	}
}

func (fake *FakeTrackSender) SetReceiverCallCount() int {
	fake.setReceiverMutex.RLock()
	defer fake.setReceiverMutex.RUnlock()
	return len(fake.setReceiverArgsForCall)
}

func (fake *FakeTrackSender) SetReceiverCalls(stub func(sfu.TrackReceiver)) {
	fake.setReceiverMutex.Lock()
	defer fake.setReceiverMutex.Unlock()
	fake.SetReceiverStub = stub
}

func (fake *FakeTrackSender) SetReceiverArgsForCall(i int) sfu.TrackReceiver {
	fake.setReceiverMutex.RLock()
	defer fake.setReceiverMutex.RUnlock()
	argsForCall := fake.setReceiverArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeTrackSender) SubscriberID() livekit.ParticipantID {
	fake.subscriberIDMutex.Lock()
	ret, specificReturn := fake.subscriberIDReturnsOnCall[len(fake.subscriberIDArgsForCall)]
	fake.subscriberIDArgsForCall = append(fake.subscriberIDArgsForCall, struct {
	}{})
	stub := fake.SubscriberIDStub
	fakeReturns := fake.subscriberIDReturns
	fake.recordInvocation("SubscriberID", []interface{}{})
	fake.subscriberIDMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeTrackSender) SubscriberIDCallCount() int {
	fake.subscriberIDMutex.RLock()
	defer fake.subscriberIDMutex.RUnlock()
	return len(fake.subscriberIDArgsForCall)
}

func (fake *FakeTrackSender) SubscriberIDCalls(stub func() livekit.ParticipantID) {
	fake.subscriberIDMutex.Lock()
	defer fake.subscriberIDMutex.Unlock()
	fake.SubscriberIDStub = stub
}

func (fake *FakeTrackSender) SubscriberIDReturns(result1 livekit.ParticipantID) {
	fake.subscriberIDMutex.Lock()
	defer fake.subscriberIDMutex.Unlock()
	fake.SubscriberIDStub = nil
	fake.subscriberIDReturns = struct {
		result1 livekit.ParticipantID
	}{result1}
}

func (fake *FakeTrackSender) SubscriberIDReturnsOnCall(i int, result1 livekit.ParticipantID) {
	fake.subscriberIDMutex.Lock()
	defer fake.subscriberIDMutex.Unlock()
	fake.SubscriberIDStub = nil
	if fake.subscriberIDReturnsOnCall == nil {
		fake.subscriberIDReturnsOnCall = make(map[int]struct {
			result1 livekit.ParticipantID
		})
	}
	fake.subscriberIDReturnsOnCall[i] = struct {
		result1 livekit.ParticipantID
	}{result1}
}

func (fake *FakeTrackSender) UpTrackBitrateAvailabilityChange() {
	fake.upTrackBitrateAvailabilityChangeMutex.Lock()
	fake.upTrackBitrateAvailabilityChangeArgsForCall = append(fake.upTrackBitrateAvailabilityChangeArgsForCall, struct {
	}{})
	stub := fake.UpTrackBitrateAvailabilityChangeStub
	fake.recordInvocation("UpTrackBitrateAvailabilityChange", []interface{}{})
	fake.upTrackBitrateAvailabilityChangeMutex.Unlock()
	if stub != nil {
		fake.UpTrackBitrateAvailabilityChangeStub()
	}
}

func (fake *FakeTrackSender) UpTrackBitrateAvailabilityChangeCallCount() int {
	fake.upTrackBitrateAvailabilityChangeMutex.RLock()
	defer fake.upTrackBitrateAvailabilityChangeMutex.RUnlock()
	return len(fake.upTrackBitrateAvailabilityChangeArgsForCall)
}

func (fake *FakeTrackSender) UpTrackBitrateAvailabilityChangeCalls(stub func()) {
	fake.upTrackBitrateAvailabilityChangeMutex.Lock()
	defer fake.upTrackBitrateAvailabilityChangeMutex.Unlock()
	fake.UpTrackBitrateAvailabilityChangeStub = stub
}

func (fake *FakeTrackSender) UpTrackBitrateReport(arg1 []int32, arg2 sfu.Bitrates) {
	var arg1Copy []int32
	if arg1 != nil {
		arg1Copy = make([]int32, len(arg1))
		copy(arg1Copy, arg1)
	}
	fake.upTrackBitrateReportMutex.Lock()
	fake.upTrackBitrateReportArgsForCall = append(fake.upTrackBitrateReportArgsForCall, struct {
		arg1 []int32
		arg2 sfu.Bitrates
	}{arg1Copy, arg2})
	stub := fake.UpTrackBitrateReportStub
	fake.recordInvocation("UpTrackBitrateReport", []interface{}{arg1Copy, arg2})
	fake.upTrackBitrateReportMutex.Unlock()
	if stub != nil {
		fake.UpTrackBitrateReportStub(arg1, arg2)
	}
}

func (fake *FakeTrackSender) UpTrackBitrateReportCallCount() int {
	fake.upTrackBitrateReportMutex.RLock()
	defer fake.upTrackBitrateReportMutex.RUnlock()
	return len(fake.upTrackBitrateReportArgsForCall)
}

func (fake *FakeTrackSender) UpTrackBitrateReportCalls(stub func([]int32, sfu.Bitrates)) {
	fake.upTrackBitrateReportMutex.Lock()
	defer fake.upTrackBitrateReportMutex.Unlock()
	fake.UpTrackBitrateReportStub = stub
}

func (fake *FakeTrackSender) UpTrackBitrateReportArgsForCall(i int) ([]int32, sfu.Bitrates) {
	fake.upTrackBitrateReportMutex.RLock()
	defer fake.upTrackBitrateReportMutex.RUnlock()
	argsForCall := fake.upTrackBitrateReportArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeTrackSender) UpTrackLayersChange() {
	fake.upTrackLayersChangeMutex.Lock()
	fake.upTrackLayersChangeArgsForCall = append(fake.upTrackLayersChangeArgsForCall, struct {
	}{})
	stub := fake.UpTrackLayersChangeStub
	fake.recordInvocation("UpTrackLayersChange", []interface{}{})
	fake.upTrackLayersChangeMutex.Unlock()
	if stub != nil {
		fake.UpTrackLayersChangeStub()
	}
}

func (fake *FakeTrackSender) UpTrackLayersChangeCallCount() int {
	fake.upTrackLayersChangeMutex.RLock()
	defer fake.upTrackLayersChangeMutex.RUnlock()
	return len(fake.upTrackLayersChangeArgsForCall)
}

func (fake *FakeTrackSender) UpTrackLayersChangeCalls(stub func()) {
	fake.upTrackLayersChangeMutex.Lock()
	defer fake.upTrackLayersChangeMutex.Unlock()
	fake.UpTrackLayersChangeStub = stub
}

func (fake *FakeTrackSender) UpTrackMaxPublishedLayerChange(arg1 int32) {
	fake.upTrackMaxPublishedLayerChangeMutex.Lock()
	fake.upTrackMaxPublishedLayerChangeArgsForCall = append(fake.upTrackMaxPublishedLayerChangeArgsForCall, struct {
		arg1 int32
	}{arg1})
	stub := fake.UpTrackMaxPublishedLayerChangeStub
	fake.recordInvocation("UpTrackMaxPublishedLayerChange", []interface{}{arg1})
	fake.upTrackMaxPublishedLayerChangeMutex.Unlock()
	if stub != nil {
		fake.UpTrackMaxPublishedLayerChangeStub(arg1)
	}
}

func (fake *FakeTrackSender) UpTrackMaxPublishedLayerChangeCallCount() int {
	fake.upTrackMaxPublishedLayerChangeMutex.RLock()
	defer fake.upTrackMaxPublishedLayerChangeMutex.RUnlock()
	return len(fake.upTrackMaxPublishedLayerChangeArgsForCall)
}

func (fake *FakeTrackSender) UpTrackMaxPublishedLayerChangeCalls(stub func(int32)) {
	fake.upTrackMaxPublishedLayerChangeMutex.Lock()
	defer fake.upTrackMaxPublishedLayerChangeMutex.Unlock()
	fake.UpTrackMaxPublishedLayerChangeStub = stub
}

func (fake *FakeTrackSender) UpTrackMaxPublishedLayerChangeArgsForCall(i int) int32 {
	fake.upTrackMaxPublishedLayerChangeMutex.RLock()
	defer fake.upTrackMaxPublishedLayerChangeMutex.RUnlock()
	argsForCall := fake.upTrackMaxPublishedLayerChangeArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeTrackSender) UpTrackMaxTemporalLayerSeenChange(arg1 int32) {
	fake.upTrackMaxTemporalLayerSeenChangeMutex.Lock()
	fake.upTrackMaxTemporalLayerSeenChangeArgsForCall = append(fake.upTrackMaxTemporalLayerSeenChangeArgsForCall, struct {
		arg1 int32
	}{arg1})
	stub := fake.UpTrackMaxTemporalLayerSeenChangeStub
	fake.recordInvocation("UpTrackMaxTemporalLayerSeenChange", []interface{}{arg1})
	fake.upTrackMaxTemporalLayerSeenChangeMutex.Unlock()
	if stub != nil {
		fake.UpTrackMaxTemporalLayerSeenChangeStub(arg1)
	}
}

func (fake *FakeTrackSender) UpTrackMaxTemporalLayerSeenChangeCallCount() int {
	fake.upTrackMaxTemporalLayerSeenChangeMutex.RLock()
	defer fake.upTrackMaxTemporalLayerSeenChangeMutex.RUnlock()
	return len(fake.upTrackMaxTemporalLayerSeenChangeArgsForCall)
}

func (fake *FakeTrackSender) UpTrackMaxTemporalLayerSeenChangeCalls(stub func(int32)) {
	fake.upTrackMaxTemporalLayerSeenChangeMutex.Lock()
	defer fake.upTrackMaxTemporalLayerSeenChangeMutex.Unlock()
	fake.UpTrackMaxTemporalLayerSeenChangeStub = stub
}

func (fake *FakeTrackSender) UpTrackMaxTemporalLayerSeenChangeArgsForCall(i int) int32 {
	fake.upTrackMaxTemporalLayerSeenChangeMutex.RLock()
	defer fake.upTrackMaxTemporalLayerSeenChangeMutex.RUnlock()
	argsForCall := fake.upTrackMaxTemporalLayerSeenChangeArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeTrackSender) WriteRTP(arg1 *buffer.ExtPacket, arg2 int32) int32 {
	fake.writeRTPMutex.Lock()
	ret, specificReturn := fake.writeRTPReturnsOnCall[len(fake.writeRTPArgsForCall)]
	fake.writeRTPArgsForCall = append(fake.writeRTPArgsForCall, struct {
		arg1 *buffer.ExtPacket
		arg2 int32
	}{arg1, arg2})
	stub := fake.WriteRTPStub
	fakeReturns := fake.writeRTPReturns
	fake.recordInvocation("WriteRTP", []interface{}{arg1, arg2})
	fake.writeRTPMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeTrackSender) WriteRTPCallCount() int {
	fake.writeRTPMutex.RLock()
	defer fake.writeRTPMutex.RUnlock()
	return len(fake.writeRTPArgsForCall)
}

func (fake *FakeTrackSender) WriteRTPCalls(stub func(*buffer.ExtPacket, int32) int32) {
	fake.writeRTPMutex.Lock()
	defer fake.writeRTPMutex.Unlock()
	fake.WriteRTPStub = stub
}

func (fake *FakeTrackSender) WriteRTPArgsForCall(i int) (*buffer.ExtPacket, int32) {
	fake.writeRTPMutex.RLock()
	defer fake.writeRTPMutex.RUnlock()
	argsForCall := fake.writeRTPArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeTrackSender) WriteRTPReturns(result1 int32) {
	fake.writeRTPMutex.Lock()
	defer fake.writeRTPMutex.Unlock()
	fake.WriteRTPStub = nil
	fake.writeRTPReturns = struct {
		result1 int32
	}{result1}
}

func (fake *FakeTrackSender) WriteRTPReturnsOnCall(i int, result1 int32) {
	fake.writeRTPMutex.Lock()
	defer fake.writeRTPMutex.Unlock()
	fake.WriteRTPStub = nil
	if fake.writeRTPReturnsOnCall == nil {
		fake.writeRTPReturnsOnCall = make(map[int]struct {
			result1 int32
		})
	}
	fake.writeRTPReturnsOnCall[i] = struct {
		result1 int32
	}{result1}
}

func (fake *FakeTrackSender) 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 *FakeTrackSender) 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 _ sfu.TrackSender = new(FakeTrackSender)