From 9e0c742f1b564126aec0071f2c93d2e912889764 Mon Sep 17 00:00:00 2001 From: Steve Anton Date: Thu, 17 Aug 2017 18:59:47 -0700 Subject: [PATCH] Reduce code repetition in RtpDemuxerTest. Converts RtpDemuxerTest to use a test fixture which creates the RtpDemuxer under test and wraps sink adding/observer adding functions to automatically remove them at the end of the test case. Bug: None Change-Id: I7e40223f6837caa5443d9850477198c1f7a8d14a Reviewed-on: https://chromium-review.googlesource.com/608906 Commit-Queue: Steve Anton Reviewed-by: Stefan Holmer Reviewed-by: Elad Alon Cr-Commit-Position: refs/heads/master@{#19400} --- webrtc/call/rtp_demuxer_unittest.cc | 596 ++++++++++++---------------- 1 file changed, 247 insertions(+), 349 deletions(-) diff --git a/webrtc/call/rtp_demuxer_unittest.cc b/webrtc/call/rtp_demuxer_unittest.cc index 92728bbc01..1d7433ac5d 100644 --- a/webrtc/call/rtp_demuxer_unittest.cc +++ b/webrtc/call/rtp_demuxer_unittest.cc @@ -11,6 +11,7 @@ #include "webrtc/call/rtp_demuxer.h" #include +#include #include #include "webrtc/call/ssrc_binding_observer.h" @@ -40,106 +41,137 @@ class MockSsrcBindingObserver : public SsrcBindingObserver { MOCK_METHOD2(OnSsrcBoundToRsid, void(const std::string& rsid, uint32_t ssrc)); }; +class RtpDemuxerTest : public testing::Test { + protected: + ~RtpDemuxerTest() { + for (auto* sink : sinks_to_tear_down_) { + demuxer_.RemoveSink(sink); + } + for (auto* observer : observers_to_tear_down_) { + demuxer_.DeregisterSsrcBindingObserver(observer); + } + } + + bool AddSinkOnlySsrc(uint32_t ssrc, RtpPacketSinkInterface* sink) { + bool added = demuxer_.AddSink(ssrc, sink); + if (added) { + sinks_to_tear_down_.insert(sink); + } + return added; + } + + void AddSinkOnlyRsid(const std::string& rsid, RtpPacketSinkInterface* sink) { + demuxer_.AddSink(rsid, sink); + sinks_to_tear_down_.insert(sink); + } + + bool RemoveSink(RtpPacketSinkInterface* sink) { + sinks_to_tear_down_.erase(sink); + return demuxer_.RemoveSink(sink); + } + + void RegisterSsrcBindingObserver(SsrcBindingObserver* observer) { + demuxer_.RegisterSsrcBindingObserver(observer); + observers_to_tear_down_.insert(observer); + } + + void DeregisterSsrcBindingObserver(SsrcBindingObserver* observer) { + demuxer_.DeregisterSsrcBindingObserver(observer); + observers_to_tear_down_.erase(observer); + } + + // The CreatePacket* methods are helpers for creating new RTP packets with + // various attributes set. Tests should use the helper that provides the + // minimum information needed to exercise the behavior under test. Tests also + // should not rely on any behavior which is not clearly described in the + // helper name/arguments. Any additional settings that are not covered by the + // helper should be set manually on the packet once it has been returned. + // For example, most tests in this file do not care about the RTP sequence + // number, but to ensure that the returned packets are valid the helpers will + // auto-increment the sequence number starting with 1. Tests that rely on + // specific sequence number behavior should call SetSequenceNumber manually on + // the returned packet. + + // Intended for use only by other CreatePacket* helpers. + std::unique_ptr CreatePacket( + uint32_t ssrc, + RtpPacketReceived::ExtensionManager* extension_manager) { + auto packet = rtc::MakeUnique(extension_manager); + packet->SetSsrc(ssrc); + packet->SetSequenceNumber(next_sequence_number_++); + return packet; + } + + std::unique_ptr CreatePacketWithSsrc(uint32_t ssrc) { + return CreatePacket(ssrc, nullptr); + } + + std::unique_ptr CreatePacketWithSsrcRsid( + uint32_t ssrc, + const std::string& rsid) { + RtpPacketReceived::ExtensionManager extension_manager; + extension_manager.Register(6); + + auto packet = CreatePacket(ssrc, &extension_manager); + packet->SetExtension(rsid); + return packet; + } + + RtpDemuxer demuxer_; + std::set sinks_to_tear_down_; + std::set observers_to_tear_down_; + uint16_t next_sequence_number_ = 1; +}; + MATCHER_P(SamePacketAs, other, "") { return arg.Ssrc() == other.Ssrc() && arg.SequenceNumber() == other.SequenceNumber(); } -std::unique_ptr CreateRtpPacketReceived( - uint32_t ssrc, - size_t sequence_number = 0) { - // |sequence_number| is declared |size_t| to prevent ugly casts when calling - // the function, but should in reality always be a |uint16_t|. - EXPECT_LT(sequence_number, 1u << 16); - - auto packet = rtc::MakeUnique(); - packet->SetSsrc(ssrc); - packet->SetSequenceNumber(static_cast(sequence_number)); - return packet; -} - -std::unique_ptr CreateRtpPacketReceivedWithRsid( - const std::string& rsid, - uint32_t ssrc, - size_t sequence_number = 0) { - // |sequence_number| is declared |size_t| to prevent ugly casts when calling - // the function, but should in reality always be a |uint16_t|. - EXPECT_LT(sequence_number, 1u << 16); - - const int rsid_extension_id = 6; - RtpPacketReceived::ExtensionManager extension_manager; - extension_manager.Register(rsid_extension_id); - auto packet = rtc::MakeUnique(&extension_manager); - packet->SetExtension(rsid); - packet->SetSsrc(ssrc); - packet->SetSequenceNumber(static_cast(sequence_number)); - return packet; -} - -TEST(RtpDemuxerTest, CanAddSinkBySsrc) { - RtpDemuxer demuxer; +TEST_F(RtpDemuxerTest, CanAddSinkBySsrc) { MockRtpPacketSink sink; constexpr uint32_t ssrc = 1; - EXPECT_TRUE(demuxer.AddSink(ssrc, &sink)); - - // Test tear-down - demuxer.RemoveSink(&sink); + EXPECT_TRUE(AddSinkOnlySsrc(ssrc, &sink)); } -TEST(RtpDemuxerTest, OnRtpPacketCalledOnCorrectSinkBySsrc) { - RtpDemuxer demuxer; - +TEST_F(RtpDemuxerTest, OnRtpPacketCalledOnCorrectSinkBySsrc) { constexpr uint32_t ssrcs[] = {101, 202, 303}; MockRtpPacketSink sinks[arraysize(ssrcs)]; for (size_t i = 0; i < arraysize(ssrcs); i++) { - demuxer.AddSink(ssrcs[i], &sinks[i]); + AddSinkOnlySsrc(ssrcs[i], &sinks[i]); } for (size_t i = 0; i < arraysize(ssrcs); i++) { - auto packet = CreateRtpPacketReceived(ssrcs[i]); + auto packet = CreatePacketWithSsrc(ssrcs[i]); EXPECT_CALL(sinks[i], OnRtpPacket(SamePacketAs(*packet))).Times(1); - EXPECT_TRUE(demuxer.OnRtpPacket(*packet)); - } - - // Test tear-down - for (const auto& sink : sinks) { - demuxer.RemoveSink(&sink); + EXPECT_TRUE(demuxer_.OnRtpPacket(*packet)); } } -TEST(RtpDemuxerTest, OnRtpPacketCalledOnCorrectSinkByRsid) { - RtpDemuxer demuxer; - +TEST_F(RtpDemuxerTest, OnRtpPacketCalledOnCorrectSinkByRsid) { const std::string rsids[] = {"a", "b", "c"}; MockRtpPacketSink sinks[arraysize(rsids)]; for (size_t i = 0; i < arraysize(rsids); i++) { - demuxer.AddSink(rsids[i], &sinks[i]); + AddSinkOnlyRsid(rsids[i], &sinks[i]); } for (size_t i = 0; i < arraysize(rsids); i++) { - auto packet = - CreateRtpPacketReceivedWithRsid(rsids[i], static_cast(i), i); + auto packet = CreatePacketWithSsrcRsid(i, rsids[i]); EXPECT_CALL(sinks[i], OnRtpPacket(SamePacketAs(*packet))).Times(1); - EXPECT_TRUE(demuxer.OnRtpPacket(*packet)); - } - - // Test tear-down - for (const auto& sink : sinks) { - demuxer.RemoveSink(&sink); + EXPECT_TRUE(demuxer_.OnRtpPacket(*packet)); } } -TEST(RtpDemuxerTest, PacketsDeliveredInRightOrder) { - RtpDemuxer demuxer; - +TEST_F(RtpDemuxerTest, PacketsDeliveredInRightOrder) { constexpr uint32_t ssrc = 101; MockRtpPacketSink sink; - demuxer.AddSink(ssrc, &sink); + AddSinkOnlySsrc(ssrc, &sink); std::unique_ptr packets[5]; for (size_t i = 0; i < arraysize(packets); i++) { - packets[i] = CreateRtpPacketReceived(ssrc, i); + packets[i] = CreatePacketWithSsrc(ssrc); + packets[i]->SetSequenceNumber(i); } InSequence sequence; @@ -148,190 +180,149 @@ TEST(RtpDemuxerTest, PacketsDeliveredInRightOrder) { } for (const auto& packet : packets) { - EXPECT_TRUE(demuxer.OnRtpPacket(*packet)); + EXPECT_TRUE(demuxer_.OnRtpPacket(*packet)); } - - // Test tear-down - demuxer.RemoveSink(&sink); } -TEST(RtpDemuxerTest, SinkMappedToMultipleSsrcs) { - RtpDemuxer demuxer; - +TEST_F(RtpDemuxerTest, SinkMappedToMultipleSsrcs) { constexpr uint32_t ssrcs[] = {404, 505, 606}; MockRtpPacketSink sink; for (uint32_t ssrc : ssrcs) { - demuxer.AddSink(ssrc, &sink); + AddSinkOnlySsrc(ssrc, &sink); } // The sink which is associated with multiple SSRCs gets the callback // triggered for each of those SSRCs. for (uint32_t ssrc : ssrcs) { - auto packet = CreateRtpPacketReceived(ssrc); + auto packet = CreatePacketWithSsrc(ssrc); EXPECT_CALL(sink, OnRtpPacket(SamePacketAs(*packet))); - EXPECT_TRUE(demuxer.OnRtpPacket(*packet)); + EXPECT_TRUE(demuxer_.OnRtpPacket(*packet)); } - - // Test tear-down - demuxer.RemoveSink(&sink); } -TEST(RtpDemuxerTest, NoCallbackOnSsrcSinkRemovedBeforeFirstPacket) { - RtpDemuxer demuxer; - +TEST_F(RtpDemuxerTest, NoCallbackOnSsrcSinkRemovedBeforeFirstPacket) { constexpr uint32_t ssrc = 404; MockRtpPacketSink sink; - demuxer.AddSink(ssrc, &sink); + AddSinkOnlySsrc(ssrc, &sink); - ASSERT_TRUE(demuxer.RemoveSink(&sink)); + ASSERT_TRUE(RemoveSink(&sink)); // The removed sink does not get callbacks. - auto packet = CreateRtpPacketReceived(ssrc); + auto packet = CreatePacketWithSsrc(ssrc); EXPECT_CALL(sink, OnRtpPacket(_)).Times(0); // Not called. - EXPECT_FALSE(demuxer.OnRtpPacket(*packet)); + EXPECT_FALSE(demuxer_.OnRtpPacket(*packet)); } -TEST(RtpDemuxerTest, NoCallbackOnSsrcSinkRemovedAfterFirstPacket) { - RtpDemuxer demuxer; - +TEST_F(RtpDemuxerTest, NoCallbackOnSsrcSinkRemovedAfterFirstPacket) { constexpr uint32_t ssrc = 404; NiceMock sink; - demuxer.AddSink(ssrc, &sink); + AddSinkOnlySsrc(ssrc, &sink); InSequence sequence; - uint16_t seq_num; - for (seq_num = 0; seq_num < 10; seq_num++) { - ASSERT_TRUE(demuxer.OnRtpPacket(*CreateRtpPacketReceived(ssrc, seq_num))); + for (size_t i = 0; i < 10; i++) { + ASSERT_TRUE(demuxer_.OnRtpPacket(*CreatePacketWithSsrc(ssrc))); } - ASSERT_TRUE(demuxer.RemoveSink(&sink)); + ASSERT_TRUE(RemoveSink(&sink)); // The removed sink does not get callbacks. - auto packet = CreateRtpPacketReceived(ssrc, seq_num); + auto packet = CreatePacketWithSsrc(ssrc); EXPECT_CALL(sink, OnRtpPacket(_)).Times(0); // Not called. - EXPECT_FALSE(demuxer.OnRtpPacket(*packet)); + EXPECT_FALSE(demuxer_.OnRtpPacket(*packet)); } -TEST(RtpDemuxerTest, AddSinkFailsIfCalledForTwoSinks) { - RtpDemuxer demuxer; +TEST_F(RtpDemuxerTest, AddSinkFailsIfCalledForTwoSinks) { MockRtpPacketSink sink_a; MockRtpPacketSink sink_b; constexpr uint32_t ssrc = 1; - ASSERT_TRUE(demuxer.AddSink(ssrc, &sink_a)); + ASSERT_TRUE(AddSinkOnlySsrc(ssrc, &sink_a)); - EXPECT_FALSE(demuxer.AddSink(ssrc, &sink_b)); - - // Test tear-down - demuxer.RemoveSink(&sink_a); + EXPECT_FALSE(AddSinkOnlySsrc(ssrc, &sink_b)); } // An SSRC may only be mapped to a single sink. However, since configuration // of this associations might come from the network, we need to fail gracefully. -TEST(RtpDemuxerTest, OnlyOneSinkPerSsrcGetsOnRtpPacketTriggered) { - RtpDemuxer demuxer; - +TEST_F(RtpDemuxerTest, OnlyOneSinkPerSsrcGetsOnRtpPacketTriggered) { MockRtpPacketSink sinks[3]; constexpr uint32_t ssrc = 404; - ASSERT_TRUE(demuxer.AddSink(ssrc, &sinks[0])); - ASSERT_FALSE(demuxer.AddSink(ssrc, &sinks[1])); - ASSERT_FALSE(demuxer.AddSink(ssrc, &sinks[2])); + ASSERT_TRUE(AddSinkOnlySsrc(ssrc, &sinks[0])); + ASSERT_FALSE(AddSinkOnlySsrc(ssrc, &sinks[1])); + ASSERT_FALSE(AddSinkOnlySsrc(ssrc, &sinks[2])); // The first sink associated with the SSRC remains active; other sinks // were not really added, and so do not get OnRtpPacket() called. - auto packet = CreateRtpPacketReceived(ssrc); + auto packet = CreatePacketWithSsrc(ssrc); EXPECT_CALL(sinks[0], OnRtpPacket(SamePacketAs(*packet))).Times(1); EXPECT_CALL(sinks[1], OnRtpPacket(_)).Times(0); EXPECT_CALL(sinks[2], OnRtpPacket(_)).Times(0); - ASSERT_TRUE(demuxer.OnRtpPacket(*packet)); - - // Test tear-down - demuxer.RemoveSink(&sinks[0]); + ASSERT_TRUE(demuxer_.OnRtpPacket(*packet)); } -TEST(RtpDemuxerTest, AddSinkFailsIfCalledTwiceEvenIfSameSink) { - RtpDemuxer demuxer; +TEST_F(RtpDemuxerTest, AddSinkFailsIfCalledTwiceEvenIfSameSink) { MockRtpPacketSink sink; constexpr uint32_t ssrc = 1; - ASSERT_TRUE(demuxer.AddSink(ssrc, &sink)); + ASSERT_TRUE(AddSinkOnlySsrc(ssrc, &sink)); - EXPECT_FALSE(demuxer.AddSink(ssrc, &sink)); - - // Test tear-down - demuxer.RemoveSink(&sink); + EXPECT_FALSE(AddSinkOnlySsrc(ssrc, &sink)); } -TEST(RtpDemuxerTest, NoRepeatedCallbackOnRepeatedAddSinkForSameSink) { - RtpDemuxer demuxer; - +TEST_F(RtpDemuxerTest, NoRepeatedCallbackOnRepeatedAddSinkForSameSink) { constexpr uint32_t ssrc = 111; MockRtpPacketSink sink; - ASSERT_TRUE(demuxer.AddSink(ssrc, &sink)); - ASSERT_FALSE(demuxer.AddSink(ssrc, &sink)); + ASSERT_TRUE(AddSinkOnlySsrc(ssrc, &sink)); + ASSERT_FALSE(AddSinkOnlySsrc(ssrc, &sink)); - auto packet = CreateRtpPacketReceived(ssrc); + auto packet = CreatePacketWithSsrc(ssrc); EXPECT_CALL(sink, OnRtpPacket(SamePacketAs(*packet))).Times(1); - EXPECT_TRUE(demuxer.OnRtpPacket(*packet)); - - // Test tear-down - demuxer.RemoveSink(&sink); + EXPECT_TRUE(demuxer_.OnRtpPacket(*packet)); } -TEST(RtpDemuxerTest, RemoveSinkReturnsFalseForNeverAddedSink) { - RtpDemuxer demuxer; +TEST_F(RtpDemuxerTest, RemoveSinkReturnsFalseForNeverAddedSink) { MockRtpPacketSink sink; - - EXPECT_FALSE(demuxer.RemoveSink(&sink)); + EXPECT_FALSE(RemoveSink(&sink)); } -TEST(RtpDemuxerTest, RemoveSinkReturnsTrueForPreviouslyAddedSsrcSink) { - RtpDemuxer demuxer; - +TEST_F(RtpDemuxerTest, RemoveSinkReturnsTrueForPreviouslyAddedSsrcSink) { constexpr uint32_t ssrc = 101; MockRtpPacketSink sink; - demuxer.AddSink(ssrc, &sink); + AddSinkOnlySsrc(ssrc, &sink); - EXPECT_TRUE(demuxer.RemoveSink(&sink)); + EXPECT_TRUE(RemoveSink(&sink)); } -TEST(RtpDemuxerTest, - RemoveSinkReturnsTrueForUnresolvedPreviouslyAddedRsidSink) { - RtpDemuxer demuxer; - +TEST_F(RtpDemuxerTest, + RemoveSinkReturnsTrueForUnresolvedPreviouslyAddedRsidSink) { const std::string rsid = "a"; MockRtpPacketSink sink; - demuxer.AddSink(rsid, &sink); + AddSinkOnlyRsid(rsid, &sink); - EXPECT_TRUE(demuxer.RemoveSink(&sink)); + EXPECT_TRUE(RemoveSink(&sink)); } -TEST(RtpDemuxerTest, RemoveSinkReturnsTrueForResolvedPreviouslyAddedRsidSink) { - RtpDemuxer demuxer; - +TEST_F(RtpDemuxerTest, + RemoveSinkReturnsTrueForResolvedPreviouslyAddedRsidSink) { const std::string rsid = "a"; constexpr uint32_t ssrc = 101; NiceMock sink; - demuxer.AddSink(rsid, &sink); - ASSERT_TRUE( - demuxer.OnRtpPacket(*CreateRtpPacketReceivedWithRsid(rsid, ssrc))); + AddSinkOnlyRsid(rsid, &sink); + ASSERT_TRUE(demuxer_.OnRtpPacket(*CreatePacketWithSsrcRsid(ssrc, rsid))); - EXPECT_TRUE(demuxer.RemoveSink(&sink)); + EXPECT_TRUE(RemoveSink(&sink)); } -TEST(RtpDemuxerTest, OnRtpPacketCalledForRsidSink) { - RtpDemuxer demuxer; - +TEST_F(RtpDemuxerTest, OnRtpPacketCalledForRsidSink) { MockRtpPacketSink sink; const std::string rsid = "a"; - demuxer.AddSink(rsid, &sink); + AddSinkOnlyRsid(rsid, &sink); // Create a sequence of RTP packets, where only the first one actually // mentions the RSID. std::unique_ptr packets[5]; constexpr uint32_t rsid_ssrc = 111; - packets[0] = CreateRtpPacketReceivedWithRsid(rsid, rsid_ssrc); + packets[0] = CreatePacketWithSsrcRsid(rsid_ssrc, rsid); for (size_t i = 1; i < arraysize(packets); i++) { - packets[i] = CreateRtpPacketReceived(rsid_ssrc, i); + packets[i] = CreatePacketWithSsrc(rsid_ssrc); } // The first packet associates the RSID with the SSRC, thereby allowing the @@ -341,66 +332,56 @@ TEST(RtpDemuxerTest, OnRtpPacketCalledForRsidSink) { EXPECT_CALL(sink, OnRtpPacket(SamePacketAs(*packet))).Times(1); } for (const auto& packet : packets) { - EXPECT_TRUE(demuxer.OnRtpPacket(*packet)); + EXPECT_TRUE(demuxer_.OnRtpPacket(*packet)); } - - // Test tear-down - demuxer.RemoveSink(&sink); } -TEST(RtpDemuxerTest, NoCallbackOnRsidSinkRemovedBeforeFirstPacket) { - RtpDemuxer demuxer; - +TEST_F(RtpDemuxerTest, NoCallbackOnRsidSinkRemovedBeforeFirstPacket) { MockRtpPacketSink sink; const std::string rsid = "a"; - demuxer.AddSink(rsid, &sink); + AddSinkOnlyRsid(rsid, &sink); // Sink removed - it won't get triggers even if packets with its RSID arrive. - ASSERT_TRUE(demuxer.RemoveSink(&sink)); + ASSERT_TRUE(RemoveSink(&sink)); constexpr uint32_t ssrc = 111; - auto packet = CreateRtpPacketReceivedWithRsid(rsid, ssrc); + auto packet = CreatePacketWithSsrcRsid(ssrc, rsid); EXPECT_CALL(sink, OnRtpPacket(_)).Times(0); // Not called. - EXPECT_FALSE(demuxer.OnRtpPacket(*packet)); + EXPECT_FALSE(demuxer_.OnRtpPacket(*packet)); } -TEST(RtpDemuxerTest, NoCallbackOnRsidSinkRemovedAfterFirstPacket) { - RtpDemuxer demuxer; - +TEST_F(RtpDemuxerTest, NoCallbackOnRsidSinkRemovedAfterFirstPacket) { NiceMock sink; const std::string rsid = "a"; - demuxer.AddSink(rsid, &sink); + AddSinkOnlyRsid(rsid, &sink); InSequence sequence; constexpr uint32_t ssrc = 111; - uint16_t seq_num; - for (seq_num = 0; seq_num < 10; seq_num++) { - auto packet = CreateRtpPacketReceivedWithRsid(rsid, ssrc, seq_num); - ASSERT_TRUE(demuxer.OnRtpPacket(*packet)); + for (size_t i = 0; i < 10; i++) { + auto packet = CreatePacketWithSsrcRsid(ssrc, rsid); + ASSERT_TRUE(demuxer_.OnRtpPacket(*packet)); } // Sink removed - it won't get triggers even if packets with its RSID arrive. - ASSERT_TRUE(demuxer.RemoveSink(&sink)); + ASSERT_TRUE(RemoveSink(&sink)); - auto packet = CreateRtpPacketReceivedWithRsid(rsid, ssrc, seq_num); + auto packet = CreatePacketWithSsrcRsid(ssrc, rsid); EXPECT_CALL(sink, OnRtpPacket(_)).Times(0); // Not called. - EXPECT_FALSE(demuxer.OnRtpPacket(*packet)); + EXPECT_FALSE(demuxer_.OnRtpPacket(*packet)); } // The RSID to SSRC mapping should be one-to-one. If we end up receiving // two (or more) packets with the same SSRC, but different RSIDs, we guarantee // remembering the first one; no guarantees are made about further associations. -TEST(RtpDemuxerTest, FirstSsrcAssociatedWithAnRsidIsNotForgotten) { - RtpDemuxer demuxer; - +TEST_F(RtpDemuxerTest, FirstSsrcAssociatedWithAnRsidIsNotForgotten) { // Each sink has a distinct RSID. MockRtpPacketSink sink_a; const std::string rsid_a = "a"; - demuxer.AddSink(rsid_a, &sink_a); + AddSinkOnlyRsid(rsid_a, &sink_a); MockRtpPacketSink sink_b; const std::string rsid_b = "b"; - demuxer.AddSink(rsid_b, &sink_b); + AddSinkOnlyRsid(rsid_b, &sink_b); InSequence sequence; // Verify that the order of delivery is unchanged. @@ -408,16 +389,16 @@ TEST(RtpDemuxerTest, FirstSsrcAssociatedWithAnRsidIsNotForgotten) { // First a packet with |rsid_a| is received, and |sink_a| is associated with // its SSRC. - auto packet_a = CreateRtpPacketReceivedWithRsid(rsid_a, shared_ssrc, 10); + auto packet_a = CreatePacketWithSsrcRsid(shared_ssrc, rsid_a); EXPECT_CALL(sink_a, OnRtpPacket(SamePacketAs(*packet_a))).Times(1); - EXPECT_TRUE(demuxer.OnRtpPacket(*packet_a)); + EXPECT_TRUE(demuxer_.OnRtpPacket(*packet_a)); // Second, a packet with |rsid_b| is received. We guarantee that |sink_a| // would receive it, and make no guarantees about |sink_b|. - auto packet_b = CreateRtpPacketReceivedWithRsid(rsid_b, shared_ssrc, 20); + auto packet_b = CreatePacketWithSsrcRsid(shared_ssrc, rsid_b); EXPECT_CALL(sink_a, OnRtpPacket(SamePacketAs(*packet_b))).Times(1); EXPECT_CALL(sink_b, OnRtpPacket(SamePacketAs(*packet_b))).Times(AtLeast(0)); - EXPECT_TRUE(demuxer.OnRtpPacket(*packet_b)); + EXPECT_TRUE(demuxer_.OnRtpPacket(*packet_b)); // Known edge-case; adding a new RSID association makes us re-examine all // SSRCs. |sink_b| may or may not be associated with the SSRC now; we make @@ -426,132 +407,94 @@ TEST(RtpDemuxerTest, FirstSsrcAssociatedWithAnRsidIsNotForgotten) { MockRtpPacketSink sink_c; const std::string rsid_c = "c"; constexpr uint32_t some_other_ssrc = shared_ssrc + 1; - demuxer.AddSink(some_other_ssrc, &sink_c); - auto packet_c = CreateRtpPacketReceivedWithRsid(rsid_c, shared_ssrc, 30); + AddSinkOnlySsrc(some_other_ssrc, &sink_c); + auto packet_c = CreatePacketWithSsrcRsid(shared_ssrc, rsid_c); EXPECT_CALL(sink_a, OnRtpPacket(SamePacketAs(*packet_c))).Times(1); EXPECT_CALL(sink_b, OnRtpPacket(SamePacketAs(*packet_c))).Times(AtLeast(0)); - EXPECT_TRUE(demuxer.OnRtpPacket(*packet_c)); - - // Test tear-down - demuxer.RemoveSink(&sink_a); - demuxer.RemoveSink(&sink_b); - demuxer.RemoveSink(&sink_c); + EXPECT_TRUE(demuxer_.OnRtpPacket(*packet_c)); } -TEST(RtpDemuxerTest, MultipleRsidsOnSameSink) { - RtpDemuxer demuxer; - +TEST_F(RtpDemuxerTest, MultipleRsidsOnSameSink) { MockRtpPacketSink sink; const std::string rsids[] = {"a", "b", "c"}; for (const std::string& rsid : rsids) { - demuxer.AddSink(rsid, &sink); + AddSinkOnlyRsid(rsid, &sink); } InSequence sequence; for (size_t i = 0; i < arraysize(rsids); i++) { // Assign different SSRCs and sequence numbers to all packets. const uint32_t ssrc = 1000 + static_cast(i); - const uint16_t sequence_number = 50 + static_cast(i); - auto packet = - CreateRtpPacketReceivedWithRsid(rsids[i], ssrc, sequence_number); + auto packet = CreatePacketWithSsrcRsid(ssrc, rsids[i]); EXPECT_CALL(sink, OnRtpPacket(SamePacketAs(*packet))).Times(1); - EXPECT_TRUE(demuxer.OnRtpPacket(*packet)); + EXPECT_TRUE(demuxer_.OnRtpPacket(*packet)); } - - // Test tear-down - demuxer.RemoveSink(&sink); } -TEST(RtpDemuxerTest, SinkWithBothRsidAndSsrcAssociations) { - RtpDemuxer demuxer; - - MockRtpPacketSink sink; +TEST_F(RtpDemuxerTest, SinkWithBothRsidAndSsrcAssociations) { constexpr uint32_t standalone_ssrc = 10101; constexpr uint32_t rsid_ssrc = 20202; const std::string rsid = "a"; - demuxer.AddSink(standalone_ssrc, &sink); - demuxer.AddSink(rsid, &sink); + MockRtpPacketSink sink; + AddSinkOnlySsrc(standalone_ssrc, &sink); + AddSinkOnlyRsid(rsid, &sink); InSequence sequence; - auto ssrc_packet = CreateRtpPacketReceived(standalone_ssrc, 11); + auto ssrc_packet = CreatePacketWithSsrc(standalone_ssrc); EXPECT_CALL(sink, OnRtpPacket(SamePacketAs(*ssrc_packet))).Times(1); - EXPECT_TRUE(demuxer.OnRtpPacket(*ssrc_packet)); + EXPECT_TRUE(demuxer_.OnRtpPacket(*ssrc_packet)); - auto rsid_packet = CreateRtpPacketReceivedWithRsid(rsid, rsid_ssrc, 22); + auto rsid_packet = CreatePacketWithSsrcRsid(rsid_ssrc, rsid); EXPECT_CALL(sink, OnRtpPacket(SamePacketAs(*rsid_packet))).Times(1); - EXPECT_TRUE(demuxer.OnRtpPacket(*rsid_packet)); - - // Test tear-down - demuxer.RemoveSink(&sink); + EXPECT_TRUE(demuxer_.OnRtpPacket(*rsid_packet)); } -TEST(RtpDemuxerTest, AssociatingByRsidAndBySsrcCannotTriggerDoubleCall) { - RtpDemuxer demuxer; - MockRtpPacketSink sink; - +TEST_F(RtpDemuxerTest, AssociatingByRsidAndBySsrcCannotTriggerDoubleCall) { constexpr uint32_t ssrc = 10101; - demuxer.AddSink(ssrc, &sink); - const std::string rsid = "a"; - demuxer.AddSink(rsid, &sink); - constexpr uint16_t seq_num = 999; - auto packet = CreateRtpPacketReceivedWithRsid(rsid, ssrc, seq_num); + MockRtpPacketSink sink; + AddSinkOnlySsrc(ssrc, &sink); + AddSinkOnlyRsid(rsid, &sink); + + auto packet = CreatePacketWithSsrcRsid(ssrc, rsid); EXPECT_CALL(sink, OnRtpPacket(SamePacketAs(*packet))).Times(1); - EXPECT_TRUE(demuxer.OnRtpPacket(*packet)); - - // Test tear-down - demuxer.RemoveSink(&sink); + EXPECT_TRUE(demuxer_.OnRtpPacket(*packet)); } -TEST(RtpDemuxerTest, RsidObserversInformedOfResolutionsOfTrackedRsids) { - RtpDemuxer demuxer; - +TEST_F(RtpDemuxerTest, RsidObserversInformedOfResolutionsOfTrackedRsids) { constexpr uint32_t ssrc = 111; const std::string rsid = "a"; // Only RSIDs which the demuxer knows may be resolved. NiceMock sink; - demuxer.AddSink(rsid, &sink); + AddSinkOnlyRsid(rsid, &sink); MockSsrcBindingObserver rsid_resolution_observers[3]; for (auto& observer : rsid_resolution_observers) { - demuxer.RegisterSsrcBindingObserver(&observer); + RegisterSsrcBindingObserver(&observer); EXPECT_CALL(observer, OnSsrcBoundToRsid(rsid, ssrc)).Times(1); } // The expected calls to OnSsrcBoundToRsid() will be triggered by this. - demuxer.OnRtpPacket(*CreateRtpPacketReceivedWithRsid(rsid, ssrc)); - - // Test tear-down - for (auto& observer : rsid_resolution_observers) { - demuxer.DeregisterSsrcBindingObserver(&observer); - } - demuxer.RemoveSink(&sink); + demuxer_.OnRtpPacket(*CreatePacketWithSsrcRsid(ssrc, rsid)); } -TEST(RtpDemuxerTest, RsidObserversNotInformedOfResolutionsOfUntrackedRsids) { - RtpDemuxer demuxer; - +TEST_F(RtpDemuxerTest, RsidObserversNotInformedOfResolutionsOfUntrackedRsids) { constexpr uint32_t ssrc = 111; const std::string rsid = "a"; MockSsrcBindingObserver rsid_resolution_observers[3]; for (auto& observer : rsid_resolution_observers) { - demuxer.RegisterSsrcBindingObserver(&observer); + RegisterSsrcBindingObserver(&observer); EXPECT_CALL(observer, OnSsrcBoundToRsid(rsid, ssrc)).Times(0); } // The expected calls to OnRsidResolved() will be triggered by this. - demuxer.OnRtpPacket(*CreateRtpPacketReceivedWithRsid(rsid, ssrc)); - - // Test tear-down - for (auto& observer : rsid_resolution_observers) { - demuxer.DeregisterSsrcBindingObserver(&observer); - } + demuxer_.OnRtpPacket(*CreatePacketWithSsrcRsid(ssrc, rsid)); } // If one sink is associated with SSRC x, and another sink with RSID y, we @@ -559,92 +502,74 @@ TEST(RtpDemuxerTest, RsidObserversNotInformedOfResolutionsOfUntrackedRsids) { // up with one SSRC mapped to two sinks. However, if such faulty input // ever reaches us, we should handle it gracefully - not crash, and keep the // packets routed only to the SSRC sink. -TEST(RtpDemuxerTest, PacketFittingBothRsidSinkAndSsrcSinkGivenOnlyToSsrcSink) { - RtpDemuxer demuxer; - +TEST_F(RtpDemuxerTest, + PacketFittingBothRsidSinkAndSsrcSinkGivenOnlyToSsrcSink) { constexpr uint32_t ssrc = 111; MockRtpPacketSink ssrc_sink; - demuxer.AddSink(ssrc, &ssrc_sink); + AddSinkOnlySsrc(ssrc, &ssrc_sink); const std::string rsid = "a"; MockRtpPacketSink rsid_sink; - demuxer.AddSink(rsid, &rsid_sink); + AddSinkOnlyRsid(rsid, &rsid_sink); - auto packet = CreateRtpPacketReceivedWithRsid(rsid, ssrc); + auto packet = CreatePacketWithSsrcRsid(ssrc, rsid); EXPECT_CALL(ssrc_sink, OnRtpPacket(SamePacketAs(*packet))).Times(1); EXPECT_CALL(rsid_sink, OnRtpPacket(SamePacketAs(*packet))).Times(0); - demuxer.OnRtpPacket(*packet); - - // Test tear-down - demuxer.RemoveSink(&ssrc_sink); - demuxer.RemoveSink(&rsid_sink); + demuxer_.OnRtpPacket(*packet); } -TEST(RtpDemuxerTest, - PacketFittingBothRsidSinkAndSsrcSinkDoesNotTriggerResolutionCallbacks) { - RtpDemuxer demuxer; - +TEST_F(RtpDemuxerTest, + PacketFittingBothRsidSinkAndSsrcSinkDoesNotTriggerResolutionCallbacks) { constexpr uint32_t ssrc = 111; NiceMock ssrc_sink; - demuxer.AddSink(ssrc, &ssrc_sink); + AddSinkOnlySsrc(ssrc, &ssrc_sink); const std::string rsid = "a"; NiceMock rsid_sink; - demuxer.AddSink(rsid, &rsid_sink); + AddSinkOnlyRsid(rsid, &rsid_sink); MockSsrcBindingObserver observer; - demuxer.RegisterSsrcBindingObserver(&observer); + RegisterSsrcBindingObserver(&observer); - auto packet = CreateRtpPacketReceivedWithRsid(rsid, ssrc); + auto packet = CreatePacketWithSsrcRsid(ssrc, rsid); EXPECT_CALL(observer, OnSsrcBoundToRsid(_, _)).Times(0); - demuxer.OnRtpPacket(*packet); - - // Test tear-down - demuxer.RemoveSink(&ssrc_sink); - demuxer.RemoveSink(&rsid_sink); + demuxer_.OnRtpPacket(*packet); } // We're not expecting RSIDs to be resolved to SSRCs which were previously // mapped to sinks, and make no guarantees except for graceful handling. -TEST(RtpDemuxerTest, GracefullyHandleRsidBeingMappedToPrevouslyAssociatedSsrc) { - RtpDemuxer demuxer; - +TEST_F(RtpDemuxerTest, + GracefullyHandleRsidBeingMappedToPrevouslyAssociatedSsrc) { constexpr uint32_t ssrc = 111; NiceMock ssrc_sink; - demuxer.AddSink(ssrc, &ssrc_sink); + AddSinkOnlySsrc(ssrc, &ssrc_sink); const std::string rsid = "a"; MockRtpPacketSink rsid_sink; - demuxer.AddSink(rsid, &rsid_sink); + AddSinkOnlyRsid(rsid, &rsid_sink); MockSsrcBindingObserver observer; - demuxer.RegisterSsrcBindingObserver(&observer); + RegisterSsrcBindingObserver(&observer); // The SSRC was mapped to an SSRC sink, but was even active (packets flowed // over it). - auto packet = CreateRtpPacketReceivedWithRsid(rsid, ssrc); - demuxer.OnRtpPacket(*packet); + auto packet = CreatePacketWithSsrcRsid(ssrc, rsid); + demuxer_.OnRtpPacket(*packet); // If the SSRC sink is ever removed, the RSID sink *might* receive indications // of packets, and observers *might* be informed. Only graceful handling // is guaranteed. - demuxer.RemoveSink(&ssrc_sink); + RemoveSink(&ssrc_sink); EXPECT_CALL(rsid_sink, OnRtpPacket(SamePacketAs(*packet))).Times(AtLeast(0)); EXPECT_CALL(observer, OnSsrcBoundToRsid(rsid, ssrc)).Times(AtLeast(0)); - demuxer.OnRtpPacket(*packet); - - // Test tear-down - demuxer.DeregisterSsrcBindingObserver(&observer); - demuxer.RemoveSink(&rsid_sink); + demuxer_.OnRtpPacket(*packet); } -TEST(RtpDemuxerTest, DeregisteredRsidObserversNotInformedOfResolutions) { - RtpDemuxer demuxer; - +TEST_F(RtpDemuxerTest, DeregisteredRsidObserversNotInformedOfResolutions) { constexpr uint32_t ssrc = 111; const std::string rsid = "a"; NiceMock sink; - demuxer.AddSink(rsid, &sink); + AddSinkOnlyRsid(rsid, &sink); // Register several, then deregister only one, to show that not all of the // observers had been forgotten when one was removed. @@ -652,92 +577,65 @@ TEST(RtpDemuxerTest, DeregisteredRsidObserversNotInformedOfResolutions) { MockSsrcBindingObserver observer_2_removed; MockSsrcBindingObserver observer_3; - demuxer.RegisterSsrcBindingObserver(&observer_1); - demuxer.RegisterSsrcBindingObserver(&observer_2_removed); - demuxer.RegisterSsrcBindingObserver(&observer_3); + RegisterSsrcBindingObserver(&observer_1); + RegisterSsrcBindingObserver(&observer_2_removed); + RegisterSsrcBindingObserver(&observer_3); - demuxer.DeregisterSsrcBindingObserver(&observer_2_removed); + DeregisterSsrcBindingObserver(&observer_2_removed); EXPECT_CALL(observer_1, OnSsrcBoundToRsid(rsid, ssrc)).Times(1); EXPECT_CALL(observer_2_removed, OnSsrcBoundToRsid(_, _)).Times(0); EXPECT_CALL(observer_3, OnSsrcBoundToRsid(rsid, ssrc)).Times(1); // The expected calls to OnSsrcBoundToRsid() will be triggered by this. - demuxer.OnRtpPacket(*CreateRtpPacketReceivedWithRsid(rsid, ssrc)); - - // Test tear-down - demuxer.RemoveSink(&sink); - demuxer.DeregisterSsrcBindingObserver(&observer_1); - demuxer.DeregisterSsrcBindingObserver(&observer_3); + demuxer_.OnRtpPacket(*CreatePacketWithSsrcRsid(ssrc, rsid)); } #if RTC_DCHECK_IS_ON && GTEST_HAS_DEATH_TEST && !defined(WEBRTC_ANDROID) -TEST(RtpDemuxerTest, RsidMustBeNonEmpty) { - RtpDemuxer demuxer; +TEST_F(RtpDemuxerTest, RsidMustBeNonEmpty) { MockRtpPacketSink sink; - - EXPECT_DEATH(demuxer.AddSink("", &sink), ""); + EXPECT_DEATH(AddSinkOnlyRsid("", &sink), ""); } -TEST(RtpDemuxerTest, RsidMustBeAlphaNumeric) { - RtpDemuxer demuxer; +TEST_F(RtpDemuxerTest, RsidMustBeAlphaNumeric) { MockRtpPacketSink sink; - - EXPECT_DEATH(demuxer.AddSink("a_3", &sink), ""); + EXPECT_DEATH(AddSinkOnlyRsid("a_3", &sink), ""); } -TEST(RtpDemuxerTest, RsidMustNotExceedMaximumLength) { - RtpDemuxer demuxer; +TEST_F(RtpDemuxerTest, RsidMustNotExceedMaximumLength) { MockRtpPacketSink sink; std::string rsid(StreamId::kMaxSize + 1, 'a'); - - EXPECT_DEATH(demuxer.AddSink(rsid, &sink), ""); + EXPECT_DEATH(AddSinkOnlyRsid(rsid, &sink), ""); } -TEST(RtpDemuxerTest, RepeatedRsidAssociationsDisallowed) { - RtpDemuxer demuxer; +TEST_F(RtpDemuxerTest, RepeatedRsidAssociationsDisallowed) { MockRtpPacketSink sink_a; MockRtpPacketSink sink_b; const std::string rsid = "a"; - demuxer.AddSink(rsid, &sink_a); + AddSinkOnlyRsid(rsid, &sink_a); - EXPECT_DEATH(demuxer.AddSink(rsid, &sink_b), ""); - - // Test tear-down - demuxer.RemoveSink(&sink_a); + EXPECT_DEATH(AddSinkOnlyRsid(rsid, &sink_b), ""); } -TEST(RtpDemuxerTest, RepeatedRsidAssociationsDisallowedEvenIfSameSink) { - RtpDemuxer demuxer; - MockRtpPacketSink sink; - +TEST_F(RtpDemuxerTest, RepeatedRsidAssociationsDisallowedEvenIfSameSink) { const std::string rsid = "a"; - demuxer.AddSink(rsid, &sink); + MockRtpPacketSink sink; + AddSinkOnlyRsid(rsid, &sink); - EXPECT_DEATH(demuxer.AddSink(rsid, &sink), ""); - - // Test tear-down - demuxer.RemoveSink(&sink); + EXPECT_DEATH(AddSinkOnlyRsid(rsid, &sink), ""); } -TEST(RtpDemuxerTest, DoubleRegisterationOfRsidResolutionObserverDisallowed) { - RtpDemuxer demuxer; +TEST_F(RtpDemuxerTest, DoubleRegisterationOfRsidResolutionObserverDisallowed) { MockSsrcBindingObserver observer; - demuxer.RegisterSsrcBindingObserver(&observer); - - EXPECT_DEATH(demuxer.RegisterSsrcBindingObserver(&observer), ""); - - // Test tear-down - demuxer.DeregisterSsrcBindingObserver(&observer); + RegisterSsrcBindingObserver(&observer); + EXPECT_DEATH(RegisterSsrcBindingObserver(&observer), ""); } -TEST(RtpDemuxerTest, - DregisterationOfNeverRegisteredRsidResolutionObserverDisallowed) { - RtpDemuxer demuxer; +TEST_F(RtpDemuxerTest, + DregisterationOfNeverRegisteredRsidResolutionObserverDisallowed) { MockSsrcBindingObserver observer; - - EXPECT_DEATH(demuxer.DeregisterSsrcBindingObserver(&observer), ""); + EXPECT_DEATH(DeregisterSsrcBindingObserver(&observer), ""); } #endif