// 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/livekit-server/pkg/sfu/bwe"
	"github.com/pion/rtcp"
)

type FakeDownTrackStreamAllocatorListener struct {
	BWETypeStub        func() bwe.BWEType
	bWETypeMutex       sync.RWMutex
	bWETypeArgsForCall []struct {
	}
	bWETypeReturns struct {
		result1 bwe.BWEType
	}
	bWETypeReturnsOnCall map[int]struct {
		result1 bwe.BWEType
	}
	IsBWEEnabledStub        func(*sfu.DownTrack) bool
	isBWEEnabledMutex       sync.RWMutex
	isBWEEnabledArgsForCall []struct {
		arg1 *sfu.DownTrack
	}
	isBWEEnabledReturns struct {
		result1 bool
	}
	isBWEEnabledReturnsOnCall map[int]struct {
		result1 bool
	}
	IsSubscribeMutableStub        func(*sfu.DownTrack) bool
	isSubscribeMutableMutex       sync.RWMutex
	isSubscribeMutableArgsForCall []struct {
		arg1 *sfu.DownTrack
	}
	isSubscribeMutableReturns struct {
		result1 bool
	}
	isSubscribeMutableReturnsOnCall map[int]struct {
		result1 bool
	}
	OnAvailableLayersChangedStub        func(*sfu.DownTrack)
	onAvailableLayersChangedMutex       sync.RWMutex
	onAvailableLayersChangedArgsForCall []struct {
		arg1 *sfu.DownTrack
	}
	OnBitrateAvailabilityChangedStub        func(*sfu.DownTrack)
	onBitrateAvailabilityChangedMutex       sync.RWMutex
	onBitrateAvailabilityChangedArgsForCall []struct {
		arg1 *sfu.DownTrack
	}
	OnMaxPublishedSpatialChangedStub        func(*sfu.DownTrack)
	onMaxPublishedSpatialChangedMutex       sync.RWMutex
	onMaxPublishedSpatialChangedArgsForCall []struct {
		arg1 *sfu.DownTrack
	}
	OnMaxPublishedTemporalChangedStub        func(*sfu.DownTrack)
	onMaxPublishedTemporalChangedMutex       sync.RWMutex
	onMaxPublishedTemporalChangedArgsForCall []struct {
		arg1 *sfu.DownTrack
	}
	OnREMBStub        func(*sfu.DownTrack, *rtcp.ReceiverEstimatedMaximumBitrate)
	onREMBMutex       sync.RWMutex
	onREMBArgsForCall []struct {
		arg1 *sfu.DownTrack
		arg2 *rtcp.ReceiverEstimatedMaximumBitrate
	}
	OnResumeStub        func(*sfu.DownTrack)
	onResumeMutex       sync.RWMutex
	onResumeArgsForCall []struct {
		arg1 *sfu.DownTrack
	}
	OnSubscribedLayerChangedStub        func(*sfu.DownTrack, buffer.VideoLayer)
	onSubscribedLayerChangedMutex       sync.RWMutex
	onSubscribedLayerChangedArgsForCall []struct {
		arg1 *sfu.DownTrack
		arg2 buffer.VideoLayer
	}
	OnSubscriptionChangedStub        func(*sfu.DownTrack)
	onSubscriptionChangedMutex       sync.RWMutex
	onSubscriptionChangedArgsForCall []struct {
		arg1 *sfu.DownTrack
	}
	OnTransportCCFeedbackStub        func(*sfu.DownTrack, *rtcp.TransportLayerCC)
	onTransportCCFeedbackMutex       sync.RWMutex
	onTransportCCFeedbackArgsForCall []struct {
		arg1 *sfu.DownTrack
		arg2 *rtcp.TransportLayerCC
	}
	invocations      map[string][][]interface{}
	invocationsMutex sync.RWMutex
}

func (fake *FakeDownTrackStreamAllocatorListener) BWEType() bwe.BWEType {
	fake.bWETypeMutex.Lock()
	ret, specificReturn := fake.bWETypeReturnsOnCall[len(fake.bWETypeArgsForCall)]
	fake.bWETypeArgsForCall = append(fake.bWETypeArgsForCall, struct {
	}{})
	stub := fake.BWETypeStub
	fakeReturns := fake.bWETypeReturns
	fake.recordInvocation("BWEType", []interface{}{})
	fake.bWETypeMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeDownTrackStreamAllocatorListener) BWETypeCallCount() int {
	fake.bWETypeMutex.RLock()
	defer fake.bWETypeMutex.RUnlock()
	return len(fake.bWETypeArgsForCall)
}

func (fake *FakeDownTrackStreamAllocatorListener) BWETypeCalls(stub func() bwe.BWEType) {
	fake.bWETypeMutex.Lock()
	defer fake.bWETypeMutex.Unlock()
	fake.BWETypeStub = stub
}

func (fake *FakeDownTrackStreamAllocatorListener) BWETypeReturns(result1 bwe.BWEType) {
	fake.bWETypeMutex.Lock()
	defer fake.bWETypeMutex.Unlock()
	fake.BWETypeStub = nil
	fake.bWETypeReturns = struct {
		result1 bwe.BWEType
	}{result1}
}

func (fake *FakeDownTrackStreamAllocatorListener) BWETypeReturnsOnCall(i int, result1 bwe.BWEType) {
	fake.bWETypeMutex.Lock()
	defer fake.bWETypeMutex.Unlock()
	fake.BWETypeStub = nil
	if fake.bWETypeReturnsOnCall == nil {
		fake.bWETypeReturnsOnCall = make(map[int]struct {
			result1 bwe.BWEType
		})
	}
	fake.bWETypeReturnsOnCall[i] = struct {
		result1 bwe.BWEType
	}{result1}
}

func (fake *FakeDownTrackStreamAllocatorListener) IsBWEEnabled(arg1 *sfu.DownTrack) bool {
	fake.isBWEEnabledMutex.Lock()
	ret, specificReturn := fake.isBWEEnabledReturnsOnCall[len(fake.isBWEEnabledArgsForCall)]
	fake.isBWEEnabledArgsForCall = append(fake.isBWEEnabledArgsForCall, struct {
		arg1 *sfu.DownTrack
	}{arg1})
	stub := fake.IsBWEEnabledStub
	fakeReturns := fake.isBWEEnabledReturns
	fake.recordInvocation("IsBWEEnabled", []interface{}{arg1})
	fake.isBWEEnabledMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeDownTrackStreamAllocatorListener) IsBWEEnabledCallCount() int {
	fake.isBWEEnabledMutex.RLock()
	defer fake.isBWEEnabledMutex.RUnlock()
	return len(fake.isBWEEnabledArgsForCall)
}

func (fake *FakeDownTrackStreamAllocatorListener) IsBWEEnabledCalls(stub func(*sfu.DownTrack) bool) {
	fake.isBWEEnabledMutex.Lock()
	defer fake.isBWEEnabledMutex.Unlock()
	fake.IsBWEEnabledStub = stub
}

func (fake *FakeDownTrackStreamAllocatorListener) IsBWEEnabledArgsForCall(i int) *sfu.DownTrack {
	fake.isBWEEnabledMutex.RLock()
	defer fake.isBWEEnabledMutex.RUnlock()
	argsForCall := fake.isBWEEnabledArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeDownTrackStreamAllocatorListener) IsBWEEnabledReturns(result1 bool) {
	fake.isBWEEnabledMutex.Lock()
	defer fake.isBWEEnabledMutex.Unlock()
	fake.IsBWEEnabledStub = nil
	fake.isBWEEnabledReturns = struct {
		result1 bool
	}{result1}
}

func (fake *FakeDownTrackStreamAllocatorListener) IsBWEEnabledReturnsOnCall(i int, result1 bool) {
	fake.isBWEEnabledMutex.Lock()
	defer fake.isBWEEnabledMutex.Unlock()
	fake.IsBWEEnabledStub = nil
	if fake.isBWEEnabledReturnsOnCall == nil {
		fake.isBWEEnabledReturnsOnCall = make(map[int]struct {
			result1 bool
		})
	}
	fake.isBWEEnabledReturnsOnCall[i] = struct {
		result1 bool
	}{result1}
}

func (fake *FakeDownTrackStreamAllocatorListener) IsSubscribeMutable(arg1 *sfu.DownTrack) bool {
	fake.isSubscribeMutableMutex.Lock()
	ret, specificReturn := fake.isSubscribeMutableReturnsOnCall[len(fake.isSubscribeMutableArgsForCall)]
	fake.isSubscribeMutableArgsForCall = append(fake.isSubscribeMutableArgsForCall, struct {
		arg1 *sfu.DownTrack
	}{arg1})
	stub := fake.IsSubscribeMutableStub
	fakeReturns := fake.isSubscribeMutableReturns
	fake.recordInvocation("IsSubscribeMutable", []interface{}{arg1})
	fake.isSubscribeMutableMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeDownTrackStreamAllocatorListener) IsSubscribeMutableCallCount() int {
	fake.isSubscribeMutableMutex.RLock()
	defer fake.isSubscribeMutableMutex.RUnlock()
	return len(fake.isSubscribeMutableArgsForCall)
}

func (fake *FakeDownTrackStreamAllocatorListener) IsSubscribeMutableCalls(stub func(*sfu.DownTrack) bool) {
	fake.isSubscribeMutableMutex.Lock()
	defer fake.isSubscribeMutableMutex.Unlock()
	fake.IsSubscribeMutableStub = stub
}

func (fake *FakeDownTrackStreamAllocatorListener) IsSubscribeMutableArgsForCall(i int) *sfu.DownTrack {
	fake.isSubscribeMutableMutex.RLock()
	defer fake.isSubscribeMutableMutex.RUnlock()
	argsForCall := fake.isSubscribeMutableArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeDownTrackStreamAllocatorListener) IsSubscribeMutableReturns(result1 bool) {
	fake.isSubscribeMutableMutex.Lock()
	defer fake.isSubscribeMutableMutex.Unlock()
	fake.IsSubscribeMutableStub = nil
	fake.isSubscribeMutableReturns = struct {
		result1 bool
	}{result1}
}

func (fake *FakeDownTrackStreamAllocatorListener) IsSubscribeMutableReturnsOnCall(i int, result1 bool) {
	fake.isSubscribeMutableMutex.Lock()
	defer fake.isSubscribeMutableMutex.Unlock()
	fake.IsSubscribeMutableStub = nil
	if fake.isSubscribeMutableReturnsOnCall == nil {
		fake.isSubscribeMutableReturnsOnCall = make(map[int]struct {
			result1 bool
		})
	}
	fake.isSubscribeMutableReturnsOnCall[i] = struct {
		result1 bool
	}{result1}
}

func (fake *FakeDownTrackStreamAllocatorListener) OnAvailableLayersChanged(arg1 *sfu.DownTrack) {
	fake.onAvailableLayersChangedMutex.Lock()
	fake.onAvailableLayersChangedArgsForCall = append(fake.onAvailableLayersChangedArgsForCall, struct {
		arg1 *sfu.DownTrack
	}{arg1})
	stub := fake.OnAvailableLayersChangedStub
	fake.recordInvocation("OnAvailableLayersChanged", []interface{}{arg1})
	fake.onAvailableLayersChangedMutex.Unlock()
	if stub != nil {
		fake.OnAvailableLayersChangedStub(arg1)
	}
}

func (fake *FakeDownTrackStreamAllocatorListener) OnAvailableLayersChangedCallCount() int {
	fake.onAvailableLayersChangedMutex.RLock()
	defer fake.onAvailableLayersChangedMutex.RUnlock()
	return len(fake.onAvailableLayersChangedArgsForCall)
}

func (fake *FakeDownTrackStreamAllocatorListener) OnAvailableLayersChangedCalls(stub func(*sfu.DownTrack)) {
	fake.onAvailableLayersChangedMutex.Lock()
	defer fake.onAvailableLayersChangedMutex.Unlock()
	fake.OnAvailableLayersChangedStub = stub
}

func (fake *FakeDownTrackStreamAllocatorListener) OnAvailableLayersChangedArgsForCall(i int) *sfu.DownTrack {
	fake.onAvailableLayersChangedMutex.RLock()
	defer fake.onAvailableLayersChangedMutex.RUnlock()
	argsForCall := fake.onAvailableLayersChangedArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeDownTrackStreamAllocatorListener) OnBitrateAvailabilityChanged(arg1 *sfu.DownTrack) {
	fake.onBitrateAvailabilityChangedMutex.Lock()
	fake.onBitrateAvailabilityChangedArgsForCall = append(fake.onBitrateAvailabilityChangedArgsForCall, struct {
		arg1 *sfu.DownTrack
	}{arg1})
	stub := fake.OnBitrateAvailabilityChangedStub
	fake.recordInvocation("OnBitrateAvailabilityChanged", []interface{}{arg1})
	fake.onBitrateAvailabilityChangedMutex.Unlock()
	if stub != nil {
		fake.OnBitrateAvailabilityChangedStub(arg1)
	}
}

func (fake *FakeDownTrackStreamAllocatorListener) OnBitrateAvailabilityChangedCallCount() int {
	fake.onBitrateAvailabilityChangedMutex.RLock()
	defer fake.onBitrateAvailabilityChangedMutex.RUnlock()
	return len(fake.onBitrateAvailabilityChangedArgsForCall)
}

func (fake *FakeDownTrackStreamAllocatorListener) OnBitrateAvailabilityChangedCalls(stub func(*sfu.DownTrack)) {
	fake.onBitrateAvailabilityChangedMutex.Lock()
	defer fake.onBitrateAvailabilityChangedMutex.Unlock()
	fake.OnBitrateAvailabilityChangedStub = stub
}

func (fake *FakeDownTrackStreamAllocatorListener) OnBitrateAvailabilityChangedArgsForCall(i int) *sfu.DownTrack {
	fake.onBitrateAvailabilityChangedMutex.RLock()
	defer fake.onBitrateAvailabilityChangedMutex.RUnlock()
	argsForCall := fake.onBitrateAvailabilityChangedArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeDownTrackStreamAllocatorListener) OnMaxPublishedSpatialChanged(arg1 *sfu.DownTrack) {
	fake.onMaxPublishedSpatialChangedMutex.Lock()
	fake.onMaxPublishedSpatialChangedArgsForCall = append(fake.onMaxPublishedSpatialChangedArgsForCall, struct {
		arg1 *sfu.DownTrack
	}{arg1})
	stub := fake.OnMaxPublishedSpatialChangedStub
	fake.recordInvocation("OnMaxPublishedSpatialChanged", []interface{}{arg1})
	fake.onMaxPublishedSpatialChangedMutex.Unlock()
	if stub != nil {
		fake.OnMaxPublishedSpatialChangedStub(arg1)
	}
}

func (fake *FakeDownTrackStreamAllocatorListener) OnMaxPublishedSpatialChangedCallCount() int {
	fake.onMaxPublishedSpatialChangedMutex.RLock()
	defer fake.onMaxPublishedSpatialChangedMutex.RUnlock()
	return len(fake.onMaxPublishedSpatialChangedArgsForCall)
}

func (fake *FakeDownTrackStreamAllocatorListener) OnMaxPublishedSpatialChangedCalls(stub func(*sfu.DownTrack)) {
	fake.onMaxPublishedSpatialChangedMutex.Lock()
	defer fake.onMaxPublishedSpatialChangedMutex.Unlock()
	fake.OnMaxPublishedSpatialChangedStub = stub
}

func (fake *FakeDownTrackStreamAllocatorListener) OnMaxPublishedSpatialChangedArgsForCall(i int) *sfu.DownTrack {
	fake.onMaxPublishedSpatialChangedMutex.RLock()
	defer fake.onMaxPublishedSpatialChangedMutex.RUnlock()
	argsForCall := fake.onMaxPublishedSpatialChangedArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeDownTrackStreamAllocatorListener) OnMaxPublishedTemporalChanged(arg1 *sfu.DownTrack) {
	fake.onMaxPublishedTemporalChangedMutex.Lock()
	fake.onMaxPublishedTemporalChangedArgsForCall = append(fake.onMaxPublishedTemporalChangedArgsForCall, struct {
		arg1 *sfu.DownTrack
	}{arg1})
	stub := fake.OnMaxPublishedTemporalChangedStub
	fake.recordInvocation("OnMaxPublishedTemporalChanged", []interface{}{arg1})
	fake.onMaxPublishedTemporalChangedMutex.Unlock()
	if stub != nil {
		fake.OnMaxPublishedTemporalChangedStub(arg1)
	}
}

func (fake *FakeDownTrackStreamAllocatorListener) OnMaxPublishedTemporalChangedCallCount() int {
	fake.onMaxPublishedTemporalChangedMutex.RLock()
	defer fake.onMaxPublishedTemporalChangedMutex.RUnlock()
	return len(fake.onMaxPublishedTemporalChangedArgsForCall)
}

func (fake *FakeDownTrackStreamAllocatorListener) OnMaxPublishedTemporalChangedCalls(stub func(*sfu.DownTrack)) {
	fake.onMaxPublishedTemporalChangedMutex.Lock()
	defer fake.onMaxPublishedTemporalChangedMutex.Unlock()
	fake.OnMaxPublishedTemporalChangedStub = stub
}

func (fake *FakeDownTrackStreamAllocatorListener) OnMaxPublishedTemporalChangedArgsForCall(i int) *sfu.DownTrack {
	fake.onMaxPublishedTemporalChangedMutex.RLock()
	defer fake.onMaxPublishedTemporalChangedMutex.RUnlock()
	argsForCall := fake.onMaxPublishedTemporalChangedArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeDownTrackStreamAllocatorListener) OnREMB(arg1 *sfu.DownTrack, arg2 *rtcp.ReceiverEstimatedMaximumBitrate) {
	fake.onREMBMutex.Lock()
	fake.onREMBArgsForCall = append(fake.onREMBArgsForCall, struct {
		arg1 *sfu.DownTrack
		arg2 *rtcp.ReceiverEstimatedMaximumBitrate
	}{arg1, arg2})
	stub := fake.OnREMBStub
	fake.recordInvocation("OnREMB", []interface{}{arg1, arg2})
	fake.onREMBMutex.Unlock()
	if stub != nil {
		fake.OnREMBStub(arg1, arg2)
	}
}

func (fake *FakeDownTrackStreamAllocatorListener) OnREMBCallCount() int {
	fake.onREMBMutex.RLock()
	defer fake.onREMBMutex.RUnlock()
	return len(fake.onREMBArgsForCall)
}

func (fake *FakeDownTrackStreamAllocatorListener) OnREMBCalls(stub func(*sfu.DownTrack, *rtcp.ReceiverEstimatedMaximumBitrate)) {
	fake.onREMBMutex.Lock()
	defer fake.onREMBMutex.Unlock()
	fake.OnREMBStub = stub
}

func (fake *FakeDownTrackStreamAllocatorListener) OnREMBArgsForCall(i int) (*sfu.DownTrack, *rtcp.ReceiverEstimatedMaximumBitrate) {
	fake.onREMBMutex.RLock()
	defer fake.onREMBMutex.RUnlock()
	argsForCall := fake.onREMBArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeDownTrackStreamAllocatorListener) OnResume(arg1 *sfu.DownTrack) {
	fake.onResumeMutex.Lock()
	fake.onResumeArgsForCall = append(fake.onResumeArgsForCall, struct {
		arg1 *sfu.DownTrack
	}{arg1})
	stub := fake.OnResumeStub
	fake.recordInvocation("OnResume", []interface{}{arg1})
	fake.onResumeMutex.Unlock()
	if stub != nil {
		fake.OnResumeStub(arg1)
	}
}

func (fake *FakeDownTrackStreamAllocatorListener) OnResumeCallCount() int {
	fake.onResumeMutex.RLock()
	defer fake.onResumeMutex.RUnlock()
	return len(fake.onResumeArgsForCall)
}

func (fake *FakeDownTrackStreamAllocatorListener) OnResumeCalls(stub func(*sfu.DownTrack)) {
	fake.onResumeMutex.Lock()
	defer fake.onResumeMutex.Unlock()
	fake.OnResumeStub = stub
}

func (fake *FakeDownTrackStreamAllocatorListener) OnResumeArgsForCall(i int) *sfu.DownTrack {
	fake.onResumeMutex.RLock()
	defer fake.onResumeMutex.RUnlock()
	argsForCall := fake.onResumeArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeDownTrackStreamAllocatorListener) OnSubscribedLayerChanged(arg1 *sfu.DownTrack, arg2 buffer.VideoLayer) {
	fake.onSubscribedLayerChangedMutex.Lock()
	fake.onSubscribedLayerChangedArgsForCall = append(fake.onSubscribedLayerChangedArgsForCall, struct {
		arg1 *sfu.DownTrack
		arg2 buffer.VideoLayer
	}{arg1, arg2})
	stub := fake.OnSubscribedLayerChangedStub
	fake.recordInvocation("OnSubscribedLayerChanged", []interface{}{arg1, arg2})
	fake.onSubscribedLayerChangedMutex.Unlock()
	if stub != nil {
		fake.OnSubscribedLayerChangedStub(arg1, arg2)
	}
}

func (fake *FakeDownTrackStreamAllocatorListener) OnSubscribedLayerChangedCallCount() int {
	fake.onSubscribedLayerChangedMutex.RLock()
	defer fake.onSubscribedLayerChangedMutex.RUnlock()
	return len(fake.onSubscribedLayerChangedArgsForCall)
}

func (fake *FakeDownTrackStreamAllocatorListener) OnSubscribedLayerChangedCalls(stub func(*sfu.DownTrack, buffer.VideoLayer)) {
	fake.onSubscribedLayerChangedMutex.Lock()
	defer fake.onSubscribedLayerChangedMutex.Unlock()
	fake.OnSubscribedLayerChangedStub = stub
}

func (fake *FakeDownTrackStreamAllocatorListener) OnSubscribedLayerChangedArgsForCall(i int) (*sfu.DownTrack, buffer.VideoLayer) {
	fake.onSubscribedLayerChangedMutex.RLock()
	defer fake.onSubscribedLayerChangedMutex.RUnlock()
	argsForCall := fake.onSubscribedLayerChangedArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeDownTrackStreamAllocatorListener) OnSubscriptionChanged(arg1 *sfu.DownTrack) {
	fake.onSubscriptionChangedMutex.Lock()
	fake.onSubscriptionChangedArgsForCall = append(fake.onSubscriptionChangedArgsForCall, struct {
		arg1 *sfu.DownTrack
	}{arg1})
	stub := fake.OnSubscriptionChangedStub
	fake.recordInvocation("OnSubscriptionChanged", []interface{}{arg1})
	fake.onSubscriptionChangedMutex.Unlock()
	if stub != nil {
		fake.OnSubscriptionChangedStub(arg1)
	}
}

func (fake *FakeDownTrackStreamAllocatorListener) OnSubscriptionChangedCallCount() int {
	fake.onSubscriptionChangedMutex.RLock()
	defer fake.onSubscriptionChangedMutex.RUnlock()
	return len(fake.onSubscriptionChangedArgsForCall)
}

func (fake *FakeDownTrackStreamAllocatorListener) OnSubscriptionChangedCalls(stub func(*sfu.DownTrack)) {
	fake.onSubscriptionChangedMutex.Lock()
	defer fake.onSubscriptionChangedMutex.Unlock()
	fake.OnSubscriptionChangedStub = stub
}

func (fake *FakeDownTrackStreamAllocatorListener) OnSubscriptionChangedArgsForCall(i int) *sfu.DownTrack {
	fake.onSubscriptionChangedMutex.RLock()
	defer fake.onSubscriptionChangedMutex.RUnlock()
	argsForCall := fake.onSubscriptionChangedArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeDownTrackStreamAllocatorListener) OnTransportCCFeedback(arg1 *sfu.DownTrack, arg2 *rtcp.TransportLayerCC) {
	fake.onTransportCCFeedbackMutex.Lock()
	fake.onTransportCCFeedbackArgsForCall = append(fake.onTransportCCFeedbackArgsForCall, struct {
		arg1 *sfu.DownTrack
		arg2 *rtcp.TransportLayerCC
	}{arg1, arg2})
	stub := fake.OnTransportCCFeedbackStub
	fake.recordInvocation("OnTransportCCFeedback", []interface{}{arg1, arg2})
	fake.onTransportCCFeedbackMutex.Unlock()
	if stub != nil {
		fake.OnTransportCCFeedbackStub(arg1, arg2)
	}
}

func (fake *FakeDownTrackStreamAllocatorListener) OnTransportCCFeedbackCallCount() int {
	fake.onTransportCCFeedbackMutex.RLock()
	defer fake.onTransportCCFeedbackMutex.RUnlock()
	return len(fake.onTransportCCFeedbackArgsForCall)
}

func (fake *FakeDownTrackStreamAllocatorListener) OnTransportCCFeedbackCalls(stub func(*sfu.DownTrack, *rtcp.TransportLayerCC)) {
	fake.onTransportCCFeedbackMutex.Lock()
	defer fake.onTransportCCFeedbackMutex.Unlock()
	fake.OnTransportCCFeedbackStub = stub
}

func (fake *FakeDownTrackStreamAllocatorListener) OnTransportCCFeedbackArgsForCall(i int) (*sfu.DownTrack, *rtcp.TransportLayerCC) {
	fake.onTransportCCFeedbackMutex.RLock()
	defer fake.onTransportCCFeedbackMutex.RUnlock()
	argsForCall := fake.onTransportCCFeedbackArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeDownTrackStreamAllocatorListener) 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 *FakeDownTrackStreamAllocatorListener) 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.DownTrackStreamAllocatorListener = new(FakeDownTrackStreamAllocatorListener)
