blob: 94a5c0bb133599c662a3cd2ae2ef93be015d6f8b [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::_;
stefan@webrtc.orgc3cc3752013-06-04 09:36:56 +000017using testing::Return;
pwestin@webrtc.orgb5180172012-11-09 20:56:23 +000018
19namespace webrtc {
pwestin@webrtc.orgdb418562013-03-22 23:39:29 +000020namespace test {
21
22static const int kTargetBitrate = 800;
pwestin@webrtc.org52b4e882013-05-02 19:02:17 +000023static const float kPaceMultiplier = 1.5f;
pwestin@webrtc.orgb5180172012-11-09 20:56:23 +000024
25class MockPacedSenderCallback : public PacedSender::Callback {
26 public:
27 MOCK_METHOD3(TimeToSendPacket,
hclam@chromium.org2e402ce2013-06-20 20:18:31 +000028 bool(uint32_t ssrc, uint16_t sequence_number, int64_t capture_time_ms));
pwestin@webrtc.orgb5180172012-11-09 20:56:23 +000029 MOCK_METHOD1(TimeToSendPadding,
stefan@webrtc.orgc3cc3752013-06-04 09:36:56 +000030 int(int bytes));
31};
32
33class PacedSenderPadding : public PacedSender::Callback {
34 public:
35 PacedSenderPadding() : padding_sent_(0) {}
36
hclam@chromium.org2e402ce2013-06-20 20:18:31 +000037 bool TimeToSendPacket(uint32_t ssrc, uint16_t sequence_number,
stefan@webrtc.orgc3cc3752013-06-04 09:36:56 +000038 int64_t capture_time_ms) {
hclam@chromium.org2e402ce2013-06-20 20:18:31 +000039 return true;
stefan@webrtc.orgc3cc3752013-06-04 09:36:56 +000040 }
41
42 int TimeToSendPadding(int bytes) {
43 const int kPaddingPacketSize = 224;
44 int num_packets = (bytes + kPaddingPacketSize - 1) / kPaddingPacketSize;
45 padding_sent_ += kPaddingPacketSize * num_packets;
46 return kPaddingPacketSize * num_packets;
47 }
48
49 int padding_sent() { return padding_sent_; }
50
51 private:
52 int padding_sent_;
pwestin@webrtc.orgb5180172012-11-09 20:56:23 +000053};
54
55class PacedSenderTest : public ::testing::Test {
56 protected:
57 PacedSenderTest() {
stefan@webrtc.orgc3cc3752013-06-04 09:36:56 +000058 srand(0);
pwestin@webrtc.orgb5180172012-11-09 20:56:23 +000059 TickTime::UseFakeClock(123456);
60 // Need to initialize PacedSender after we initialize clock.
pwestin@webrtc.org52b4e882013-05-02 19:02:17 +000061 send_bucket_.reset(new PacedSender(&callback_, kTargetBitrate,
62 kPaceMultiplier));
pwestin@webrtc.orgb5180172012-11-09 20:56:23 +000063 send_bucket_->SetStatus(true);
64 }
stefan@webrtc.orgc3cc3752013-06-04 09:36:56 +000065
stefan@webrtc.org8ccb9f92013-06-19 14:13:42 +000066 void SendAndExpectPacket(PacedSender::Priority priority,
67 uint32_t ssrc, uint16_t sequence_number,
68 int64_t capture_time_ms, int size) {
69 EXPECT_FALSE(send_bucket_->SendPacket(priority, ssrc,
70 sequence_number, capture_time_ms, size));
71 EXPECT_CALL(callback_, TimeToSendPacket(
hclam@chromium.org2e402ce2013-06-20 20:18:31 +000072 ssrc, sequence_number, capture_time_ms))
73 .Times(1)
74 .WillRepeatedly(Return(true));
stefan@webrtc.org8ccb9f92013-06-19 14:13:42 +000075 }
76
pwestin@webrtc.orgb5180172012-11-09 20:56:23 +000077 MockPacedSenderCallback callback_;
78 scoped_ptr<PacedSender> send_bucket_;
79};
80
81TEST_F(PacedSenderTest, QueuePacket) {
82 uint32_t ssrc = 12345;
83 uint16_t sequence_number = 1234;
84 int64_t capture_time_ms = 56789;
pwestin@webrtc.orgb5180172012-11-09 20:56:23 +000085 // Due to the multiplicative factor we can send 3 packets not 2 packets.
stefan@webrtc.org8ccb9f92013-06-19 14:13:42 +000086 SendAndExpectPacket(PacedSender::kNormalPriority, ssrc, sequence_number++,
87 capture_time_ms, 250);
88 SendAndExpectPacket(PacedSender::kNormalPriority, ssrc, sequence_number++,
89 capture_time_ms, 250);
90 SendAndExpectPacket(PacedSender::kNormalPriority, ssrc, sequence_number++,
91 capture_time_ms, 250);
pwestin@webrtc.orgb5180172012-11-09 20:56:23 +000092 EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority, ssrc,
93 sequence_number, capture_time_ms, 250));
stefan@webrtc.org8ccb9f92013-06-19 14:13:42 +000094 send_bucket_->Process();
pwestin@webrtc.orgb5180172012-11-09 20:56:23 +000095 EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
pwestin@webrtc.orgdb418562013-03-22 23:39:29 +000096 EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0);
pwestin@webrtc.orgb5180172012-11-09 20:56:23 +000097 EXPECT_CALL(callback_,
98 TimeToSendPacket(ssrc, sequence_number, capture_time_ms)).Times(0);
99 TickTime::AdvanceFakeClock(4);
100 EXPECT_EQ(1, send_bucket_->TimeUntilNextProcess());
pwestin@webrtc.orgb5180172012-11-09 20:56:23 +0000101 TickTime::AdvanceFakeClock(1);
102 EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
stefan@webrtc.org8ccb9f92013-06-19 14:13:42 +0000103 EXPECT_CALL(callback_, TimeToSendPacket(
hclam@chromium.org2e402ce2013-06-20 20:18:31 +0000104 ssrc, sequence_number++, capture_time_ms))
105 .Times(1)
106 .WillRepeatedly(Return(true));
stefan@webrtc.org8ccb9f92013-06-19 14:13:42 +0000107 send_bucket_->Process();
pwestin@webrtc.orgb5180172012-11-09 20:56:23 +0000108 sequence_number++;
stefan@webrtc.org8ccb9f92013-06-19 14:13:42 +0000109 SendAndExpectPacket(PacedSender::kNormalPriority, ssrc, sequence_number++,
110 capture_time_ms, 250);
111 SendAndExpectPacket(PacedSender::kNormalPriority, ssrc, sequence_number++,
112 capture_time_ms, 250);
pwestin@webrtc.orgb5180172012-11-09 20:56:23 +0000113 EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority, ssrc,
114 sequence_number++, capture_time_ms, 250));
stefan@webrtc.org8ccb9f92013-06-19 14:13:42 +0000115 send_bucket_->Process();
pwestin@webrtc.orgb5180172012-11-09 20:56:23 +0000116}
117
118TEST_F(PacedSenderTest, PaceQueuedPackets) {
119 uint32_t ssrc = 12345;
120 uint16_t sequence_number = 1234;
121 int64_t capture_time_ms = 56789;
122
123 // Due to the multiplicative factor we can send 3 packets not 2 packets.
124 for (int i = 0; i < 3; ++i) {
stefan@webrtc.org8ccb9f92013-06-19 14:13:42 +0000125 SendAndExpectPacket(PacedSender::kNormalPriority, ssrc, sequence_number++,
126 capture_time_ms, 250);
pwestin@webrtc.orgb5180172012-11-09 20:56:23 +0000127 }
128 for (int j = 0; j < 30; ++j) {
129 EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority, ssrc,
130 sequence_number++, capture_time_ms, 250));
131 }
stefan@webrtc.org8ccb9f92013-06-19 14:13:42 +0000132 send_bucket_->Process();
pwestin@webrtc.orgdb418562013-03-22 23:39:29 +0000133 EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0);
pwestin@webrtc.orgb5180172012-11-09 20:56:23 +0000134 for (int k = 0; k < 10; ++k) {
135 EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
136 TickTime::AdvanceFakeClock(5);
137 EXPECT_CALL(callback_,
hclam@chromium.org2e402ce2013-06-20 20:18:31 +0000138 TimeToSendPacket(ssrc, _, capture_time_ms))
139 .Times(3)
140 .WillRepeatedly(Return(true));
pwestin@webrtc.orgb5180172012-11-09 20:56:23 +0000141 EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
142 EXPECT_EQ(0, send_bucket_->Process());
143 }
144 EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
145 TickTime::AdvanceFakeClock(5);
146 EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
147 EXPECT_EQ(0, send_bucket_->Process());
stefan@webrtc.org8ccb9f92013-06-19 14:13:42 +0000148 SendAndExpectPacket(PacedSender::kNormalPriority, ssrc, sequence_number++,
149 capture_time_ms, 250);
150 SendAndExpectPacket(PacedSender::kNormalPriority, ssrc, sequence_number++,
151 capture_time_ms, 250);
152 SendAndExpectPacket(PacedSender::kNormalPriority, ssrc, sequence_number++,
153 capture_time_ms, 250);
pwestin@webrtc.orgb5180172012-11-09 20:56:23 +0000154 EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority, ssrc,
stefan@webrtc.org8ccb9f92013-06-19 14:13:42 +0000155 sequence_number, capture_time_ms, 250));
156 send_bucket_->Process();
pwestin@webrtc.orgb5180172012-11-09 20:56:23 +0000157}
158
pwestin@webrtc.org52aa0192013-04-25 17:35:56 +0000159TEST_F(PacedSenderTest, PaceQueuedPacketsWithDuplicates) {
160 uint32_t ssrc = 12345;
161 uint16_t sequence_number = 1234;
162 int64_t capture_time_ms = 56789;
163 uint16_t queued_sequence_number;
164
165 // Due to the multiplicative factor we can send 3 packets not 2 packets.
166 for (int i = 0; i < 3; ++i) {
stefan@webrtc.org8ccb9f92013-06-19 14:13:42 +0000167 SendAndExpectPacket(PacedSender::kNormalPriority, ssrc, sequence_number++,
168 capture_time_ms, 250);
pwestin@webrtc.org52aa0192013-04-25 17:35:56 +0000169 }
170 queued_sequence_number = sequence_number;
171
172 for (int j = 0; j < 30; ++j) {
173 // Send in duplicate packets.
174 EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority, ssrc,
175 sequence_number, capture_time_ms, 250));
176 EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority, ssrc,
177 sequence_number++, capture_time_ms, 250));
178 }
179 EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0);
stefan@webrtc.org8ccb9f92013-06-19 14:13:42 +0000180 send_bucket_->Process();
pwestin@webrtc.org52aa0192013-04-25 17:35:56 +0000181 for (int k = 0; k < 10; ++k) {
182 EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
183 TickTime::AdvanceFakeClock(5);
184
185 for (int i = 0; i < 3; ++i) {
186 EXPECT_CALL(callback_, TimeToSendPacket(ssrc, queued_sequence_number++,
hclam@chromium.org2e402ce2013-06-20 20:18:31 +0000187 capture_time_ms))
188 .Times(1)
189 .WillRepeatedly(Return(true));
pwestin@webrtc.org52aa0192013-04-25 17:35:56 +0000190 }
191 EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
192 EXPECT_EQ(0, send_bucket_->Process());
193 }
194 EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
195 TickTime::AdvanceFakeClock(5);
196 EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
197 EXPECT_EQ(0, send_bucket_->Process());
stefan@webrtc.org8ccb9f92013-06-19 14:13:42 +0000198 SendAndExpectPacket(PacedSender::kNormalPriority, ssrc, sequence_number++,
199 capture_time_ms, 250);
200 SendAndExpectPacket(PacedSender::kNormalPriority, ssrc, sequence_number++,
201 capture_time_ms, 250);
202 SendAndExpectPacket(PacedSender::kNormalPriority, ssrc, sequence_number++,
203 capture_time_ms, 250);
pwestin@webrtc.org52aa0192013-04-25 17:35:56 +0000204 EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority, ssrc,
205 sequence_number++, capture_time_ms, 250));
stefan@webrtc.org8ccb9f92013-06-19 14:13:42 +0000206 send_bucket_->Process();
pwestin@webrtc.org52aa0192013-04-25 17:35:56 +0000207}
208
pwestin@webrtc.orgb5180172012-11-09 20:56:23 +0000209TEST_F(PacedSenderTest, Padding) {
210 uint32_t ssrc = 12345;
211 uint16_t sequence_number = 1234;
212 int64_t capture_time_ms = 56789;
213
stefan@webrtc.orgc3cc3752013-06-04 09:36:56 +0000214 send_bucket_->UpdateBitrate(kTargetBitrate, kTargetBitrate);
pwestin@webrtc.orgb5180172012-11-09 20:56:23 +0000215 // Due to the multiplicative factor we can send 3 packets not 2 packets.
stefan@webrtc.org8ccb9f92013-06-19 14:13:42 +0000216 SendAndExpectPacket(PacedSender::kNormalPriority, ssrc, sequence_number++,
217 capture_time_ms, 250);
218 SendAndExpectPacket(PacedSender::kNormalPriority, ssrc, sequence_number++,
219 capture_time_ms, 250);
220 SendAndExpectPacket(PacedSender::kNormalPriority, ssrc, sequence_number++,
221 capture_time_ms, 250);
stefan@webrtc.orgc3cc3752013-06-04 09:36:56 +0000222 // No padding is expected since we have sent too much already.
223 EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0);
pwestin@webrtc.orgb5180172012-11-09 20:56:23 +0000224 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
stefan@webrtc.orgc3cc3752013-06-04 09:36:56 +0000229 // 5 milliseconds later we have enough budget to send some padding.
230 EXPECT_CALL(callback_, TimeToSendPadding(250)).Times(1).
231 WillOnce(Return(250));
pwestin@webrtc.orgb5180172012-11-09 20:56:23 +0000232 EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
233 TickTime::AdvanceFakeClock(5);
234 EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
235 EXPECT_EQ(0, send_bucket_->Process());
236}
237
stefan@webrtc.orgc3cc3752013-06-04 09:36:56 +0000238TEST_F(PacedSenderTest, VerifyPaddingUpToBitrate) {
239 uint32_t ssrc = 12345;
240 uint16_t sequence_number = 1234;
241 int64_t capture_time_ms = 56789;
242 const int kTimeStep = 5;
243 const int64_t kBitrateWindow = 100;
244 send_bucket_->UpdateBitrate(kTargetBitrate, kTargetBitrate);
245 int64_t start_time = TickTime::MillisecondTimestamp();
246 while (TickTime::MillisecondTimestamp() - start_time < kBitrateWindow) {
stefan@webrtc.org8ccb9f92013-06-19 14:13:42 +0000247 SendAndExpectPacket(PacedSender::kNormalPriority, ssrc, sequence_number++,
248 capture_time_ms, 250);
stefan@webrtc.orgc3cc3752013-06-04 09:36:56 +0000249 TickTime::AdvanceFakeClock(kTimeStep);
250 EXPECT_CALL(callback_, TimeToSendPadding(250)).Times(1).
251 WillOnce(Return(250));
252 send_bucket_->Process();
253 }
254}
255
256TEST_F(PacedSenderTest, VerifyMaxPaddingBitrate) {
257 uint32_t ssrc = 12345;
258 uint16_t sequence_number = 1234;
259 int64_t capture_time_ms = 56789;
260 const int kTimeStep = 5;
261 const int64_t kBitrateWindow = 100;
262 const int kTargetBitrate = 1500;
263 send_bucket_->UpdateBitrate(kTargetBitrate, kTargetBitrate);
264 int64_t start_time = TickTime::MillisecondTimestamp();
265 while (TickTime::MillisecondTimestamp() - start_time < kBitrateWindow) {
stefan@webrtc.org8ccb9f92013-06-19 14:13:42 +0000266 SendAndExpectPacket(PacedSender::kNormalPriority, ssrc, sequence_number++,
267 capture_time_ms, 250);
stefan@webrtc.orgc3cc3752013-06-04 09:36:56 +0000268 TickTime::AdvanceFakeClock(kTimeStep);
269 EXPECT_CALL(callback_, TimeToSendPadding(500)).Times(1).
270 WillOnce(Return(250));
271 send_bucket_->Process();
272 }
273}
274
275TEST_F(PacedSenderTest, VerifyAverageBitrateVaryingMediaPayload) {
276 uint32_t ssrc = 12345;
277 uint16_t sequence_number = 1234;
278 int64_t capture_time_ms = 56789;
279 const int kTimeStep = 5;
280 const int64_t kBitrateWindow = 10000;
281 PacedSenderPadding callback;
282 send_bucket_.reset(new PacedSender(&callback, kTargetBitrate,
283 kPaceMultiplier));
stefan@webrtc.org8ccb9f92013-06-19 14:13:42 +0000284 send_bucket_->SetStatus(true);
stefan@webrtc.orgc3cc3752013-06-04 09:36:56 +0000285 send_bucket_->UpdateBitrate(kTargetBitrate, kTargetBitrate);
286 int64_t start_time = TickTime::MillisecondTimestamp();
287 int media_bytes = 0;
288 while (TickTime::MillisecondTimestamp() - start_time < kBitrateWindow) {
289 int media_payload = rand() % 100 + 200; // [200, 300] bytes.
stefan@webrtc.org8ccb9f92013-06-19 14:13:42 +0000290 EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority, ssrc,
291 sequence_number++, capture_time_ms,
292 media_payload));
stefan@webrtc.orgc3cc3752013-06-04 09:36:56 +0000293 media_bytes += media_payload;
294 TickTime::AdvanceFakeClock(kTimeStep);
295 send_bucket_->Process();
296 }
297 EXPECT_NEAR(kTargetBitrate, 8 * (media_bytes + callback.padding_sent()) /
298 kBitrateWindow, 1);
299}
300
pwestin@webrtc.orgb5180172012-11-09 20:56:23 +0000301TEST_F(PacedSenderTest, Priority) {
302 uint32_t ssrc_low_priority = 12345;
303 uint32_t ssrc = 12346;
304 uint16_t sequence_number = 1234;
305 int64_t capture_time_ms = 56789;
306 int64_t capture_time_ms_low_priority = 1234567;
307
308 // Due to the multiplicative factor we can send 3 packets not 2 packets.
stefan@webrtc.org8ccb9f92013-06-19 14:13:42 +0000309 SendAndExpectPacket(PacedSender::kLowPriority, ssrc, sequence_number++,
310 capture_time_ms, 250);
311 SendAndExpectPacket(PacedSender::kNormalPriority, ssrc, sequence_number++,
312 capture_time_ms, 250);
313 SendAndExpectPacket(PacedSender::kNormalPriority, ssrc, sequence_number++,
314 capture_time_ms, 250);
315 send_bucket_->Process();
pwestin@webrtc.orgb5180172012-11-09 20:56:23 +0000316
317 // Expect normal and low priority to be queued and high to pass through.
318 EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kLowPriority,
319 ssrc_low_priority, sequence_number++, capture_time_ms_low_priority, 250));
320 EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority,
321 ssrc, sequence_number++, capture_time_ms, 250));
322 EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority,
323 ssrc, sequence_number++, capture_time_ms, 250));
pwestin@webrtc.orgdb418562013-03-22 23:39:29 +0000324 EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kHighPriority,
pwestin@webrtc.orgb5180172012-11-09 20:56:23 +0000325 ssrc, sequence_number++, capture_time_ms, 250));
326
pwestin@webrtc.orgdb418562013-03-22 23:39:29 +0000327 // Expect all high and normal priority to be sent out first.
328 EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0);
hclam@chromium.org2e402ce2013-06-20 20:18:31 +0000329 EXPECT_CALL(callback_, TimeToSendPacket(ssrc, _, capture_time_ms))
330 .Times(3)
331 .WillRepeatedly(Return(true));
pwestin@webrtc.orgb5180172012-11-09 20:56:23 +0000332
333 EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
334 TickTime::AdvanceFakeClock(5);
335 EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
336 EXPECT_EQ(0, send_bucket_->Process());
337
pwestin@webrtc.orgdb418562013-03-22 23:39:29 +0000338 EXPECT_CALL(callback_, TimeToSendPacket(
hclam@chromium.org2e402ce2013-06-20 20:18:31 +0000339 ssrc_low_priority, _, capture_time_ms_low_priority))
340 .Times(1)
341 .WillRepeatedly(Return(true));
pwestin@webrtc.orgb5180172012-11-09 20:56:23 +0000342
343 EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
344 TickTime::AdvanceFakeClock(5);
345 EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
346 EXPECT_EQ(0, send_bucket_->Process());
347}
348
pwestin@webrtc.orgdb418562013-03-22 23:39:29 +0000349TEST_F(PacedSenderTest, Pause) {
350 uint32_t ssrc_low_priority = 12345;
351 uint32_t ssrc = 12346;
352 uint16_t sequence_number = 1234;
stefan@webrtc.orgbfacda62013-03-27 16:36:01 +0000353 int64_t capture_time_ms = TickTime::MillisecondTimestamp();
354 TickTime::AdvanceFakeClock(10000);
355 int64_t second_capture_time_ms = TickTime::MillisecondTimestamp();
356
357 EXPECT_EQ(0, send_bucket_->QueueInMs());
pwestin@webrtc.orgdb418562013-03-22 23:39:29 +0000358
359 // Due to the multiplicative factor we can send 3 packets not 2 packets.
stefan@webrtc.org8ccb9f92013-06-19 14:13:42 +0000360 SendAndExpectPacket(PacedSender::kLowPriority, ssrc, sequence_number++,
361 capture_time_ms, 250);
362 SendAndExpectPacket(PacedSender::kNormalPriority, ssrc, sequence_number++,
363 capture_time_ms, 250);
364 SendAndExpectPacket(PacedSender::kNormalPriority, ssrc, sequence_number++,
365 capture_time_ms, 250);
366 send_bucket_->Process();
pwestin@webrtc.orgdb418562013-03-22 23:39:29 +0000367
368 send_bucket_->Pause();
369
370 // Expect everything to be queued.
371 EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kLowPriority,
stefan@webrtc.org8ccb9f92013-06-19 14:13:42 +0000372 ssrc_low_priority, sequence_number++, second_capture_time_ms, 250));
pwestin@webrtc.orgdb418562013-03-22 23:39:29 +0000373 EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority,
374 ssrc, sequence_number++, capture_time_ms, 250));
375 EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority,
stefan@webrtc.org8ccb9f92013-06-19 14:13:42 +0000376 ssrc, sequence_number++, capture_time_ms, 250));
pwestin@webrtc.orgdb418562013-03-22 23:39:29 +0000377 EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kHighPriority,
378 ssrc, sequence_number++, capture_time_ms, 250));
379
stefan@webrtc.orgbfacda62013-03-27 16:36:01 +0000380 EXPECT_EQ(TickTime::MillisecondTimestamp() - capture_time_ms,
381 send_bucket_->QueueInMs());
382
pwestin@webrtc.orgdb418562013-03-22 23:39:29 +0000383 // Expect no packet to come out while paused.
384 EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0);
385 EXPECT_CALL(callback_, TimeToSendPacket(_, _, _)).Times(0);
386
387 for (int i = 0; i < 10; ++i) {
388 TickTime::AdvanceFakeClock(5);
389 EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
390 EXPECT_EQ(0, send_bucket_->Process());
391 }
392 // Expect high prio packets to come out first followed by all packets in the
393 // way they were added.
hclam@chromium.org2e402ce2013-06-20 20:18:31 +0000394 EXPECT_CALL(callback_, TimeToSendPacket(_, _, capture_time_ms))
395 .Times(3)
396 .WillRepeatedly(Return(true));
pwestin@webrtc.orgdb418562013-03-22 23:39:29 +0000397 send_bucket_->Resume();
398
399 EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
400 TickTime::AdvanceFakeClock(5);
401 EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
402 EXPECT_EQ(0, send_bucket_->Process());
403
hclam@chromium.org2e402ce2013-06-20 20:18:31 +0000404 EXPECT_CALL(callback_, TimeToSendPacket(_, _, second_capture_time_ms))
405 .Times(1)
406 .WillRepeatedly(Return(true));
pwestin@webrtc.orgdb418562013-03-22 23:39:29 +0000407 EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
408 TickTime::AdvanceFakeClock(5);
409 EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
410 EXPECT_EQ(0, send_bucket_->Process());
stefan@webrtc.orgbfacda62013-03-27 16:36:01 +0000411 EXPECT_EQ(0, send_bucket_->QueueInMs());
pwestin@webrtc.orgdb418562013-03-22 23:39:29 +0000412}
413
hclam@chromium.org2e402ce2013-06-20 20:18:31 +0000414TEST_F(PacedSenderTest, ResendPacket) {
415 uint32_t ssrc = 12346;
416 uint16_t sequence_number = 1234;
417 int64_t capture_time_ms = TickTime::MillisecondTimestamp();
418 EXPECT_EQ(0, send_bucket_->QueueInMs());
419
420 EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority,
421 ssrc,
422 sequence_number,
423 capture_time_ms,
424 250));
425 EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority,
426 ssrc,
427 sequence_number + 1,
428 capture_time_ms + 1,
429 250));
430 TickTime::AdvanceFakeClock(10000);
431 EXPECT_EQ(TickTime::MillisecondTimestamp() - capture_time_ms,
432 send_bucket_->QueueInMs());
433 // Fails to send first packet so only one call.
434 EXPECT_CALL(callback_, TimeToSendPacket(
435 ssrc, sequence_number, capture_time_ms))
436 .Times(1)
437 .WillOnce(Return(false));
438 TickTime::AdvanceFakeClock(10000);
439 send_bucket_->Process();
440
441 // Queue remains unchanged.
442 EXPECT_EQ(TickTime::MillisecondTimestamp() - capture_time_ms,
443 send_bucket_->QueueInMs());
444
445 // Fails to send second packet.
446 EXPECT_CALL(callback_, TimeToSendPacket(
447 ssrc, sequence_number, capture_time_ms))
448 .Times(1)
449 .WillOnce(Return(true));
450 EXPECT_CALL(callback_, TimeToSendPacket(
451 ssrc, sequence_number + 1, capture_time_ms + 1))
452 .Times(1)
453 .WillOnce(Return(false));
454 TickTime::AdvanceFakeClock(10000);
455 send_bucket_->Process();
456
457 // Queue is reduced by 1 packet.
458 EXPECT_EQ(TickTime::MillisecondTimestamp() - capture_time_ms - 1,
459 send_bucket_->QueueInMs());
460
461 // Send second packet and queue becomes empty.
462 EXPECT_CALL(callback_, TimeToSendPacket(
463 ssrc, sequence_number + 1, capture_time_ms + 1))
464 .Times(1)
465 .WillOnce(Return(true));
466 TickTime::AdvanceFakeClock(10000);
467 send_bucket_->Process();
468 EXPECT_EQ(0, send_bucket_->QueueInMs());
469}
470
pwestin@webrtc.orgdb418562013-03-22 23:39:29 +0000471} // namespace test
pwestin@webrtc.orgb5180172012-11-09 20:56:23 +0000472} // namespace webrtc