mediasoup 3.26.0 → 3.27.0

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

@@ -0,0 +1,546 @@
+#include "common.hpp"
+#include "RTC/BWE/FeedbackAdapter.hpp"
+#include "RTC/BWE/SendPacketHistory.hpp"
+#include "RTC/RTCP/FeedbackRtpTransport.hpp"
+#include <catch2/catch_test_macros.hpp>
+
+SCENARIO("BWE FeedbackAdapter", "[bwe][feedbackadapter]")
+{
+	// The clock starts well away from zero so that a mistake taking a time for a
+	// duration doesn't go unnoticed.
+	constexpr int64_t InitialTimeUs{ 100000000 };
+	// The remote clock has nothing to do with ours, and is a whole number of base
+	// time ticks so that the arrival times survive the feedback untouched.
+	constexpr int64_t RemoteTimeUs{ 1000000000000 };
+	constexpr size_t PacketSize{ 1000 };
+	constexpr uint32_t Ssrc{ 1111 };
+	constexpr uint32_t SenderSsrc{ 2222 };
+	constexpr uint32_t MediaSsrc{ 3333 };
+	constexpr size_t RtcpMtu{ 1200 };
+
+	// Builds the feedback a receiver would send, reporting the given arrival
+	// times. The sequence numbers left out of them are reported as lost.
+	auto createFeedback = [SenderSsrc, MediaSsrc](
+	                        uint16_t baseSequenceNumber,
+	                        int64_t baseTimeUs,
+	                        const std::vector<std::pair<uint16_t, int64_t>>& receivedPackets)
+	  -> std::unique_ptr<RTC::RTCP::FeedbackRtpTransportPacket>
+	{
+		auto feedback = std::make_unique<RTC::RTCP::FeedbackRtpTransportPacket>(SenderSsrc, MediaSsrc);
+
+		feedback->SetBase(baseSequenceNumber, baseTimeUs);
+
+		for (const auto& [sequenceNumber, receivedAtUs] : receivedPackets)
+		{
+			feedback->AddPacket(sequenceNumber, receivedAtUs, RtcpMtu);
+		}
+
+		feedback->Finish();
+
+		return feedback;
+	};
+
+	SECTION("a feedback is resolved into the packets that were sent")
+	{
+		RTC::BWE::SendPacketHistory sendPacketHistory;
+		RTC::BWE::FeedbackAdapter feedbackAdapter(&sendPacketHistory);
+
+		sendPacketHistory.AddPacket(Ssrc, 100, PacketSize, false, InitialTimeUs);
+		sendPacketHistory.AddPacket(Ssrc, 101, PacketSize, false, InitialTimeUs + 10000);
+		sendPacketHistory.AddPacket(Ssrc, 102, PacketSize, false, InitialTimeUs + 20000);
+
+		const auto feedback = createFeedback(
+		  0,
+		  RemoteTimeUs,
+		  {
+		    { 0, RemoteTimeUs         },
+        { 1, RemoteTimeUs + 10000 },
+        { 2, RemoteTimeUs + 20000 }
+    });
+
+		const auto processedFeedback =
+		  feedbackAdapter.ProcessTransportFeedback(feedback.get(), InitialTimeUs + 50000);
+
+		REQUIRE(processedFeedback.has_value());
+
+		// NOLINTNEXTLINE(bugprone-unchecked-optional-access)
+		const auto& result = processedFeedback.value();
+
+		REQUIRE(result.feedbackTimeUs == InitialTimeUs + 50000);
+		REQUIRE(result.packetFeedbacks.size() == 3);
+
+		int64_t expectedSequenceNumber{ 0 };
+
+		for (const auto& packetResult : result.packetFeedbacks)
+		{
+			REQUIRE(packetResult.sentPacket.sequenceNumber == expectedSequenceNumber);
+			REQUIRE(packetResult.sentPacket.sendTimeUs == InitialTimeUs + (expectedSequenceNumber * 10000));
+			REQUIRE(packetResult.sentPacket.size == PacketSize);
+			REQUIRE(packetResult.IsReceived());
+
+			++expectedSequenceNumber;
+		}
+
+		// The first feedback is anchored on the time it was received.
+		REQUIRE(result.packetFeedbacks[0].receiveTimeUs == InitialTimeUs + 50000);
+		REQUIRE(result.packetFeedbacks[1].receiveTimeUs == InitialTimeUs + 60000);
+		REQUIRE(result.packetFeedbacks[2].receiveTimeUs == InitialTimeUs + 70000);
+	}
+
+	SECTION("a packet reported as lost comes back with no arrival time")
+	{
+		RTC::BWE::SendPacketHistory sendPacketHistory;
+		RTC::BWE::FeedbackAdapter feedbackAdapter(&sendPacketHistory);
+
+		sendPacketHistory.AddPacket(Ssrc, 100, PacketSize, false, InitialTimeUs);
+		sendPacketHistory.AddPacket(Ssrc, 101, PacketSize, false, InitialTimeUs + 10000);
+		sendPacketHistory.AddPacket(Ssrc, 102, PacketSize, false, InitialTimeUs + 20000);
+
+		const auto feedback = createFeedback(
+		  0,
+		  RemoteTimeUs,
+		  {
+		    { 0, RemoteTimeUs         },
+        { 2, RemoteTimeUs + 20000 }
+    });
+
+		const auto processedFeedback =
+		  feedbackAdapter.ProcessTransportFeedback(feedback.get(), InitialTimeUs + 50000);
+
+		REQUIRE(processedFeedback.has_value());
+
+		// NOLINTNEXTLINE(bugprone-unchecked-optional-access)
+		const auto& result = processedFeedback.value();
+
+		REQUIRE(result.packetFeedbacks.size() == 3);
+		REQUIRE(result.packetFeedbacks[0].IsReceived());
+		REQUIRE(!result.packetFeedbacks[1].IsReceived());
+		REQUIRE(result.packetFeedbacks[2].IsReceived());
+	}
+
+	SECTION("whether a packet is audio survives the feedback")
+	{
+		RTC::BWE::SendPacketHistory sendPacketHistory;
+		RTC::BWE::FeedbackAdapter feedbackAdapter(&sendPacketHistory);
+
+		sendPacketHistory.AddPacket(Ssrc, 100, PacketSize, true, InitialTimeUs);
+		sendPacketHistory.AddPacket(Ssrc, 101, PacketSize, false, InitialTimeUs + 10000);
+
+		const auto feedback = createFeedback(
+		  0,
+		  RemoteTimeUs,
+		  {
+		    { 0, RemoteTimeUs         },
+        { 1, RemoteTimeUs + 10000 }
+    });
+
+		const auto processedFeedback =
+		  feedbackAdapter.ProcessTransportFeedback(feedback.get(), InitialTimeUs + 50000);
+
+		REQUIRE(processedFeedback.has_value());
+
+		// NOLINTNEXTLINE(bugprone-unchecked-optional-access)
+		const auto& result = processedFeedback.value();
+
+		REQUIRE(result.packetFeedbacks.size() == 2);
+		REQUIRE(result.packetFeedbacks[0].sentPacket.audio == true);
+		REQUIRE(result.packetFeedbacks[1].sentPacket.audio == false);
+	}
+
+	SECTION("the feedback tells the data still in flight once it's been resolved")
+	{
+		RTC::BWE::SendPacketHistory sendPacketHistory;
+		RTC::BWE::FeedbackAdapter feedbackAdapter(&sendPacketHistory);
+
+		sendPacketHistory.AddPacket(Ssrc, 100, 200, false, InitialTimeUs);
+		sendPacketHistory.AddPacket(Ssrc, 101, 300, false, InitialTimeUs + 10000);
+
+		const auto firstFeedback = createFeedback(
+		  0,
+		  RemoteTimeUs,
+		  {
+		    { 0, RemoteTimeUs }
+    });
+		const auto secondFeedback = createFeedback(
+		  1,
+		  RemoteTimeUs + 10000,
+		  {
+		    { 1, RemoteTimeUs + 10000 }
+    });
+
+		const auto firstResult =
+		  feedbackAdapter.ProcessTransportFeedback(firstFeedback.get(), InitialTimeUs + 50000);
+
+		REQUIRE(firstResult.has_value());
+		// NOLINTNEXTLINE(bugprone-unchecked-optional-access)
+		REQUIRE(firstResult->dataInFlight == 300);
+
+		const auto secondResult =
+		  feedbackAdapter.ProcessTransportFeedback(secondFeedback.get(), InitialTimeUs + 60000);
+
+		REQUIRE(secondResult.has_value());
+		// NOLINTNEXTLINE(bugprone-unchecked-optional-access)
+		REQUIRE(secondResult->dataInFlight == 0);
+	}
+
+	SECTION("the packets the history no longer holds are left out")
+	{
+		constexpr int64_t WindowDurationUs{ 1000000 };
+
+		RTC::BWE::SendPacketHistory sendPacketHistory({ .windowDurationUs = WindowDurationUs });
+		RTC::BWE::FeedbackAdapter feedbackAdapter(&sendPacketHistory);
+
+		sendPacketHistory.AddPacket(Ssrc, 100, PacketSize, false, InitialTimeUs);
+
+		// Long enough afterwards for the window to drop the first packet.
+		sendPacketHistory.AddPacket(
+		  Ssrc, 101, PacketSize, false, InitialTimeUs + WindowDurationUs + 10000);
+
+		const auto feedback = createFeedback(
+		  0,
+		  RemoteTimeUs,
+		  {
+		    { 0, RemoteTimeUs         },
+        { 1, RemoteTimeUs + 10000 }
+    });
+
+		const auto processedFeedback = feedbackAdapter.ProcessTransportFeedback(
+		  feedback.get(), InitialTimeUs + WindowDurationUs + 50000);
+
+		REQUIRE(processedFeedback.has_value());
+
+		// NOLINTNEXTLINE(bugprone-unchecked-optional-access)
+		const auto& result = processedFeedback.value();
+
+		REQUIRE(result.packetFeedbacks.size() == 1);
+		REQUIRE(result.packetFeedbacks[0].sentPacket.sequenceNumber == 1);
+	}
+
+	SECTION("the arrival times of consecutive feedbacks share a single timeline")
+	{
+		RTC::BWE::SendPacketHistory sendPacketHistory;
+		RTC::BWE::FeedbackAdapter feedbackAdapter(&sendPacketHistory);
+
+		sendPacketHistory.AddPacket(Ssrc, 100, PacketSize, false, InitialTimeUs);
+		sendPacketHistory.AddPacket(Ssrc, 101, PacketSize, false, InitialTimeUs + 100000);
+
+		const auto firstFeedback = createFeedback(
+		  0,
+		  RemoteTimeUs,
+		  {
+		    { 0, RemoteTimeUs }
+    });
+		const auto secondFeedback = createFeedback(
+		  1,
+		  RemoteTimeUs + 100000,
+		  {
+		    { 1, RemoteTimeUs + 100000 }
+    });
+
+		const auto firstProcessedFeedback =
+		  feedbackAdapter.ProcessTransportFeedback(firstFeedback.get(), InitialTimeUs + 50000);
+		const auto secondProcessedFeedback =
+		  feedbackAdapter.ProcessTransportFeedback(secondFeedback.get(), InitialTimeUs + 150000);
+
+		REQUIRE(firstProcessedFeedback.has_value());
+		REQUIRE(secondProcessedFeedback.has_value());
+
+		// NOLINTNEXTLINE(bugprone-unchecked-optional-access)
+		const auto& firstResult = firstProcessedFeedback.value();
+		// NOLINTNEXTLINE(bugprone-unchecked-optional-access)
+		const auto& secondResult = secondProcessedFeedback.value();
+
+		REQUIRE(firstResult.packetFeedbacks.size() == 1);
+		REQUIRE(secondResult.packetFeedbacks.size() == 1);
+
+		// Both packets took the very same time to arrive, so both feedbacks have to
+		// tell the same however each of them was anchored.
+		const auto& firstPacketResult  = firstResult.packetFeedbacks[0];
+		const auto& secondPacketResult = secondResult.packetFeedbacks[0];
+
+		const int64_t firstDelayUs =
+		  // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
+		  firstPacketResult.receiveTimeUs.value() - firstPacketResult.sentPacket.sendTimeUs;
+		const int64_t secondDelayUs =
+		  // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
+		  secondPacketResult.receiveTimeUs.value() - secondPacketResult.sentPacket.sendTimeUs;
+
+		REQUIRE(firstDelayUs == secondDelayUs);
+	}
+
+	SECTION("a feedback arriving out of order keeps the timeline")
+	{
+		RTC::BWE::SendPacketHistory sendPacketHistory;
+		RTC::BWE::FeedbackAdapter feedbackAdapter(&sendPacketHistory);
+
+		sendPacketHistory.AddPacket(Ssrc, 100, PacketSize, false, InitialTimeUs);
+		sendPacketHistory.AddPacket(Ssrc, 101, PacketSize, false, InitialTimeUs + 100000);
+
+		const auto firstFeedback = createFeedback(
+		  0,
+		  RemoteTimeUs,
+		  {
+		    { 0, RemoteTimeUs }
+    });
+		const auto secondFeedback = createFeedback(
+		  1,
+		  RemoteTimeUs + 100000,
+		  {
+		    { 1, RemoteTimeUs + 100000 }
+    });
+
+		// The second feedback is processed first, and the first one arrives late.
+		const auto secondProcessedFeedback =
+		  feedbackAdapter.ProcessTransportFeedback(secondFeedback.get(), InitialTimeUs + 150000);
+		const auto firstProcessedFeedback =
+		  feedbackAdapter.ProcessTransportFeedback(firstFeedback.get(), InitialTimeUs + 160000);
+
+		REQUIRE(secondProcessedFeedback.has_value());
+		REQUIRE(firstProcessedFeedback.has_value());
+
+		// NOLINTNEXTLINE(bugprone-unchecked-optional-access)
+		const auto& firstResult = firstProcessedFeedback.value();
+		// NOLINTNEXTLINE(bugprone-unchecked-optional-access)
+		const auto& secondResult = secondProcessedFeedback.value();
+
+		REQUIRE(firstResult.packetFeedbacks.size() == 1);
+		REQUIRE(secondResult.packetFeedbacks.size() == 1);
+
+		const auto& firstPacketResult  = firstResult.packetFeedbacks[0];
+		const auto& secondPacketResult = secondResult.packetFeedbacks[0];
+
+		const int64_t firstDelayUs =
+		  // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
+		  firstPacketResult.receiveTimeUs.value() - firstPacketResult.sentPacket.sendTimeUs;
+		const int64_t secondDelayUs =
+		  // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
+		  secondPacketResult.receiveTimeUs.value() - secondPacketResult.sentPacket.sendTimeUs;
+
+		REQUIRE(firstDelayUs == secondDelayUs);
+	}
+
+	SECTION("the base time wrapping around does not break the timeline")
+	{
+		constexpr int64_t FirstBaseTimeUs{ RTC::RTCP::FeedbackRtpTransportPacket::TimeWrapPeriodUs -
+		                                   RTC::RTCP::FeedbackRtpTransportPacket::BaseTimeTickUs };
+		constexpr int64_t SecondBaseTimeUs{ RTC::RTCP::FeedbackRtpTransportPacket::TimeWrapPeriodUs };
+		constexpr int64_t ElapsedUs{ SecondBaseTimeUs - FirstBaseTimeUs };
+
+		RTC::BWE::SendPacketHistory sendPacketHistory;
+		RTC::BWE::FeedbackAdapter feedbackAdapter(&sendPacketHistory);
+
+		sendPacketHistory.AddPacket(Ssrc, 100, PacketSize, false, InitialTimeUs);
+		sendPacketHistory.AddPacket(Ssrc, 101, PacketSize, false, InitialTimeUs + ElapsedUs);
+
+		const auto firstFeedback = createFeedback(
+		  0,
+		  FirstBaseTimeUs,
+		  {
+		    { 0, FirstBaseTimeUs }
+    });
+		const auto secondFeedback = createFeedback(
+		  1,
+		  SecondBaseTimeUs,
+		  {
+		    { 1, SecondBaseTimeUs }
+    });
+
+		const auto firstProcessedFeedback =
+		  feedbackAdapter.ProcessTransportFeedback(firstFeedback.get(), InitialTimeUs + 50000);
+		const auto secondProcessedFeedback = feedbackAdapter.ProcessTransportFeedback(
+		  secondFeedback.get(), InitialTimeUs + ElapsedUs + 50000);
+
+		REQUIRE(firstProcessedFeedback.has_value());
+		REQUIRE(secondProcessedFeedback.has_value());
+
+		// NOLINTNEXTLINE(bugprone-unchecked-optional-access)
+		const auto& firstResult = firstProcessedFeedback.value();
+		// NOLINTNEXTLINE(bugprone-unchecked-optional-access)
+		const auto& secondResult = secondProcessedFeedback.value();
+
+		REQUIRE(firstResult.packetFeedbacks.size() == 1);
+		REQUIRE(secondResult.packetFeedbacks.size() == 1);
+
+		const auto& firstPacketResult  = firstResult.packetFeedbacks[0];
+		const auto& secondPacketResult = secondResult.packetFeedbacks[0];
+
+		const int64_t firstDelayUs =
+		  // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
+		  firstPacketResult.receiveTimeUs.value() - firstPacketResult.sentPacket.sendTimeUs;
+		const int64_t secondDelayUs =
+		  // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
+		  secondPacketResult.receiveTimeUs.value() - secondPacketResult.sentPacket.sendTimeUs;
+
+		REQUIRE(firstDelayUs == secondDelayUs);
+	}
+
+	SECTION("the packets are reported in the order the feedback reports them")
+	{
+		RTC::BWE::SendPacketHistory sendPacketHistory;
+		RTC::BWE::FeedbackAdapter feedbackAdapter(&sendPacketHistory);
+
+		sendPacketHistory.AddPacket(Ssrc, 100, PacketSize, false, InitialTimeUs);
+		sendPacketHistory.AddPacket(Ssrc, 101, PacketSize, false, InitialTimeUs + 10000);
+		sendPacketHistory.AddPacket(Ssrc, 102, PacketSize, false, InitialTimeUs + 20000);
+
+		// The packets sent later arrived earlier, which is up to whoever consumes
+		// this to reorder.
+		const auto feedback = createFeedback(
+		  0,
+		  RemoteTimeUs + 20000,
+		  {
+		    { 0, RemoteTimeUs + 20000 },
+        { 1, RemoteTimeUs + 10000 },
+        { 2, RemoteTimeUs         }
+    });
+
+		const auto processedFeedback =
+		  feedbackAdapter.ProcessTransportFeedback(feedback.get(), InitialTimeUs + 50000);
+
+		REQUIRE(processedFeedback.has_value());
+
+		// NOLINTNEXTLINE(bugprone-unchecked-optional-access)
+		const auto& result = processedFeedback.value();
+
+		REQUIRE(result.packetFeedbacks.size() == 3);
+		REQUIRE(result.packetFeedbacks[0].sentPacket.sequenceNumber == 0);
+		REQUIRE(result.packetFeedbacks[1].sentPacket.sequenceNumber == 1);
+		REQUIRE(result.packetFeedbacks[2].sentPacket.sequenceNumber == 2);
+		REQUIRE(result.packetFeedbacks[0].receiveTimeUs > result.packetFeedbacks[1].receiveTimeUs);
+		REQUIRE(result.packetFeedbacks[1].receiveTimeUs > result.packetFeedbacks[2].receiveTimeUs);
+	}
+
+	SECTION("the packets a lost feedback reported on are not reported as lost")
+	{
+		RTC::BWE::SendPacketHistory sendPacketHistory;
+		RTC::BWE::FeedbackAdapter feedbackAdapter(&sendPacketHistory);
+
+		sendPacketHistory.AddPacket(Ssrc, 100, PacketSize, false, InitialTimeUs);
+		sendPacketHistory.AddPacket(Ssrc, 101, PacketSize, false, InitialTimeUs + 10000);
+		sendPacketHistory.AddPacket(Ssrc, 102, PacketSize, false, InitialTimeUs + 20000);
+
+		// The feedback reporting on the first two packets never made it, so the next
+		// one starts at the third.
+		const auto feedback = createFeedback(
+		  2,
+		  RemoteTimeUs + 20000,
+		  {
+		    { 2, RemoteTimeUs + 20000 }
+    });
+
+		const auto processedFeedback =
+		  feedbackAdapter.ProcessTransportFeedback(feedback.get(), InitialTimeUs + 50000);
+
+		REQUIRE(processedFeedback.has_value());
+
+		// NOLINTNEXTLINE(bugprone-unchecked-optional-access)
+		const auto& result = processedFeedback.value();
+
+		REQUIRE(result.packetFeedbacks.size() == 1);
+		REQUIRE(result.packetFeedbacks[0].sentPacket.sequenceNumber == 2);
+	}
+
+	SECTION("the feedbacks are resolved although the packets being sent run far ahead of them")
+	{
+		// More than half the range of the sequence numbers the wire carries, which is
+		// what makes the latest packet sent useless to resolve against.
+		constexpr int64_t PacketCount{ 40000 };
+
+		RTC::BWE::SendPacketHistory sendPacketHistory;
+		RTC::BWE::FeedbackAdapter feedbackAdapter(&sendPacketHistory);
+
+		sendPacketHistory.AddPacket(Ssrc, 100, PacketSize, false, InitialTimeUs);
+		sendPacketHistory.AddPacket(Ssrc, 101, PacketSize, false, InitialTimeUs);
+
+		// The first feedback reports on the packets sent so far.
+		const auto firstFeedback = createFeedback(
+		  0,
+		  RemoteTimeUs,
+		  {
+		    { 0, RemoteTimeUs },
+        { 1, RemoteTimeUs }
+    });
+
+		const auto firstResult =
+		  feedbackAdapter.ProcessTransportFeedback(firstFeedback.get(), InitialTimeUs + 50000);
+
+		REQUIRE(firstResult.has_value());
+		// NOLINTNEXTLINE(bugprone-unchecked-optional-access)
+		REQUIRE(firstResult->packetFeedbacks.size() == 2);
+
+		// And now a lot of packets are sent before the next feedback comes.
+		for (int64_t idx{ 2 }; idx < PacketCount; ++idx)
+		{
+			sendPacketHistory.AddPacket(Ssrc, 102, PacketSize, false, InitialTimeUs);
+		}
+
+		REQUIRE(sendPacketHistory.GetLastSequenceNumber() == PacketCount - 1);
+
+		const auto secondFeedback = createFeedback(
+		  2,
+		  RemoteTimeUs,
+		  {
+		    { 2, RemoteTimeUs }
+    });
+
+		const auto secondProcessedFeedback =
+		  feedbackAdapter.ProcessTransportFeedback(secondFeedback.get(), InitialTimeUs + 60000);
+
+		REQUIRE(secondProcessedFeedback.has_value());
+
+		// NOLINTNEXTLINE(bugprone-unchecked-optional-access)
+		const auto& secondResult = secondProcessedFeedback.value();
+
+		REQUIRE(secondResult.packetFeedbacks.size() == 1);
+		REQUIRE(secondResult.packetFeedbacks[0].sentPacket.sequenceNumber == 2);
+	}
+
+	SECTION("a feedback reporting on no packet at all yields no value")
+	{
+		RTC::BWE::SendPacketHistory sendPacketHistory;
+		RTC::BWE::FeedbackAdapter feedbackAdapter(&sendPacketHistory);
+
+		sendPacketHistory.AddPacket(Ssrc, 100, PacketSize, false, InitialTimeUs);
+
+		const auto feedback = createFeedback(0, RemoteTimeUs, {});
+
+		REQUIRE(feedback->GetPacketStatusCount() == 0);
+		REQUIRE(
+		  feedbackAdapter.ProcessTransportFeedback(feedback.get(), InitialTimeUs + 50000) == std::nullopt);
+	}
+
+	SECTION("a feedback received before any packet was sent yields no value")
+	{
+		RTC::BWE::SendPacketHistory sendPacketHistory;
+		RTC::BWE::FeedbackAdapter feedbackAdapter(&sendPacketHistory);
+
+		const auto feedback = createFeedback(
+		  0,
+		  RemoteTimeUs,
+		  {
+		    { 0, RemoteTimeUs }
+    });
+
+		REQUIRE(
+		  feedbackAdapter.ProcessTransportFeedback(feedback.get(), InitialTimeUs + 50000) == std::nullopt);
+	}
+
+	SECTION("a feedback reporting on no packet the history holds yields no value")
+	{
+		RTC::BWE::SendPacketHistory sendPacketHistory;
+		RTC::BWE::FeedbackAdapter feedbackAdapter(&sendPacketHistory);
+
+		sendPacketHistory.AddPacket(Ssrc, 100, PacketSize, false, InitialTimeUs);
+
+		// A sequence number this history never gave out.
+		const auto feedback = createFeedback(
+		  1000,
+		  RemoteTimeUs,
+		  {
+		    { 1000, RemoteTimeUs }
+    });
+
+		REQUIRE(
+		  feedbackAdapter.ProcessTransportFeedback(feedback.get(), InitialTimeUs + 50000) == std::nullopt);
+	}
+}