mediasoup 3.27.0 → 3.28.0

package/worker/test/src/RTC/BWE/TestRembGenerator.cpp

@@ -0,0 +1,285 @@
+#include "common.hpp"
+#include "RTC/BWE/RembGenerator.hpp"
+#include "RTC/RTCP/FeedbackPsRemb.hpp"
+#include <catch2/catch_test_macros.hpp>
+#include <vector>
+
+SCENARIO("BWE RembGenerator", "[bwe][rembgenerator]")
+{
+	struct TestRemb
+	{
+		int64_t bitrate;
+		std::vector<uint32_t> ssrcs;
+	};
+
+	class TestRembGeneratorListener : public RTC::BWE::RembGenerator::Listener
+	{
+	public:
+		void OnRembGeneratorSendRemb(
+		  RTC::BWE::RembGenerator* /*rembGenerator*/, RTC::RTCP::FeedbackPsRembPacket* packet) override
+		{
+			this->rembs.push_back(TestRemb{ .bitrate = packet->GetBitrate(), .ssrcs = packet->GetSsrcs() });
+		}
+
+	public:
+		std::vector<TestRemb> rembs;
+	};
+
+	// Instant the scenarios below start at, which is irrelevant other than for
+	// being far from zero.
+	constexpr int64_t BaseTimeMs{ 1000 };
+	const std::vector<uint32_t> ssrcs{ 1, 2, 3 };
+
+	SECTION("the first estimation is announced right away")
+	{
+		TestRembGeneratorListener listener;
+		RTC::BWE::RembGenerator rembGenerator(std::addressof(listener));
+
+		rembGenerator.OnReceiveBitrateChanged(BaseTimeMs, ssrcs, 12345);
+
+		REQUIRE(listener.rembs.size() == 1);
+		REQUIRE(listener.rembs.at(0).bitrate == 12345);
+		REQUIRE(listener.rembs.at(0).ssrcs == ssrcs);
+	}
+
+	SECTION("an estimation that barely drops waits")
+	{
+		TestRembGeneratorListener listener;
+		RTC::BWE::RembGenerator rembGenerator(std::addressof(listener));
+
+		rembGenerator.OnReceiveBitrateChanged(BaseTimeMs, ssrcs, 12346);
+
+		REQUIRE(listener.rembs.size() == 1);
+
+		// Less than 3 % below the one announced, so it waits.
+		rembGenerator.OnReceiveBitrateChanged(BaseTimeMs + 100, ssrcs, 12345);
+
+		REQUIRE(listener.rembs.size() == 1);
+
+		// Past the 200 ms, so it goes out even though it barely moved.
+		rembGenerator.OnReceiveBitrateChanged(BaseTimeMs + 201, ssrcs, 12345);
+
+		REQUIRE(listener.rembs.size() == 2);
+		REQUIRE(listener.rembs.at(1).bitrate == 12345);
+	}
+
+	SECTION("an estimation that drops a lot is announced right away")
+	{
+		TestRembGeneratorListener listener;
+		RTC::BWE::RembGenerator rembGenerator(std::addressof(listener));
+
+		rembGenerator.OnReceiveBitrateChanged(BaseTimeMs, ssrcs, 2345);
+		rembGenerator.OnReceiveBitrateChanged(BaseTimeMs + 1, ssrcs, 1234);
+
+		REQUIRE(listener.rembs.size() == 2);
+		REQUIRE(listener.rembs.at(0).bitrate == 2345);
+		REQUIRE(listener.rembs.at(1).bitrate == 1234);
+	}
+
+	SECTION("an estimation that rises waits")
+	{
+		TestRembGeneratorListener listener;
+		RTC::BWE::RembGenerator rembGenerator(std::addressof(listener));
+
+		rembGenerator.OnReceiveBitrateChanged(BaseTimeMs, ssrcs, 1234);
+		rembGenerator.OnReceiveBitrateChanged(BaseTimeMs + 100, ssrcs, 2345);
+
+		REQUIRE(listener.rembs.size() == 1);
+
+		rembGenerator.OnReceiveBitrateChanged(BaseTimeMs + 201, ssrcs, 2345);
+
+		REQUIRE(listener.rembs.size() == 2);
+		REQUIRE(listener.rembs.at(1).bitrate == 2345);
+	}
+
+	SECTION("setting a cap announces it")
+	{
+		TestRembGeneratorListener listener;
+		RTC::BWE::RembGenerator rembGenerator(std::addressof(listener));
+
+		rembGenerator.SetMaxIncomingBitrate(BaseTimeMs, 1234);
+
+		REQUIRE(listener.rembs.size() == 1);
+		REQUIRE(listener.rembs.at(0).bitrate == 1234);
+		// The cap says nothing about which streams it applies to.
+		REQUIRE(listener.rembs.at(0).ssrcs.empty());
+	}
+
+	SECTION("a cap that cannot be expressed is ignored")
+	{
+		TestRembGeneratorListener listener;
+		RTC::BWE::RembGenerator rembGenerator(std::addressof(listener));
+
+		rembGenerator.SetMaxIncomingBitrate(BaseTimeMs, 1000);
+
+		REQUIRE(listener.rembs.size() == 1);
+
+		// A REMB of zero is how the wire says there is no limit, so zero cannot be
+		// a cap, and a negative one means nothing.
+		rembGenerator.SetMaxIncomingBitrate(BaseTimeMs + 1000, 0);
+		rembGenerator.SetMaxIncomingBitrate(BaseTimeMs + 2000, -1);
+
+		REQUIRE(listener.rembs.size() == 1);
+
+		// The cap that was set is still the one in force.
+		rembGenerator.OnReceiveBitrateChanged(BaseTimeMs + 3000, ssrcs, 5000);
+
+		REQUIRE(listener.rembs.size() == 2);
+		REQUIRE(listener.rembs.at(1).bitrate == 1000);
+	}
+
+	SECTION("the lowest of the cap and the estimation is announced")
+	{
+		TestRembGeneratorListener listener;
+		RTC::BWE::RembGenerator rembGenerator(std::addressof(listener));
+
+		rembGenerator.OnReceiveBitrateChanged(BaseTimeMs, ssrcs, 1234);
+
+		REQUIRE(listener.rembs.size() == 1);
+		REQUIRE(listener.rembs.at(0).bitrate == 1234);
+
+		// Nothing to tell, since what was just announced is already below the cap.
+		rembGenerator.SetMaxIncomingBitrate(BaseTimeMs + 1, 4567);
+
+		REQUIRE(listener.rembs.size() == 1);
+
+		rembGenerator.OnReceiveBitrateChanged(BaseTimeMs + 201, ssrcs, 5678);
+
+		REQUIRE(listener.rembs.size() == 2);
+		REQUIRE(listener.rembs.at(1).bitrate == 4567);
+	}
+
+	SECTION("a cap that needs no telling is not told at the next packet either")
+	{
+		TestRembGeneratorListener listener;
+		RTC::BWE::RembGenerator rembGenerator(std::addressof(listener));
+
+		rembGenerator.OnReceiveBitrateChanged(BaseTimeMs, ssrcs, 1234);
+
+		REQUIRE(listener.rembs.size() == 1);
+
+		// Nothing to tell, since what was just announced is already below the cap.
+		rembGenerator.SetMaxIncomingBitrate(BaseTimeMs + 1, 4567);
+
+		REQUIRE(listener.rembs.size() == 1);
+
+		// And nothing right behind that REMB either, which would undo the wait
+		// between one REMB and the next.
+		rembGenerator.MaySendLimitationRembFeedback(BaseTimeMs + 2);
+
+		REQUIRE(listener.rembs.size() == 1);
+	}
+
+	SECTION("a cap is not announced while the estimation keeps going out")
+	{
+		TestRembGeneratorListener listener;
+		RTC::BWE::RembGenerator rembGenerator(std::addressof(listener));
+
+		rembGenerator.SetMaxIncomingBitrate(BaseTimeMs, 1000);
+
+		REQUIRE(listener.rembs.size() == 1);
+
+		// Well past the interval the cap would be announced again at, but the
+		// estimation went out in between and that one is no higher than the cap.
+		rembGenerator.OnReceiveBitrateChanged(BaseTimeMs + 1400, ssrcs, 5000);
+
+		REQUIRE(listener.rembs.size() == 2);
+		REQUIRE(listener.rembs.at(1).bitrate == 1000);
+
+		rembGenerator.MaySendLimitationRembFeedback(BaseTimeMs + 1501);
+
+		REQUIRE(listener.rembs.size() == 2);
+
+		// Once the estimation stops, the cap has to be told again.
+		rembGenerator.MaySendLimitationRembFeedback(BaseTimeMs + 2902);
+
+		REQUIRE(listener.rembs.size() == 3);
+		REQUIRE(listener.rembs.at(2).bitrate == 1000);
+	}
+
+	SECTION("removing the cap is announced four times")
+	{
+		TestRembGeneratorListener listener;
+		RTC::BWE::RembGenerator rembGenerator(std::addressof(listener));
+
+		rembGenerator.SetMaxIncomingBitrate(BaseTimeMs, 1000);
+
+		REQUIRE(listener.rembs.size() == 1);
+
+		// The first of the four goes out without waiting.
+		rembGenerator.SetMaxIncomingBitrate(BaseTimeMs + 1, std::nullopt);
+
+		REQUIRE(listener.rembs.size() == 2);
+		REQUIRE(listener.rembs.at(1).bitrate == 0);
+
+		int64_t nowMs = BaseTimeMs + 1;
+
+		for (size_t idx{ 0 }; idx < 3; ++idx)
+		{
+			// Before the interval is up nothing goes out.
+			rembGenerator.MaySendLimitationRembFeedback(nowMs + 1);
+
+			REQUIRE(listener.rembs.size() == idx + 2);
+
+			nowMs += 1501;
+
+			rembGenerator.MaySendLimitationRembFeedback(nowMs);
+
+			REQUIRE(listener.rembs.size() == idx + 3);
+			REQUIRE(listener.rembs.back().bitrate == 0);
+		}
+
+		REQUIRE(listener.rembs.size() == 5);
+
+		// The four are spent, and with no cap there is nothing left to announce.
+		nowMs += 1501;
+
+		rembGenerator.MaySendLimitationRembFeedback(nowMs);
+
+		REQUIRE(listener.rembs.size() == 5);
+	}
+
+	SECTION("a cap in force is announced again")
+	{
+		TestRembGeneratorListener listener;
+		RTC::BWE::RembGenerator rembGenerator(std::addressof(listener));
+
+		rembGenerator.SetMaxIncomingBitrate(BaseTimeMs, 1000);
+
+		REQUIRE(listener.rembs.size() == 1);
+
+		rembGenerator.MaySendLimitationRembFeedback(BaseTimeMs + 1500);
+
+		REQUIRE(listener.rembs.size() == 1);
+
+		rembGenerator.MaySendLimitationRembFeedback(BaseTimeMs + 1501);
+
+		REQUIRE(listener.rembs.size() == 2);
+		REQUIRE(listener.rembs.at(1).bitrate == 1000);
+	}
+
+	SECTION("a cap set again stops announcing that it was removed")
+	{
+		TestRembGeneratorListener listener;
+		RTC::BWE::RembGenerator rembGenerator(std::addressof(listener));
+
+		rembGenerator.SetMaxIncomingBitrate(BaseTimeMs, 1000);
+		rembGenerator.SetMaxIncomingBitrate(BaseTimeMs + 1, std::nullopt);
+
+		REQUIRE(listener.rembs.size() == 2);
+		REQUIRE(listener.rembs.at(1).bitrate == 0);
+
+		// Three of the four were still owed, and they no longer say anything true.
+		rembGenerator.SetMaxIncomingBitrate(BaseTimeMs + 2, 2000);
+
+		REQUIRE(listener.rembs.size() == 3);
+		REQUIRE(listener.rembs.at(2).bitrate == 2000);
+
+		// What comes out once the interval is up is the cap, not one of the zeros
+		// that were owed.
+		rembGenerator.MaySendLimitationRembFeedback(BaseTimeMs + 2000);
+
+		REQUIRE(listener.rembs.size() == 4);
+		REQUIRE(listener.rembs.at(3).bitrate == 2000);
+	}
+}

package/worker/test/src/RTC/BWE/TestRemoteBitrateEstimatorAbsSendTime.cpp

@@ -0,0 +1,414 @@
+#include "common.hpp"
+#include "RTC/BWE/RemoteBitrateEstimatorAbsSendTime.hpp"
+#include "RTC/RTP/HeaderExtensionIds.hpp"
+#include "RTC/RTP/Packet.hpp"
+#include "RTC/RtpDictionaries.hpp"
+#include "Utils.hpp"
+#include "test/include/RTC/BWE/helpers/RemoteBitrateEstimatorAbsSendTimeTestHelper.hpp"
+#include "test/include/RTC/RTP/rtpCommon.hpp"
+#include <catch2/catch_test_macros.hpp>
+#include <cstdlib> // std::abs()
+#include <vector>
+
+SCENARIO("BWE RemoteBitrateEstimatorAbsSendTime", "[bwe][remotebitrateestimatorabssendtime]")
+{
+	class TestRemoteBitrateEstimatorAbsSendTimeListener
+	  : public RTC::BWE::RemoteBitrateEstimatorAbsSendTime::Listener
+	{
+	public:
+		void OnRemoteBitrateEstimatorAbsSendTimeBitrateChanged(
+		  RTC::BWE::RemoteBitrateEstimatorAbsSendTime* /*remoteBitrateEstimator*/,
+		  const std::vector<uint32_t>& ssrcs,
+		  int64_t bitrate) override
+		{
+			this->updated       = true;
+			this->latestBitrate = bitrate;
+			this->latestSsrcs   = ssrcs;
+		}
+
+	public:
+		bool updated{ false };
+		int64_t latestBitrate{ 0 };
+		std::vector<uint32_t> latestSsrcs;
+	};
+
+	constexpr uint32_t Ssrc{ 1111 };
+	// Instant the scenarios below start at, which is irrelevant other than for
+	// being far from zero.
+	constexpr int64_t BaseTimeUs{ 1000 * 1000 };
+	// Fewest packets a burst needs for it to be taken as one.
+	constexpr int Probes{ 5 };
+
+	// Builds a packet of the given size carrying the given instant in its
+	// `abs-send-time` extension.
+	//
+	// NOTE: Every scenario reuses `rtpCommon::FactoryBuffer`, so the returned
+	// packet is only valid until the next call.
+	auto buildPacket = [](size_t payloadSize, int64_t sendTimeUs) -> std::unique_ptr<RTC::RTP::Packet>
+	{
+		std::unique_ptr<RTC::RTP::Packet> packet(
+		  RTC::RTP::Packet::Factory(rtpCommon::FactoryBuffer, sizeof(rtpCommon::FactoryBuffer)));
+
+		REQUIRE(packet);
+
+		packet->SetSsrc(Ssrc);
+
+		const auto absSendTimeId = static_cast<uint8_t>(RTC::RtpHeaderExtensionUri::Type::ABS_SEND_TIME);
+
+		const std::vector<RTC::RTP::Packet::Extension> extensions{
+			{ RTC::RtpHeaderExtensionUri::Type::ABS_SEND_TIME, absSendTimeId, /*len*/ 3, rtpCommon::DataBuffer }
+		};
+
+		packet->SetExtensions(RTC::RTP::Packet::ExtensionsType::OneByte, extensions);
+
+		RTC::RTP::HeaderExtensionIds headerExtensionIds;
+
+		headerExtensionIds.absSendTime = absSendTimeId;
+
+		packet->AssignExtensionIds(headerExtensionIds);
+
+		packet->SetPayloadLength(payloadSize);
+
+		REQUIRE(packet->UpdateAbsSendTime(Utils::Time::TimeUsToAbsSendTime(sendTimeUs)));
+
+		return packet;
+	};
+
+	// Feeds a packet that says it left at `sendTimeUs` and arrived at
+	// `arrivalTimeUs`, which is also taken as the current instant.
+	auto feedPacket = [&buildPacket](
+	                    RTC::BWE::RemoteBitrateEstimatorAbsSendTime& remoteBitrateEstimator,
+	                    size_t payloadSize,
+	                    int64_t sendTimeUs,
+	                    int64_t arrivalTimeUs,
+	                    int64_t nowUs) -> void
+	{
+		const auto packet = buildPacket(payloadSize, sendTimeUs);
+
+		remoteBitrateEstimator.IncomingPacket(packet.get(), arrivalTimeUs, nowUs);
+	};
+
+	SECTION("a burst faster than the one before it raises the estimation")
+	{
+		TestRemoteBitrateEstimatorAbsSendTimeListener listener;
+		RTC::BWE::RemoteBitrateEstimatorAbsSendTime remoteBitrateEstimator(std::addressof(listener));
+
+		int64_t nowUs{ BaseTimeUs };
+
+		// First burst sent at 8 * 1000 / 10 = 800 kbps.
+		for (int i{ 0 }; i < Probes; ++i)
+		{
+			nowUs += 10 * 1000;
+
+			feedPacket(remoteBitrateEstimator, 1000, nowUs, nowUs, nowUs);
+		}
+
+		// Second burst sent at 8 * 1000 / 5 = 1600 kbps.
+		for (int i{ 0 }; i < Probes; ++i)
+		{
+			nowUs += 5 * 1000;
+
+			feedPacket(remoteBitrateEstimator, 1000, nowUs, nowUs, nowUs);
+		}
+
+		REQUIRE(listener.updated);
+		REQUIRE(listener.latestBitrate > 1500000);
+	}
+
+	SECTION("packets that were not paced do not spoil the burst")
+	{
+		TestRemoteBitrateEstimatorAbsSendTimeListener listener;
+		RTC::BWE::RemoteBitrateEstimatorAbsSendTime remoteBitrateEstimator(std::addressof(listener));
+
+		int64_t nowUs{ BaseTimeUs };
+
+		// Burst sent at 8 * 1000 / 10 = 800 kbps, with a small packet in between
+		// each pair of its packets.
+		for (int i{ 0 }; i < Probes; ++i)
+		{
+			nowUs += 5 * 1000;
+
+			const int64_t burstTimeUs = nowUs;
+
+			feedPacket(remoteBitrateEstimator, 1000, burstTimeUs, burstTimeUs, nowUs);
+
+			nowUs += 5 * 1000;
+
+			feedPacket(remoteBitrateEstimator, 100, burstTimeUs, burstTimeUs, nowUs);
+		}
+
+		REQUIRE(listener.updated);
+		REQUIRE(listener.latestBitrate > 800000);
+	}
+
+	SECTION("a burst that arrives dispersed is measured by how it arrived")
+	{
+		TestRemoteBitrateEstimatorAbsSendTimeListener listener;
+		RTC::BWE::RemoteBitrateEstimatorAbsSendTime remoteBitrateEstimator(std::addressof(listener));
+
+		int64_t nowUs{ BaseTimeUs };
+		int64_t sendTimeUs{ BaseTimeUs };
+
+		// First burst sent at 8 * 1000 / 10 = 800 kbps.
+		for (int i{ 0 }; i < Probes; ++i)
+		{
+			nowUs += 10 * 1000;
+			sendTimeUs += 10 * 1000;
+
+			feedPacket(remoteBitrateEstimator, 1000, sendTimeUs, nowUs, nowUs);
+		}
+
+		// Second burst sent at 8 * 1000 / 5 = 1600 kbps but arriving at
+		// 8 * 1000 / 8 = 1000 kbps, so the link did not take it.
+		for (int i{ 0 }; i < Probes; ++i)
+		{
+			nowUs += 8 * 1000;
+			sendTimeUs += 5 * 1000;
+
+			feedPacket(remoteBitrateEstimator, 1000, sendTimeUs, nowUs, nowUs);
+		}
+
+		REQUIRE(listener.updated);
+		REQUIRE(std::abs(listener.latestBitrate - 800000) <= 10000);
+	}
+
+	SECTION("a burst that arrives slightly faster than it was sent is taken")
+	{
+		TestRemoteBitrateEstimatorAbsSendTimeListener listener;
+		RTC::BWE::RemoteBitrateEstimatorAbsSendTime remoteBitrateEstimator(std::addressof(listener));
+
+		int64_t nowUs{ BaseTimeUs };
+		int64_t sendTimeUs{ BaseTimeUs };
+
+		// Sent at 8 * 1000 / 10 = 800 kbps, arriving at 8 * 1000 / 5 = 1600 kbps.
+		for (int i{ 0 }; i < Probes; ++i)
+		{
+			nowUs += 5 * 1000;
+			sendTimeUs += 10 * 1000;
+
+			feedPacket(remoteBitrateEstimator, 1000, sendTimeUs, nowUs, nowUs);
+		}
+
+		REQUIRE(listener.updated);
+		REQUIRE(listener.latestBitrate > 800000);
+	}
+
+	SECTION("a burst that arrives far faster than it was sent says nothing")
+	{
+		TestRemoteBitrateEstimatorAbsSendTimeListener listener;
+		RTC::BWE::RemoteBitrateEstimatorAbsSendTime remoteBitrateEstimator(std::addressof(listener));
+
+		int64_t nowUs{ BaseTimeUs };
+		int64_t sendTimeUs{ BaseTimeUs };
+
+		// Sent at 8 * 1000 / 10 = 800 kbps, arriving ten times faster, which no
+		// link explains.
+		for (int i{ 0 }; i < Probes; ++i)
+		{
+			nowUs += 1 * 1000;
+			sendTimeUs += 10 * 1000;
+
+			feedPacket(remoteBitrateEstimator, 1000, sendTimeUs, nowUs, nowUs);
+		}
+
+		REQUIRE(!listener.updated);
+	}
+
+	SECTION("a burst that arrives slower than it was sent is measured by how it arrived")
+	{
+		TestRemoteBitrateEstimatorAbsSendTimeListener listener;
+		RTC::BWE::RemoteBitrateEstimatorAbsSendTime remoteBitrateEstimator(std::addressof(listener));
+
+		int64_t nowUs{ BaseTimeUs };
+		int64_t sendTimeUs{ BaseTimeUs };
+
+		// Sent at 8 * 1000 / 5 = 1600 kbps, arriving at 8 * 1000 / 7 = 1142 kbps.
+		for (int i{ 0 }; i < Probes; ++i)
+		{
+			nowUs += 7 * 1000;
+			sendTimeUs += 5 * 1000;
+
+			feedPacket(remoteBitrateEstimator, 1000, sendTimeUs, nowUs, nowUs);
+		}
+
+		REQUIRE(listener.updated);
+		REQUIRE(std::abs(listener.latestBitrate - 1140000) <= 10000);
+	}
+
+	SECTION("a fast burst that arrives slower is measured by how it arrived")
+	{
+		TestRemoteBitrateEstimatorAbsSendTimeListener listener;
+		RTC::BWE::RemoteBitrateEstimatorAbsSendTime remoteBitrateEstimator(std::addressof(listener));
+
+		int64_t nowUs{ BaseTimeUs };
+		int64_t sendTimeUs{ BaseTimeUs };
+
+		// Sent at 8 * 1000 / 1 = 8000 kbps, arriving at 8 * 1000 / 2 = 4000 kbps.
+		for (int i{ 0 }; i < Probes; ++i)
+		{
+			nowUs += 2 * 1000;
+			sendTimeUs += 1 * 1000;
+
+			feedPacket(remoteBitrateEstimator, 1000, sendTimeUs, nowUs, nowUs);
+		}
+
+		REQUIRE(listener.updated);
+		REQUIRE(std::abs(listener.latestBitrate - 4000000) <= 10000);
+	}
+
+	SECTION("packets too small to have been paced are not taken as a burst")
+	{
+		TestRemoteBitrateEstimatorAbsSendTimeListener listener;
+		RTC::BWE::RemoteBitrateEstimatorAbsSendTime remoteBitrateEstimator(std::addressof(listener));
+
+		int64_t nowUs{ BaseTimeUs };
+
+		// 200 bytes every 10 ms, which is not big enough to have been paced.
+		for (int i{ 0 }; i < Probes; ++i)
+		{
+			nowUs += 10 * 1000;
+
+			feedPacket(remoteBitrateEstimator, 200, nowUs, nowUs, nowUs);
+		}
+
+		REQUIRE(!listener.updated);
+
+		// The same cadence with packets that are big enough is a burst.
+		for (int i{ 0 }; i < Probes; ++i)
+		{
+			nowUs += 10 * 1000;
+
+			feedPacket(remoteBitrateEstimator, 1000, nowUs, nowUs, nowUs);
+		}
+
+		REQUIRE(listener.updated);
+		REQUIRE(std::abs(listener.latestBitrate - 800000) <= 10000);
+	}
+
+	// NOTE: What this pins is that a packet arriving after every stream has timed
+	// out, and every packet after that one, never reach a null inter arrival or
+	// overuse estimator.
+	SECTION("a packet after every stream timed out is handled")
+	{
+		TestRemoteBitrateEstimatorAbsSendTimeListener listener;
+		RTC::BWE::RemoteBitrateEstimatorAbsSendTime remoteBitrateEstimator(std::addressof(listener));
+
+		int64_t nowUs{ BaseTimeUs };
+
+		feedPacket(remoteBitrateEstimator, 1000, nowUs, nowUs, nowUs);
+
+		// Longer than the two seconds a stream may be silent for.
+		nowUs += 2001 * 1000;
+
+		feedPacket(remoteBitrateEstimator, 1000, nowUs, nowUs, nowUs);
+
+		nowUs += 1000 * 1000;
+
+		feedPacket(remoteBitrateEstimator, 1000, nowUs, nowUs, nowUs);
+	}
+
+	SECTION("initial behavior")
+	{
+		bweHelpers::RemoteBitrateEstimatorAbsSendTimeTestHelper helper;
+
+		helper.InitialBehaviorTestHelper(674840);
+	}
+
+	SECTION("a rate increase with reordered packets")
+	{
+		bweHelpers::RemoteBitrateEstimatorAbsSendTimeTestHelper helper;
+
+		helper.RateIncreaseReorderingTestHelper(674840);
+	}
+
+	SECTION("a rate increase measured in rtp timestamps")
+	{
+		bweHelpers::RemoteBitrateEstimatorAbsSendTimeTestHelper helper;
+
+		helper.RateIncreaseRtpTimestampsTestHelper(1237);
+	}
+
+	SECTION("a capacity drop with one stream")
+	{
+		bweHelpers::RemoteBitrateEstimatorAbsSendTimeTestHelper helper;
+
+		helper.CapacityDropTestHelper(1, false, 633, 0);
+	}
+
+	SECTION("a capacity drop with the receiver clock moved forward")
+	{
+		bweHelpers::RemoteBitrateEstimatorAbsSendTimeTestHelper helper;
+
+		helper.CapacityDropTestHelper(1, false, 267, 30000);
+	}
+
+	SECTION("a capacity drop with the receiver clock moved back")
+	{
+		bweHelpers::RemoteBitrateEstimatorAbsSendTimeTestHelper helper;
+
+		helper.CapacityDropTestHelper(1, false, 267, -30000);
+	}
+
+	SECTION("a capacity drop with one stream whose timestamps wrap")
+	{
+		bweHelpers::RemoteBitrateEstimatorAbsSendTimeTestHelper helper;
+
+		helper.CapacityDropTestHelper(1, true, 633, 0);
+	}
+
+	SECTION("a capacity drop with two streams whose timestamps wrap")
+	{
+		bweHelpers::RemoteBitrateEstimatorAbsSendTimeTestHelper helper;
+
+		helper.CapacityDropTestHelper(2, true, 700, 0);
+	}
+
+	SECTION("a capacity drop with three streams whose timestamps wrap")
+	{
+		bweHelpers::RemoteBitrateEstimatorAbsSendTimeTestHelper helper;
+
+		helper.CapacityDropTestHelper(3, true, 633, 0);
+	}
+
+	SECTION("a capacity drop with thirteen streams whose timestamps wrap")
+	{
+		bweHelpers::RemoteBitrateEstimatorAbsSendTimeTestHelper helper;
+
+		helper.CapacityDropTestHelper(13, true, 667, 0);
+	}
+
+	SECTION("a capacity drop with nineteen streams whose timestamps wrap")
+	{
+		bweHelpers::RemoteBitrateEstimatorAbsSendTimeTestHelper helper;
+
+		helper.CapacityDropTestHelper(19, true, 667, 0);
+	}
+
+	SECTION("a capacity drop with thirty streams whose timestamps wrap")
+	{
+		bweHelpers::RemoteBitrateEstimatorAbsSendTimeTestHelper helper;
+
+		helper.CapacityDropTestHelper(30, true, 667, 0);
+	}
+
+	SECTION("packets sent very close together are taken as one group")
+	{
+		bweHelpers::RemoteBitrateEstimatorAbsSendTimeTestHelper helper;
+
+		helper.TestTimestampGroupingTestHelper();
+	}
+
+	SECTION("a sender rejoining after a short silence, which wraps abs-send-time")
+	{
+		bweHelpers::RemoteBitrateEstimatorAbsSendTimeTestHelper helper;
+
+		helper.TestWrappingHelper(35);
+	}
+
+	SECTION("a sender rejoining after a silence that leaves abs-send-time unchanged")
+	{
+		bweHelpers::RemoteBitrateEstimatorAbsSendTimeTestHelper helper;
+
+		helper.TestWrappingHelper(10 * 64);
+	}
+}