upstream-livekit/pkg/sfu/sfufakes/fake_redtransformer.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/mediatransportutil/pkg/codec"
	"github.com/livekit/protocol/codecs/mime"
	"github.com/livekit/protocol/livekit"
	webrtc "github.com/pion/webrtc/v4"
)

type FakeREDTransformer 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()
	}
	CanCloseStub        func() bool
	canCloseMutex       sync.RWMutex
	canCloseArgsForCall []struct {
	}
	canCloseReturns struct {
		result1 bool
	}
	canCloseReturnsOnCall map[int]struct {
		result1 bool
	}
	CloseStub        func()
	closeMutex       sync.RWMutex
	closeArgsForCall []struct {
	}
	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
	}
	ForwardRTCPSenderReportStub        func(webrtc.PayloadType, int32, *livekit.RTCPSenderReportState)
	forwardRTCPSenderReportMutex       sync.RWMutex
	forwardRTCPSenderReportArgsForCall []struct {
		arg1 webrtc.PayloadType
		arg2 int32
		arg3 *livekit.RTCPSenderReportState
	}
	ForwardRTPStub        func(*buffer.ExtPacket, int32) int32
	forwardRTPMutex       sync.RWMutex
	forwardRTPArgsForCall []struct {
		arg1 *buffer.ExtPacket
		arg2 int32
	}
	forwardRTPReturns struct {
		result1 int32
	}
	forwardRTPReturnsOnCall map[int]struct {
		result1 int32
	}
	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
	}
	OnStreamRestartStub        func()
	onStreamRestartMutex       sync.RWMutex
	onStreamRestartArgsForCall []struct {
	}
	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
	}
	ResyncDownTracksStub        func()
	resyncDownTracksMutex       sync.RWMutex
	resyncDownTracksArgsForCall []struct {
	}
	SendPLIStub        func(int32, bool)
	sendPLIMutex       sync.RWMutex
	sendPLIArgsForCall []struct {
		arg1 int32
		arg2 bool
	}
	SetLBThresholdStub        func(int)
	setLBThresholdMutex       sync.RWMutex
	setLBThresholdArgsForCall []struct {
		arg1 int
	}
	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 *FakeREDTransformer) 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 *FakeREDTransformer) AddDownTrackCallCount() int {
	fake.addDownTrackMutex.RLock()
	defer fake.addDownTrackMutex.RUnlock()
	return len(fake.addDownTrackArgsForCall)
}

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

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

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

func (fake *FakeREDTransformer) 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 *FakeREDTransformer) 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 *FakeREDTransformer) AddOnCodecStateChangeCallCount() int {
	fake.addOnCodecStateChangeMutex.RLock()
	defer fake.addOnCodecStateChangeMutex.RUnlock()
	return len(fake.addOnCodecStateChangeArgsForCall)
}

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

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

func (fake *FakeREDTransformer) 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 *FakeREDTransformer) AddOnReadyCallCount() int {
	fake.addOnReadyMutex.RLock()
	defer fake.addOnReadyMutex.RUnlock()
	return len(fake.addOnReadyArgsForCall)
}

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

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

func (fake *FakeREDTransformer) CanClose() bool {
	fake.canCloseMutex.Lock()
	ret, specificReturn := fake.canCloseReturnsOnCall[len(fake.canCloseArgsForCall)]
	fake.canCloseArgsForCall = append(fake.canCloseArgsForCall, struct {
	}{})
	stub := fake.CanCloseStub
	fakeReturns := fake.canCloseReturns
	fake.recordInvocation("CanClose", []interface{}{})
	fake.canCloseMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeREDTransformer) CanCloseCallCount() int {
	fake.canCloseMutex.RLock()
	defer fake.canCloseMutex.RUnlock()
	return len(fake.canCloseArgsForCall)
}

func (fake *FakeREDTransformer) CanCloseCalls(stub func() bool) {
	fake.canCloseMutex.Lock()
	defer fake.canCloseMutex.Unlock()
	fake.CanCloseStub = stub
}

func (fake *FakeREDTransformer) CanCloseReturns(result1 bool) {
	fake.canCloseMutex.Lock()
	defer fake.canCloseMutex.Unlock()
	fake.CanCloseStub = nil
	fake.canCloseReturns = struct {
		result1 bool
	}{result1}
}

func (fake *FakeREDTransformer) CanCloseReturnsOnCall(i int, result1 bool) {
	fake.canCloseMutex.Lock()
	defer fake.canCloseMutex.Unlock()
	fake.CanCloseStub = nil
	if fake.canCloseReturnsOnCall == nil {
		fake.canCloseReturnsOnCall = make(map[int]struct {
			result1 bool
		})
	}
	fake.canCloseReturnsOnCall[i] = struct {
		result1 bool
	}{result1}
}

func (fake *FakeREDTransformer) 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 *FakeREDTransformer) CloseCallCount() int {
	fake.closeMutex.RLock()
	defer fake.closeMutex.RUnlock()
	return len(fake.closeArgsForCall)
}

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

func (fake *FakeREDTransformer) 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 *FakeREDTransformer) CodecCallCount() int {
	fake.codecMutex.RLock()
	defer fake.codecMutex.RUnlock()
	return len(fake.codecArgsForCall)
}

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

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

func (fake *FakeREDTransformer) 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 *FakeREDTransformer) 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 *FakeREDTransformer) CodecStateCallCount() int {
	fake.codecStateMutex.RLock()
	defer fake.codecStateMutex.RUnlock()
	return len(fake.codecStateArgsForCall)
}

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

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

func (fake *FakeREDTransformer) 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 *FakeREDTransformer) 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 *FakeREDTransformer) DebugInfoCallCount() int {
	fake.debugInfoMutex.RLock()
	defer fake.debugInfoMutex.RUnlock()
	return len(fake.debugInfoArgsForCall)
}

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

func (fake *FakeREDTransformer) 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 *FakeREDTransformer) 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 *FakeREDTransformer) 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 *FakeREDTransformer) DeleteDownTrackCallCount() int {
	fake.deleteDownTrackMutex.RLock()
	defer fake.deleteDownTrackMutex.RUnlock()
	return len(fake.deleteDownTrackArgsForCall)
}

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

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

func (fake *FakeREDTransformer) ForwardRTCPSenderReport(arg1 webrtc.PayloadType, arg2 int32, arg3 *livekit.RTCPSenderReportState) {
	fake.forwardRTCPSenderReportMutex.Lock()
	fake.forwardRTCPSenderReportArgsForCall = append(fake.forwardRTCPSenderReportArgsForCall, struct {
		arg1 webrtc.PayloadType
		arg2 int32
		arg3 *livekit.RTCPSenderReportState
	}{arg1, arg2, arg3})
	stub := fake.ForwardRTCPSenderReportStub
	fake.recordInvocation("ForwardRTCPSenderReport", []interface{}{arg1, arg2, arg3})
	fake.forwardRTCPSenderReportMutex.Unlock()
	if stub != nil {
		fake.ForwardRTCPSenderReportStub(arg1, arg2, arg3)
	}
}

func (fake *FakeREDTransformer) ForwardRTCPSenderReportCallCount() int {
	fake.forwardRTCPSenderReportMutex.RLock()
	defer fake.forwardRTCPSenderReportMutex.RUnlock()
	return len(fake.forwardRTCPSenderReportArgsForCall)
}

func (fake *FakeREDTransformer) ForwardRTCPSenderReportCalls(stub func(webrtc.PayloadType, int32, *livekit.RTCPSenderReportState)) {
	fake.forwardRTCPSenderReportMutex.Lock()
	defer fake.forwardRTCPSenderReportMutex.Unlock()
	fake.ForwardRTCPSenderReportStub = stub
}

func (fake *FakeREDTransformer) ForwardRTCPSenderReportArgsForCall(i int) (webrtc.PayloadType, int32, *livekit.RTCPSenderReportState) {
	fake.forwardRTCPSenderReportMutex.RLock()
	defer fake.forwardRTCPSenderReportMutex.RUnlock()
	argsForCall := fake.forwardRTCPSenderReportArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeREDTransformer) ForwardRTP(arg1 *buffer.ExtPacket, arg2 int32) int32 {
	fake.forwardRTPMutex.Lock()
	ret, specificReturn := fake.forwardRTPReturnsOnCall[len(fake.forwardRTPArgsForCall)]
	fake.forwardRTPArgsForCall = append(fake.forwardRTPArgsForCall, struct {
		arg1 *buffer.ExtPacket
		arg2 int32
	}{arg1, arg2})
	stub := fake.ForwardRTPStub
	fakeReturns := fake.forwardRTPReturns
	fake.recordInvocation("ForwardRTP", []interface{}{arg1, arg2})
	fake.forwardRTPMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeREDTransformer) ForwardRTPCallCount() int {
	fake.forwardRTPMutex.RLock()
	defer fake.forwardRTPMutex.RUnlock()
	return len(fake.forwardRTPArgsForCall)
}

func (fake *FakeREDTransformer) ForwardRTPCalls(stub func(*buffer.ExtPacket, int32) int32) {
	fake.forwardRTPMutex.Lock()
	defer fake.forwardRTPMutex.Unlock()
	fake.ForwardRTPStub = stub
}

func (fake *FakeREDTransformer) ForwardRTPArgsForCall(i int) (*buffer.ExtPacket, int32) {
	fake.forwardRTPMutex.RLock()
	defer fake.forwardRTPMutex.RUnlock()
	argsForCall := fake.forwardRTPArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeREDTransformer) ForwardRTPReturns(result1 int32) {
	fake.forwardRTPMutex.Lock()
	defer fake.forwardRTPMutex.Unlock()
	fake.ForwardRTPStub = nil
	fake.forwardRTPReturns = struct {
		result1 int32
	}{result1}
}

func (fake *FakeREDTransformer) ForwardRTPReturnsOnCall(i int, result1 int32) {
	fake.forwardRTPMutex.Lock()
	defer fake.forwardRTPMutex.Unlock()
	fake.ForwardRTPStub = nil
	if fake.forwardRTPReturnsOnCall == nil {
		fake.forwardRTPReturnsOnCall = make(map[int]struct {
			result1 int32
		})
	}
	fake.forwardRTPReturnsOnCall[i] = struct {
		result1 int32
	}{result1}
}

func (fake *FakeREDTransformer) 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 *FakeREDTransformer) GetAudioLevelCallCount() int {
	fake.getAudioLevelMutex.RLock()
	defer fake.getAudioLevelMutex.RUnlock()
	return len(fake.getAudioLevelArgsForCall)
}

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

func (fake *FakeREDTransformer) 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 *FakeREDTransformer) 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 *FakeREDTransformer) 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 *FakeREDTransformer) GetDownTracksCallCount() int {
	fake.getDownTracksMutex.RLock()
	defer fake.getDownTracksMutex.RUnlock()
	return len(fake.getDownTracksArgsForCall)
}

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

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

func (fake *FakeREDTransformer) 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 *FakeREDTransformer) 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 *FakeREDTransformer) GetLayeredBitrateCallCount() int {
	fake.getLayeredBitrateMutex.RLock()
	defer fake.getLayeredBitrateMutex.RUnlock()
	return len(fake.getLayeredBitrateArgsForCall)
}

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

func (fake *FakeREDTransformer) 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 *FakeREDTransformer) 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 *FakeREDTransformer) 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 *FakeREDTransformer) GetPrimaryReceiverForRedCallCount() int {
	fake.getPrimaryReceiverForRedMutex.RLock()
	defer fake.getPrimaryReceiverForRedMutex.RUnlock()
	return len(fake.getPrimaryReceiverForRedArgsForCall)
}

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

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

func (fake *FakeREDTransformer) 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 *FakeREDTransformer) 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 *FakeREDTransformer) GetRedReceiverCallCount() int {
	fake.getRedReceiverMutex.RLock()
	defer fake.getRedReceiverMutex.RUnlock()
	return len(fake.getRedReceiverArgsForCall)
}

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

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

func (fake *FakeREDTransformer) 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 *FakeREDTransformer) 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 *FakeREDTransformer) GetTemporalLayerFpsForSpatialCallCount() int {
	fake.getTemporalLayerFpsForSpatialMutex.RLock()
	defer fake.getTemporalLayerFpsForSpatialMutex.RUnlock()
	return len(fake.getTemporalLayerFpsForSpatialArgsForCall)
}

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

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

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

func (fake *FakeREDTransformer) 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 *FakeREDTransformer) 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 *FakeREDTransformer) GetTrackStatsCallCount() int {
	fake.getTrackStatsMutex.RLock()
	defer fake.getTrackStatsMutex.RUnlock()
	return len(fake.getTrackStatsArgsForCall)
}

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

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

func (fake *FakeREDTransformer) 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 *FakeREDTransformer) 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 *FakeREDTransformer) HeaderExtensionsCallCount() int {
	fake.headerExtensionsMutex.RLock()
	defer fake.headerExtensionsMutex.RUnlock()
	return len(fake.headerExtensionsArgsForCall)
}

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

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

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

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

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

func (fake *FakeREDTransformer) 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 *FakeREDTransformer) 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 *FakeREDTransformer) MimeCallCount() int {
	fake.mimeMutex.RLock()
	defer fake.mimeMutex.RUnlock()
	return len(fake.mimeArgsForCall)
}

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

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

func (fake *FakeREDTransformer) 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 *FakeREDTransformer) OnStreamRestart() {
	fake.onStreamRestartMutex.Lock()
	fake.onStreamRestartArgsForCall = append(fake.onStreamRestartArgsForCall, struct {
	}{})
	stub := fake.OnStreamRestartStub
	fake.recordInvocation("OnStreamRestart", []interface{}{})
	fake.onStreamRestartMutex.Unlock()
	if stub != nil {
		fake.OnStreamRestartStub()
	}
}

func (fake *FakeREDTransformer) OnStreamRestartCallCount() int {
	fake.onStreamRestartMutex.RLock()
	defer fake.onStreamRestartMutex.RUnlock()
	return len(fake.onStreamRestartArgsForCall)
}

func (fake *FakeREDTransformer) OnStreamRestartCalls(stub func()) {
	fake.onStreamRestartMutex.Lock()
	defer fake.onStreamRestartMutex.Unlock()
	fake.OnStreamRestartStub = stub
}

func (fake *FakeREDTransformer) 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 *FakeREDTransformer) ReadRTPCallCount() int {
	fake.readRTPMutex.RLock()
	defer fake.readRTPMutex.RUnlock()
	return len(fake.readRTPArgsForCall)
}

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

func (fake *FakeREDTransformer) 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 *FakeREDTransformer) 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 *FakeREDTransformer) 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 *FakeREDTransformer) 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 *FakeREDTransformer) RestartCallCount() int {
	fake.restartMutex.RLock()
	defer fake.restartMutex.RUnlock()
	return len(fake.restartArgsForCall)
}

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

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

func (fake *FakeREDTransformer) ResyncDownTracks() {
	fake.resyncDownTracksMutex.Lock()
	fake.resyncDownTracksArgsForCall = append(fake.resyncDownTracksArgsForCall, struct {
	}{})
	stub := fake.ResyncDownTracksStub
	fake.recordInvocation("ResyncDownTracks", []interface{}{})
	fake.resyncDownTracksMutex.Unlock()
	if stub != nil {
		fake.ResyncDownTracksStub()
	}
}

func (fake *FakeREDTransformer) ResyncDownTracksCallCount() int {
	fake.resyncDownTracksMutex.RLock()
	defer fake.resyncDownTracksMutex.RUnlock()
	return len(fake.resyncDownTracksArgsForCall)
}

func (fake *FakeREDTransformer) ResyncDownTracksCalls(stub func()) {
	fake.resyncDownTracksMutex.Lock()
	defer fake.resyncDownTracksMutex.Unlock()
	fake.ResyncDownTracksStub = stub
}

func (fake *FakeREDTransformer) 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 *FakeREDTransformer) SendPLICallCount() int {
	fake.sendPLIMutex.RLock()
	defer fake.sendPLIMutex.RUnlock()
	return len(fake.sendPLIArgsForCall)
}

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

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

func (fake *FakeREDTransformer) SetLBThreshold(arg1 int) {
	fake.setLBThresholdMutex.Lock()
	fake.setLBThresholdArgsForCall = append(fake.setLBThresholdArgsForCall, struct {
		arg1 int
	}{arg1})
	stub := fake.SetLBThresholdStub
	fake.recordInvocation("SetLBThreshold", []interface{}{arg1})
	fake.setLBThresholdMutex.Unlock()
	if stub != nil {
		fake.SetLBThresholdStub(arg1)
	}
}

func (fake *FakeREDTransformer) SetLBThresholdCallCount() int {
	fake.setLBThresholdMutex.RLock()
	defer fake.setLBThresholdMutex.RUnlock()
	return len(fake.setLBThresholdArgsForCall)
}

func (fake *FakeREDTransformer) SetLBThresholdCalls(stub func(int)) {
	fake.setLBThresholdMutex.Lock()
	defer fake.setLBThresholdMutex.Unlock()
	fake.SetLBThresholdStub = stub
}

func (fake *FakeREDTransformer) SetLBThresholdArgsForCall(i int) int {
	fake.setLBThresholdMutex.RLock()
	defer fake.setLBThresholdMutex.RUnlock()
	argsForCall := fake.setLBThresholdArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeREDTransformer) 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 *FakeREDTransformer) SetMaxExpectedSpatialLayerCallCount() int {
	fake.setMaxExpectedSpatialLayerMutex.RLock()
	defer fake.setMaxExpectedSpatialLayerMutex.RUnlock()
	return len(fake.setMaxExpectedSpatialLayerArgsForCall)
}

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

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

func (fake *FakeREDTransformer) 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 *FakeREDTransformer) StreamIDCallCount() int {
	fake.streamIDMutex.RLock()
	defer fake.streamIDMutex.RUnlock()
	return len(fake.streamIDArgsForCall)
}

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

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

func (fake *FakeREDTransformer) 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 *FakeREDTransformer) 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 *FakeREDTransformer) TrackIDCallCount() int {
	fake.trackIDMutex.RLock()
	defer fake.trackIDMutex.RUnlock()
	return len(fake.trackIDArgsForCall)
}

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

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

func (fake *FakeREDTransformer) 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 *FakeREDTransformer) 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 *FakeREDTransformer) TrackInfoCallCount() int {
	fake.trackInfoMutex.RLock()
	defer fake.trackInfoMutex.RUnlock()
	return len(fake.trackInfoArgsForCall)
}

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

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

func (fake *FakeREDTransformer) 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 *FakeREDTransformer) 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 *FakeREDTransformer) UpdateTrackInfoCallCount() int {
	fake.updateTrackInfoMutex.RLock()
	defer fake.updateTrackInfoMutex.RUnlock()
	return len(fake.updateTrackInfoArgsForCall)
}

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

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

func (fake *FakeREDTransformer) 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 *FakeREDTransformer) VideoLayerModeCallCount() int {
	fake.videoLayerModeMutex.RLock()
	defer fake.videoLayerModeMutex.RUnlock()
	return len(fake.videoLayerModeArgsForCall)
}

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

func (fake *FakeREDTransformer) 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 *FakeREDTransformer) 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 *FakeREDTransformer) 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 *FakeREDTransformer) VideoSizesCallCount() int {
	fake.videoSizesMutex.RLock()
	defer fake.videoSizesMutex.RUnlock()
	return len(fake.videoSizesArgsForCall)
}

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

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

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