mediasoup 3.26.0 → 3.27.1

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

@@ -0,0 +1,337 @@
+#include "common.hpp"
+#include "RTC/BWE/BweTypes.hpp"
+#include "RTC/BWE/TargetRateController.hpp"
+#include <catch2/catch_test_macros.hpp>
+
+SCENARIO("BWE TargetRateController", "[bwe][targetratecontroller]")
+{
+	constexpr int64_t InitialTimeUs{ 123456 * 1000 };
+	// Shortest span of send times that closes an observation of the loss
+	// controller, and hence the pace at which it can be fed.
+	constexpr int64_t ObservationDurationLowerBoundUs{ 250 * 1000 };
+	constexpr int64_t PacketSizeBytes{ 15000 };
+
+	int64_t sequenceNumber{ 0 };
+
+	// Results of a feedback closing one observation of the loss controller, with
+	// every packet reported as lost or as received.
+	const auto createResults = [&sequenceNumber](
+	                             int64_t firstSendTimeUs,
+	                             bool received) -> std::vector<RTC::BWE::Types::PacketResult>
+	{
+		std::vector<RTC::BWE::Types::PacketResult> packetResults(2);
+
+		for (size_t idx{ 0 }; idx < packetResults.size(); ++idx)
+		{
+			auto& packetResult = packetResults[idx];
+
+			packetResult.sentPacket.sequenceNumber = sequenceNumber++;
+			packetResult.sentPacket.size           = PacketSizeBytes;
+			packetResult.sentPacket.sendTimeUs =
+			  firstSendTimeUs + (static_cast<int64_t>(idx) * ObservationDurationLowerBoundUs);
+
+			if (received)
+			{
+				packetResult.receiveTimeUs =
+				  firstSendTimeUs + (static_cast<int64_t>(idx + 1) * ObservationDurationLowerBoundUs);
+			}
+		}
+
+		return packetResults;
+	};
+
+	// Feed a bound of the given kind and let the controller act on it.
+	const auto feedLimit = [](
+	                         RTC::BWE::TargetRateController& targetRateController,
+	                         bool delayBased,
+	                         int64_t bitrate,
+	                         int64_t nowUs) -> void
+	{
+		if (delayBased)
+		{
+			targetRateController.SetDelayBasedEstimate(bitrate);
+		}
+		else
+		{
+			targetRateController.SetReceiverEstimate(bitrate);
+		}
+
+		targetRateController.Update(nowUs);
+	};
+
+	SECTION("the first bound applies at once but a later one has to wait")
+	{
+		// Both bounds behave the same here, so the very same case is run twice.
+		for (const bool delayBased : { false, true })
+		{
+			RTC::BWE::TargetRateController targetRateController;
+			int64_t nowUs{ InitialTimeUs };
+
+			targetRateController.SetBitrateLimits(100000, 1500000);
+			targetRateController.SetSendBitrate(200000);
+
+			targetRateController.UpdatePacketsLost(/*lostPackets*/ 0, /*totalPackets*/ 1, nowUs);
+			targetRateController.UpdateRtt(50 * 1000);
+
+			constexpr int64_t FirstBitrate{ 1000000 };
+			constexpr int64_t SecondBitrate{ FirstBitrate + 500000 };
+
+			feedLimit(targetRateController, delayBased, FirstBitrate, nowUs);
+
+			REQUIRE(targetRateController.GetTargetBitrate() == FirstBitrate);
+
+			// Once the start phase is over the target no longer just follows its
+			// bounds, so the second one only raises the ceiling.
+			nowUs += 2001 * 1000;
+
+			feedLimit(targetRateController, delayBased, SecondBitrate, nowUs);
+
+			REQUIRE(targetRateController.GetTargetBitrate() == FirstBitrate);
+		}
+	}
+
+	SECTION("a decrease is not reapplied while no further loss is reported")
+	{
+		constexpr int64_t MinBitrate{ 100000 };
+		constexpr int64_t InitialBitrate{ 1000000 };
+		constexpr uint8_t FractionLost{ 128 };
+		constexpr int64_t RttUs{ 50 * 1000 };
+
+		RTC::BWE::TargetRateController targetRateController;
+		int64_t nowUs{ InitialTimeUs };
+
+		targetRateController.SetBitrateLimits(MinBitrate, 1500000);
+		targetRateController.SetSendBitrate(InitialBitrate);
+
+		nowUs += 10000 * 1000;
+
+		REQUIRE(targetRateController.GetTargetBitrate() == InitialBitrate);
+		REQUIRE(targetRateController.GetFractionLost() == 0);
+		REQUIRE(targetRateController.GetRttUs() == 0);
+
+		// Report heavy loss so that the target goes down.
+		targetRateController.UpdatePacketsLost(/*lostPackets*/ 50, /*totalPackets*/ 100, nowUs);
+		targetRateController.UpdateRtt(RttUs);
+
+		nowUs += 1000 * 1000;
+
+		targetRateController.Update(nowUs);
+
+		const int64_t decreasedBitrate = targetRateController.GetTargetBitrate();
+
+		REQUIRE(decreasedBitrate < InitialBitrate);
+		// A single decrease must not reach the minimum, or this case would prove
+		// nothing.
+		REQUIRE(decreasedBitrate > MinBitrate);
+		REQUIRE(targetRateController.GetFractionLost() == FractionLost);
+		REQUIRE(targetRateController.GetRttUs() == RttUs);
+
+		// Without a new report there is nothing saying whether the decrease was
+		// enough, so the target must not move again in either direction.
+		nowUs += 1000 * 1000;
+
+		targetRateController.Update(nowUs);
+
+		REQUIRE(targetRateController.GetTargetBitrate() == decreasedBitrate);
+		REQUIRE(targetRateController.GetFractionLost() == FractionLost);
+		REQUIRE(targetRateController.GetRttUs() == RttUs);
+	}
+
+	SECTION("setting the send bitrate overrides the bound of the delay based path")
+	{
+		constexpr int64_t InitialBitrate{ 300000 };
+		constexpr int64_t DelayBasedBitrate{ 350000 };
+		constexpr int64_t ForcedHighBitrate{ 2500000 };
+
+		RTC::BWE::TargetRateController targetRateController;
+		const int64_t nowUs{ InitialTimeUs };
+
+		targetRateController.SetBitrateLimits(10000, 10000000);
+		targetRateController.SetSendBitrate(InitialBitrate);
+
+		targetRateController.SetDelayBasedEstimate(DelayBasedBitrate);
+		targetRateController.Update(nowUs);
+
+		REQUIRE(targetRateController.GetTargetBitrate() >= InitialBitrate);
+		REQUIRE(targetRateController.GetTargetBitrate() <= DelayBasedBitrate);
+
+		targetRateController.SetSendBitrate(ForcedHighBitrate);
+
+		REQUIRE(targetRateController.GetTargetBitrate() == ForcedHighBitrate);
+	}
+
+	SECTION("a negative number of lost packets doesn't overflow the reported fraction")
+	{
+		RTC::BWE::TargetRateController targetRateController;
+		int64_t nowUs{ InitialTimeUs };
+
+		targetRateController.SetBitrateLimits(100000, 1500000);
+		targetRateController.SetSendBitrate(1000000);
+
+		nowUs += 10000 * 1000;
+
+		REQUIRE(targetRateController.GetFractionLost() == 0);
+
+		targetRateController.UpdatePacketsLost(/*lostPackets*/ -1, /*totalPackets*/ 100, nowUs);
+
+		REQUIRE(targetRateController.GetFractionLost() == 0);
+	}
+
+	SECTION("the round trip time is above the limit once it exceeds it")
+	{
+		RTC::BWE::TargetRateController targetRateController;
+		const int64_t nowUs{ InitialTimeUs };
+
+		targetRateController.SetBitrateLimits(10000, 10000000);
+		targetRateController.SetSendBitrate(300000);
+
+		targetRateController.UpdatePropagationRtt(/*propagationRttUs*/ 5000 * 1000, nowUs);
+
+		REQUIRE(targetRateController.IsRttAboveLimit());
+	}
+
+	SECTION("the round trip time is below the limit while it doesn't reach it")
+	{
+		RTC::BWE::TargetRateController targetRateController;
+		const int64_t nowUs{ InitialTimeUs };
+
+		targetRateController.SetBitrateLimits(10000, 10000000);
+		targetRateController.SetSendBitrate(300000);
+
+		targetRateController.UpdatePropagationRtt(/*propagationRttUs*/ 1000 * 1000, nowUs);
+
+		REQUIRE(!targetRateController.IsRttAboveLimit());
+	}
+
+	SECTION("the round trip time backoff can be disabled")
+	{
+		// A limit that no round trip time can reach disables the backoff, which is
+		// what the sender of a link known to be slow would want.
+		const RTC::BWE::TargetRateController::TargetRateControllerOptions options{
+			.maxRttUs = RTC::BWE::Types::TimeUsInfinite
+		};
+
+		RTC::BWE::TargetRateController targetRateController(options);
+		const int64_t nowUs{ InitialTimeUs };
+
+		targetRateController.SetBitrateLimits(10000, 10000000);
+		targetRateController.SetSendBitrate(300000);
+
+		targetRateController.UpdatePropagationRtt(/*propagationRttUs*/ 5000 * 1000, nowUs);
+
+		REQUIRE(!targetRateController.IsRttAboveLimit());
+	}
+
+	SECTION("a round trip time above the limit drops the target")
+	{
+		constexpr int64_t InitialBitrate{ 300000 };
+
+		RTC::BWE::TargetRateController targetRateController;
+		int64_t nowUs{ InitialTimeUs };
+
+		targetRateController.SetBitrateLimits(10000, 10000000);
+		targetRateController.SetSendBitrate(InitialBitrate);
+
+		targetRateController.UpdatePropagationRtt(/*propagationRttUs*/ 5000 * 1000, nowUs);
+		targetRateController.Update(nowUs);
+
+		// Four fifths of 300000.
+		REQUIRE(targetRateController.GetTargetBitrate() == 240000);
+
+		// The drop happens at most once per interval.
+		nowUs += 500 * 1000;
+
+		targetRateController.Update(nowUs);
+
+		REQUIRE(targetRateController.GetTargetBitrate() == 240000);
+
+		nowUs += 500 * 1000;
+
+		targetRateController.Update(nowUs);
+
+		// And four fifths of that.
+		REQUIRE(targetRateController.GetTargetBitrate() == 192000);
+	}
+
+	SECTION("a report telling no loss increases the target by 8% plus a bit")
+	{
+		constexpr int64_t InitialBitrate{ 300000 };
+
+		RTC::BWE::TargetRateController targetRateController;
+		int64_t nowUs{ InitialTimeUs };
+
+		targetRateController.SetBitrateLimits(10000, 10000000);
+		targetRateController.SetSendBitrate(InitialBitrate);
+
+		// A report covering enough packets reconsiders the target by itself.
+		targetRateController.UpdatePacketsLost(/*lostPackets*/ 0, /*totalPackets*/ 100, nowUs);
+
+		// 8% over 300000 is 324000, plus the extra 1000.
+		REQUIRE(targetRateController.GetTargetBitrate() == 325000);
+
+		// Long enough for the value grown from to have left the window, so the next
+		// increase grows from the current target.
+		nowUs += 2001 * 1000;
+
+		targetRateController.Update(nowUs);
+
+		// And 8% over 325000 is 351000, plus the extra 1000.
+		REQUIRE(targetRateController.GetTargetBitrate() == 352000);
+	}
+
+	SECTION("the loss rules drive the target until the loss controller is ready")
+	{
+		constexpr int64_t InitialBitrate{ 600000 };
+
+		RTC::BWE::TargetRateController targetRateController;
+		int64_t nowUs{ InitialTimeUs };
+
+		targetRateController.SetBitrateLimits(10000, 10000000);
+		targetRateController.SetSendBitrate(InitialBitrate);
+		// NOTE: After SetSendBitrate(), which drops it on purpose, so that the loss
+		// controller has a bitrate to start its estimate from.
+		targetRateController.SetDelayBasedEstimate(InitialBitrate);
+
+		// Two observations, one short of what the loss controller needs.
+		for (int64_t i{ 0 }; i < 2; ++i)
+		{
+			targetRateController.UpdateLossBasedController(
+			  createResults(nowUs, /*received*/ false), /*inAlr*/ false, nowUs);
+
+			nowUs += 2 * ObservationDurationLowerBoundUs;
+		}
+
+		// Losing every packet would have brought the estimate down, so the target
+		// staying put shows that nothing of it is being used yet.
+		REQUIRE(
+		  targetRateController.GetLossBasedState() ==
+		  RTC::BWE::LossBasedController::State::DELAY_BASED_ESTIMATE);
+		REQUIRE(targetRateController.GetTargetBitrate() == InitialBitrate);
+	}
+
+	SECTION("the loss controller takes the target over once it is ready")
+	{
+		constexpr int64_t InitialBitrate{ 600000 };
+
+		RTC::BWE::TargetRateController targetRateController;
+		int64_t nowUs{ InitialTimeUs };
+
+		targetRateController.SetBitrateLimits(10000, 10000000);
+		targetRateController.SetSendBitrate(InitialBitrate);
+		// NOTE: After SetSendBitrate(), which drops it on purpose, so that the loss
+		// controller has a bitrate to start its estimate from.
+		targetRateController.SetDelayBasedEstimate(InitialBitrate);
+
+		for (int64_t i{ 0 }; i < 3; ++i)
+		{
+			targetRateController.UpdateLossBasedController(
+			  createResults(nowUs, /*received*/ false), /*inAlr*/ false, nowUs);
+
+			nowUs += 2 * ObservationDurationLowerBoundUs;
+		}
+
+		REQUIRE(
+		  targetRateController.GetLossBasedState() == RTC::BWE::LossBasedController::State::DECREASING);
+		REQUIRE(targetRateController.GetTargetBitrate() < InitialBitrate);
+	}
+}

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

@@ -0,0 +1,182 @@
+#include "common.hpp"
+#include "RTC/BWE/TrendlineEstimator.hpp"
+#include <catch2/catch_test_macros.hpp>
+
+SCENARIO("BWE TrendlineEstimator", "[bwe][trendlineestimator]")
+{
+	// Number of packets a test is given.
+	constexpr size_t PacketCount{ 25 };
+	// Time between two consecutive groups of packets.
+	constexpr int64_t SendDeltaUs{ 20 * 1000 };
+	constexpr int64_t InitialArrivalTimeUs{ 987654321000 };
+
+	// Feed groups delivered at `deliveryPace` times the pace they were sent at,
+	// until the state changes or the packets are exhausted.
+	//
+	// Both `count` and `arrivalTimeUs` are shared by every run within a test, so
+	// that consecutive runs consume a single budget of packets and carry on from
+	// the network conditions left by the previous one.
+	auto runUntilStateChange = [](
+	                             RTC::BWE::TrendlineEstimator& trendlineEstimator,
+	                             double deliveryPace,
+	                             size_t& count,
+	                             size_t packetCount,
+	                             int64_t& arrivalTimeUs) -> void
+	{
+		const auto initialState   = trendlineEstimator.GetState();
+		const auto arrivalDeltaUs = static_cast<int64_t>(SendDeltaUs * deliveryPace);
+
+		for (; count < packetCount; ++count)
+		{
+			arrivalTimeUs += arrivalDeltaUs;
+
+			trendlineEstimator.Update(SendDeltaUs, arrivalDeltaUs, arrivalTimeUs);
+
+			if (trendlineEstimator.GetState() != initialState)
+			{
+				return;
+			}
+		}
+	};
+
+	SECTION("a network delivering at the pace it's fed stays in normal state")
+	{
+		RTC::BWE::TrendlineEstimator trendlineEstimator;
+		size_t count{ 1 };
+		int64_t arrivalTimeUs{ InitialArrivalTimeUs };
+
+		REQUIRE(trendlineEstimator.GetState() == RTC::BWE::Types::BandwidthUsage::NORMAL);
+
+		runUntilStateChange(trendlineEstimator, /*deliveryPace*/ 1.0, count, PacketCount, arrivalTimeUs);
+
+		REQUIRE(trendlineEstimator.GetState() == RTC::BWE::Types::BandwidthUsage::NORMAL);
+		// Every packet was processed, so the state never changed.
+		REQUIRE(count == PacketCount);
+	}
+
+	SECTION("a 10% slower delivery is detected as overusing")
+	{
+		RTC::BWE::TrendlineEstimator trendlineEstimator;
+		size_t count{ 1 };
+		int64_t arrivalTimeUs{ InitialArrivalTimeUs };
+
+		REQUIRE(trendlineEstimator.GetState() == RTC::BWE::Types::BandwidthUsage::NORMAL);
+
+		runUntilStateChange(trendlineEstimator, /*deliveryPace*/ 1.1, count, PacketCount, arrivalTimeUs);
+
+		REQUIRE(trendlineEstimator.GetState() == RTC::BWE::Types::BandwidthUsage::OVERUSING);
+
+		// The state is kept while the delay keeps growing.
+		runUntilStateChange(trendlineEstimator, /*deliveryPace*/ 1.1, count, PacketCount, arrivalTimeUs);
+
+		REQUIRE(trendlineEstimator.GetState() == RTC::BWE::Types::BandwidthUsage::OVERUSING);
+		REQUIRE(count == PacketCount);
+	}
+
+	SECTION("a 15% faster delivery is detected as underusing")
+	{
+		RTC::BWE::TrendlineEstimator trendlineEstimator;
+		size_t count{ 1 };
+		int64_t arrivalTimeUs{ InitialArrivalTimeUs };
+
+		REQUIRE(trendlineEstimator.GetState() == RTC::BWE::Types::BandwidthUsage::NORMAL);
+
+		runUntilStateChange(trendlineEstimator, /*deliveryPace*/ 0.85, count, PacketCount, arrivalTimeUs);
+
+		REQUIRE(trendlineEstimator.GetState() == RTC::BWE::Types::BandwidthUsage::UNDERUSING);
+
+		// The state is kept while the delay keeps shrinking.
+		runUntilStateChange(trendlineEstimator, /*deliveryPace*/ 0.85, count, PacketCount, arrivalTimeUs);
+
+		REQUIRE(trendlineEstimator.GetState() == RTC::BWE::Types::BandwidthUsage::UNDERUSING);
+		REQUIRE(count == PacketCount);
+	}
+
+	SECTION("an isolated delay spike is not detected as overusing")
+	{
+		RTC::BWE::TrendlineEstimator trendlineEstimator;
+		size_t count{ 1 };
+		int64_t arrivalTimeUs{ InitialArrivalTimeUs };
+
+		// Fill the regression window with a well behaved network.
+		runUntilStateChange(trendlineEstimator, /*deliveryPace*/ 1.0, count, PacketCount, arrivalTimeUs);
+
+		REQUIRE(trendlineEstimator.GetState() == RTC::BWE::Types::BandwidthUsage::NORMAL);
+
+		// A single group arrives 50 ms late and the very next one recovers that same
+		// time, which is a jitter spike and not a queue that keeps growing.
+		arrivalTimeUs += SendDeltaUs + (50 * 1000);
+		trendlineEstimator.Update(SendDeltaUs, SendDeltaUs + (50 * 1000), arrivalTimeUs);
+
+		arrivalTimeUs += SendDeltaUs - (50 * 1000);
+		trendlineEstimator.Update(SendDeltaUs, SendDeltaUs - (50 * 1000), arrivalTimeUs);
+
+		// This is the hysteresis being tested: overuse requires the condition to
+		// persist over more than one sample.
+		REQUIRE(trendlineEstimator.GetState() == RTC::BWE::Types::BandwidthUsage::NORMAL);
+	}
+
+	SECTION("recovers to normal once the delay stops growing")
+	{
+		RTC::BWE::TrendlineEstimator trendlineEstimator;
+		size_t count{ 1 };
+		int64_t arrivalTimeUs{ InitialArrivalTimeUs };
+
+		runUntilStateChange(
+		  trendlineEstimator, /*deliveryPace*/ 1.1, count, /*packetCount*/ 100, arrivalTimeUs);
+
+		REQUIRE(trendlineEstimator.GetState() == RTC::BWE::Types::BandwidthUsage::OVERUSING);
+
+		// The delay stops growing but doesn't shrink either, so the accumulated
+		// delay flattens out and the slope goes back to zero.
+		runUntilStateChange(
+		  trendlineEstimator, /*deliveryPace*/ 1.0, count, /*packetCount*/ 100, arrivalTimeUs);
+
+		REQUIRE(trendlineEstimator.GetState() == RTC::BWE::Types::BandwidthUsage::NORMAL);
+	}
+
+	SECTION("the slope cap doesn't get in the way of a delivery that is really slower")
+	{
+		// The cap is the slope between the least delayed samples of both ends of
+		// the window. Under a steadily slower delivery those are the first sample
+		// of each end, so the cap is the very slope being capped and nothing is
+		// filtered out. It only bites when the middle of the window is more
+		// delayed than both ends, which is not a queue growing.
+		const RTC::BWE::TrendlineEstimator::TrendlineEstimatorOptions options{ .enableCap = true };
+
+		RTC::BWE::TrendlineEstimator trendlineEstimator(options);
+		size_t count{ 1 };
+		int64_t arrivalTimeUs{ InitialArrivalTimeUs };
+
+		runUntilStateChange(
+		  trendlineEstimator, /*deliveryPace*/ 1.1, count, /*packetCount*/ 100, arrivalTimeUs);
+
+		REQUIRE(trendlineEstimator.GetState() == RTC::BWE::Types::BandwidthUsage::OVERUSING);
+	}
+
+	SECTION("a group arriving out of order doesn't throw the estimator off")
+	{
+		// Sorting only decides which sample is dropped when the window is full and
+		// what the ends of the window are for the slope cap, since fitting a line
+		// doesn't depend on the order of the points.
+		const RTC::BWE::TrendlineEstimator::TrendlineEstimatorOptions options{ .enableSort = true,
+		                                                                       .enableCap  = true };
+
+		RTC::BWE::TrendlineEstimator trendlineEstimator(options);
+
+		for (size_t idx{ 0 }; idx < 30; ++idx)
+		{
+			const int64_t arrivalTimeUs = InitialArrivalTimeUs + (static_cast<int64_t>(idx) * SendDeltaUs);
+
+			trendlineEstimator.Update(SendDeltaUs, SendDeltaUs, arrivalTimeUs);
+		}
+
+		REQUIRE(trendlineEstimator.GetState() == RTC::BWE::Types::BandwidthUsage::NORMAL);
+
+		// A group whose arrival time goes backwards, which is what a source giving
+		// them out of order looks like.
+		trendlineEstimator.Update(SendDeltaUs, SendDeltaUs, InitialArrivalTimeUs + (15 * SendDeltaUs));
+
+		REQUIRE(trendlineEstimator.GetState() == RTC::BWE::Types::BandwidthUsage::NORMAL);
+	}
+}

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

@@ -0,0 +1,61 @@
+#include "common.hpp"
+#include "RTC/BWE/BweTypes.hpp"
+#include "RTC/BWE/Utils.hpp"
+#include <catch2/catch_test_macros.hpp>
+
+SCENARIO("BWE Utils", "[bwe][utils]")
+{
+	SECTION("ApplyBitrateFactor() gives the bitrate times the factor")
+	{
+		REQUIRE(RTC::BWE::Utils::ApplyBitrateFactor(600000, 1.02) == 612000);
+		REQUIRE(RTC::BWE::Utils::ApplyBitrateFactor(600000, 0.95) == 570000);
+		REQUIRE(RTC::BWE::Utils::ApplyBitrateFactor(600000, 1.0) == 600000);
+	}
+
+	SECTION("ApplyBitrateFactor() rounds to the nearest bitrate, away from zero on a tie")
+	{
+		REQUIRE(RTC::BWE::Utils::ApplyBitrateFactor(3, 0.4) == 1);
+		REQUIRE(RTC::BWE::Utils::ApplyBitrateFactor(3, 0.5) == 2);
+		REQUIRE(RTC::BWE::Utils::ApplyBitrateFactor(7, 0.5) == 4);
+	}
+
+	SECTION("ApplyBitrateFactor() gives no bitrate at all beyond what the type holds")
+	{
+		// Anything over the maximum means no limit, which is what its own value
+		// already means.
+		REQUIRE(
+		  RTC::BWE::Utils::ApplyBitrateFactor(RTC::BWE::Types::BitrateInfinite, 1.3) ==
+		  RTC::BWE::Types::BitrateInfinite);
+		REQUIRE(
+		  RTC::BWE::Utils::ApplyBitrateFactor(RTC::BWE::Types::BitrateInfinite / 2, 4.0) ==
+		  RTC::BWE::Types::BitrateInfinite);
+		REQUIRE(
+		  RTC::BWE::Utils::ApplyBitrateFactor(RTC::BWE::Types::BitrateInfinite, 1.0) ==
+		  RTC::BWE::Types::BitrateInfinite);
+	}
+
+	SECTION("ApplyBitrateFactor() never gives a negative bitrate")
+	{
+		REQUIRE(RTC::BWE::Utils::ApplyBitrateFactor(600000, -1.0) == 0);
+		REQUIRE(RTC::BWE::Utils::ApplyBitrateFactor(0, 1.5) == 0);
+	}
+
+	SECTION("AddBitrates() gives the sum")
+	{
+		REQUIRE(RTC::BWE::Utils::AddBitrates(600000, 1000) == 601000);
+		REQUIRE(RTC::BWE::Utils::AddBitrates(600000, 0) == 600000);
+	}
+
+	SECTION("AddBitrates() gives no bitrate at all beyond what the type holds")
+	{
+		REQUIRE(
+		  RTC::BWE::Utils::AddBitrates(RTC::BWE::Types::BitrateInfinite, 1000) ==
+		  RTC::BWE::Types::BitrateInfinite);
+		REQUIRE(
+		  RTC::BWE::Utils::AddBitrates(RTC::BWE::Types::BitrateInfinite - 1000, 1001) ==
+		  RTC::BWE::Types::BitrateInfinite);
+		REQUIRE(
+		  RTC::BWE::Utils::AddBitrates(RTC::BWE::Types::BitrateInfinite - 1000, 1000) ==
+		  RTC::BWE::Types::BitrateInfinite);
+	}
+}