snapshot of https://github.com/livekit/livekit.git @ 08c5433449c106943231037d0b892895f6e92d3b (2026-09-15)

pkg/sfu/sfufakes/fake_track_sender.go

@@ -0,0 +1,683 @@
+// Code generated by counterfeiter. DO NOT EDIT.
+package sfufakes
+
+import (
+	"sync"
+
+	"github.com/livekit/livekit-server/pkg/sfu"
+	"github.com/livekit/livekit-server/pkg/sfu/buffer"
+	"github.com/livekit/protocol/livekit"
+	webrtc "github.com/pion/webrtc/v4"
+)
+
+type FakeTrackSender struct {
+	CloseStub        func()
+	closeMutex       sync.RWMutex
+	closeArgsForCall []struct {
+	}
+	HandleRTCPSenderReportDataStub        func(webrtc.PayloadType, int32, *livekit.RTCPSenderReportState) error
+	handleRTCPSenderReportDataMutex       sync.RWMutex
+	handleRTCPSenderReportDataArgsForCall []struct {
+		arg1 webrtc.PayloadType
+		arg2 int32
+		arg3 *livekit.RTCPSenderReportState
+	}
+	handleRTCPSenderReportDataReturns struct {
+		result1 error
+	}
+	handleRTCPSenderReportDataReturnsOnCall map[int]struct {
+		result1 error
+	}
+	IDStub        func() string
+	iDMutex       sync.RWMutex
+	iDArgsForCall []struct {
+	}
+	iDReturns struct {
+		result1 string
+	}
+	iDReturnsOnCall map[int]struct {
+		result1 string
+	}
+	IsClosedStub        func() bool
+	isClosedMutex       sync.RWMutex
+	isClosedArgsForCall []struct {
+	}
+	isClosedReturns struct {
+		result1 bool
+	}
+	isClosedReturnsOnCall map[int]struct {
+		result1 bool
+	}
+	ReceiverRestartStub        func(sfu.TrackReceiver)
+	receiverRestartMutex       sync.RWMutex
+	receiverRestartArgsForCall []struct {
+		arg1 sfu.TrackReceiver
+	}
+	ResyncStub        func()
+	resyncMutex       sync.RWMutex
+	resyncArgsForCall []struct {
+	}
+	SetReceiverStub        func(sfu.TrackReceiver)
+	setReceiverMutex       sync.RWMutex
+	setReceiverArgsForCall []struct {
+		arg1 sfu.TrackReceiver
+	}
+	SubscriberIDStub        func() livekit.ParticipantID
+	subscriberIDMutex       sync.RWMutex
+	subscriberIDArgsForCall []struct {
+	}
+	subscriberIDReturns struct {
+		result1 livekit.ParticipantID
+	}
+	subscriberIDReturnsOnCall map[int]struct {
+		result1 livekit.ParticipantID
+	}
+	UpTrackBitrateAvailabilityChangeStub        func()
+	upTrackBitrateAvailabilityChangeMutex       sync.RWMutex
+	upTrackBitrateAvailabilityChangeArgsForCall []struct {
+	}
+	UpTrackBitrateReportStub        func([]int32, sfu.Bitrates)
+	upTrackBitrateReportMutex       sync.RWMutex
+	upTrackBitrateReportArgsForCall []struct {
+		arg1 []int32
+		arg2 sfu.Bitrates
+	}
+	UpTrackLayersChangeStub        func()
+	upTrackLayersChangeMutex       sync.RWMutex
+	upTrackLayersChangeArgsForCall []struct {
+	}
+	UpTrackMaxPublishedLayerChangeStub        func(int32)
+	upTrackMaxPublishedLayerChangeMutex       sync.RWMutex
+	upTrackMaxPublishedLayerChangeArgsForCall []struct {
+		arg1 int32
+	}
+	UpTrackMaxTemporalLayerSeenChangeStub        func(int32)
+	upTrackMaxTemporalLayerSeenChangeMutex       sync.RWMutex
+	upTrackMaxTemporalLayerSeenChangeArgsForCall []struct {
+		arg1 int32
+	}
+	WriteRTPStub        func(*buffer.ExtPacket, int32) int32
+	writeRTPMutex       sync.RWMutex
+	writeRTPArgsForCall []struct {
+		arg1 *buffer.ExtPacket
+		arg2 int32
+	}
+	writeRTPReturns struct {
+		result1 int32
+	}
+	writeRTPReturnsOnCall map[int]struct {
+		result1 int32
+	}
+	invocations      map[string][][]interface{}
+	invocationsMutex sync.RWMutex
+}
+
+func (fake *FakeTrackSender) Close() {
+	fake.closeMutex.Lock()
+	fake.closeArgsForCall = append(fake.closeArgsForCall, struct {
+	}{})
+	stub := fake.CloseStub
+	fake.recordInvocation("Close", []interface{}{})
+	fake.closeMutex.Unlock()
+	if stub != nil {
+		fake.CloseStub()
+	}
+}
+
+func (fake *FakeTrackSender) CloseCallCount() int {
+	fake.closeMutex.RLock()
+	defer fake.closeMutex.RUnlock()
+	return len(fake.closeArgsForCall)
+}
+
+func (fake *FakeTrackSender) CloseCalls(stub func()) {
+	fake.closeMutex.Lock()
+	defer fake.closeMutex.Unlock()
+	fake.CloseStub = stub
+}
+
+func (fake *FakeTrackSender) HandleRTCPSenderReportData(arg1 webrtc.PayloadType, arg2 int32, arg3 *livekit.RTCPSenderReportState) error {
+	fake.handleRTCPSenderReportDataMutex.Lock()
+	ret, specificReturn := fake.handleRTCPSenderReportDataReturnsOnCall[len(fake.handleRTCPSenderReportDataArgsForCall)]
+	fake.handleRTCPSenderReportDataArgsForCall = append(fake.handleRTCPSenderReportDataArgsForCall, struct {
+		arg1 webrtc.PayloadType
+		arg2 int32
+		arg3 *livekit.RTCPSenderReportState
+	}{arg1, arg2, arg3})
+	stub := fake.HandleRTCPSenderReportDataStub
+	fakeReturns := fake.handleRTCPSenderReportDataReturns
+	fake.recordInvocation("HandleRTCPSenderReportData", []interface{}{arg1, arg2, arg3})
+	fake.handleRTCPSenderReportDataMutex.Unlock()
+	if stub != nil {
+		return stub(arg1, arg2, arg3)
+	}
+	if specificReturn {
+		return ret.result1
+	}
+	return fakeReturns.result1
+}
+
+func (fake *FakeTrackSender) HandleRTCPSenderReportDataCallCount() int {
+	fake.handleRTCPSenderReportDataMutex.RLock()
+	defer fake.handleRTCPSenderReportDataMutex.RUnlock()
+	return len(fake.handleRTCPSenderReportDataArgsForCall)
+}
+
+func (fake *FakeTrackSender) HandleRTCPSenderReportDataCalls(stub func(webrtc.PayloadType, int32, *livekit.RTCPSenderReportState) error) {
+	fake.handleRTCPSenderReportDataMutex.Lock()
+	defer fake.handleRTCPSenderReportDataMutex.Unlock()
+	fake.HandleRTCPSenderReportDataStub = stub
+}
+
+func (fake *FakeTrackSender) HandleRTCPSenderReportDataArgsForCall(i int) (webrtc.PayloadType, int32, *livekit.RTCPSenderReportState) {
+	fake.handleRTCPSenderReportDataMutex.RLock()
+	defer fake.handleRTCPSenderReportDataMutex.RUnlock()
+	argsForCall := fake.handleRTCPSenderReportDataArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
+}
+
+func (fake *FakeTrackSender) HandleRTCPSenderReportDataReturns(result1 error) {
+	fake.handleRTCPSenderReportDataMutex.Lock()
+	defer fake.handleRTCPSenderReportDataMutex.Unlock()
+	fake.HandleRTCPSenderReportDataStub = nil
+	fake.handleRTCPSenderReportDataReturns = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakeTrackSender) HandleRTCPSenderReportDataReturnsOnCall(i int, result1 error) {
+	fake.handleRTCPSenderReportDataMutex.Lock()
+	defer fake.handleRTCPSenderReportDataMutex.Unlock()
+	fake.HandleRTCPSenderReportDataStub = nil
+	if fake.handleRTCPSenderReportDataReturnsOnCall == nil {
+		fake.handleRTCPSenderReportDataReturnsOnCall = make(map[int]struct {
+			result1 error
+		})
+	}
+	fake.handleRTCPSenderReportDataReturnsOnCall[i] = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakeTrackSender) ID() string {
+	fake.iDMutex.Lock()
+	ret, specificReturn := fake.iDReturnsOnCall[len(fake.iDArgsForCall)]
+	fake.iDArgsForCall = append(fake.iDArgsForCall, struct {
+	}{})
+	stub := fake.IDStub
+	fakeReturns := fake.iDReturns
+	fake.recordInvocation("ID", []interface{}{})
+	fake.iDMutex.Unlock()
+	if stub != nil {
+		return stub()
+	}
+	if specificReturn {
+		return ret.result1
+	}
+	return fakeReturns.result1
+}
+
+func (fake *FakeTrackSender) IDCallCount() int {
+	fake.iDMutex.RLock()
+	defer fake.iDMutex.RUnlock()
+	return len(fake.iDArgsForCall)
+}
+
+func (fake *FakeTrackSender) IDCalls(stub func() string) {
+	fake.iDMutex.Lock()
+	defer fake.iDMutex.Unlock()
+	fake.IDStub = stub
+}
+
+func (fake *FakeTrackSender) IDReturns(result1 string) {
+	fake.iDMutex.Lock()
+	defer fake.iDMutex.Unlock()
+	fake.IDStub = nil
+	fake.iDReturns = struct {
+		result1 string
+	}{result1}
+}
+
+func (fake *FakeTrackSender) IDReturnsOnCall(i int, result1 string) {
+	fake.iDMutex.Lock()
+	defer fake.iDMutex.Unlock()
+	fake.IDStub = nil
+	if fake.iDReturnsOnCall == nil {
+		fake.iDReturnsOnCall = make(map[int]struct {
+			result1 string
+		})
+	}
+	fake.iDReturnsOnCall[i] = struct {
+		result1 string
+	}{result1}
+}
+
+func (fake *FakeTrackSender) IsClosed() bool {
+	fake.isClosedMutex.Lock()
+	ret, specificReturn := fake.isClosedReturnsOnCall[len(fake.isClosedArgsForCall)]
+	fake.isClosedArgsForCall = append(fake.isClosedArgsForCall, struct {
+	}{})
+	stub := fake.IsClosedStub
+	fakeReturns := fake.isClosedReturns
+	fake.recordInvocation("IsClosed", []interface{}{})
+	fake.isClosedMutex.Unlock()
+	if stub != nil {
+		return stub()
+	}
+	if specificReturn {
+		return ret.result1
+	}
+	return fakeReturns.result1
+}
+
+func (fake *FakeTrackSender) IsClosedCallCount() int {
+	fake.isClosedMutex.RLock()
+	defer fake.isClosedMutex.RUnlock()
+	return len(fake.isClosedArgsForCall)
+}
+
+func (fake *FakeTrackSender) IsClosedCalls(stub func() bool) {
+	fake.isClosedMutex.Lock()
+	defer fake.isClosedMutex.Unlock()
+	fake.IsClosedStub = stub
+}
+
+func (fake *FakeTrackSender) IsClosedReturns(result1 bool) {
+	fake.isClosedMutex.Lock()
+	defer fake.isClosedMutex.Unlock()
+	fake.IsClosedStub = nil
+	fake.isClosedReturns = struct {
+		result1 bool
+	}{result1}
+}
+
+func (fake *FakeTrackSender) IsClosedReturnsOnCall(i int, result1 bool) {
+	fake.isClosedMutex.Lock()
+	defer fake.isClosedMutex.Unlock()
+	fake.IsClosedStub = nil
+	if fake.isClosedReturnsOnCall == nil {
+		fake.isClosedReturnsOnCall = make(map[int]struct {
+			result1 bool
+		})
+	}
+	fake.isClosedReturnsOnCall[i] = struct {
+		result1 bool
+	}{result1}
+}
+
+func (fake *FakeTrackSender) ReceiverRestart(arg1 sfu.TrackReceiver) {
+	fake.receiverRestartMutex.Lock()
+	fake.receiverRestartArgsForCall = append(fake.receiverRestartArgsForCall, struct {
+		arg1 sfu.TrackReceiver
+	}{arg1})
+	stub := fake.ReceiverRestartStub
+	fake.recordInvocation("ReceiverRestart", []interface{}{arg1})
+	fake.receiverRestartMutex.Unlock()
+	if stub != nil {
+		fake.ReceiverRestartStub(arg1)
+	}
+}
+
+func (fake *FakeTrackSender) ReceiverRestartCallCount() int {
+	fake.receiverRestartMutex.RLock()
+	defer fake.receiverRestartMutex.RUnlock()
+	return len(fake.receiverRestartArgsForCall)
+}
+
+func (fake *FakeTrackSender) ReceiverRestartCalls(stub func(sfu.TrackReceiver)) {
+	fake.receiverRestartMutex.Lock()
+	defer fake.receiverRestartMutex.Unlock()
+	fake.ReceiverRestartStub = stub
+}
+
+func (fake *FakeTrackSender) ReceiverRestartArgsForCall(i int) sfu.TrackReceiver {
+	fake.receiverRestartMutex.RLock()
+	defer fake.receiverRestartMutex.RUnlock()
+	argsForCall := fake.receiverRestartArgsForCall[i]
+	return argsForCall.arg1
+}
+
+func (fake *FakeTrackSender) Resync() {
+	fake.resyncMutex.Lock()
+	fake.resyncArgsForCall = append(fake.resyncArgsForCall, struct {
+	}{})
+	stub := fake.ResyncStub
+	fake.recordInvocation("Resync", []interface{}{})
+	fake.resyncMutex.Unlock()
+	if stub != nil {
+		fake.ResyncStub()
+	}
+}
+
+func (fake *FakeTrackSender) ResyncCallCount() int {
+	fake.resyncMutex.RLock()
+	defer fake.resyncMutex.RUnlock()
+	return len(fake.resyncArgsForCall)
+}
+
+func (fake *FakeTrackSender) ResyncCalls(stub func()) {
+	fake.resyncMutex.Lock()
+	defer fake.resyncMutex.Unlock()
+	fake.ResyncStub = stub
+}
+
+func (fake *FakeTrackSender) SetReceiver(arg1 sfu.TrackReceiver) {
+	fake.setReceiverMutex.Lock()
+	fake.setReceiverArgsForCall = append(fake.setReceiverArgsForCall, struct {
+		arg1 sfu.TrackReceiver
+	}{arg1})
+	stub := fake.SetReceiverStub
+	fake.recordInvocation("SetReceiver", []interface{}{arg1})
+	fake.setReceiverMutex.Unlock()
+	if stub != nil {
+		fake.SetReceiverStub(arg1)
+	}
+}
+
+func (fake *FakeTrackSender) SetReceiverCallCount() int {
+	fake.setReceiverMutex.RLock()
+	defer fake.setReceiverMutex.RUnlock()
+	return len(fake.setReceiverArgsForCall)
+}
+
+func (fake *FakeTrackSender) SetReceiverCalls(stub func(sfu.TrackReceiver)) {
+	fake.setReceiverMutex.Lock()
+	defer fake.setReceiverMutex.Unlock()
+	fake.SetReceiverStub = stub
+}
+
+func (fake *FakeTrackSender) SetReceiverArgsForCall(i int) sfu.TrackReceiver {
+	fake.setReceiverMutex.RLock()
+	defer fake.setReceiverMutex.RUnlock()
+	argsForCall := fake.setReceiverArgsForCall[i]
+	return argsForCall.arg1
+}
+
+func (fake *FakeTrackSender) SubscriberID() livekit.ParticipantID {
+	fake.subscriberIDMutex.Lock()
+	ret, specificReturn := fake.subscriberIDReturnsOnCall[len(fake.subscriberIDArgsForCall)]
+	fake.subscriberIDArgsForCall = append(fake.subscriberIDArgsForCall, struct {
+	}{})
+	stub := fake.SubscriberIDStub
+	fakeReturns := fake.subscriberIDReturns
+	fake.recordInvocation("SubscriberID", []interface{}{})
+	fake.subscriberIDMutex.Unlock()
+	if stub != nil {
+		return stub()
+	}
+	if specificReturn {
+		return ret.result1
+	}
+	return fakeReturns.result1
+}
+
+func (fake *FakeTrackSender) SubscriberIDCallCount() int {
+	fake.subscriberIDMutex.RLock()
+	defer fake.subscriberIDMutex.RUnlock()
+	return len(fake.subscriberIDArgsForCall)
+}
+
+func (fake *FakeTrackSender) SubscriberIDCalls(stub func() livekit.ParticipantID) {
+	fake.subscriberIDMutex.Lock()
+	defer fake.subscriberIDMutex.Unlock()
+	fake.SubscriberIDStub = stub
+}
+
+func (fake *FakeTrackSender) SubscriberIDReturns(result1 livekit.ParticipantID) {
+	fake.subscriberIDMutex.Lock()
+	defer fake.subscriberIDMutex.Unlock()
+	fake.SubscriberIDStub = nil
+	fake.subscriberIDReturns = struct {
+		result1 livekit.ParticipantID
+	}{result1}
+}
+
+func (fake *FakeTrackSender) SubscriberIDReturnsOnCall(i int, result1 livekit.ParticipantID) {
+	fake.subscriberIDMutex.Lock()
+	defer fake.subscriberIDMutex.Unlock()
+	fake.SubscriberIDStub = nil
+	if fake.subscriberIDReturnsOnCall == nil {
+		fake.subscriberIDReturnsOnCall = make(map[int]struct {
+			result1 livekit.ParticipantID
+		})
+	}
+	fake.subscriberIDReturnsOnCall[i] = struct {
+		result1 livekit.ParticipantID
+	}{result1}
+}
+
+func (fake *FakeTrackSender) UpTrackBitrateAvailabilityChange() {
+	fake.upTrackBitrateAvailabilityChangeMutex.Lock()
+	fake.upTrackBitrateAvailabilityChangeArgsForCall = append(fake.upTrackBitrateAvailabilityChangeArgsForCall, struct {
+	}{})
+	stub := fake.UpTrackBitrateAvailabilityChangeStub
+	fake.recordInvocation("UpTrackBitrateAvailabilityChange", []interface{}{})
+	fake.upTrackBitrateAvailabilityChangeMutex.Unlock()
+	if stub != nil {
+		fake.UpTrackBitrateAvailabilityChangeStub()
+	}
+}
+
+func (fake *FakeTrackSender) UpTrackBitrateAvailabilityChangeCallCount() int {
+	fake.upTrackBitrateAvailabilityChangeMutex.RLock()
+	defer fake.upTrackBitrateAvailabilityChangeMutex.RUnlock()
+	return len(fake.upTrackBitrateAvailabilityChangeArgsForCall)
+}
+
+func (fake *FakeTrackSender) UpTrackBitrateAvailabilityChangeCalls(stub func()) {
+	fake.upTrackBitrateAvailabilityChangeMutex.Lock()
+	defer fake.upTrackBitrateAvailabilityChangeMutex.Unlock()
+	fake.UpTrackBitrateAvailabilityChangeStub = stub
+}
+
+func (fake *FakeTrackSender) UpTrackBitrateReport(arg1 []int32, arg2 sfu.Bitrates) {
+	var arg1Copy []int32
+	if arg1 != nil {
+		arg1Copy = make([]int32, len(arg1))
+		copy(arg1Copy, arg1)
+	}
+	fake.upTrackBitrateReportMutex.Lock()
+	fake.upTrackBitrateReportArgsForCall = append(fake.upTrackBitrateReportArgsForCall, struct {
+		arg1 []int32
+		arg2 sfu.Bitrates
+	}{arg1Copy, arg2})
+	stub := fake.UpTrackBitrateReportStub
+	fake.recordInvocation("UpTrackBitrateReport", []interface{}{arg1Copy, arg2})
+	fake.upTrackBitrateReportMutex.Unlock()
+	if stub != nil {
+		fake.UpTrackBitrateReportStub(arg1, arg2)
+	}
+}
+
+func (fake *FakeTrackSender) UpTrackBitrateReportCallCount() int {
+	fake.upTrackBitrateReportMutex.RLock()
+	defer fake.upTrackBitrateReportMutex.RUnlock()
+	return len(fake.upTrackBitrateReportArgsForCall)
+}
+
+func (fake *FakeTrackSender) UpTrackBitrateReportCalls(stub func([]int32, sfu.Bitrates)) {
+	fake.upTrackBitrateReportMutex.Lock()
+	defer fake.upTrackBitrateReportMutex.Unlock()
+	fake.UpTrackBitrateReportStub = stub
+}
+
+func (fake *FakeTrackSender) UpTrackBitrateReportArgsForCall(i int) ([]int32, sfu.Bitrates) {
+	fake.upTrackBitrateReportMutex.RLock()
+	defer fake.upTrackBitrateReportMutex.RUnlock()
+	argsForCall := fake.upTrackBitrateReportArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2
+}
+
+func (fake *FakeTrackSender) UpTrackLayersChange() {
+	fake.upTrackLayersChangeMutex.Lock()
+	fake.upTrackLayersChangeArgsForCall = append(fake.upTrackLayersChangeArgsForCall, struct {
+	}{})
+	stub := fake.UpTrackLayersChangeStub
+	fake.recordInvocation("UpTrackLayersChange", []interface{}{})
+	fake.upTrackLayersChangeMutex.Unlock()
+	if stub != nil {
+		fake.UpTrackLayersChangeStub()
+	}
+}
+
+func (fake *FakeTrackSender) UpTrackLayersChangeCallCount() int {
+	fake.upTrackLayersChangeMutex.RLock()
+	defer fake.upTrackLayersChangeMutex.RUnlock()
+	return len(fake.upTrackLayersChangeArgsForCall)
+}
+
+func (fake *FakeTrackSender) UpTrackLayersChangeCalls(stub func()) {
+	fake.upTrackLayersChangeMutex.Lock()
+	defer fake.upTrackLayersChangeMutex.Unlock()
+	fake.UpTrackLayersChangeStub = stub
+}
+
+func (fake *FakeTrackSender) UpTrackMaxPublishedLayerChange(arg1 int32) {
+	fake.upTrackMaxPublishedLayerChangeMutex.Lock()
+	fake.upTrackMaxPublishedLayerChangeArgsForCall = append(fake.upTrackMaxPublishedLayerChangeArgsForCall, struct {
+		arg1 int32
+	}{arg1})
+	stub := fake.UpTrackMaxPublishedLayerChangeStub
+	fake.recordInvocation("UpTrackMaxPublishedLayerChange", []interface{}{arg1})
+	fake.upTrackMaxPublishedLayerChangeMutex.Unlock()
+	if stub != nil {
+		fake.UpTrackMaxPublishedLayerChangeStub(arg1)
+	}
+}
+
+func (fake *FakeTrackSender) UpTrackMaxPublishedLayerChangeCallCount() int {
+	fake.upTrackMaxPublishedLayerChangeMutex.RLock()
+	defer fake.upTrackMaxPublishedLayerChangeMutex.RUnlock()
+	return len(fake.upTrackMaxPublishedLayerChangeArgsForCall)
+}
+
+func (fake *FakeTrackSender) UpTrackMaxPublishedLayerChangeCalls(stub func(int32)) {
+	fake.upTrackMaxPublishedLayerChangeMutex.Lock()
+	defer fake.upTrackMaxPublishedLayerChangeMutex.Unlock()
+	fake.UpTrackMaxPublishedLayerChangeStub = stub
+}
+
+func (fake *FakeTrackSender) UpTrackMaxPublishedLayerChangeArgsForCall(i int) int32 {
+	fake.upTrackMaxPublishedLayerChangeMutex.RLock()
+	defer fake.upTrackMaxPublishedLayerChangeMutex.RUnlock()
+	argsForCall := fake.upTrackMaxPublishedLayerChangeArgsForCall[i]
+	return argsForCall.arg1
+}
+
+func (fake *FakeTrackSender) UpTrackMaxTemporalLayerSeenChange(arg1 int32) {
+	fake.upTrackMaxTemporalLayerSeenChangeMutex.Lock()
+	fake.upTrackMaxTemporalLayerSeenChangeArgsForCall = append(fake.upTrackMaxTemporalLayerSeenChangeArgsForCall, struct {
+		arg1 int32
+	}{arg1})
+	stub := fake.UpTrackMaxTemporalLayerSeenChangeStub
+	fake.recordInvocation("UpTrackMaxTemporalLayerSeenChange", []interface{}{arg1})
+	fake.upTrackMaxTemporalLayerSeenChangeMutex.Unlock()
+	if stub != nil {
+		fake.UpTrackMaxTemporalLayerSeenChangeStub(arg1)
+	}
+}
+
+func (fake *FakeTrackSender) UpTrackMaxTemporalLayerSeenChangeCallCount() int {
+	fake.upTrackMaxTemporalLayerSeenChangeMutex.RLock()
+	defer fake.upTrackMaxTemporalLayerSeenChangeMutex.RUnlock()
+	return len(fake.upTrackMaxTemporalLayerSeenChangeArgsForCall)
+}
+
+func (fake *FakeTrackSender) UpTrackMaxTemporalLayerSeenChangeCalls(stub func(int32)) {
+	fake.upTrackMaxTemporalLayerSeenChangeMutex.Lock()
+	defer fake.upTrackMaxTemporalLayerSeenChangeMutex.Unlock()
+	fake.UpTrackMaxTemporalLayerSeenChangeStub = stub
+}
+
+func (fake *FakeTrackSender) UpTrackMaxTemporalLayerSeenChangeArgsForCall(i int) int32 {
+	fake.upTrackMaxTemporalLayerSeenChangeMutex.RLock()
+	defer fake.upTrackMaxTemporalLayerSeenChangeMutex.RUnlock()
+	argsForCall := fake.upTrackMaxTemporalLayerSeenChangeArgsForCall[i]
+	return argsForCall.arg1
+}
+
+func (fake *FakeTrackSender) WriteRTP(arg1 *buffer.ExtPacket, arg2 int32) int32 {
+	fake.writeRTPMutex.Lock()
+	ret, specificReturn := fake.writeRTPReturnsOnCall[len(fake.writeRTPArgsForCall)]
+	fake.writeRTPArgsForCall = append(fake.writeRTPArgsForCall, struct {
+		arg1 *buffer.ExtPacket
+		arg2 int32
+	}{arg1, arg2})
+	stub := fake.WriteRTPStub
+	fakeReturns := fake.writeRTPReturns
+	fake.recordInvocation("WriteRTP", []interface{}{arg1, arg2})
+	fake.writeRTPMutex.Unlock()
+	if stub != nil {
+		return stub(arg1, arg2)
+	}
+	if specificReturn {
+		return ret.result1
+	}
+	return fakeReturns.result1
+}
+
+func (fake *FakeTrackSender) WriteRTPCallCount() int {
+	fake.writeRTPMutex.RLock()
+	defer fake.writeRTPMutex.RUnlock()
+	return len(fake.writeRTPArgsForCall)
+}
+
+func (fake *FakeTrackSender) WriteRTPCalls(stub func(*buffer.ExtPacket, int32) int32) {
+	fake.writeRTPMutex.Lock()
+	defer fake.writeRTPMutex.Unlock()
+	fake.WriteRTPStub = stub
+}
+
+func (fake *FakeTrackSender) WriteRTPArgsForCall(i int) (*buffer.ExtPacket, int32) {
+	fake.writeRTPMutex.RLock()
+	defer fake.writeRTPMutex.RUnlock()
+	argsForCall := fake.writeRTPArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2
+}
+
+func (fake *FakeTrackSender) WriteRTPReturns(result1 int32) {
+	fake.writeRTPMutex.Lock()
+	defer fake.writeRTPMutex.Unlock()
+	fake.WriteRTPStub = nil
+	fake.writeRTPReturns = struct {
+		result1 int32
+	}{result1}
+}
+
+func (fake *FakeTrackSender) WriteRTPReturnsOnCall(i int, result1 int32) {
+	fake.writeRTPMutex.Lock()
+	defer fake.writeRTPMutex.Unlock()
+	fake.WriteRTPStub = nil
+	if fake.writeRTPReturnsOnCall == nil {
+		fake.writeRTPReturnsOnCall = make(map[int]struct {
+			result1 int32
+		})
+	}
+	fake.writeRTPReturnsOnCall[i] = struct {
+		result1 int32
+	}{result1}
+}
+
+func (fake *FakeTrackSender) Invocations() map[string][][]interface{} {
+	fake.invocationsMutex.RLock()
+	defer fake.invocationsMutex.RUnlock()
+	copiedInvocations := map[string][][]interface{}{}
+	for key, value := range fake.invocations {
+		copiedInvocations[key] = value
+	}
+	return copiedInvocations
+}
+
+func (fake *FakeTrackSender) recordInvocation(key string, args []interface{}) {
+	fake.invocationsMutex.Lock()
+	defer fake.invocationsMutex.Unlock()
+	if fake.invocations == nil {
+		fake.invocations = map[string][][]interface{}{}
+	}
+	if fake.invocations[key] == nil {
+		fake.invocations[key] = [][]interface{}{}
+	}
+	fake.invocations[key] = append(fake.invocations[key], args)
+}
+
+var _ sfu.TrackSender = new(FakeTrackSender)