blob: a0adceefdf4e7609d7609e301444fdd2e305da63 [file] [log] [blame]
pwestin@webrtc.orgb5180172012-11-09 20:56:23 +00001/*
2 * Copyright (c) 2012 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 <gmock/gmock.h>
12#include <gtest/gtest.h>
13
14#include "webrtc/modules/pacing/include/paced_sender.h"
15
pwestin@webrtc.orgdb418562013-03-22 23:39:29 +000016using testing::_;
pwestin@webrtc.orgb5180172012-11-09 20:56:23 +000017
18namespace webrtc {
pwestin@webrtc.orgdb418562013-03-22 23:39:29 +000019namespace test {
20
21static const int kTargetBitrate = 800;
pwestin@webrtc.orgb5180172012-11-09 20:56:23 +000022
23class MockPacedSenderCallback : public PacedSender::Callback {
24 public:
25 MOCK_METHOD3(TimeToSendPacket,
26 void(uint32_t ssrc, uint16_t sequence_number, int64_t capture_time_ms));
27 MOCK_METHOD1(TimeToSendPadding,
28 void(int bytes));
29};
30
31class PacedSenderTest : public ::testing::Test {
32 protected:
33 PacedSenderTest() {
34 TickTime::UseFakeClock(123456);
35 // Need to initialize PacedSender after we initialize clock.
36 send_bucket_.reset(new PacedSender(&callback_, kTargetBitrate));
37 send_bucket_->SetStatus(true);
38 }
39 MockPacedSenderCallback callback_;
40 scoped_ptr<PacedSender> send_bucket_;
41};
42
43TEST_F(PacedSenderTest, QueuePacket) {
44 uint32_t ssrc = 12345;
45 uint16_t sequence_number = 1234;
46 int64_t capture_time_ms = 56789;
47
48 // Due to the multiplicative factor we can send 3 packets not 2 packets.
49 EXPECT_TRUE(send_bucket_->SendPacket(PacedSender::kNormalPriority, ssrc,
50 sequence_number++, capture_time_ms, 250));
51 EXPECT_TRUE(send_bucket_->SendPacket(PacedSender::kNormalPriority, ssrc,
52 sequence_number++, capture_time_ms, 250));
53 EXPECT_TRUE(send_bucket_->SendPacket(PacedSender::kNormalPriority, ssrc,
54 sequence_number++, capture_time_ms, 250));
55 EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority, ssrc,
56 sequence_number, capture_time_ms, 250));
57 EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
pwestin@webrtc.orgdb418562013-03-22 23:39:29 +000058 EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0);
pwestin@webrtc.orgb5180172012-11-09 20:56:23 +000059 EXPECT_CALL(callback_,
60 TimeToSendPacket(ssrc, sequence_number, capture_time_ms)).Times(0);
61 TickTime::AdvanceFakeClock(4);
62 EXPECT_EQ(1, send_bucket_->TimeUntilNextProcess());
63 EXPECT_CALL(callback_,
64 TimeToSendPacket(ssrc, sequence_number, capture_time_ms)).Times(1);
65 TickTime::AdvanceFakeClock(1);
66 EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
67 EXPECT_EQ(0, send_bucket_->Process());
68 sequence_number++;
69 EXPECT_TRUE(send_bucket_->SendPacket(PacedSender::kNormalPriority, ssrc,
70 sequence_number++, capture_time_ms, 250));
71 EXPECT_TRUE(send_bucket_->SendPacket(PacedSender::kNormalPriority, ssrc,
72 sequence_number++, capture_time_ms, 250));
73 EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority, ssrc,
74 sequence_number++, capture_time_ms, 250));
75}
76
77TEST_F(PacedSenderTest, PaceQueuedPackets) {
78 uint32_t ssrc = 12345;
79 uint16_t sequence_number = 1234;
80 int64_t capture_time_ms = 56789;
81
82 // Due to the multiplicative factor we can send 3 packets not 2 packets.
83 for (int i = 0; i < 3; ++i) {
84 EXPECT_TRUE(send_bucket_->SendPacket(PacedSender::kNormalPriority, ssrc,
85 sequence_number++, capture_time_ms, 250));
86 }
87 for (int j = 0; j < 30; ++j) {
88 EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority, ssrc,
89 sequence_number++, capture_time_ms, 250));
90 }
pwestin@webrtc.orgdb418562013-03-22 23:39:29 +000091 EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0);
pwestin@webrtc.orgb5180172012-11-09 20:56:23 +000092 for (int k = 0; k < 10; ++k) {
93 EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
94 TickTime::AdvanceFakeClock(5);
95 EXPECT_CALL(callback_,
pwestin@webrtc.orgdb418562013-03-22 23:39:29 +000096 TimeToSendPacket(ssrc, _, capture_time_ms)).Times(3);
pwestin@webrtc.orgb5180172012-11-09 20:56:23 +000097 EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
98 EXPECT_EQ(0, send_bucket_->Process());
99 }
100 EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
101 TickTime::AdvanceFakeClock(5);
102 EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
103 EXPECT_EQ(0, send_bucket_->Process());
104 EXPECT_TRUE(send_bucket_->SendPacket(PacedSender::kNormalPriority, ssrc,
105 sequence_number++, capture_time_ms, 250));
106 EXPECT_TRUE(send_bucket_->SendPacket(PacedSender::kNormalPriority, ssrc,
107 sequence_number++, capture_time_ms, 250));
108 EXPECT_TRUE(send_bucket_->SendPacket(PacedSender::kNormalPriority, ssrc,
109 sequence_number++, capture_time_ms, 250));
110 EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority, ssrc,
111 sequence_number++, capture_time_ms, 250));
112}
113
pwestin@webrtc.org52aa0192013-04-25 17:35:56 +0000114TEST_F(PacedSenderTest, PaceQueuedPacketsWithDuplicates) {
115 uint32_t ssrc = 12345;
116 uint16_t sequence_number = 1234;
117 int64_t capture_time_ms = 56789;
118 uint16_t queued_sequence_number;
119
120 // Due to the multiplicative factor we can send 3 packets not 2 packets.
121 for (int i = 0; i < 3; ++i) {
122 EXPECT_TRUE(send_bucket_->SendPacket(PacedSender::kNormalPriority, ssrc,
123 sequence_number++, capture_time_ms, 250));
124 }
125 queued_sequence_number = sequence_number;
126
127 for (int j = 0; j < 30; ++j) {
128 // Send in duplicate packets.
129 EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority, ssrc,
130 sequence_number, capture_time_ms, 250));
131 EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority, ssrc,
132 sequence_number++, capture_time_ms, 250));
133 }
134 EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0);
135 for (int k = 0; k < 10; ++k) {
136 EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
137 TickTime::AdvanceFakeClock(5);
138
139 for (int i = 0; i < 3; ++i) {
140 EXPECT_CALL(callback_, TimeToSendPacket(ssrc, queued_sequence_number++,
141 capture_time_ms)).Times(1);
142 }
143 EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
144 EXPECT_EQ(0, send_bucket_->Process());
145 }
146 EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
147 TickTime::AdvanceFakeClock(5);
148 EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
149 EXPECT_EQ(0, send_bucket_->Process());
150 EXPECT_TRUE(send_bucket_->SendPacket(PacedSender::kNormalPriority, ssrc,
151 sequence_number++, capture_time_ms, 250));
152 EXPECT_TRUE(send_bucket_->SendPacket(PacedSender::kNormalPriority, ssrc,
153 sequence_number++, capture_time_ms, 250));
154 EXPECT_TRUE(send_bucket_->SendPacket(PacedSender::kNormalPriority, ssrc,
155 sequence_number++, capture_time_ms, 250));
156 EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority, ssrc,
157 sequence_number++, capture_time_ms, 250));
158}
159
pwestin@webrtc.orgb5180172012-11-09 20:56:23 +0000160TEST_F(PacedSenderTest, Padding) {
161 uint32_t ssrc = 12345;
162 uint16_t sequence_number = 1234;
163 int64_t capture_time_ms = 56789;
164
165 // Due to the multiplicative factor we can send 3 packets not 2 packets.
166 EXPECT_TRUE(send_bucket_->SendPacket(PacedSender::kNormalPriority, ssrc,
167 sequence_number++, capture_time_ms, 250));
168 EXPECT_TRUE(send_bucket_->SendPacket(PacedSender::kNormalPriority, ssrc,
169 sequence_number++, capture_time_ms, 250));
170 EXPECT_TRUE(send_bucket_->SendPacket(PacedSender::kNormalPriority, ssrc,
171 sequence_number++, capture_time_ms, 250));
172 EXPECT_CALL(callback_, TimeToSendPadding(250)).Times(1);
173 EXPECT_CALL(callback_,
174 TimeToSendPacket(ssrc, sequence_number, capture_time_ms)).Times(0);
175 EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
176 TickTime::AdvanceFakeClock(5);
177 EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
178 EXPECT_EQ(0, send_bucket_->Process());
179
180 EXPECT_CALL(callback_, TimeToSendPadding(500)).Times(1);
181 EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
182 TickTime::AdvanceFakeClock(5);
183 EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
184 EXPECT_EQ(0, send_bucket_->Process());
185}
186
187TEST_F(PacedSenderTest, Priority) {
188 uint32_t ssrc_low_priority = 12345;
189 uint32_t ssrc = 12346;
190 uint16_t sequence_number = 1234;
191 int64_t capture_time_ms = 56789;
192 int64_t capture_time_ms_low_priority = 1234567;
193
194 // Due to the multiplicative factor we can send 3 packets not 2 packets.
195 EXPECT_TRUE(send_bucket_->SendPacket(PacedSender::kLowPriority,
196 ssrc_low_priority, sequence_number++, capture_time_ms_low_priority, 250));
197 EXPECT_TRUE(send_bucket_->SendPacket(PacedSender::kNormalPriority,
198 ssrc, sequence_number++, capture_time_ms, 250));
199 EXPECT_TRUE(send_bucket_->SendPacket(PacedSender::kNormalPriority,
200 ssrc, sequence_number++, capture_time_ms, 250));
201
202 // Expect normal and low priority to be queued and high to pass through.
203 EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kLowPriority,
204 ssrc_low_priority, sequence_number++, capture_time_ms_low_priority, 250));
205 EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority,
206 ssrc, sequence_number++, capture_time_ms, 250));
207 EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority,
208 ssrc, sequence_number++, capture_time_ms, 250));
pwestin@webrtc.orgdb418562013-03-22 23:39:29 +0000209 EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kHighPriority,
pwestin@webrtc.orgb5180172012-11-09 20:56:23 +0000210 ssrc, sequence_number++, capture_time_ms, 250));
211
pwestin@webrtc.orgdb418562013-03-22 23:39:29 +0000212 // Expect all high and normal priority to be sent out first.
213 EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0);
214 EXPECT_CALL(callback_, TimeToSendPacket(ssrc, _, capture_time_ms)).Times(3);
pwestin@webrtc.orgb5180172012-11-09 20:56:23 +0000215
216 EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
217 TickTime::AdvanceFakeClock(5);
218 EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
219 EXPECT_EQ(0, send_bucket_->Process());
220
pwestin@webrtc.orgdb418562013-03-22 23:39:29 +0000221 EXPECT_CALL(callback_, TimeToSendPacket(
222 ssrc_low_priority, _, capture_time_ms_low_priority)).Times(1);
pwestin@webrtc.orgb5180172012-11-09 20:56:23 +0000223
224 EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
225 TickTime::AdvanceFakeClock(5);
226 EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
227 EXPECT_EQ(0, send_bucket_->Process());
228}
229
pwestin@webrtc.orgdb418562013-03-22 23:39:29 +0000230TEST_F(PacedSenderTest, Pause) {
231 uint32_t ssrc_low_priority = 12345;
232 uint32_t ssrc = 12346;
233 uint16_t sequence_number = 1234;
stefan@webrtc.orgbfacda62013-03-27 16:36:01 +0000234 int64_t capture_time_ms = TickTime::MillisecondTimestamp();
235 TickTime::AdvanceFakeClock(10000);
236 int64_t second_capture_time_ms = TickTime::MillisecondTimestamp();
237
238 EXPECT_EQ(0, send_bucket_->QueueInMs());
pwestin@webrtc.orgdb418562013-03-22 23:39:29 +0000239
240 // Due to the multiplicative factor we can send 3 packets not 2 packets.
241 EXPECT_TRUE(send_bucket_->SendPacket(PacedSender::kLowPriority,
242 ssrc_low_priority, sequence_number++, capture_time_ms, 250));
243 EXPECT_TRUE(send_bucket_->SendPacket(PacedSender::kNormalPriority,
244 ssrc, sequence_number++, capture_time_ms, 250));
245 EXPECT_TRUE(send_bucket_->SendPacket(PacedSender::kNormalPriority,
246 ssrc, sequence_number++, capture_time_ms, 250));
247
248 send_bucket_->Pause();
249
250 // Expect everything to be queued.
251 EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kLowPriority,
252 ssrc_low_priority, sequence_number++, capture_time_ms, 250));
253 EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority,
254 ssrc, sequence_number++, capture_time_ms, 250));
255 EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority,
256 ssrc, sequence_number++, second_capture_time_ms, 250));
257 EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kHighPriority,
258 ssrc, sequence_number++, capture_time_ms, 250));
259
stefan@webrtc.orgbfacda62013-03-27 16:36:01 +0000260 EXPECT_EQ(TickTime::MillisecondTimestamp() - capture_time_ms,
261 send_bucket_->QueueInMs());
262
pwestin@webrtc.orgdb418562013-03-22 23:39:29 +0000263 // Expect no packet to come out while paused.
264 EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0);
265 EXPECT_CALL(callback_, TimeToSendPacket(_, _, _)).Times(0);
266
267 for (int i = 0; i < 10; ++i) {
268 TickTime::AdvanceFakeClock(5);
269 EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
270 EXPECT_EQ(0, send_bucket_->Process());
271 }
272 // Expect high prio packets to come out first followed by all packets in the
273 // way they were added.
274 EXPECT_CALL(callback_, TimeToSendPacket(_, _, capture_time_ms)).Times(3);
275
276 send_bucket_->Resume();
277
278 EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
279 TickTime::AdvanceFakeClock(5);
280 EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
281 EXPECT_EQ(0, send_bucket_->Process());
282
283 EXPECT_CALL(callback_,
284 TimeToSendPacket(_, _, second_capture_time_ms)).Times(1);
285
286 EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
287 TickTime::AdvanceFakeClock(5);
288 EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
289 EXPECT_EQ(0, send_bucket_->Process());
stefan@webrtc.orgbfacda62013-03-27 16:36:01 +0000290 EXPECT_EQ(0, send_bucket_->QueueInMs());
pwestin@webrtc.orgdb418562013-03-22 23:39:29 +0000291}
292
293} // namespace test
pwestin@webrtc.orgb5180172012-11-09 20:56:23 +0000294} // namespace webrtc