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 "webrtc/system_wrappers/include/clock.h"
 #include "webrtc/test/gtest.h"
 
 namespace webrtc {
 namespace {
 const int kDefaultProcessIntervalMs = 2000;
+const uint32_t kStreamId = 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, kStreamId);
     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 134 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, kStreamId);
+  counter.Set(188, kStreamId);
   clock_.AdvanceTimeMilliseconds(kDefaultProcessIntervalMs);
   // Trigger process (sample included in next interval).
-  counter.Set(192);
+  counter.Set(192, kStreamId);
   // 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_RateAccCounterWithMultipleStreamIds) {
+  StatsCounterObserverImpl* observer = new StatsCounterObserverImpl();
+  RateAccCounter counter(&clock_, observer, true);
+  counter.Set(175, kStreamId);
+  counter.Set(188, kStreamId);
+  counter.Set(100, kStreamId + 1);
+  clock_.AdvanceTimeMilliseconds(kDefaultProcessIntervalMs);
+  // Trigger process (sample included in next interval).
+  counter.Set(150, kStreamId + 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(kDefaultProcessIntervalMs);
+  // Trigger process (sample included in next interval).
+  counter.Set(198, kStreamId);
+  // 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(kDefaultProcessIntervalMs);
+  // Trigger process (sample included in next interval).
+  counter.Set(200, kStreamId);
+  // 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, false);
   const int kSample1 = 1;
   const int kSample2 = 5;
   const int kSample3 = 8;
   const int kSample4 = 11;
   const int kSample5 = 50;
   AddSampleAndAdvance(kSample1, kDefaultProcessIntervalMs, &counter);
   AddSampleAndAdvance(kSample2, kDefaultProcessIntervalMs, &counter);
   AddSampleAndAdvance(kSample3, kDefaultProcessIntervalMs, &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, kDefaultProcessIntervalMs, &counter);
   SetSampleAndAdvance(kSample2, kDefaultProcessIntervalMs, &counter);
   SetSampleAndAdvance(kSample3, kDefaultProcessIntervalMs, &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, kStreamId);
   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 99 matching lines @@
 TEST_F(StatsCounterTest, TestRateAccCounter_IntervalsWithoutSamplesIncluded) {
   // Samples: | 12 | x | x | x | 60 |  // x: empty interval
   // Stats:   | 6  | 0 | 0 | 0 | 24 |  // x -> zero reported
   StatsCounterObserverImpl* observer = new StatsCounterObserverImpl();
   RateAccCounter counter(&clock_, observer, true);
   VerifyStatsIsNotSet(counter.ProcessAndGetStats());
   // Advance one interval and verify stats.
   clock_.AdvanceTimeMilliseconds(kDefaultProcessIntervalMs);
   VerifyStatsIsNotSet(counter.ProcessAndGetStats());
   // Add sample and advance 3 intervals (2 w/o samples -> zero reported).
-  counter.Set(12);
+  counter.Set(12, kStreamId);
   clock_.AdvanceTimeMilliseconds(kDefaultProcessIntervalMs * 4 - 1);
   // Trigger process and verify stats: [0:2][6:1]
   counter.ProcessAndGetStats();
   EXPECT_EQ(3, observer->num_calls_);
   EXPECT_EQ(0, observer->last_sample_);
   // Make next interval pass (1 w/o samples -> zero reported), [0:3][6:1]
   clock_.AdvanceTimeMilliseconds(1);
   counter.ProcessAndGetStats();
   EXPECT_EQ(4, observer->num_calls_);
   EXPECT_EQ(0, observer->last_sample_);
   // Insert sample and advance non-complete interval, no change, [0:3][6:1]
   clock_.AdvanceTimeMilliseconds(kDefaultProcessIntervalMs - 1);
-  counter.Set(60);
+  counter.Set(60, kStreamId);
   EXPECT_EQ(4, observer->num_calls_);
   // Make next interval pass, [0:3][6:1][24:1]
   clock_.AdvanceTimeMilliseconds(1);
   AggregatedStats stats = counter.ProcessAndGetStats();
   EXPECT_EQ(5, observer->num_calls_);
   EXPECT_EQ(24, observer->last_sample_);
   EXPECT_EQ(6, stats.average);
 }
 
 TEST_F(StatsCounterTest, TestRateAccCounter_IntervalsWithoutSamplesIgnored) {
   // Samples: | 12 | x | x | x | 60 |  // x: empty interval
   // Stats:   | 6  | x | x | x | 24 |  // x -> ignored
   StatsCounterObserverImpl* observer = new StatsCounterObserverImpl();
   RateAccCounter counter(&clock_, observer, false);
   // Add sample and advance 3 intervals (2 w/o samples -> ignored).
-  counter.Set(12);
+  counter.Set(12, kStreamId);
   clock_.AdvanceTimeMilliseconds(kDefaultProcessIntervalMs * 4 - 1);
   // Trigger process and verify stats: [6:1]
   counter.ProcessAndGetStats();
   EXPECT_EQ(1, observer->num_calls_);
   EXPECT_EQ(6, observer->last_sample_);
   // Make next interval pass (1 w/o samples -> ignored), [6:1]
   clock_.AdvanceTimeMilliseconds(1);
   counter.ProcessAndGetStats();
   EXPECT_EQ(1, observer->num_calls_);
   // Insert sample and advance non-complete interval, no change, [6:1]
   clock_.AdvanceTimeMilliseconds(kDefaultProcessIntervalMs - 1);
-  counter.Set(60);
+  counter.Set(60, kStreamId);
   counter.ProcessAndGetStats();
   EXPECT_EQ(1, observer->num_calls_);
   // Make next interval pass, [6:1][24:1]
   clock_.AdvanceTimeMilliseconds(1);
   counter.ProcessAndGetStats();
   EXPECT_EQ(2, observer->num_calls_);
   EXPECT_EQ(24, observer->last_sample_);
 }
 
 }  // namespace webrtc