OLD | NEW |
(Empty) | |
| 1 /* |
| 2 * Copyright (c) 2015 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 "webrtc/modules/remote_bitrate_estimator/test/bwe.h" |
| 12 |
| 13 #include <vector> |
| 14 |
| 15 #include "testing/gtest/include/gtest/gtest.h" |
| 16 |
| 17 namespace webrtc { |
| 18 namespace testing { |
| 19 namespace bwe { |
| 20 |
| 21 const int kSetCapacity = 1000; |
| 22 |
| 23 class LinkedSetTest : public ::testing::Test { |
| 24 public: |
| 25 LinkedSetTest() : linked_set_(kSetCapacity) {} |
| 26 |
| 27 ~LinkedSetTest() {} |
| 28 |
| 29 protected: |
| 30 LinkedSet linked_set_; |
| 31 }; |
| 32 |
| 33 TEST_F(LinkedSetTest, EmptySet) { |
| 34 EXPECT_EQ(linked_set_.OldestSeqNumber(), 0); |
| 35 EXPECT_EQ(linked_set_.NewestSeqNumber(), 0); |
| 36 } |
| 37 |
| 38 TEST_F(LinkedSetTest, SinglePacket) { |
| 39 const uint16_t kSeqNumber = 1; // Arbitrary. |
| 40 // Other parameters don't matter here. |
| 41 linked_set_.Insert(kSeqNumber, 0, 0, 0); |
| 42 |
| 43 EXPECT_EQ(linked_set_.OldestSeqNumber(), kSeqNumber); |
| 44 EXPECT_EQ(linked_set_.NewestSeqNumber(), kSeqNumber); |
| 45 } |
| 46 |
| 47 TEST_F(LinkedSetTest, MultiplePackets) { |
| 48 const uint16_t kNumberPackets = 100; |
| 49 |
| 50 std::vector<uint16_t> sequence_numbers; |
| 51 for (size_t i = 0; i < kNumberPackets; ++i) { |
| 52 sequence_numbers.push_back(static_cast<uint16_t>(i + 1)); |
| 53 } |
| 54 random_shuffle(sequence_numbers.begin(), sequence_numbers.end()); |
| 55 |
| 56 for (size_t i = 0; i < kNumberPackets; ++i) { |
| 57 // Other parameters don't matter here. |
| 58 linked_set_.Insert(static_cast<uint16_t>(i), 0, 0, 0); |
| 59 } |
| 60 |
| 61 // Packets arriving out of order should not affect the following values: |
| 62 EXPECT_EQ(linked_set_.OldestSeqNumber(), 0); |
| 63 EXPECT_EQ(linked_set_.NewestSeqNumber(), kNumberPackets - 1); |
| 64 } |
| 65 |
| 66 TEST_F(LinkedSetTest, Overflow) { |
| 67 const int kFirstSeqNumber = -100; |
| 68 const int kLastSeqNumber = 100; |
| 69 |
| 70 for (int i = kFirstSeqNumber; i <= kLastSeqNumber; ++i) { |
| 71 // Other parameters don't matter here. |
| 72 linked_set_.Insert(static_cast<uint16_t>(i), 0, 0, 0); |
| 73 } |
| 74 |
| 75 // Packets arriving out of order should not affect the following values: |
| 76 EXPECT_EQ(linked_set_.OldestSeqNumber(), |
| 77 static_cast<uint16_t>(kFirstSeqNumber)); |
| 78 EXPECT_EQ(linked_set_.NewestSeqNumber(), |
| 79 static_cast<uint16_t>(kLastSeqNumber)); |
| 80 } |
| 81 |
| 82 class SequenceNumberOlderThanTest : public ::testing::Test { |
| 83 public: |
| 84 SequenceNumberOlderThanTest() {} |
| 85 ~SequenceNumberOlderThanTest() {} |
| 86 |
| 87 protected: |
| 88 SequenceNumberOlderThan comparator_; |
| 89 }; |
| 90 |
| 91 TEST_F(SequenceNumberOlderThanTest, Operator) { |
| 92 // Operator()(x, y) returns true <==> y is newer than x. |
| 93 EXPECT_TRUE(comparator_.operator()(0x0000, 0x0001)); |
| 94 EXPECT_TRUE(comparator_.operator()(0x0001, 0x1000)); |
| 95 EXPECT_FALSE(comparator_.operator()(0x0001, 0x0000)); |
| 96 EXPECT_FALSE(comparator_.operator()(0x0002, 0x0002)); |
| 97 EXPECT_TRUE(comparator_.operator()(0xFFF6, 0x000A)); |
| 98 EXPECT_FALSE(comparator_.operator()(0x000A, 0xFFF6)); |
| 99 EXPECT_TRUE(comparator_.operator()(0x0000, 0x8000)); |
| 100 EXPECT_FALSE(comparator_.operator()(0x8000, 0x0000)); |
| 101 } |
| 102 |
| 103 class LossAccountTest : public ::testing::Test { |
| 104 public: |
| 105 LossAccountTest() {} |
| 106 ~LossAccountTest() {} |
| 107 |
| 108 protected: |
| 109 LossAccount loss_account_; |
| 110 }; |
| 111 |
| 112 TEST_F(LossAccountTest, Operations) { |
| 113 const size_t kTotal = 100; // Arbitrary values. |
| 114 const size_t kLost = 10; |
| 115 |
| 116 LossAccount rhs(kTotal, kLost); |
| 117 |
| 118 loss_account_.Add(rhs); |
| 119 EXPECT_EQ(loss_account_.num_total, kTotal); |
| 120 EXPECT_EQ(loss_account_.num_lost, kLost); |
| 121 EXPECT_NEAR(loss_account_.LossRatio(), static_cast<float>(kLost) / kTotal, |
| 122 0.001f); |
| 123 |
| 124 loss_account_.Subtract(rhs); |
| 125 EXPECT_EQ(loss_account_.num_total, 0UL); |
| 126 EXPECT_EQ(loss_account_.num_lost, 0UL); |
| 127 EXPECT_NEAR(loss_account_.LossRatio(), 0.0f, 0.001f); |
| 128 } |
| 129 |
| 130 class BweReceiverTest : public ::testing::Test { |
| 131 public: |
| 132 BweReceiverTest() : bwe_receiver_(kFlowId) {} |
| 133 ~BweReceiverTest() {} |
| 134 |
| 135 protected: |
| 136 const int kFlowId = 1; // Arbitrary. |
| 137 BweReceiver bwe_receiver_; |
| 138 }; |
| 139 |
| 140 TEST_F(BweReceiverTest, ReceivingRateNoPackets) { |
| 141 EXPECT_EQ(bwe_receiver_.RecentKbps(), static_cast<size_t>(0)); |
| 142 } |
| 143 |
| 144 TEST_F(BweReceiverTest, ReceivingRateSinglePacket) { |
| 145 const size_t kPayloadSizeBytes = 500 * 1000; |
| 146 const int64_t kSendTimeUs = 300 * 1000; |
| 147 const int64_t kArrivalTimeMs = kSendTimeUs / 1000 + 100; |
| 148 const uint16_t kSequenceNumber = 1; |
| 149 const int64_t kTimeWindowMs = BweReceiver::kReceivingRateTimeWindowMs; |
| 150 |
| 151 const MediaPacket media_packet(kFlowId, kSendTimeUs, kPayloadSizeBytes, |
| 152 kSequenceNumber); |
| 153 bwe_receiver_.ReceivePacket(kArrivalTimeMs, media_packet); |
| 154 |
| 155 const size_t kReceivingRateKbps = 8 * kPayloadSizeBytes / kTimeWindowMs; |
| 156 |
| 157 EXPECT_NEAR(bwe_receiver_.RecentKbps(), kReceivingRateKbps, |
| 158 static_cast<float>(kReceivingRateKbps) / 100.0f); |
| 159 } |
| 160 |
| 161 TEST_F(BweReceiverTest, ReceivingRateSmallPackets) { |
| 162 const size_t kPayloadSizeBytes = 100 * 1000; |
| 163 const int64_t kTimeGapMs = 50; // Between each packet. |
| 164 const int64_t kOneWayDelayMs = 50; |
| 165 |
| 166 for (int i = 1; i < 50; ++i) { |
| 167 int64_t send_time_us = i * kTimeGapMs * 1000; |
| 168 int64_t arrival_time_ms = send_time_us / 1000 + kOneWayDelayMs; |
| 169 uint16_t sequence_number = i; |
| 170 const MediaPacket media_packet(kFlowId, send_time_us, kPayloadSizeBytes, |
| 171 sequence_number); |
| 172 bwe_receiver_.ReceivePacket(arrival_time_ms, media_packet); |
| 173 } |
| 174 |
| 175 const size_t kReceivingRateKbps = 8 * kPayloadSizeBytes / kTimeGapMs; |
| 176 EXPECT_NEAR(bwe_receiver_.RecentKbps(), kReceivingRateKbps, |
| 177 static_cast<float>(kReceivingRateKbps) / 100.0f); |
| 178 } |
| 179 |
| 180 TEST_F(BweReceiverTest, PacketLossNoPackets) { |
| 181 EXPECT_EQ(bwe_receiver_.RecentPacketLossRatio(), 0.0f); |
| 182 } |
| 183 |
| 184 TEST_F(BweReceiverTest, PacketLossSinglePacket) { |
| 185 const MediaPacket media_packet(kFlowId, 0, 0, 0); |
| 186 bwe_receiver_.ReceivePacket(0, media_packet); |
| 187 EXPECT_EQ(bwe_receiver_.RecentPacketLossRatio(), 0.0f); |
| 188 } |
| 189 |
| 190 TEST_F(BweReceiverTest, PacketLossContiguousPackets) { |
| 191 const int64_t kTimeWindowMs = BweReceiver::kPacketLossTimeWindowMs; |
| 192 size_t set_capacity = bwe_receiver_.GetSetCapacity(); |
| 193 |
| 194 for (int i = 0; i < 10; ++i) { |
| 195 uint16_t sequence_number = static_cast<uint16_t>(i); |
| 196 // Sequence_number and flow_id are the only members that matter here. |
| 197 const MediaPacket media_packet(kFlowId, 0, 0, sequence_number); |
| 198 // Arrival time = 0, all packets will be considered. |
| 199 bwe_receiver_.ReceivePacket(0, media_packet); |
| 200 } |
| 201 EXPECT_EQ(bwe_receiver_.RecentPacketLossRatio(), 0.0f); |
| 202 |
| 203 for (int i = 30; i > 20; i--) { |
| 204 uint16_t sequence_number = static_cast<uint16_t>(i); |
| 205 // Sequence_number and flow_id are the only members that matter here. |
| 206 const MediaPacket media_packet(kFlowId, 0, 0, sequence_number); |
| 207 // Only the packets sent in this for loop will be considered. |
| 208 bwe_receiver_.ReceivePacket(2 * kTimeWindowMs, media_packet); |
| 209 } |
| 210 EXPECT_EQ(bwe_receiver_.RecentPacketLossRatio(), 0.0f); |
| 211 |
| 212 // Should handle uint16_t overflow. |
| 213 for (int i = 0xFFFF - 10; i < 0xFFFF + 10; ++i) { |
| 214 uint16_t sequence_number = static_cast<uint16_t>(i); |
| 215 const MediaPacket media_packet(kFlowId, 0, 0, sequence_number); |
| 216 // Only the packets sent in this for loop will be considered. |
| 217 bwe_receiver_.ReceivePacket(4 * kTimeWindowMs, media_packet); |
| 218 } |
| 219 EXPECT_EQ(bwe_receiver_.RecentPacketLossRatio(), 0.0f); |
| 220 |
| 221 // Should handle set overflow. |
| 222 for (int i = 0; i < set_capacity * 1.5; ++i) { |
| 223 uint16_t sequence_number = static_cast<uint16_t>(i); |
| 224 const MediaPacket media_packet(kFlowId, 0, 0, sequence_number); |
| 225 // Only the packets sent in this for loop will be considered. |
| 226 bwe_receiver_.ReceivePacket(6 * kTimeWindowMs, media_packet); |
| 227 } |
| 228 EXPECT_EQ(bwe_receiver_.RecentPacketLossRatio(), 0.0f); |
| 229 } |
| 230 |
| 231 // Should handle duplicates. |
| 232 TEST_F(BweReceiverTest, PacketLossDuplicatedPackets) { |
| 233 const int64_t kTimeWindowMs = BweReceiver::kPacketLossTimeWindowMs; |
| 234 |
| 235 for (int i = 0; i < 10; ++i) { |
| 236 const MediaPacket media_packet(kFlowId, 0, 0, 0); |
| 237 // Arrival time = 0, all packets will be considered. |
| 238 bwe_receiver_.ReceivePacket(0, media_packet); |
| 239 } |
| 240 EXPECT_EQ(bwe_receiver_.RecentPacketLossRatio(), 0.0f); |
| 241 |
| 242 // Missing the element 5. |
| 243 const uint16_t kSequenceNumbers[] = {1, 2, 3, 4, 6, 7, 8}; |
| 244 const int kNumPackets = ARRAY_SIZE(kSequenceNumbers); |
| 245 |
| 246 // Insert each sequence number twice. |
| 247 for (int i = 0; i < 2; ++i) { |
| 248 for (int j = 0; j < kNumPackets; j++) { |
| 249 const MediaPacket media_packet(kFlowId, 0, 0, kSequenceNumbers[j]); |
| 250 // Only the packets sent in this for loop will be considered. |
| 251 bwe_receiver_.ReceivePacket(2 * kTimeWindowMs, media_packet); |
| 252 } |
| 253 } |
| 254 |
| 255 EXPECT_NEAR(bwe_receiver_.RecentPacketLossRatio(), 1.0f / (kNumPackets + 1), |
| 256 0.1f / (kNumPackets + 1)); |
| 257 } |
| 258 |
| 259 TEST_F(BweReceiverTest, PacketLossLakingPackets) { |
| 260 size_t set_capacity = bwe_receiver_.GetSetCapacity(); |
| 261 EXPECT_LT(set_capacity, static_cast<size_t>(0xFFFF)); |
| 262 |
| 263 // Missing every other packet. |
| 264 for (size_t i = 0; i < set_capacity; ++i) { |
| 265 if ((i & 1) == 0) { // Only even sequence numbers. |
| 266 uint16_t sequence_number = static_cast<uint16_t>(i); |
| 267 const MediaPacket media_packet(kFlowId, 0, 0, sequence_number); |
| 268 // Arrival time = 0, all packets will be considered. |
| 269 bwe_receiver_.ReceivePacket(0, media_packet); |
| 270 } |
| 271 } |
| 272 EXPECT_NEAR(bwe_receiver_.RecentPacketLossRatio(), 0.5f, 0.01f); |
| 273 } |
| 274 |
| 275 TEST_F(BweReceiverTest, PacketLossLakingFewPackets) { |
| 276 size_t set_capacity = bwe_receiver_.GetSetCapacity(); |
| 277 EXPECT_LT(set_capacity, static_cast<size_t>(0xFFFF)); |
| 278 |
| 279 const int kPeriod = 100; |
| 280 // Missing one for each kPeriod packets. |
| 281 for (size_t i = 0; i < set_capacity; ++i) { |
| 282 if ((i % kPeriod) != 0) { |
| 283 uint16_t sequence_number = static_cast<uint16_t>(i); |
| 284 const MediaPacket media_packet(kFlowId, 0, 0, sequence_number); |
| 285 // Arrival time = 0, all packets will be considered. |
| 286 bwe_receiver_.ReceivePacket(0, media_packet); |
| 287 } |
| 288 } |
| 289 EXPECT_NEAR(bwe_receiver_.RecentPacketLossRatio(), 1.0f / kPeriod, |
| 290 0.1f / kPeriod); |
| 291 } |
| 292 |
| 293 // Packet's sequence numbers greatly apart, expect high loss. |
| 294 TEST_F(BweReceiverTest, PacketLossWideGap) { |
| 295 const int64_t kTimeWindowMs = BweReceiver::kPacketLossTimeWindowMs; |
| 296 |
| 297 const MediaPacket media_packet1(0, 0, 0, 1); |
| 298 const MediaPacket media_packet2(0, 0, 0, 1000); |
| 299 // Only these two packets will be considered. |
| 300 bwe_receiver_.ReceivePacket(0, media_packet1); |
| 301 bwe_receiver_.ReceivePacket(0, media_packet2); |
| 302 EXPECT_NEAR(bwe_receiver_.RecentPacketLossRatio(), 0.998f, 0.0001f); |
| 303 |
| 304 const MediaPacket media_packet3(0, 0, 0, 0); |
| 305 const MediaPacket media_packet4(0, 0, 0, 0x8000); |
| 306 // Only these two packets will be considered. |
| 307 bwe_receiver_.ReceivePacket(2 * kTimeWindowMs, media_packet3); |
| 308 bwe_receiver_.ReceivePacket(2 * kTimeWindowMs, media_packet4); |
| 309 EXPECT_NEAR(bwe_receiver_.RecentPacketLossRatio(), 0.99994f, 0.00001f); |
| 310 } |
| 311 |
| 312 // Packets arriving unordered should not be counted as losted. |
| 313 TEST_F(BweReceiverTest, PacketLossUnorderedPackets) { |
| 314 size_t num_packets = bwe_receiver_.GetSetCapacity() / 2; |
| 315 std::vector<uint16_t> sequence_numbers; |
| 316 |
| 317 for (size_t i = 0; i < num_packets; ++i) { |
| 318 sequence_numbers.push_back(static_cast<uint16_t>(i + 1)); |
| 319 } |
| 320 |
| 321 random_shuffle(sequence_numbers.begin(), sequence_numbers.end()); |
| 322 |
| 323 for (size_t i = 0; i < num_packets; ++i) { |
| 324 const MediaPacket media_packet(kFlowId, 0, 0, sequence_numbers[i]); |
| 325 // Arrival time = 0, all packets will be considered. |
| 326 bwe_receiver_.ReceivePacket(0, media_packet); |
| 327 } |
| 328 |
| 329 EXPECT_EQ(bwe_receiver_.RecentPacketLossRatio(), 0.0f); |
| 330 } |
| 331 |
| 332 TEST_F(BweReceiverTest, RecentKbps) { |
| 333 EXPECT_EQ(bwe_receiver_.RecentKbps(), 0U); |
| 334 |
| 335 const size_t kPacketSizeBytes = 1200; |
| 336 const int kNumPackets = 100; |
| 337 |
| 338 double window_size_s = bwe_receiver_.BitrateWindowS(); |
| 339 |
| 340 // Receive packets at the same time. |
| 341 for (int i = 0; i < kNumPackets; ++i) { |
| 342 MediaPacket packet(kFlowId, 0L, kPacketSizeBytes, static_cast<uint16_t>(i)); |
| 343 bwe_receiver_.ReceivePacket(0, packet); |
| 344 } |
| 345 |
| 346 EXPECT_NEAR(bwe_receiver_.RecentKbps(), |
| 347 (8 * kNumPackets * kPacketSizeBytes) / (1000 * window_size_s), |
| 348 10); |
| 349 |
| 350 int64_t time_gap_ms = |
| 351 2 * 1000 * window_size_s; // Larger than rate_counter time window. |
| 352 |
| 353 MediaPacket packet(kFlowId, time_gap_ms * 1000, kPacketSizeBytes, |
| 354 static_cast<uint16_t>(kNumPackets)); |
| 355 bwe_receiver_.ReceivePacket(time_gap_ms, packet); |
| 356 |
| 357 EXPECT_NEAR(bwe_receiver_.RecentKbps(), |
| 358 (8 * kPacketSizeBytes) / (1000 * window_size_s), 10); |
| 359 } |
| 360 |
| 361 TEST_F(BweReceiverTest, Loss) { |
| 362 EXPECT_NEAR(bwe_receiver_.GlobalReceiverPacketLossRatio(), 0.0f, 0.001f); |
| 363 |
| 364 LossAccount loss_account = bwe_receiver_.LinkedSetPacketLossRatio(); |
| 365 EXPECT_NEAR(loss_account.LossRatio(), 0.0f, 0.001f); |
| 366 |
| 367 // Insert packets 1-50 and 151-200; |
| 368 for (int i = 1; i <= 200; ++i) { |
| 369 // Packet size and timestamp do not matter here. |
| 370 MediaPacket packet(kFlowId, 0L, 0UL, static_cast<uint16_t>(i)); |
| 371 bwe_receiver_.ReceivePacket(0, packet); |
| 372 if (i == 50) { |
| 373 i += 100; |
| 374 } |
| 375 } |
| 376 |
| 377 loss_account = bwe_receiver_.LinkedSetPacketLossRatio(); |
| 378 EXPECT_NEAR(loss_account.LossRatio(), 0.5f, 0.001f); |
| 379 |
| 380 bwe_receiver_.RelieveSetAndUpdateLoss(); |
| 381 EXPECT_EQ(bwe_receiver_.received_packets_.size(), 100U / 10); |
| 382 |
| 383 // No packet loss within the preserved packets. |
| 384 loss_account = bwe_receiver_.LinkedSetPacketLossRatio(); |
| 385 EXPECT_NEAR(loss_account.LossRatio(), 0.0f, 0.001f); |
| 386 |
| 387 // RelieveSetAndUpdateLoss automatically updates loss account. |
| 388 EXPECT_NEAR(bwe_receiver_.GlobalReceiverPacketLossRatio(), 0.5f, 0.001f); |
| 389 } |
| 390 |
| 391 } // namespace bwe |
| 392 } // namespace testing |
| 393 } // namespace webrtc |
OLD | NEW |