Add AlrDetector

webrtc/modules/pacing/paced_sender_unittest.cc

 /*
  *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 81 matching lines @@
 
   int packets_sent() const { return packets_sent_; }
 
   int padding_sent() const { return padding_sent_; }
 
  private:
   int packets_sent_;
   int padding_sent_;
 };
 
+class PacingObserver : public PacedSender::PacingObserver {
+ public:
+  PacingObserver() : total_bytes_sent_(0), total_elapsed_time_(0) {}
+
+  void OnBytesSent(size_t bytes_sent, int64_t elapsed_time_ms) override {
+    total_bytes_sent_ += bytes_sent;
+    total_elapsed_time_ += elapsed_time_ms;
+  }
+
+  size_t bytes_sent() { return total_bytes_sent_; }
+
+  int64_t elapsed_time_ms() { return total_elapsed_time_; }
+
+ private:
+  size_t total_bytes_sent_;
+  int64_t total_elapsed_time_;
+};
+
 class PacedSenderTest : public ::testing::Test {
  protected:
   PacedSenderTest() : clock_(123456) {
     srand(0);
     // Need to initialize PacedSender after we initialize clock.
     send_bucket_.reset(new PacedSender(&clock_, &callback_));
     send_bucket_->CreateProbeCluster(kFirstClusterBps, kFirstClusterCount);
     send_bucket_->CreateProbeCluster(kSecondClusterBps, kSecondClusterCount);
     // Default to bitrate probing disabled for testing purposes. Probing tests
     // have to enable probing, either by creating a new PacedSender instance or
@@ skipping 793 matching lines @@
   }
   int packets_sent = packet_sender.packets_sent();
   int padding_sent = packet_sender.padding_sent();
   EXPECT_EQ(padding_sent, 0);
   // Validate first cluster bitrate.
   EXPECT_NEAR(((packets_sent - 1) * kPacketSize * 8000) /
                   (clock_.TimeInMilliseconds() - start),
               kFirstClusterBps, kBitrateProbingError);
 }
 
+TEST_F(PacedSenderTest, ValidatePacingObserver) {
+  const size_t kPacketSize = 1200;
+  const int kInitialBitrateBps = 300000;
+  uint32_t ssrc = 12346;
+  uint16_t sequence_number = 1234;
+
+  PacedSenderProbing packet_sender;
+  PacingObserver pacing_observer;
+  send_bucket_.reset(
+      new PacedSender(&clock_, &packet_sender, &pacing_observer));
+  send_bucket_->CreateProbeCluster(kFirstClusterBps, kFirstClusterCount);
+  send_bucket_->SetEstimatedBitrate(kInitialBitrateBps);
+
+  for (int i = 0; i < kFirstClusterCount; ++i) {
+    send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc,
+                               sequence_number++, clock_.TimeInMilliseconds(),
+                               kPacketSize, false);
+  }
+
+  int64_t start = clock_.TimeInMilliseconds();
+  while (packet_sender.packets_sent() < kFirstClusterCount) {
+    int time_until_process = send_bucket_->TimeUntilNextProcess();
+    if (time_until_process <= 0) {
+      send_bucket_->Process();
+    } else {
+      clock_.AdvanceTimeMilliseconds(time_until_process);
+    }
+  }
+
+  EXPECT_EQ(pacing_observer.bytes_sent(), kPacketSize * kFirstClusterCount);
+  EXPECT_GE(pacing_observer.elapsed_time_ms(),
+            (clock_.TimeInMilliseconds() - start));
+}
+
 TEST_F(PacedSenderTest, PriorityInversion) {
   uint32_t ssrc = 12346;
   uint16_t sequence_number = 1234;
   const size_t kPacketSize = 1200;
 
   send_bucket_->InsertPacket(
       PacedSender::kHighPriority, ssrc, sequence_number + 3,
       clock_.TimeInMilliseconds() + 33, kPacketSize, true);
 
   send_bucket_->InsertPacket(
@@ skipping 142 matching lines @@
 
   // No more probing packets.
   EXPECT_CALL(callback_, TimeToSendPadding(_, PacketInfo::kNotAProbe))
         .Times(1)
         .WillRepeatedly(Return(500));
   send_bucket_->Process();
 }
 
 }  // namespace test
 }  // namespace webrtc