1 /*
2 * Copyright (c) 2019 The WebRTC project authors. All Rights Reserved.
3 *
4 * Use of this source code is governed by a BSD-style license
5 * that can be found in the LICENSE file in the root of the source
6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree.
9 */
10
11 #include "media/engine/unhandled_packets_buffer.h"
12
13 #include <memory>
14
15 #include "absl/memory/memory.h"
16 #include "test/gmock.h"
17 #include "test/gtest.h"
18
19 using ::testing::_;
20
21 namespace {
22
Create(int n)23 rtc::CopyOnWriteBuffer Create(int n) {
24 return rtc::CopyOnWriteBuffer(std::to_string(n));
25 }
26
27 constexpr int64_t kPacketTimeUs = 122;
28
29 } // namespace
30
31 namespace cricket {
32
TEST(UnhandledPacketsBuffer,NoPackets)33 TEST(UnhandledPacketsBuffer, NoPackets) {
34 UnhandledPacketsBuffer buff;
35 buff.AddPacket(2, kPacketTimeUs, Create(3));
36
37 std::vector<uint32_t> ssrcs = {3};
38 std::vector<rtc::CopyOnWriteBuffer> packets;
39 buff.BackfillPackets(ssrcs, [&packets](uint32_t ssrc, int64_t packet_time_us,
40 rtc::CopyOnWriteBuffer packet) {
41 packets.push_back(packet);
42 });
43 EXPECT_EQ(0u, packets.size());
44 }
45
TEST(UnhandledPacketsBuffer,OnePacket)46 TEST(UnhandledPacketsBuffer, OnePacket) {
47 UnhandledPacketsBuffer buff;
48 buff.AddPacket(2, kPacketTimeUs, Create(3));
49
50 std::vector<uint32_t> ssrcs = {2};
51 std::vector<rtc::CopyOnWriteBuffer> packets;
52 buff.BackfillPackets(ssrcs, [&packets](uint32_t ssrc, int64_t packet_time_us,
53 rtc::CopyOnWriteBuffer packet) {
54 packets.push_back(packet);
55 });
56 ASSERT_EQ(1u, packets.size());
57 EXPECT_EQ(Create(3), packets[0]);
58 }
59
TEST(UnhandledPacketsBuffer,TwoPacketsTwoSsrcs)60 TEST(UnhandledPacketsBuffer, TwoPacketsTwoSsrcs) {
61 UnhandledPacketsBuffer buff;
62 buff.AddPacket(2, kPacketTimeUs, Create(3));
63 buff.AddPacket(3, kPacketTimeUs, Create(4));
64
65 std::vector<uint32_t> ssrcs = {2, 3};
66 std::vector<rtc::CopyOnWriteBuffer> packets;
67 buff.BackfillPackets(ssrcs, [&packets](uint32_t ssrc, int64_t packet_time_us,
68 rtc::CopyOnWriteBuffer packet) {
69 packets.push_back(packet);
70 });
71 ASSERT_EQ(2u, packets.size());
72 EXPECT_EQ(Create(3), packets[0]);
73 EXPECT_EQ(Create(4), packets[1]);
74 }
75
TEST(UnhandledPacketsBuffer,TwoPacketsTwoSsrcsOneMatch)76 TEST(UnhandledPacketsBuffer, TwoPacketsTwoSsrcsOneMatch) {
77 UnhandledPacketsBuffer buff;
78 buff.AddPacket(2, kPacketTimeUs, Create(3));
79 buff.AddPacket(3, kPacketTimeUs, Create(4));
80
81 std::vector<uint32_t> ssrcs = {3};
82 buff.BackfillPackets(ssrcs, [](uint32_t ssrc, int64_t packet_time_us,
83 rtc::CopyOnWriteBuffer packet) {
84 EXPECT_EQ(ssrc, 3u);
85 EXPECT_EQ(Create(4), packet);
86 });
87
88 std::vector<uint32_t> ssrcs_again = {2};
89 buff.BackfillPackets(ssrcs, [](uint32_t ssrc, int64_t packet_time_us,
90 rtc::CopyOnWriteBuffer packet) {
91 EXPECT_EQ(ssrc, 2u);
92 EXPECT_EQ(Create(3), packet);
93 });
94 }
95
TEST(UnhandledPacketsBuffer,Full)96 TEST(UnhandledPacketsBuffer, Full) {
97 const size_t cnt = UnhandledPacketsBuffer::kMaxStashedPackets;
98 UnhandledPacketsBuffer buff;
99 for (size_t i = 0; i < cnt; i++) {
100 buff.AddPacket(2, kPacketTimeUs, Create(i));
101 }
102
103 std::vector<uint32_t> ssrcs = {2};
104 std::vector<rtc::CopyOnWriteBuffer> packets;
105 buff.BackfillPackets(ssrcs, [&packets](uint32_t ssrc, int64_t packet_time_us,
106 rtc::CopyOnWriteBuffer packet) {
107 packets.push_back(packet);
108 });
109 ASSERT_EQ(cnt, packets.size());
110 for (size_t i = 0; i < cnt; i++) {
111 EXPECT_EQ(Create(i), packets[i]);
112 }
113
114 // Add a packet after backfill and check that it comes back.
115 buff.AddPacket(23, kPacketTimeUs, Create(1001));
116 buff.BackfillPackets(ssrcs, [](uint32_t ssrc, int64_t packet_time_us,
117 rtc::CopyOnWriteBuffer packet) {
118 EXPECT_EQ(ssrc, 23u);
119 EXPECT_EQ(Create(1001), packet);
120 });
121 }
122
TEST(UnhandledPacketsBuffer,Wrap)123 TEST(UnhandledPacketsBuffer, Wrap) {
124 UnhandledPacketsBuffer buff;
125 size_t cnt = UnhandledPacketsBuffer::kMaxStashedPackets + 10;
126 for (size_t i = 0; i < cnt; i++) {
127 buff.AddPacket(2, kPacketTimeUs, Create(i));
128 }
129
130 std::vector<uint32_t> ssrcs = {2};
131 std::vector<rtc::CopyOnWriteBuffer> packets;
132 buff.BackfillPackets(ssrcs, [&packets](uint32_t ssrc, int64_t packet_time_us,
133 rtc::CopyOnWriteBuffer packet) {
134 packets.push_back(packet);
135 });
136 for (size_t i = 0; i < packets.size(); i++) {
137 EXPECT_EQ(Create(i + 10), packets[i]);
138 }
139
140 // Add a packet after backfill and check that it comes back.
141 buff.AddPacket(23, kPacketTimeUs, Create(1001));
142 buff.BackfillPackets(ssrcs, [](uint32_t ssrc, int64_t packet_time_us,
143 rtc::CopyOnWriteBuffer packet) {
144 EXPECT_EQ(ssrc, 23u);
145 EXPECT_EQ(Create(1001), packet);
146 });
147 }
148
TEST(UnhandledPacketsBuffer,Interleaved)149 TEST(UnhandledPacketsBuffer, Interleaved) {
150 UnhandledPacketsBuffer buff;
151 buff.AddPacket(2, kPacketTimeUs, Create(2));
152 buff.AddPacket(3, kPacketTimeUs, Create(3));
153
154 std::vector<uint32_t> ssrcs = {2};
155 buff.BackfillPackets(ssrcs, [](uint32_t ssrc, int64_t packet_time_us,
156 rtc::CopyOnWriteBuffer packet) {
157 EXPECT_EQ(ssrc, 2u);
158 EXPECT_EQ(Create(2), packet);
159 });
160
161 buff.AddPacket(4, kPacketTimeUs, Create(4));
162
163 ssrcs = {3};
164 buff.BackfillPackets(ssrcs, [](uint32_t ssrc, int64_t packet_time_us,
165 rtc::CopyOnWriteBuffer packet) {
166 EXPECT_EQ(ssrc, 3u);
167 EXPECT_EQ(Create(3), packet);
168 });
169 }
170
171 } // namespace cricket
172