More Simulation Framework features

webrtc/modules/remote_bitrate_estimator/test/estimators/nada_unittest.cc

Index: webrtc/modules/remote_bitrate_estimator/test/estimators/nada_unittest.cc
diff --git a/webrtc/modules/remote_bitrate_estimator/test/estimators/nada_unittest.cc b/webrtc/modules/remote_bitrate_estimator/test/estimators/nada_unittest.cc
index 967c2b2b5e47c3cda41a935e3a2b13ba44f07af7..e2f4d04f14a972246e5dd21b629c41a4df52175d 100644
--- a/webrtc/modules/remote_bitrate_estimator/test/estimators/nada_unittest.cc
+++ b/webrtc/modules/remote_bitrate_estimator/test/estimators/nada_unittest.cc
@@ -167,7 +167,7 @@ class NadaFbGenerator {
 TEST_F(NadaSenderSideTest, AcceleratedRampUp) {
   const int64_t kRefSignalMs = 3;
   const int64_t kOneWayDelayMs = 50;
-  int original_bitrate = 2 * NadaBweSender::kMinRefRateKbps;
+  int original_bitrate = 2 * kMinBitrateKbps;
   size_t receiving_rate = static_cast<size_t>(original_bitrate);
   int64_t send_time_ms = nada_sender_.NowMs() - kOneWayDelayMs;
 
@@ -199,7 +199,7 @@ TEST_F(NadaSenderSideTest, AcceleratedRampUp) {
 // Verify if AcceleratedRampDown is called and if bitrate decreases.
 TEST_F(NadaSenderSideTest, AcceleratedRampDown) {
   const int64_t kOneWayDelayMs = 50;
-  int original_bitrate = 3 * NadaBweSender::kMinRefRateKbps;
+  int original_bitrate = 3 * kMinBitrateKbps;
   size_t receiving_rate = static_cast<size_t>(original_bitrate);
   int64_t send_time_ms = nada_sender_.NowMs() - kOneWayDelayMs;
 
@@ -217,7 +217,7 @@ TEST_F(NadaSenderSideTest, AcceleratedRampDown) {
   // parameters.
   nada_sender_.AcceleratedRampDown(congested_fb);
   int bitrate_2_kbps =
-      std::max(nada_sender_.bitrate_kbps(), NadaBweSender::kMinRefRateKbps);
+      std::max(nada_sender_.bitrate_kbps(), kMinBitrateKbps);
   EXPECT_EQ(bitrate_2_kbps, bitrate_1_kbps);
 }
 
@@ -225,7 +225,7 @@ TEST_F(NadaSenderSideTest, GradualRateUpdate) {
   const int64_t kDeltaSMs = 20;
   const int64_t kRefSignalMs = 20;
   const int64_t kOneWayDelayMs = 50;
-  int original_bitrate = 2 * NadaBweSender::kMinRefRateKbps;
+  int original_bitrate = 2 * kMinBitrateKbps;
   size_t receiving_rate = static_cast<size_t>(original_bitrate);
   int64_t send_time_ms = nada_sender_.NowMs() - kOneWayDelayMs;
 
@@ -251,8 +251,8 @@ TEST_F(NadaSenderSideTest, GradualRateUpdate) {
 // Sending bitrate should decrease and reach its Min bound.
 TEST_F(NadaSenderSideTest, VeryLowBandwith) {
   const int64_t kOneWayDelayMs = 50;
-  const int kMin = NadaBweSender::kMinRefRateKbps;
-  size_t receiving_rate = static_cast<size_t>(kMin);
+
+  size_t receiving_rate = static_cast<size_t>(kMinBitrateKbps);
   int64_t send_time_ms = nada_sender_.NowMs() - kOneWayDelayMs;
 
   NadaFeedback extremely_congested_fb =
@@ -260,7 +260,7 @@ TEST_F(NadaSenderSideTest, VeryLowBandwith) {
   NadaFeedback congested_fb =
       NadaFbGenerator::CongestedFb(receiving_rate, send_time_ms);
 
-  nada_sender_.set_bitrate_kbps(5 * kMin);
+  nada_sender_.set_bitrate_kbps(5 * kMinBitrateKbps);
   nada_sender_.set_original_operating_mode(true);
   for (int i = 0; i < 100; ++i) {
     // Trigger GradualRateUpdate mode.
@@ -268,10 +268,10 @@ TEST_F(NadaSenderSideTest, VeryLowBandwith) {
   }
   // The original implementation doesn't allow the bitrate to stay at kMin,
   // even if the congestion signal is very high.
-  EXPECT_GE(nada_sender_.bitrate_kbps(), kMin);
+  EXPECT_GE(nada_sender_.bitrate_kbps(), kMinBitrateKbps);
 
   nada_sender_.set_original_operating_mode(false);
-  nada_sender_.set_bitrate_kbps(5 * kMin);
+  nada_sender_.set_bitrate_kbps(5 * kMinBitrateKbps);
 
   for (int i = 0; i < 100; ++i) {
     int previous_bitrate = nada_sender_.bitrate_kbps();
@@ -279,14 +279,13 @@ TEST_F(NadaSenderSideTest, VeryLowBandwith) {
     nada_sender_.GiveFeedback(congested_fb);
     EXPECT_LE(nada_sender_.bitrate_kbps(), previous_bitrate);
   }
-  EXPECT_EQ(nada_sender_.bitrate_kbps(), kMin);
+  EXPECT_EQ(nada_sender_.bitrate_kbps(), kMinBitrateKbps);
 }
 
 // Sending bitrate should increase and reach its Max bound.
 TEST_F(NadaSenderSideTest, VeryHighBandwith) {
   const int64_t kOneWayDelayMs = 50;
-  const int kMax = NadaBweSender::kMaxRefRateKbps;
-  const size_t kRecentReceivingRate = static_cast<size_t>(kMax);
+  const size_t kRecentReceivingRate = static_cast<size_t>(kMaxBitrateKbps);
   const int64_t kRefSignalMs = 5;
   int64_t send_time_ms = nada_sender_.NowMs() - kOneWayDelayMs;
 
@@ -299,21 +298,21 @@ TEST_F(NadaSenderSideTest, VeryHighBandwith) {
     nada_sender_.GiveFeedback(not_congested_fb);
     EXPECT_GE(nada_sender_.bitrate_kbps(), previous_bitrate);
   }
-  EXPECT_EQ(nada_sender_.bitrate_kbps(), kMax);
+  EXPECT_EQ(nada_sender_.bitrate_kbps(), kMaxBitrateKbps);
 
   nada_sender_.set_original_operating_mode(false);
-  nada_sender_.set_bitrate_kbps(NadaBweSender::kMinRefRateKbps);
+  nada_sender_.set_bitrate_kbps(kMinBitrateKbps);
 
   for (int i = 0; i < 100; ++i) {
     int previous_bitrate = nada_sender_.bitrate_kbps();
     nada_sender_.GiveFeedback(not_congested_fb);
     EXPECT_GE(nada_sender_.bitrate_kbps(), previous_bitrate);
   }
-  EXPECT_EQ(nada_sender_.bitrate_kbps(), kMax);
+  EXPECT_EQ(nada_sender_.bitrate_kbps(), kMaxBitrateKbps);
 }
 
 TEST_F(NadaReceiverSideTest, ReceivingRateNoPackets) {
-  EXPECT_EQ(nada_receiver_.RecentReceivingRate(), static_cast<size_t>(0));
+  EXPECT_EQ(nada_receiver_.RecentKbps(), static_cast<size_t>(0));
 }
 
 TEST_F(NadaReceiverSideTest, ReceivingRateSinglePacket) {
@@ -329,25 +328,8 @@ TEST_F(NadaReceiverSideTest, ReceivingRateSinglePacket) {
 
   const size_t kReceivingRateKbps = 8 * kPayloadSizeBytes / kTimeWindowMs;
 
-  EXPECT_EQ(nada_receiver_.RecentReceivingRate(), kReceivingRateKbps);
-}
-
-TEST_F(NadaReceiverSideTest, ReceivingRateLargePackets) {
-  const size_t kPayloadSizeBytes = 3000 * 1000;
-  const int64_t kTimeGapMs = 3000;  // Between each packet.
-  const int64_t kOneWayDelayMs = 1000;
-
-  for (int i = 1; i < 5; ++i) {
-    int64_t send_time_us = i * kTimeGapMs * 1000;
-    int64_t arrival_time_ms = send_time_us / 1000 + kOneWayDelayMs;
-    uint16_t sequence_number = i;
-    const MediaPacket media_packet(kFlowId, send_time_us, kPayloadSizeBytes,
-                                   sequence_number);
-    nada_receiver_.ReceivePacket(arrival_time_ms, media_packet);
-  }
-
-  const size_t kReceivingRateKbps = 8 * kPayloadSizeBytes / kTimeGapMs;
-  EXPECT_EQ(nada_receiver_.RecentReceivingRate(), kReceivingRateKbps);
+  EXPECT_NEAR(nada_receiver_.RecentKbps(), kReceivingRateKbps,
+              static_cast<float>(kReceivingRateKbps) / 100);
 }
 
 TEST_F(NadaReceiverSideTest, ReceivingRateSmallPackets) {
@@ -365,62 +347,8 @@ TEST_F(NadaReceiverSideTest, ReceivingRateSmallPackets) {
   }
 
   const size_t kReceivingRateKbps = 8 * kPayloadSizeBytes / kTimeGapMs;
-  EXPECT_EQ(nada_receiver_.RecentReceivingRate(), kReceivingRateKbps);
-}
-
-TEST_F(NadaReceiverSideTest, ReceivingRateIntermittentPackets) {
-  const size_t kPayloadSizeBytes = 100 * 1000;
-  const int64_t kTimeGapMs = 50;  // Between each packet.
-  const int64_t kFirstSendTimeMs = 0;
-  const int64_t kOneWayDelayMs = 50;
-
-  // Gap between first and other packets
-  const MediaPacket media_packet(kFlowId, kFirstSendTimeMs, kPayloadSizeBytes,
-                                 1);
-  nada_receiver_.ReceivePacket(kFirstSendTimeMs + kOneWayDelayMs, media_packet);
-
-  const int64_t kDelayAfterFirstPacketMs = 1000;
-  const int kNumPackets = 5;  // Small enough so that all packets are covered.
-  EXPECT_LT((kNumPackets - 2) * kTimeGapMs,
-            NadaBweReceiver::kReceivingRateTimeWindowMs);
-  const int64_t kTimeWindowMs =
-      kDelayAfterFirstPacketMs + (kNumPackets - 2) * kTimeGapMs;
-
-  for (int i = 2; i <= kNumPackets; ++i) {
-    int64_t send_time_us =
-        ((i - 2) * kTimeGapMs + kFirstSendTimeMs + kDelayAfterFirstPacketMs) *
-        1000;
-    int64_t arrival_time_ms = send_time_us / 1000 + kOneWayDelayMs;
-    uint16_t sequence_number = i;
-    const MediaPacket media_packet(kFlowId, send_time_us, kPayloadSizeBytes,
-                                   sequence_number);
-    nada_receiver_.ReceivePacket(arrival_time_ms, media_packet);
-  }
-
-  const size_t kTotalReceivedKb = 8 * kNumPackets * kPayloadSizeBytes;
-  const int64_t kCorrectedTimeWindowMs =
-      (kTimeWindowMs * kNumPackets) / (kNumPackets - 1);
-  EXPECT_EQ(nada_receiver_.RecentReceivingRate(),
-            kTotalReceivedKb / kCorrectedTimeWindowMs);
-}
-
-TEST_F(NadaReceiverSideTest, ReceivingRateDuplicatedPackets) {
-  const size_t kPayloadSizeBytes = 500 * 1000;
-  const int64_t kSendTimeUs = 300 * 1000;
-  const int64_t kArrivalTimeMs = kSendTimeUs / 1000 + 100;
-  const uint16_t kSequenceNumber = 1;
-  const int64_t kTimeWindowMs = NadaBweReceiver::kReceivingRateTimeWindowMs;
-
-  // Insert the same packet twice.
-  for (int i = 0; i < 2; ++i) {
-    const MediaPacket media_packet(kFlowId, kSendTimeUs + 50 * i,
-                                   kPayloadSizeBytes, kSequenceNumber);
-    nada_receiver_.ReceivePacket(kArrivalTimeMs + 50 * i, media_packet);
-  }
-  // Should be counted only once.
-  const size_t kReceivingRateKbps = 8 * kPayloadSizeBytes / kTimeWindowMs;
-
-  EXPECT_EQ(nada_receiver_.RecentReceivingRate(), kReceivingRateKbps);
+  EXPECT_NEAR(nada_receiver_.RecentKbps(), kReceivingRateKbps,
+              static_cast<float>(kReceivingRateKbps) / 100);

[stefan-webrtc, 2015/07/09 09:55:00]

divide with 100.0f here and above.

[magalhaesc, 2015/07/09 11:43:22]

Done.

 }
 
 TEST_F(NadaReceiverSideTest, PacketLossNoPackets) {