Add ability to handle data from multiple streams in RateAccCounter.

webrtc/video/stats_counter_unittest.cc

 /*
  *  Copyright (c) 2016 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.
  */
 
 #include "webrtc/video/stats_counter.h"
 
 #include "testing/gtest/include/gtest/gtest.h"
 
 #include "webrtc/system_wrappers/include/clock.h"
 
 namespace webrtc {
 namespace {
 const int kProcessIntervalMs = 2000;
+const int kSsrc = 123456;
 
 class StatsCounterObserverImpl : public StatsCounterObserver {
  public:
   StatsCounterObserverImpl() : num_calls_(0), last_sample_(-1) {}
   void OnMetricUpdated(int sample) override {
     ++num_calls_;
     last_sample_ = sample;
   }
   int num_calls_;
   int last_sample_;
 };
 }  // namespace
 
 class StatsCounterTest : public ::testing::Test {
  protected:
   StatsCounterTest()
       : clock_(1234) {}
 
   void AddSampleAndAdvance(int sample, int interval_ms, AvgCounter* counter) {
     counter->Add(sample);
     clock_.AdvanceTimeMilliseconds(interval_ms);
   }
 
   void SetSampleAndAdvance(int sample,
                            int interval_ms,
                            RateAccCounter* counter) {
-    counter->Set(sample);
+    counter->Set(sample, kSsrc);
     clock_.AdvanceTimeMilliseconds(interval_ms);
   }
 
   void VerifyStatsIsNotSet(const AggregatedStats& stats) {
     EXPECT_EQ(0, stats.num_samples);
     EXPECT_EQ(-1, stats.min);
     EXPECT_EQ(-1, stats.max);
     EXPECT_EQ(-1, stats.average);
   }
 
@@ skipping 126 matching lines @@
   // Aggregated stats.
   AggregatedStats stats = counter.GetStats();
   EXPECT_EQ(1, stats.num_samples);
   EXPECT_EQ(279, stats.min);
   EXPECT_EQ(279, stats.max);
 }
 
 TEST_F(StatsCounterTest, TestMetric_RateAccCounter) {
   StatsCounterObserverImpl* observer = new StatsCounterObserverImpl();
   RateAccCounter counter(&clock_, observer, true);
-  counter.Set(175);
-  counter.Set(188);
+  counter.Set(175, kSsrc);
+  counter.Set(188, kSsrc);
   clock_.AdvanceTimeMilliseconds(kProcessIntervalMs);
   // Trigger process (sample included in next interval).
-  counter.Set(192);
+  counter.Set(192, kSsrc);
   // Rate per interval: (188 - 0) / 2 sec = 94 samples/sec
   EXPECT_EQ(1, observer->num_calls_);
   EXPECT_EQ(94, observer->last_sample_);
   // Aggregated stats.
   AggregatedStats stats = counter.GetStats();
   EXPECT_EQ(1, stats.num_samples);
   EXPECT_EQ(94, stats.min);
   EXPECT_EQ(94, stats.max);
 }
 
+TEST_F(StatsCounterTest, TestMetric_RateAccCounterWithMultipleSsrcs) {
+  StatsCounterObserverImpl* observer = new StatsCounterObserverImpl();
+  RateAccCounter counter(&clock_, observer, true);
+  counter.Set(175, kSsrc);
+  counter.Set(188, kSsrc);
+  counter.Set(100, kSsrc + 1);
+  clock_.AdvanceTimeMilliseconds(kProcessIntervalMs);
+  // Trigger process (sample included in next interval).
+  counter.Set(150, kSsrc + 1);
+  // Rate per interval: ((188 - 0) + (100 - 0)) / 2 sec = 144 samples/sec
+  EXPECT_EQ(1, observer->num_calls_);
+  EXPECT_EQ(144, observer->last_sample_);
+  clock_.AdvanceTimeMilliseconds(kProcessIntervalMs);
+  // Trigger process (sample included in next interval).
+  counter.Set(198, kSsrc);
+  // Rate per interval: (0 + (150 - 100)) / 2 sec = 25 samples/sec
+  EXPECT_EQ(2, observer->num_calls_);
+  EXPECT_EQ(25, observer->last_sample_);
+  clock_.AdvanceTimeMilliseconds(kProcessIntervalMs);
+  // Trigger process (sample included in next interval).
+  counter.Set(200, kSsrc);
+  // Rate per interval: ((198 - 188) + (0)) / 2 sec = 5 samples/sec
+  EXPECT_EQ(3, observer->num_calls_);
+  EXPECT_EQ(5, observer->last_sample_);
+  // Aggregated stats.
+  AggregatedStats stats = counter.GetStats();
+  EXPECT_EQ(3, stats.num_samples);
+  EXPECT_EQ(5, stats.min);
+  EXPECT_EQ(144, stats.max);
+}
+
 TEST_F(StatsCounterTest, TestGetStats_MultipleIntervals) {
   AvgCounter counter(&clock_, nullptr);
   const int kSample1 = 1;
   const int kSample2 = 5;
   const int kSample3 = 8;
   const int kSample4 = 11;
   const int kSample5 = 50;
   AddSampleAndAdvance(kSample1, kProcessIntervalMs, &counter);
   AddSampleAndAdvance(kSample2, kProcessIntervalMs, &counter);
   AddSampleAndAdvance(kSample3, kProcessIntervalMs, &counter);
@@ skipping 34 matching lines @@
   const int kSample1 = 200;  //  200 / 2 sec
   const int kSample2 = 100;  // -100 / 2 sec - negative ignored
   const int kSample3 = 700;  //  600 / 2 sec
   RateAccCounter counter(&clock_, observer, true);
   SetSampleAndAdvance(kSample1, kProcessIntervalMs, &counter);
   SetSampleAndAdvance(kSample2, kProcessIntervalMs, &counter);
   SetSampleAndAdvance(kSample3, kProcessIntervalMs, &counter);
   EXPECT_EQ(1, observer->num_calls_);
   EXPECT_EQ(100, observer->last_sample_);
   // Trigger process (sample included in next interval).
-  counter.Set(2000);
+  counter.Set(2000, kSsrc);
   EXPECT_EQ(2, observer->num_calls_);
   EXPECT_EQ(300, observer->last_sample_);
   // Aggregated stats.
   AggregatedStats stats = counter.GetStats();
   EXPECT_EQ(2, stats.num_samples);
   EXPECT_EQ(100, stats.min);
   EXPECT_EQ(300, stats.max);
   EXPECT_EQ(200, stats.average);
 }
 
@@ skipping 65 matching lines @@
   EXPECT_EQ(3, observer->num_calls_);
   EXPECT_EQ(10, observer->last_sample_);
   // Aggregated stats.
   AggregatedStats stats = counter.GetStats();
   EXPECT_EQ(3, stats.num_samples);
   EXPECT_EQ(0, stats.min);
   EXPECT_EQ(25, stats.max);
 }
 
 }  // namespace webrtc