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

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

import (
	"sync"

	"github.com/livekit/livekit-server/pkg/sfu"
	"github.com/livekit/mediatransportutil/pkg/codec"
	"github.com/livekit/protocol/codecs/mime"
	"github.com/livekit/protocol/livekit"
	webrtc "github.com/pion/webrtc/v4"
)

type FakeTrackReceiver struct {
	AddDownTrackStub        func(sfu.TrackSender) error
	addDownTrackMutex       sync.RWMutex
	addDownTrackArgsForCall []struct {
		arg1 sfu.TrackSender
	}
	addDownTrackReturns struct {
		result1 error
	}
	addDownTrackReturnsOnCall map[int]struct {
		result1 error
	}
	AddOnCodecStateChangeStub        func(func(webrtc.RTPCodecParameters, sfu.ReceiverCodecState))
	addOnCodecStateChangeMutex       sync.RWMutex
	addOnCodecStateChangeArgsForCall []struct {
		arg1 func(webrtc.RTPCodecParameters, sfu.ReceiverCodecState)
	}
	AddOnReadyStub        func(func())
	addOnReadyMutex       sync.RWMutex
	addOnReadyArgsForCall []struct {
		arg1 func()
	}
	CodecStub        func() webrtc.RTPCodecParameters
	codecMutex       sync.RWMutex
	codecArgsForCall []struct {
	}
	codecReturns struct {
		result1 webrtc.RTPCodecParameters
	}
	codecReturnsOnCall map[int]struct {
		result1 webrtc.RTPCodecParameters
	}
	CodecStateStub        func() sfu.ReceiverCodecState
	codecStateMutex       sync.RWMutex
	codecStateArgsForCall []struct {
	}
	codecStateReturns struct {
		result1 sfu.ReceiverCodecState
	}
	codecStateReturnsOnCall map[int]struct {
		result1 sfu.ReceiverCodecState
	}
	DebugInfoStub        func() map[string]any
	debugInfoMutex       sync.RWMutex
	debugInfoArgsForCall []struct {
	}
	debugInfoReturns struct {
		result1 map[string]any
	}
	debugInfoReturnsOnCall map[int]struct {
		result1 map[string]any
	}
	DeleteDownTrackStub        func(livekit.ParticipantID)
	deleteDownTrackMutex       sync.RWMutex
	deleteDownTrackArgsForCall []struct {
		arg1 livekit.ParticipantID
	}
	GetAudioLevelStub        func() (float64, bool)
	getAudioLevelMutex       sync.RWMutex
	getAudioLevelArgsForCall []struct {
	}
	getAudioLevelReturns struct {
		result1 float64
		result2 bool
	}
	getAudioLevelReturnsOnCall map[int]struct {
		result1 float64
		result2 bool
	}
	GetDownTracksStub        func() []sfu.TrackSender
	getDownTracksMutex       sync.RWMutex
	getDownTracksArgsForCall []struct {
	}
	getDownTracksReturns struct {
		result1 []sfu.TrackSender
	}
	getDownTracksReturnsOnCall map[int]struct {
		result1 []sfu.TrackSender
	}
	GetLayeredBitrateStub        func() ([]int32, sfu.Bitrates)
	getLayeredBitrateMutex       sync.RWMutex
	getLayeredBitrateArgsForCall []struct {
	}
	getLayeredBitrateReturns struct {
		result1 []int32
		result2 sfu.Bitrates
	}
	getLayeredBitrateReturnsOnCall map[int]struct {
		result1 []int32
		result2 sfu.Bitrates
	}
	GetPrimaryReceiverForRedStub        func() sfu.TrackReceiver
	getPrimaryReceiverForRedMutex       sync.RWMutex
	getPrimaryReceiverForRedArgsForCall []struct {
	}
	getPrimaryReceiverForRedReturns struct {
		result1 sfu.TrackReceiver
	}
	getPrimaryReceiverForRedReturnsOnCall map[int]struct {
		result1 sfu.TrackReceiver
	}
	GetRedReceiverStub        func() sfu.TrackReceiver
	getRedReceiverMutex       sync.RWMutex
	getRedReceiverArgsForCall []struct {
	}
	getRedReceiverReturns struct {
		result1 sfu.TrackReceiver
	}
	getRedReceiverReturnsOnCall map[int]struct {
		result1 sfu.TrackReceiver
	}
	GetTemporalLayerFpsForSpatialStub        func(int32) []float32
	getTemporalLayerFpsForSpatialMutex       sync.RWMutex
	getTemporalLayerFpsForSpatialArgsForCall []struct {
		arg1 int32
	}
	getTemporalLayerFpsForSpatialReturns struct {
		result1 []float32
	}
	getTemporalLayerFpsForSpatialReturnsOnCall map[int]struct {
		result1 []float32
	}
	GetTrackStatsStub        func() *livekit.RTPStats
	getTrackStatsMutex       sync.RWMutex
	getTrackStatsArgsForCall []struct {
	}
	getTrackStatsReturns struct {
		result1 *livekit.RTPStats
	}
	getTrackStatsReturnsOnCall map[int]struct {
		result1 *livekit.RTPStats
	}
	HeaderExtensionsStub        func() []webrtc.RTPHeaderExtensionParameter
	headerExtensionsMutex       sync.RWMutex
	headerExtensionsArgsForCall []struct {
	}
	headerExtensionsReturns struct {
		result1 []webrtc.RTPHeaderExtensionParameter
	}
	headerExtensionsReturnsOnCall map[int]struct {
		result1 []webrtc.RTPHeaderExtensionParameter
	}
	IsClosedStub        func() bool
	isClosedMutex       sync.RWMutex
	isClosedArgsForCall []struct {
	}
	isClosedReturns struct {
		result1 bool
	}
	isClosedReturnsOnCall map[int]struct {
		result1 bool
	}
	MimeStub        func() mime.MimeType
	mimeMutex       sync.RWMutex
	mimeArgsForCall []struct {
	}
	mimeReturns struct {
		result1 mime.MimeType
	}
	mimeReturnsOnCall map[int]struct {
		result1 mime.MimeType
	}
	ReadRTPStub        func([]byte, uint8, uint64) (int, error)
	readRTPMutex       sync.RWMutex
	readRTPArgsForCall []struct {
		arg1 []byte
		arg2 uint8
		arg3 uint64
	}
	readRTPReturns struct {
		result1 int
		result2 error
	}
	readRTPReturnsOnCall map[int]struct {
		result1 int
		result2 error
	}
	RestartStub        func(string)
	restartMutex       sync.RWMutex
	restartArgsForCall []struct {
		arg1 string
	}
	SendPLIStub        func(int32, bool)
	sendPLIMutex       sync.RWMutex
	sendPLIArgsForCall []struct {
		arg1 int32
		arg2 bool
	}
	SetMaxExpectedSpatialLayerStub        func(int32)
	setMaxExpectedSpatialLayerMutex       sync.RWMutex
	setMaxExpectedSpatialLayerArgsForCall []struct {
		arg1 int32
	}
	StreamIDStub        func() string
	streamIDMutex       sync.RWMutex
	streamIDArgsForCall []struct {
	}
	streamIDReturns struct {
		result1 string
	}
	streamIDReturnsOnCall map[int]struct {
		result1 string
	}
	TrackIDStub        func() livekit.TrackID
	trackIDMutex       sync.RWMutex
	trackIDArgsForCall []struct {
	}
	trackIDReturns struct {
		result1 livekit.TrackID
	}
	trackIDReturnsOnCall map[int]struct {
		result1 livekit.TrackID
	}
	TrackInfoStub        func() *livekit.TrackInfo
	trackInfoMutex       sync.RWMutex
	trackInfoArgsForCall []struct {
	}
	trackInfoReturns struct {
		result1 *livekit.TrackInfo
	}
	trackInfoReturnsOnCall map[int]struct {
		result1 *livekit.TrackInfo
	}
	UpdateTrackInfoStub        func(*livekit.TrackInfo)
	updateTrackInfoMutex       sync.RWMutex
	updateTrackInfoArgsForCall []struct {
		arg1 *livekit.TrackInfo
	}
	VideoLayerModeStub        func() livekit.VideoLayer_Mode
	videoLayerModeMutex       sync.RWMutex
	videoLayerModeArgsForCall []struct {
	}
	videoLayerModeReturns struct {
		result1 livekit.VideoLayer_Mode
	}
	videoLayerModeReturnsOnCall map[int]struct {
		result1 livekit.VideoLayer_Mode
	}
	VideoSizesStub        func() []codec.VideoSize
	videoSizesMutex       sync.RWMutex
	videoSizesArgsForCall []struct {
	}
	videoSizesReturns struct {
		result1 []codec.VideoSize
	}
	videoSizesReturnsOnCall map[int]struct {
		result1 []codec.VideoSize
	}
	invocations      map[string][][]interface{}
	invocationsMutex sync.RWMutex
}

func (fake *FakeTrackReceiver) AddDownTrack(arg1 sfu.TrackSender) error {
	fake.addDownTrackMutex.Lock()
	ret, specificReturn := fake.addDownTrackReturnsOnCall[len(fake.addDownTrackArgsForCall)]
	fake.addDownTrackArgsForCall = append(fake.addDownTrackArgsForCall, struct {
		arg1 sfu.TrackSender
	}{arg1})
	stub := fake.AddDownTrackStub
	fakeReturns := fake.addDownTrackReturns
	fake.recordInvocation("AddDownTrack", []interface{}{arg1})
	fake.addDownTrackMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeTrackReceiver) AddDownTrackCallCount() int {
	fake.addDownTrackMutex.RLock()
	defer fake.addDownTrackMutex.RUnlock()
	return len(fake.addDownTrackArgsForCall)
}

func (fake *FakeTrackReceiver) AddDownTrackCalls(stub func(sfu.TrackSender) error) {
	fake.addDownTrackMutex.Lock()
	defer fake.addDownTrackMutex.Unlock()
	fake.AddDownTrackStub = stub
}

func (fake *FakeTrackReceiver) AddDownTrackArgsForCall(i int) sfu.TrackSender {
	fake.addDownTrackMutex.RLock()
	defer fake.addDownTrackMutex.RUnlock()
	argsForCall := fake.addDownTrackArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeTrackReceiver) AddDownTrackReturns(result1 error) {
	fake.addDownTrackMutex.Lock()
	defer fake.addDownTrackMutex.Unlock()
	fake.AddDownTrackStub = nil
	fake.addDownTrackReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeTrackReceiver) AddDownTrackReturnsOnCall(i int, result1 error) {
	fake.addDownTrackMutex.Lock()
	defer fake.addDownTrackMutex.Unlock()
	fake.AddDownTrackStub = nil
	if fake.addDownTrackReturnsOnCall == nil {
		fake.addDownTrackReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.addDownTrackReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeTrackReceiver) AddOnCodecStateChange(arg1 func(webrtc.RTPCodecParameters, sfu.ReceiverCodecState)) {
	fake.addOnCodecStateChangeMutex.Lock()
	fake.addOnCodecStateChangeArgsForCall = append(fake.addOnCodecStateChangeArgsForCall, struct {
		arg1 func(webrtc.RTPCodecParameters, sfu.ReceiverCodecState)
	}{arg1})
	stub := fake.AddOnCodecStateChangeStub
	fake.recordInvocation("AddOnCodecStateChange", []interface{}{arg1})
	fake.addOnCodecStateChangeMutex.Unlock()
	if stub != nil {
		fake.AddOnCodecStateChangeStub(arg1)
	}
}

func (fake *FakeTrackReceiver) AddOnCodecStateChangeCallCount() int {
	fake.addOnCodecStateChangeMutex.RLock()
	defer fake.addOnCodecStateChangeMutex.RUnlock()
	return len(fake.addOnCodecStateChangeArgsForCall)
}

func (fake *FakeTrackReceiver) AddOnCodecStateChangeCalls(stub func(func(webrtc.RTPCodecParameters, sfu.ReceiverCodecState))) {
	fake.addOnCodecStateChangeMutex.Lock()
	defer fake.addOnCodecStateChangeMutex.Unlock()
	fake.AddOnCodecStateChangeStub = stub
}

func (fake *FakeTrackReceiver) AddOnCodecStateChangeArgsForCall(i int) func(webrtc.RTPCodecParameters, sfu.ReceiverCodecState) {
	fake.addOnCodecStateChangeMutex.RLock()
	defer fake.addOnCodecStateChangeMutex.RUnlock()
	argsForCall := fake.addOnCodecStateChangeArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeTrackReceiver) AddOnReady(arg1 func()) {
	fake.addOnReadyMutex.Lock()
	fake.addOnReadyArgsForCall = append(fake.addOnReadyArgsForCall, struct {
		arg1 func()
	}{arg1})
	stub := fake.AddOnReadyStub
	fake.recordInvocation("AddOnReady", []interface{}{arg1})
	fake.addOnReadyMutex.Unlock()
	if stub != nil {
		fake.AddOnReadyStub(arg1)
	}
}

func (fake *FakeTrackReceiver) AddOnReadyCallCount() int {
	fake.addOnReadyMutex.RLock()
	defer fake.addOnReadyMutex.RUnlock()
	return len(fake.addOnReadyArgsForCall)
}

func (fake *FakeTrackReceiver) AddOnReadyCalls(stub func(func())) {
	fake.addOnReadyMutex.Lock()
	defer fake.addOnReadyMutex.Unlock()
	fake.AddOnReadyStub = stub
}

func (fake *FakeTrackReceiver) AddOnReadyArgsForCall(i int) func() {
	fake.addOnReadyMutex.RLock()
	defer fake.addOnReadyMutex.RUnlock()
	argsForCall := fake.addOnReadyArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeTrackReceiver) Codec() webrtc.RTPCodecParameters {
	fake.codecMutex.Lock()
	ret, specificReturn := fake.codecReturnsOnCall[len(fake.codecArgsForCall)]
	fake.codecArgsForCall = append(fake.codecArgsForCall, struct {
	}{})
	stub := fake.CodecStub
	fakeReturns := fake.codecReturns
	fake.recordInvocation("Codec", []interface{}{})
	fake.codecMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeTrackReceiver) CodecCallCount() int {
	fake.codecMutex.RLock()
	defer fake.codecMutex.RUnlock()
	return len(fake.codecArgsForCall)
}

func (fake *FakeTrackReceiver) CodecCalls(stub func() webrtc.RTPCodecParameters) {
	fake.codecMutex.Lock()
	defer fake.codecMutex.Unlock()
	fake.CodecStub = stub
}

func (fake *FakeTrackReceiver) CodecReturns(result1 webrtc.RTPCodecParameters) {
	fake.codecMutex.Lock()
	defer fake.codecMutex.Unlock()
	fake.CodecStub = nil
	fake.codecReturns = struct {
		result1 webrtc.RTPCodecParameters
	}{result1}
}

func (fake *FakeTrackReceiver) CodecReturnsOnCall(i int, result1 webrtc.RTPCodecParameters) {
	fake.codecMutex.Lock()
	defer fake.codecMutex.Unlock()
	fake.CodecStub = nil
	if fake.codecReturnsOnCall == nil {
		fake.codecReturnsOnCall = make(map[int]struct {
			result1 webrtc.RTPCodecParameters
		})
	}
	fake.codecReturnsOnCall[i] = struct {
		result1 webrtc.RTPCodecParameters
	}{result1}
}

func (fake *FakeTrackReceiver) CodecState() sfu.ReceiverCodecState {
	fake.codecStateMutex.Lock()
	ret, specificReturn := fake.codecStateReturnsOnCall[len(fake.codecStateArgsForCall)]
	fake.codecStateArgsForCall = append(fake.codecStateArgsForCall, struct {
	}{})
	stub := fake.CodecStateStub
	fakeReturns := fake.codecStateReturns
	fake.recordInvocation("CodecState", []interface{}{})
	fake.codecStateMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeTrackReceiver) CodecStateCallCount() int {
	fake.codecStateMutex.RLock()
	defer fake.codecStateMutex.RUnlock()
	return len(fake.codecStateArgsForCall)
}

func (fake *FakeTrackReceiver) CodecStateCalls(stub func() sfu.ReceiverCodecState) {
	fake.codecStateMutex.Lock()
	defer fake.codecStateMutex.Unlock()
	fake.CodecStateStub = stub
}

func (fake *FakeTrackReceiver) CodecStateReturns(result1 sfu.ReceiverCodecState) {
	fake.codecStateMutex.Lock()
	defer fake.codecStateMutex.Unlock()
	fake.CodecStateStub = nil
	fake.codecStateReturns = struct {
		result1 sfu.ReceiverCodecState
	}{result1}
}

func (fake *FakeTrackReceiver) CodecStateReturnsOnCall(i int, result1 sfu.ReceiverCodecState) {
	fake.codecStateMutex.Lock()
	defer fake.codecStateMutex.Unlock()
	fake.CodecStateStub = nil
	if fake.codecStateReturnsOnCall == nil {
		fake.codecStateReturnsOnCall = make(map[int]struct {
			result1 sfu.ReceiverCodecState
		})
	}
	fake.codecStateReturnsOnCall[i] = struct {
		result1 sfu.ReceiverCodecState
	}{result1}
}

func (fake *FakeTrackReceiver) DebugInfo() map[string]any {
	fake.debugInfoMutex.Lock()
	ret, specificReturn := fake.debugInfoReturnsOnCall[len(fake.debugInfoArgsForCall)]
	fake.debugInfoArgsForCall = append(fake.debugInfoArgsForCall, struct {
	}{})
	stub := fake.DebugInfoStub
	fakeReturns := fake.debugInfoReturns
	fake.recordInvocation("DebugInfo", []interface{}{})
	fake.debugInfoMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeTrackReceiver) DebugInfoCallCount() int {
	fake.debugInfoMutex.RLock()
	defer fake.debugInfoMutex.RUnlock()
	return len(fake.debugInfoArgsForCall)
}

func (fake *FakeTrackReceiver) DebugInfoCalls(stub func() map[string]any) {
	fake.debugInfoMutex.Lock()
	defer fake.debugInfoMutex.Unlock()
	fake.DebugInfoStub = stub
}

func (fake *FakeTrackReceiver) DebugInfoReturns(result1 map[string]any) {
	fake.debugInfoMutex.Lock()
	defer fake.debugInfoMutex.Unlock()
	fake.DebugInfoStub = nil
	fake.debugInfoReturns = struct {
		result1 map[string]any
	}{result1}
}

func (fake *FakeTrackReceiver) DebugInfoReturnsOnCall(i int, result1 map[string]any) {
	fake.debugInfoMutex.Lock()
	defer fake.debugInfoMutex.Unlock()
	fake.DebugInfoStub = nil
	if fake.debugInfoReturnsOnCall == nil {
		fake.debugInfoReturnsOnCall = make(map[int]struct {
			result1 map[string]any
		})
	}
	fake.debugInfoReturnsOnCall[i] = struct {
		result1 map[string]any
	}{result1}
}

func (fake *FakeTrackReceiver) DeleteDownTrack(arg1 livekit.ParticipantID) {
	fake.deleteDownTrackMutex.Lock()
	fake.deleteDownTrackArgsForCall = append(fake.deleteDownTrackArgsForCall, struct {
		arg1 livekit.ParticipantID
	}{arg1})
	stub := fake.DeleteDownTrackStub
	fake.recordInvocation("DeleteDownTrack", []interface{}{arg1})
	fake.deleteDownTrackMutex.Unlock()
	if stub != nil {
		fake.DeleteDownTrackStub(arg1)
	}
}

func (fake *FakeTrackReceiver) DeleteDownTrackCallCount() int {
	fake.deleteDownTrackMutex.RLock()
	defer fake.deleteDownTrackMutex.RUnlock()
	return len(fake.deleteDownTrackArgsForCall)
}

func (fake *FakeTrackReceiver) DeleteDownTrackCalls(stub func(livekit.ParticipantID)) {
	fake.deleteDownTrackMutex.Lock()
	defer fake.deleteDownTrackMutex.Unlock()
	fake.DeleteDownTrackStub = stub
}

func (fake *FakeTrackReceiver) DeleteDownTrackArgsForCall(i int) livekit.ParticipantID {
	fake.deleteDownTrackMutex.RLock()
	defer fake.deleteDownTrackMutex.RUnlock()
	argsForCall := fake.deleteDownTrackArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeTrackReceiver) GetAudioLevel() (float64, bool) {
	fake.getAudioLevelMutex.Lock()
	ret, specificReturn := fake.getAudioLevelReturnsOnCall[len(fake.getAudioLevelArgsForCall)]
	fake.getAudioLevelArgsForCall = append(fake.getAudioLevelArgsForCall, struct {
	}{})
	stub := fake.GetAudioLevelStub
	fakeReturns := fake.getAudioLevelReturns
	fake.recordInvocation("GetAudioLevel", []interface{}{})
	fake.getAudioLevelMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeTrackReceiver) GetAudioLevelCallCount() int {
	fake.getAudioLevelMutex.RLock()
	defer fake.getAudioLevelMutex.RUnlock()
	return len(fake.getAudioLevelArgsForCall)
}

func (fake *FakeTrackReceiver) GetAudioLevelCalls(stub func() (float64, bool)) {
	fake.getAudioLevelMutex.Lock()
	defer fake.getAudioLevelMutex.Unlock()
	fake.GetAudioLevelStub = stub
}

func (fake *FakeTrackReceiver) GetAudioLevelReturns(result1 float64, result2 bool) {
	fake.getAudioLevelMutex.Lock()
	defer fake.getAudioLevelMutex.Unlock()
	fake.GetAudioLevelStub = nil
	fake.getAudioLevelReturns = struct {
		result1 float64
		result2 bool
	}{result1, result2}
}

func (fake *FakeTrackReceiver) GetAudioLevelReturnsOnCall(i int, result1 float64, result2 bool) {
	fake.getAudioLevelMutex.Lock()
	defer fake.getAudioLevelMutex.Unlock()
	fake.GetAudioLevelStub = nil
	if fake.getAudioLevelReturnsOnCall == nil {
		fake.getAudioLevelReturnsOnCall = make(map[int]struct {
			result1 float64
			result2 bool
		})
	}
	fake.getAudioLevelReturnsOnCall[i] = struct {
		result1 float64
		result2 bool
	}{result1, result2}
}

func (fake *FakeTrackReceiver) GetDownTracks() []sfu.TrackSender {
	fake.getDownTracksMutex.Lock()
	ret, specificReturn := fake.getDownTracksReturnsOnCall[len(fake.getDownTracksArgsForCall)]
	fake.getDownTracksArgsForCall = append(fake.getDownTracksArgsForCall, struct {
	}{})
	stub := fake.GetDownTracksStub
	fakeReturns := fake.getDownTracksReturns
	fake.recordInvocation("GetDownTracks", []interface{}{})
	fake.getDownTracksMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeTrackReceiver) GetDownTracksCallCount() int {
	fake.getDownTracksMutex.RLock()
	defer fake.getDownTracksMutex.RUnlock()
	return len(fake.getDownTracksArgsForCall)
}

func (fake *FakeTrackReceiver) GetDownTracksCalls(stub func() []sfu.TrackSender) {
	fake.getDownTracksMutex.Lock()
	defer fake.getDownTracksMutex.Unlock()
	fake.GetDownTracksStub = stub
}

func (fake *FakeTrackReceiver) GetDownTracksReturns(result1 []sfu.TrackSender) {
	fake.getDownTracksMutex.Lock()
	defer fake.getDownTracksMutex.Unlock()
	fake.GetDownTracksStub = nil
	fake.getDownTracksReturns = struct {
		result1 []sfu.TrackSender
	}{result1}
}

func (fake *FakeTrackReceiver) GetDownTracksReturnsOnCall(i int, result1 []sfu.TrackSender) {
	fake.getDownTracksMutex.Lock()
	defer fake.getDownTracksMutex.Unlock()
	fake.GetDownTracksStub = nil
	if fake.getDownTracksReturnsOnCall == nil {
		fake.getDownTracksReturnsOnCall = make(map[int]struct {
			result1 []sfu.TrackSender
		})
	}
	fake.getDownTracksReturnsOnCall[i] = struct {
		result1 []sfu.TrackSender
	}{result1}
}

func (fake *FakeTrackReceiver) GetLayeredBitrate() ([]int32, sfu.Bitrates) {
	fake.getLayeredBitrateMutex.Lock()
	ret, specificReturn := fake.getLayeredBitrateReturnsOnCall[len(fake.getLayeredBitrateArgsForCall)]
	fake.getLayeredBitrateArgsForCall = append(fake.getLayeredBitrateArgsForCall, struct {
	}{})
	stub := fake.GetLayeredBitrateStub
	fakeReturns := fake.getLayeredBitrateReturns
	fake.recordInvocation("GetLayeredBitrate", []interface{}{})
	fake.getLayeredBitrateMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeTrackReceiver) GetLayeredBitrateCallCount() int {
	fake.getLayeredBitrateMutex.RLock()
	defer fake.getLayeredBitrateMutex.RUnlock()
	return len(fake.getLayeredBitrateArgsForCall)
}

func (fake *FakeTrackReceiver) GetLayeredBitrateCalls(stub func() ([]int32, sfu.Bitrates)) {
	fake.getLayeredBitrateMutex.Lock()
	defer fake.getLayeredBitrateMutex.Unlock()
	fake.GetLayeredBitrateStub = stub
}

func (fake *FakeTrackReceiver) GetLayeredBitrateReturns(result1 []int32, result2 sfu.Bitrates) {
	fake.getLayeredBitrateMutex.Lock()
	defer fake.getLayeredBitrateMutex.Unlock()
	fake.GetLayeredBitrateStub = nil
	fake.getLayeredBitrateReturns = struct {
		result1 []int32
		result2 sfu.Bitrates
	}{result1, result2}
}

func (fake *FakeTrackReceiver) GetLayeredBitrateReturnsOnCall(i int, result1 []int32, result2 sfu.Bitrates) {
	fake.getLayeredBitrateMutex.Lock()
	defer fake.getLayeredBitrateMutex.Unlock()
	fake.GetLayeredBitrateStub = nil
	if fake.getLayeredBitrateReturnsOnCall == nil {
		fake.getLayeredBitrateReturnsOnCall = make(map[int]struct {
			result1 []int32
			result2 sfu.Bitrates
		})
	}
	fake.getLayeredBitrateReturnsOnCall[i] = struct {
		result1 []int32
		result2 sfu.Bitrates
	}{result1, result2}
}

func (fake *FakeTrackReceiver) GetPrimaryReceiverForRed() sfu.TrackReceiver {
	fake.getPrimaryReceiverForRedMutex.Lock()
	ret, specificReturn := fake.getPrimaryReceiverForRedReturnsOnCall[len(fake.getPrimaryReceiverForRedArgsForCall)]
	fake.getPrimaryReceiverForRedArgsForCall = append(fake.getPrimaryReceiverForRedArgsForCall, struct {
	}{})
	stub := fake.GetPrimaryReceiverForRedStub
	fakeReturns := fake.getPrimaryReceiverForRedReturns
	fake.recordInvocation("GetPrimaryReceiverForRed", []interface{}{})
	fake.getPrimaryReceiverForRedMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeTrackReceiver) GetPrimaryReceiverForRedCallCount() int {
	fake.getPrimaryReceiverForRedMutex.RLock()
	defer fake.getPrimaryReceiverForRedMutex.RUnlock()
	return len(fake.getPrimaryReceiverForRedArgsForCall)
}

func (fake *FakeTrackReceiver) GetPrimaryReceiverForRedCalls(stub func() sfu.TrackReceiver) {
	fake.getPrimaryReceiverForRedMutex.Lock()
	defer fake.getPrimaryReceiverForRedMutex.Unlock()
	fake.GetPrimaryReceiverForRedStub = stub
}

func (fake *FakeTrackReceiver) GetPrimaryReceiverForRedReturns(result1 sfu.TrackReceiver) {
	fake.getPrimaryReceiverForRedMutex.Lock()
	defer fake.getPrimaryReceiverForRedMutex.Unlock()
	fake.GetPrimaryReceiverForRedStub = nil
	fake.getPrimaryReceiverForRedReturns = struct {
		result1 sfu.TrackReceiver
	}{result1}
}

func (fake *FakeTrackReceiver) GetPrimaryReceiverForRedReturnsOnCall(i int, result1 sfu.TrackReceiver) {
	fake.getPrimaryReceiverForRedMutex.Lock()
	defer fake.getPrimaryReceiverForRedMutex.Unlock()
	fake.GetPrimaryReceiverForRedStub = nil
	if fake.getPrimaryReceiverForRedReturnsOnCall == nil {
		fake.getPrimaryReceiverForRedReturnsOnCall = make(map[int]struct {
			result1 sfu.TrackReceiver
		})
	}
	fake.getPrimaryReceiverForRedReturnsOnCall[i] = struct {
		result1 sfu.TrackReceiver
	}{result1}
}

func (fake *FakeTrackReceiver) GetRedReceiver() sfu.TrackReceiver {
	fake.getRedReceiverMutex.Lock()
	ret, specificReturn := fake.getRedReceiverReturnsOnCall[len(fake.getRedReceiverArgsForCall)]
	fake.getRedReceiverArgsForCall = append(fake.getRedReceiverArgsForCall, struct {
	}{})
	stub := fake.GetRedReceiverStub
	fakeReturns := fake.getRedReceiverReturns
	fake.recordInvocation("GetRedReceiver", []interface{}{})
	fake.getRedReceiverMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeTrackReceiver) GetRedReceiverCallCount() int {
	fake.getRedReceiverMutex.RLock()
	defer fake.getRedReceiverMutex.RUnlock()
	return len(fake.getRedReceiverArgsForCall)
}

func (fake *FakeTrackReceiver) GetRedReceiverCalls(stub func() sfu.TrackReceiver) {
	fake.getRedReceiverMutex.Lock()
	defer fake.getRedReceiverMutex.Unlock()
	fake.GetRedReceiverStub = stub
}

func (fake *FakeTrackReceiver) GetRedReceiverReturns(result1 sfu.TrackReceiver) {
	fake.getRedReceiverMutex.Lock()
	defer fake.getRedReceiverMutex.Unlock()
	fake.GetRedReceiverStub = nil
	fake.getRedReceiverReturns = struct {
		result1 sfu.TrackReceiver
	}{result1}
}

func (fake *FakeTrackReceiver) GetRedReceiverReturnsOnCall(i int, result1 sfu.TrackReceiver) {
	fake.getRedReceiverMutex.Lock()
	defer fake.getRedReceiverMutex.Unlock()
	fake.GetRedReceiverStub = nil
	if fake.getRedReceiverReturnsOnCall == nil {
		fake.getRedReceiverReturnsOnCall = make(map[int]struct {
			result1 sfu.TrackReceiver
		})
	}
	fake.getRedReceiverReturnsOnCall[i] = struct {
		result1 sfu.TrackReceiver
	}{result1}
}

func (fake *FakeTrackReceiver) GetTemporalLayerFpsForSpatial(arg1 int32) []float32 {
	fake.getTemporalLayerFpsForSpatialMutex.Lock()
	ret, specificReturn := fake.getTemporalLayerFpsForSpatialReturnsOnCall[len(fake.getTemporalLayerFpsForSpatialArgsForCall)]
	fake.getTemporalLayerFpsForSpatialArgsForCall = append(fake.getTemporalLayerFpsForSpatialArgsForCall, struct {
		arg1 int32
	}{arg1})
	stub := fake.GetTemporalLayerFpsForSpatialStub
	fakeReturns := fake.getTemporalLayerFpsForSpatialReturns
	fake.recordInvocation("GetTemporalLayerFpsForSpatial", []interface{}{arg1})
	fake.getTemporalLayerFpsForSpatialMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeTrackReceiver) GetTemporalLayerFpsForSpatialCallCount() int {
	fake.getTemporalLayerFpsForSpatialMutex.RLock()
	defer fake.getTemporalLayerFpsForSpatialMutex.RUnlock()
	return len(fake.getTemporalLayerFpsForSpatialArgsForCall)
}

func (fake *FakeTrackReceiver) GetTemporalLayerFpsForSpatialCalls(stub func(int32) []float32) {
	fake.getTemporalLayerFpsForSpatialMutex.Lock()
	defer fake.getTemporalLayerFpsForSpatialMutex.Unlock()
	fake.GetTemporalLayerFpsForSpatialStub = stub
}

func (fake *FakeTrackReceiver) GetTemporalLayerFpsForSpatialArgsForCall(i int) int32 {
	fake.getTemporalLayerFpsForSpatialMutex.RLock()
	defer fake.getTemporalLayerFpsForSpatialMutex.RUnlock()
	argsForCall := fake.getTemporalLayerFpsForSpatialArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeTrackReceiver) GetTemporalLayerFpsForSpatialReturns(result1 []float32) {
	fake.getTemporalLayerFpsForSpatialMutex.Lock()
	defer fake.getTemporalLayerFpsForSpatialMutex.Unlock()
	fake.GetTemporalLayerFpsForSpatialStub = nil
	fake.getTemporalLayerFpsForSpatialReturns = struct {
		result1 []float32
	}{result1}
}

func (fake *FakeTrackReceiver) GetTemporalLayerFpsForSpatialReturnsOnCall(i int, result1 []float32) {
	fake.getTemporalLayerFpsForSpatialMutex.Lock()
	defer fake.getTemporalLayerFpsForSpatialMutex.Unlock()
	fake.GetTemporalLayerFpsForSpatialStub = nil
	if fake.getTemporalLayerFpsForSpatialReturnsOnCall == nil {
		fake.getTemporalLayerFpsForSpatialReturnsOnCall = make(map[int]struct {
			result1 []float32
		})
	}
	fake.getTemporalLayerFpsForSpatialReturnsOnCall[i] = struct {
		result1 []float32
	}{result1}
}

func (fake *FakeTrackReceiver) GetTrackStats() *livekit.RTPStats {
	fake.getTrackStatsMutex.Lock()
	ret, specificReturn := fake.getTrackStatsReturnsOnCall[len(fake.getTrackStatsArgsForCall)]
	fake.getTrackStatsArgsForCall = append(fake.getTrackStatsArgsForCall, struct {
	}{})
	stub := fake.GetTrackStatsStub
	fakeReturns := fake.getTrackStatsReturns
	fake.recordInvocation("GetTrackStats", []interface{}{})
	fake.getTrackStatsMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeTrackReceiver) GetTrackStatsCallCount() int {
	fake.getTrackStatsMutex.RLock()
	defer fake.getTrackStatsMutex.RUnlock()
	return len(fake.getTrackStatsArgsForCall)
}

func (fake *FakeTrackReceiver) GetTrackStatsCalls(stub func() *livekit.RTPStats) {
	fake.getTrackStatsMutex.Lock()
	defer fake.getTrackStatsMutex.Unlock()
	fake.GetTrackStatsStub = stub
}

func (fake *FakeTrackReceiver) GetTrackStatsReturns(result1 *livekit.RTPStats) {
	fake.getTrackStatsMutex.Lock()
	defer fake.getTrackStatsMutex.Unlock()
	fake.GetTrackStatsStub = nil
	fake.getTrackStatsReturns = struct {
		result1 *livekit.RTPStats
	}{result1}
}

func (fake *FakeTrackReceiver) GetTrackStatsReturnsOnCall(i int, result1 *livekit.RTPStats) {
	fake.getTrackStatsMutex.Lock()
	defer fake.getTrackStatsMutex.Unlock()
	fake.GetTrackStatsStub = nil
	if fake.getTrackStatsReturnsOnCall == nil {
		fake.getTrackStatsReturnsOnCall = make(map[int]struct {
			result1 *livekit.RTPStats
		})
	}
	fake.getTrackStatsReturnsOnCall[i] = struct {
		result1 *livekit.RTPStats
	}{result1}
}

func (fake *FakeTrackReceiver) HeaderExtensions() []webrtc.RTPHeaderExtensionParameter {
	fake.headerExtensionsMutex.Lock()
	ret, specificReturn := fake.headerExtensionsReturnsOnCall[len(fake.headerExtensionsArgsForCall)]
	fake.headerExtensionsArgsForCall = append(fake.headerExtensionsArgsForCall, struct {
	}{})
	stub := fake.HeaderExtensionsStub
	fakeReturns := fake.headerExtensionsReturns
	fake.recordInvocation("HeaderExtensions", []interface{}{})
	fake.headerExtensionsMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeTrackReceiver) HeaderExtensionsCallCount() int {
	fake.headerExtensionsMutex.RLock()
	defer fake.headerExtensionsMutex.RUnlock()
	return len(fake.headerExtensionsArgsForCall)
}

func (fake *FakeTrackReceiver) HeaderExtensionsCalls(stub func() []webrtc.RTPHeaderExtensionParameter) {
	fake.headerExtensionsMutex.Lock()
	defer fake.headerExtensionsMutex.Unlock()
	fake.HeaderExtensionsStub = stub
}

func (fake *FakeTrackReceiver) HeaderExtensionsReturns(result1 []webrtc.RTPHeaderExtensionParameter) {
	fake.headerExtensionsMutex.Lock()
	defer fake.headerExtensionsMutex.Unlock()
	fake.HeaderExtensionsStub = nil
	fake.headerExtensionsReturns = struct {
		result1 []webrtc.RTPHeaderExtensionParameter
	}{result1}
}

func (fake *FakeTrackReceiver) HeaderExtensionsReturnsOnCall(i int, result1 []webrtc.RTPHeaderExtensionParameter) {
	fake.headerExtensionsMutex.Lock()
	defer fake.headerExtensionsMutex.Unlock()
	fake.HeaderExtensionsStub = nil
	if fake.headerExtensionsReturnsOnCall == nil {
		fake.headerExtensionsReturnsOnCall = make(map[int]struct {
			result1 []webrtc.RTPHeaderExtensionParameter
		})
	}
	fake.headerExtensionsReturnsOnCall[i] = struct {
		result1 []webrtc.RTPHeaderExtensionParameter
	}{result1}
}

func (fake *FakeTrackReceiver) 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 *FakeTrackReceiver) IsClosedCallCount() int {
	fake.isClosedMutex.RLock()
	defer fake.isClosedMutex.RUnlock()
	return len(fake.isClosedArgsForCall)
}

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

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

func (fake *FakeTrackReceiver) 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 *FakeTrackReceiver) Mime() mime.MimeType {
	fake.mimeMutex.Lock()
	ret, specificReturn := fake.mimeReturnsOnCall[len(fake.mimeArgsForCall)]
	fake.mimeArgsForCall = append(fake.mimeArgsForCall, struct {
	}{})
	stub := fake.MimeStub
	fakeReturns := fake.mimeReturns
	fake.recordInvocation("Mime", []interface{}{})
	fake.mimeMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeTrackReceiver) MimeCallCount() int {
	fake.mimeMutex.RLock()
	defer fake.mimeMutex.RUnlock()
	return len(fake.mimeArgsForCall)
}

func (fake *FakeTrackReceiver) MimeCalls(stub func() mime.MimeType) {
	fake.mimeMutex.Lock()
	defer fake.mimeMutex.Unlock()
	fake.MimeStub = stub
}

func (fake *FakeTrackReceiver) MimeReturns(result1 mime.MimeType) {
	fake.mimeMutex.Lock()
	defer fake.mimeMutex.Unlock()
	fake.MimeStub = nil
	fake.mimeReturns = struct {
		result1 mime.MimeType
	}{result1}
}

func (fake *FakeTrackReceiver) MimeReturnsOnCall(i int, result1 mime.MimeType) {
	fake.mimeMutex.Lock()
	defer fake.mimeMutex.Unlock()
	fake.MimeStub = nil
	if fake.mimeReturnsOnCall == nil {
		fake.mimeReturnsOnCall = make(map[int]struct {
			result1 mime.MimeType
		})
	}
	fake.mimeReturnsOnCall[i] = struct {
		result1 mime.MimeType
	}{result1}
}

func (fake *FakeTrackReceiver) ReadRTP(arg1 []byte, arg2 uint8, arg3 uint64) (int, error) {
	var arg1Copy []byte
	if arg1 != nil {
		arg1Copy = make([]byte, len(arg1))
		copy(arg1Copy, arg1)
	}
	fake.readRTPMutex.Lock()
	ret, specificReturn := fake.readRTPReturnsOnCall[len(fake.readRTPArgsForCall)]
	fake.readRTPArgsForCall = append(fake.readRTPArgsForCall, struct {
		arg1 []byte
		arg2 uint8
		arg3 uint64
	}{arg1Copy, arg2, arg3})
	stub := fake.ReadRTPStub
	fakeReturns := fake.readRTPReturns
	fake.recordInvocation("ReadRTP", []interface{}{arg1Copy, arg2, arg3})
	fake.readRTPMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeTrackReceiver) ReadRTPCallCount() int {
	fake.readRTPMutex.RLock()
	defer fake.readRTPMutex.RUnlock()
	return len(fake.readRTPArgsForCall)
}

func (fake *FakeTrackReceiver) ReadRTPCalls(stub func([]byte, uint8, uint64) (int, error)) {
	fake.readRTPMutex.Lock()
	defer fake.readRTPMutex.Unlock()
	fake.ReadRTPStub = stub
}

func (fake *FakeTrackReceiver) ReadRTPArgsForCall(i int) ([]byte, uint8, uint64) {
	fake.readRTPMutex.RLock()
	defer fake.readRTPMutex.RUnlock()
	argsForCall := fake.readRTPArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeTrackReceiver) ReadRTPReturns(result1 int, result2 error) {
	fake.readRTPMutex.Lock()
	defer fake.readRTPMutex.Unlock()
	fake.ReadRTPStub = nil
	fake.readRTPReturns = struct {
		result1 int
		result2 error
	}{result1, result2}
}

func (fake *FakeTrackReceiver) ReadRTPReturnsOnCall(i int, result1 int, result2 error) {
	fake.readRTPMutex.Lock()
	defer fake.readRTPMutex.Unlock()
	fake.ReadRTPStub = nil
	if fake.readRTPReturnsOnCall == nil {
		fake.readRTPReturnsOnCall = make(map[int]struct {
			result1 int
			result2 error
		})
	}
	fake.readRTPReturnsOnCall[i] = struct {
		result1 int
		result2 error
	}{result1, result2}
}

func (fake *FakeTrackReceiver) Restart(arg1 string) {
	fake.restartMutex.Lock()
	fake.restartArgsForCall = append(fake.restartArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.RestartStub
	fake.recordInvocation("Restart", []interface{}{arg1})
	fake.restartMutex.Unlock()
	if stub != nil {
		fake.RestartStub(arg1)
	}
}

func (fake *FakeTrackReceiver) RestartCallCount() int {
	fake.restartMutex.RLock()
	defer fake.restartMutex.RUnlock()
	return len(fake.restartArgsForCall)
}

func (fake *FakeTrackReceiver) RestartCalls(stub func(string)) {
	fake.restartMutex.Lock()
	defer fake.restartMutex.Unlock()
	fake.RestartStub = stub
}

func (fake *FakeTrackReceiver) RestartArgsForCall(i int) string {
	fake.restartMutex.RLock()
	defer fake.restartMutex.RUnlock()
	argsForCall := fake.restartArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeTrackReceiver) SendPLI(arg1 int32, arg2 bool) {
	fake.sendPLIMutex.Lock()
	fake.sendPLIArgsForCall = append(fake.sendPLIArgsForCall, struct {
		arg1 int32
		arg2 bool
	}{arg1, arg2})
	stub := fake.SendPLIStub
	fake.recordInvocation("SendPLI", []interface{}{arg1, arg2})
	fake.sendPLIMutex.Unlock()
	if stub != nil {
		fake.SendPLIStub(arg1, arg2)
	}
}

func (fake *FakeTrackReceiver) SendPLICallCount() int {
	fake.sendPLIMutex.RLock()
	defer fake.sendPLIMutex.RUnlock()
	return len(fake.sendPLIArgsForCall)
}

func (fake *FakeTrackReceiver) SendPLICalls(stub func(int32, bool)) {
	fake.sendPLIMutex.Lock()
	defer fake.sendPLIMutex.Unlock()
	fake.SendPLIStub = stub
}

func (fake *FakeTrackReceiver) SendPLIArgsForCall(i int) (int32, bool) {
	fake.sendPLIMutex.RLock()
	defer fake.sendPLIMutex.RUnlock()
	argsForCall := fake.sendPLIArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeTrackReceiver) SetMaxExpectedSpatialLayer(arg1 int32) {
	fake.setMaxExpectedSpatialLayerMutex.Lock()
	fake.setMaxExpectedSpatialLayerArgsForCall = append(fake.setMaxExpectedSpatialLayerArgsForCall, struct {
		arg1 int32
	}{arg1})
	stub := fake.SetMaxExpectedSpatialLayerStub
	fake.recordInvocation("SetMaxExpectedSpatialLayer", []interface{}{arg1})
	fake.setMaxExpectedSpatialLayerMutex.Unlock()
	if stub != nil {
		fake.SetMaxExpectedSpatialLayerStub(arg1)
	}
}

func (fake *FakeTrackReceiver) SetMaxExpectedSpatialLayerCallCount() int {
	fake.setMaxExpectedSpatialLayerMutex.RLock()
	defer fake.setMaxExpectedSpatialLayerMutex.RUnlock()
	return len(fake.setMaxExpectedSpatialLayerArgsForCall)
}

func (fake *FakeTrackReceiver) SetMaxExpectedSpatialLayerCalls(stub func(int32)) {
	fake.setMaxExpectedSpatialLayerMutex.Lock()
	defer fake.setMaxExpectedSpatialLayerMutex.Unlock()
	fake.SetMaxExpectedSpatialLayerStub = stub
}

func (fake *FakeTrackReceiver) SetMaxExpectedSpatialLayerArgsForCall(i int) int32 {
	fake.setMaxExpectedSpatialLayerMutex.RLock()
	defer fake.setMaxExpectedSpatialLayerMutex.RUnlock()
	argsForCall := fake.setMaxExpectedSpatialLayerArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeTrackReceiver) StreamID() string {
	fake.streamIDMutex.Lock()
	ret, specificReturn := fake.streamIDReturnsOnCall[len(fake.streamIDArgsForCall)]
	fake.streamIDArgsForCall = append(fake.streamIDArgsForCall, struct {
	}{})
	stub := fake.StreamIDStub
	fakeReturns := fake.streamIDReturns
	fake.recordInvocation("StreamID", []interface{}{})
	fake.streamIDMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeTrackReceiver) StreamIDCallCount() int {
	fake.streamIDMutex.RLock()
	defer fake.streamIDMutex.RUnlock()
	return len(fake.streamIDArgsForCall)
}

func (fake *FakeTrackReceiver) StreamIDCalls(stub func() string) {
	fake.streamIDMutex.Lock()
	defer fake.streamIDMutex.Unlock()
	fake.StreamIDStub = stub
}

func (fake *FakeTrackReceiver) StreamIDReturns(result1 string) {
	fake.streamIDMutex.Lock()
	defer fake.streamIDMutex.Unlock()
	fake.StreamIDStub = nil
	fake.streamIDReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeTrackReceiver) StreamIDReturnsOnCall(i int, result1 string) {
	fake.streamIDMutex.Lock()
	defer fake.streamIDMutex.Unlock()
	fake.StreamIDStub = nil
	if fake.streamIDReturnsOnCall == nil {
		fake.streamIDReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.streamIDReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeTrackReceiver) TrackID() livekit.TrackID {
	fake.trackIDMutex.Lock()
	ret, specificReturn := fake.trackIDReturnsOnCall[len(fake.trackIDArgsForCall)]
	fake.trackIDArgsForCall = append(fake.trackIDArgsForCall, struct {
	}{})
	stub := fake.TrackIDStub
	fakeReturns := fake.trackIDReturns
	fake.recordInvocation("TrackID", []interface{}{})
	fake.trackIDMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeTrackReceiver) TrackIDCallCount() int {
	fake.trackIDMutex.RLock()
	defer fake.trackIDMutex.RUnlock()
	return len(fake.trackIDArgsForCall)
}

func (fake *FakeTrackReceiver) TrackIDCalls(stub func() livekit.TrackID) {
	fake.trackIDMutex.Lock()
	defer fake.trackIDMutex.Unlock()
	fake.TrackIDStub = stub
}

func (fake *FakeTrackReceiver) TrackIDReturns(result1 livekit.TrackID) {
	fake.trackIDMutex.Lock()
	defer fake.trackIDMutex.Unlock()
	fake.TrackIDStub = nil
	fake.trackIDReturns = struct {
		result1 livekit.TrackID
	}{result1}
}

func (fake *FakeTrackReceiver) TrackIDReturnsOnCall(i int, result1 livekit.TrackID) {
	fake.trackIDMutex.Lock()
	defer fake.trackIDMutex.Unlock()
	fake.TrackIDStub = nil
	if fake.trackIDReturnsOnCall == nil {
		fake.trackIDReturnsOnCall = make(map[int]struct {
			result1 livekit.TrackID
		})
	}
	fake.trackIDReturnsOnCall[i] = struct {
		result1 livekit.TrackID
	}{result1}
}

func (fake *FakeTrackReceiver) TrackInfo() *livekit.TrackInfo {
	fake.trackInfoMutex.Lock()
	ret, specificReturn := fake.trackInfoReturnsOnCall[len(fake.trackInfoArgsForCall)]
	fake.trackInfoArgsForCall = append(fake.trackInfoArgsForCall, struct {
	}{})
	stub := fake.TrackInfoStub
	fakeReturns := fake.trackInfoReturns
	fake.recordInvocation("TrackInfo", []interface{}{})
	fake.trackInfoMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeTrackReceiver) TrackInfoCallCount() int {
	fake.trackInfoMutex.RLock()
	defer fake.trackInfoMutex.RUnlock()
	return len(fake.trackInfoArgsForCall)
}

func (fake *FakeTrackReceiver) TrackInfoCalls(stub func() *livekit.TrackInfo) {
	fake.trackInfoMutex.Lock()
	defer fake.trackInfoMutex.Unlock()
	fake.TrackInfoStub = stub
}

func (fake *FakeTrackReceiver) TrackInfoReturns(result1 *livekit.TrackInfo) {
	fake.trackInfoMutex.Lock()
	defer fake.trackInfoMutex.Unlock()
	fake.TrackInfoStub = nil
	fake.trackInfoReturns = struct {
		result1 *livekit.TrackInfo
	}{result1}
}

func (fake *FakeTrackReceiver) TrackInfoReturnsOnCall(i int, result1 *livekit.TrackInfo) {
	fake.trackInfoMutex.Lock()
	defer fake.trackInfoMutex.Unlock()
	fake.TrackInfoStub = nil
	if fake.trackInfoReturnsOnCall == nil {
		fake.trackInfoReturnsOnCall = make(map[int]struct {
			result1 *livekit.TrackInfo
		})
	}
	fake.trackInfoReturnsOnCall[i] = struct {
		result1 *livekit.TrackInfo
	}{result1}
}

func (fake *FakeTrackReceiver) UpdateTrackInfo(arg1 *livekit.TrackInfo) {
	fake.updateTrackInfoMutex.Lock()
	fake.updateTrackInfoArgsForCall = append(fake.updateTrackInfoArgsForCall, struct {
		arg1 *livekit.TrackInfo
	}{arg1})
	stub := fake.UpdateTrackInfoStub
	fake.recordInvocation("UpdateTrackInfo", []interface{}{arg1})
	fake.updateTrackInfoMutex.Unlock()
	if stub != nil {
		fake.UpdateTrackInfoStub(arg1)
	}
}

func (fake *FakeTrackReceiver) UpdateTrackInfoCallCount() int {
	fake.updateTrackInfoMutex.RLock()
	defer fake.updateTrackInfoMutex.RUnlock()
	return len(fake.updateTrackInfoArgsForCall)
}

func (fake *FakeTrackReceiver) UpdateTrackInfoCalls(stub func(*livekit.TrackInfo)) {
	fake.updateTrackInfoMutex.Lock()
	defer fake.updateTrackInfoMutex.Unlock()
	fake.UpdateTrackInfoStub = stub
}

func (fake *FakeTrackReceiver) UpdateTrackInfoArgsForCall(i int) *livekit.TrackInfo {
	fake.updateTrackInfoMutex.RLock()
	defer fake.updateTrackInfoMutex.RUnlock()
	argsForCall := fake.updateTrackInfoArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeTrackReceiver) VideoLayerMode() livekit.VideoLayer_Mode {
	fake.videoLayerModeMutex.Lock()
	ret, specificReturn := fake.videoLayerModeReturnsOnCall[len(fake.videoLayerModeArgsForCall)]
	fake.videoLayerModeArgsForCall = append(fake.videoLayerModeArgsForCall, struct {
	}{})
	stub := fake.VideoLayerModeStub
	fakeReturns := fake.videoLayerModeReturns
	fake.recordInvocation("VideoLayerMode", []interface{}{})
	fake.videoLayerModeMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeTrackReceiver) VideoLayerModeCallCount() int {
	fake.videoLayerModeMutex.RLock()
	defer fake.videoLayerModeMutex.RUnlock()
	return len(fake.videoLayerModeArgsForCall)
}

func (fake *FakeTrackReceiver) VideoLayerModeCalls(stub func() livekit.VideoLayer_Mode) {
	fake.videoLayerModeMutex.Lock()
	defer fake.videoLayerModeMutex.Unlock()
	fake.VideoLayerModeStub = stub
}

func (fake *FakeTrackReceiver) VideoLayerModeReturns(result1 livekit.VideoLayer_Mode) {
	fake.videoLayerModeMutex.Lock()
	defer fake.videoLayerModeMutex.Unlock()
	fake.VideoLayerModeStub = nil
	fake.videoLayerModeReturns = struct {
		result1 livekit.VideoLayer_Mode
	}{result1}
}

func (fake *FakeTrackReceiver) VideoLayerModeReturnsOnCall(i int, result1 livekit.VideoLayer_Mode) {
	fake.videoLayerModeMutex.Lock()
	defer fake.videoLayerModeMutex.Unlock()
	fake.VideoLayerModeStub = nil
	if fake.videoLayerModeReturnsOnCall == nil {
		fake.videoLayerModeReturnsOnCall = make(map[int]struct {
			result1 livekit.VideoLayer_Mode
		})
	}
	fake.videoLayerModeReturnsOnCall[i] = struct {
		result1 livekit.VideoLayer_Mode
	}{result1}
}

func (fake *FakeTrackReceiver) VideoSizes() []codec.VideoSize {
	fake.videoSizesMutex.Lock()
	ret, specificReturn := fake.videoSizesReturnsOnCall[len(fake.videoSizesArgsForCall)]
	fake.videoSizesArgsForCall = append(fake.videoSizesArgsForCall, struct {
	}{})
	stub := fake.VideoSizesStub
	fakeReturns := fake.videoSizesReturns
	fake.recordInvocation("VideoSizes", []interface{}{})
	fake.videoSizesMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeTrackReceiver) VideoSizesCallCount() int {
	fake.videoSizesMutex.RLock()
	defer fake.videoSizesMutex.RUnlock()
	return len(fake.videoSizesArgsForCall)
}

func (fake *FakeTrackReceiver) VideoSizesCalls(stub func() []codec.VideoSize) {
	fake.videoSizesMutex.Lock()
	defer fake.videoSizesMutex.Unlock()
	fake.VideoSizesStub = stub
}

func (fake *FakeTrackReceiver) VideoSizesReturns(result1 []codec.VideoSize) {
	fake.videoSizesMutex.Lock()
	defer fake.videoSizesMutex.Unlock()
	fake.VideoSizesStub = nil
	fake.videoSizesReturns = struct {
		result1 []codec.VideoSize
	}{result1}
}

func (fake *FakeTrackReceiver) VideoSizesReturnsOnCall(i int, result1 []codec.VideoSize) {
	fake.videoSizesMutex.Lock()
	defer fake.videoSizesMutex.Unlock()
	fake.VideoSizesStub = nil
	if fake.videoSizesReturnsOnCall == nil {
		fake.videoSizesReturnsOnCall = make(map[int]struct {
			result1 []codec.VideoSize
		})
	}
	fake.videoSizesReturnsOnCall[i] = struct {
		result1 []codec.VideoSize
	}{result1}
}

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