Create unit tests for RtpDemuxer

webrtc/call/rtp_demuxer_unittest.cc

Index: webrtc/call/rtp_demuxer_unittest.cc
diff --git a/webrtc/call/rtp_demuxer_unittest.cc b/webrtc/call/rtp_demuxer_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..9073ed049231195cd0f3389c7dc030730556c0b4
--- /dev/null
+++ b/webrtc/call/rtp_demuxer_unittest.cc
@@ -0,0 +1,157 @@
+/*
+ *  Copyright (c) 2017 The WebRTC project authors. All Rights Reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS.  All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include "webrtc/call/rtp_demuxer.h"
+
+#include <memory>
+
+#include "webrtc/modules/rtp_rtcp/source/rtp_packet_received.h"
+
+#include "webrtc/base/arraysize.h"
+#include "webrtc/base/checks.h"
+#include "webrtc/test/gmock.h"
+#include "webrtc/test/gtest.h"
+
+namespace webrtc {
+
+namespace {
+
+class MockRtpPacketSink : public RtpPacketSinkInterface {
+ public:
+  MOCK_METHOD1(OnRtpPacket, void(const RtpPacketReceived&));
+};
+
+constexpr uint32_t kSsrcs[] = {101, 202, 303};
+
+MATCHER_P(SsrcSameAsIn, other, "") {
+  return arg.Ssrc() == other.Ssrc();
+}
+
+std::unique_ptr<RtpPacketReceived> CreateRtpPacketReceived(uint32_t ssrc) {
+  std::unique_ptr<RtpPacketReceived> packet(new RtpPacketReceived());
+  packet->SetSsrc(ssrc);
+  return packet;
+}
+
+class RtpDemuxerTest : public ::testing::Test {
+ protected:
+  RtpDemuxerTest() {
+    for (size_t i = 0; i < kNumOfSinks; i++) {
+      demuxer.AddSink(kSsrcs[i], &sinks[i]);
+    }
+  }
+
+  ~RtpDemuxerTest() override {
+    for (size_t i = 0; i < kNumOfSinks; i++) {
+      EXPECT_EQ(demuxer.RemoveSink(&sinks[i]), 1u);
+    }
+  }
+
+  RtpDemuxer demuxer;
+  static constexpr size_t kNumOfSinks = 3;

[nisse-webrtc, 2017/05/29 07:58:22]

I'm no real c++ guru, but does static really make sense together with constexpr,
and if so, what does it mean?

[danilchap, 2017/05/29 08:59:53]

afaik it is a compile error to use constexpr without static for member variable.
static still mean same: the variable is bound to class, not to object.

+  MockRtpPacketSink sinks[kNumOfSinks];
+};
+
+TEST_F(RtpDemuxerTest, OnRtpPacketCalledOnCorrectSink) {
+  for (size_t i = 0; i < kNumOfSinks; i++) {
+    auto packet = CreateRtpPacketReceived(kSsrcs[i]);
+    EXPECT_CALL(sinks[i], OnRtpPacket(SsrcSameAsIn(*packet)));

[nisse-webrtc, 2017/05/29 07:58:22]

You could compare the address of the packet, which would arguably be stricter
than comparing ssrc. I think it would work with just testing::Ref(*packet).

[eladalon, 2017/05/30 14:23:37]

Thanks for the tip, but I think it would introduce an assumption that RtpDemuxer
does not replicate the data, as it might wish to do if it were, for example,
multi-threaded, in which case it might wish to buffer the replicated object for
the other thread.

+    demuxer.OnRtpPacket(*packet);
+    testing::Mock::VerifyAndClearExpectations(&sinks[i]);

[nisse-webrtc, 2017/05/29 07:58:22]

Why do you need to call this explicitly? If it's really beneficial, I think it
deserves a comment explaining why.

[eladalon, 2017/05/30 14:23:37]

I'll remove, then.

+  }
+}
+
+TEST_F(RtpDemuxerTest, MultipleSinksMappedToSameSsrc) {
+  // |sinks| associated with different SSRCs each. Add a few additional sinks
+  // that are all associated with one new, distinct SSRC.
+  constexpr size_t kNumOfSameSsrcSinks = 3;
+  MockRtpPacketSink same_ssrc_sinks[kNumOfSameSsrcSinks];
+  constexpr uint32_t kSharedSsrc = 404;
+  for (size_t i = 0; i < kNumOfSameSsrcSinks; i++) {
+    demuxer.AddSink(kSharedSsrc, &same_ssrc_sinks[i]);
+  }
+
+  // Reception of an RTP packet associated with the shared SSRC triggers the
+  // callback on all of the interfaces associated with it.
+  auto packet = CreateRtpPacketReceived(kSharedSsrc);
+  for (size_t i = 0; i < kNumOfSameSsrcSinks; i++) {
+    EXPECT_CALL(same_ssrc_sinks[i], OnRtpPacket(SsrcSameAsIn(*packet)));
+  }
+  demuxer.OnRtpPacket(*packet);
+
+  // Test-specific tear-down
+  for (size_t i = 0; i < kNumOfSameSsrcSinks; i++) {
+    EXPECT_EQ(demuxer.RemoveSink(&same_ssrc_sinks[i]), 1u);
+  }
+}
+
+TEST_F(RtpDemuxerTest, SinkMappedToMultipleSsrcs) {
+  // |sinks| associated with different SSRCs each. We set one of them to also
+  // be mapped to additional SSRCs.
+  constexpr uint32_t kSsrcsOfMultiSsrcSink[] = {404, 505, 606};
+  MockRtpPacketSink multi_ssrc_sink;
+  for (uint32_t ssrc : kSsrcsOfMultiSsrcSink) {
+    demuxer.AddSink(ssrc, &multi_ssrc_sink);
+  }
+
+  // The sink which is associated with multiple SSRCs gets the callback
+  // triggered for each of those SSRCs.
+  for (uint32_t ssrc : kSsrcsOfMultiSsrcSink) {
+    auto packet = CreateRtpPacketReceived(ssrc);
+    EXPECT_CALL(multi_ssrc_sink, OnRtpPacket(SsrcSameAsIn(*packet)));
+    demuxer.OnRtpPacket(*packet);
+    testing::Mock::VerifyAndClearExpectations(&multi_ssrc_sink);
+  }
+
+  // Test-specific tear-down
+  EXPECT_EQ(demuxer.RemoveSink(&multi_ssrc_sink),
+            arraysize(kSsrcsOfMultiSsrcSink));
+}
+
+TEST_F(RtpDemuxerTest, OnRtpPacketNotCalledOnRemovedSinks) {
+  // |sinks| associated with different SSRCs each. We set one of them to also
+  // be mapped to additional SSRCs.
+  constexpr uint32_t kSsrcsOfMultiSsrcSink[] = {404, 505, 606};
+  MockRtpPacketSink multi_ssrc_sink;
+  for (uint32_t ssrc : kSsrcsOfMultiSsrcSink) {
+    demuxer.AddSink(ssrc, &multi_ssrc_sink);
+  }
+
+  // Remove the sink.
+  EXPECT_EQ(demuxer.RemoveSink(&multi_ssrc_sink),
+            arraysize(kSsrcsOfMultiSsrcSink));
+
+  // The removed sink does not get callbacks triggered for any of the SSRCs
+  // with which it was previously associated.
+  for (uint32_t ssrc : kSsrcsOfMultiSsrcSink) {
+    auto packet = CreateRtpPacketReceived(ssrc);
+    demuxer.OnRtpPacket(*packet);
+  }
+}
+
+#if RTC_DCHECK_IS_ON && GTEST_HAS_DEATH_TEST && !defined(WEBRTC_ANDROID)
+TEST_F(RtpDemuxerTest, RepeatedAssociationsForbidden) {
+  // Set-up already associated sinks[0] with kSsrcs[0]. Repeating the
+  // association is an error.
+  EXPECT_DEATH(demuxer.AddSink(kSsrcs[0], &sinks[0]), "");
+}
+
+TEST_F(RtpDemuxerTest, SinksMustBeRemovedBeforeDestruction) {
+  std::unique_ptr<RtpDemuxer> bad_demuxer(new RtpDemuxer());
+  MockRtpPacketSink sink;
+  constexpr uint32_t ssrc = 111;
+  bad_demuxer->AddSink(ssrc, &sink);
+  EXPECT_DEATH(bad_demuxer.reset(), "");
+  EXPECT_EQ(bad_demuxer->RemoveSink(&sink), 1u);
+}
+#endif
+
+}  // namespace
+}  // namespace webrtc