FeedbackSignalAccumulator utility class for averaging feedback signals

content/browser/media/capture/time_weighted_average_unittest.cc

Index: content/browser/media/capture/time_weighted_average_unittest.cc
diff --git a/content/browser/media/capture/time_weighted_average_unittest.cc b/content/browser/media/capture/time_weighted_average_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..75d3c8c93211a7e162a39fa2d89d100121793f6c
--- /dev/null
+++ b/content/browser/media/capture/time_weighted_average_unittest.cc
@@ -0,0 +1,231 @@
+// Copyright (c) 2015 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "content/browser/media/capture/time_weighted_average.h"
+
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace content {
+
+class TimeWeightedAverageTest : public ::testing::Test {
+ public:
+  TimeWeightedAverageTest()
+      : half_life_(base::TimeDelta::FromSeconds(1)),
+        average_(half_life_),
+        t_(base::TimeTicks() + base::TimeDelta::FromSeconds(120)) {
+    average_.Reset(0.0, t_);
+  }
+
+ protected:
+  const base::TimeDelta half_life_;
+  TimeWeightedAverage average_;
+  base::TimeTicks t_;
+};
+
+TEST_F(TimeWeightedAverageTest, HasCorrectStartingValueAfterReset) {
+  ASSERT_EQ(0.0, average_.current());
+  ASSERT_EQ(t_, average_.last_reset_time());
+  ASSERT_EQ(t_, average_.latest_timestamp());
+
+  average_.Reset(1.0, t_);
+  ASSERT_EQ(1.0, average_.current());
+  ASSERT_EQ(t_, average_.last_reset_time());
+  ASSERT_EQ(t_, average_.latest_timestamp());
+
+  t_ += half_life_;
+  average_.Reset(2.0, t_);
+  ASSERT_EQ(2.0, average_.current());
+  ASSERT_EQ(t_, average_.last_reset_time());
+  ASSERT_EQ(t_, average_.latest_timestamp());
+}
+
+TEST_F(TimeWeightedAverageTest, DoesNotUpdateIfBeforeResetTime) {
+  average_.Reset(0.0, t_);
+  ASSERT_EQ(0.0, average_.current());
+  ASSERT_EQ(t_, average_.latest_timestamp());
+
+  const base::TimeTicks one_usec_before =
+      t_ - base::TimeDelta::FromMicroseconds(1);
+  ASSERT_FALSE(average_.Update(1.0, one_usec_before));
+  ASSERT_EQ(0.0, average_.current());
+  ASSERT_EQ(t_, average_.latest_timestamp());
+
+  const base::TimeTicks one_usec_after =
+      t_ + base::TimeDelta::FromMicroseconds(1);
+  ASSERT_TRUE(average_.Update(1.0, one_usec_after));
+  ASSERT_LT(0.0, average_.current());
+  ASSERT_EQ(one_usec_after, average_.latest_timestamp());
+}
+
+TEST_F(TimeWeightedAverageTest,
+       DoesArithmeticAverageIfAllUpdatesAreAtResetTime) {
+  average_.Reset(0.0, t_);
+  ASSERT_EQ(0.0, average_.current());
+  ASSERT_EQ(t_, average_.latest_timestamp());
+
+  ASSERT_TRUE(average_.Update(1.0, t_));
+  ASSERT_EQ(0.5, average_.current());
+  ASSERT_EQ(t_, average_.latest_timestamp());
+
+  ASSERT_TRUE(average_.Update(2.0, t_));
+  ASSERT_EQ(1.0, average_.current());
+  ASSERT_EQ(t_, average_.latest_timestamp());
+
+  ASSERT_TRUE(average_.Update(3.0, t_));
+  ASSERT_EQ(1.5, average_.current());
+  ASSERT_EQ(t_, average_.latest_timestamp());
+}
+
+TEST_F(TimeWeightedAverageTest, HandlesUpdatesWithSameTimestamp) {
+  average_.Reset(0.0, t_);
+  ASSERT_EQ(0.0, average_.current());
+  ASSERT_EQ(t_, average_.latest_timestamp());
+  t_ += 1 * half_life_;
+
+  // Update with an identical value at the same timestamp.
+  for (int i = 0; i < 3; ++i) {
+    ASSERT_TRUE(average_.Update(1.0, t_));
+    ASSERT_EQ(0.5, average_.current());
+    ASSERT_EQ(t_, average_.latest_timestamp());
+  }
+
+  // Now continue updating with different values at the same timestamp.
+  ASSERT_TRUE(average_.Update(2.0, t_));
+  ASSERT_EQ(0.625, average_.current());
+  ASSERT_EQ(t_, average_.latest_timestamp());
+  ASSERT_TRUE(average_.Update(3.0, t_));
+  ASSERT_EQ(0.8, average_.current());
+  ASSERT_EQ(t_, average_.latest_timestamp());
+  ASSERT_TRUE(average_.Update(4.0, t_));
+  ASSERT_EQ(1.0, average_.current());
+  ASSERT_EQ(t_, average_.latest_timestamp());
+}
+
+TEST_F(TimeWeightedAverageTest, ProvidesExpectedInputHoldResponse) {
+  // Step one half-life interval per update.
+  average_.Reset(0.0, t_);
+  ASSERT_EQ(0.0, average_.current());
+  ASSERT_EQ(t_, average_.latest_timestamp());
+  t_ += 1 * half_life_;
+  ASSERT_TRUE(average_.Update(1.0, t_));
+  ASSERT_EQ(0.5, average_.current());
+  ASSERT_EQ(t_, average_.latest_timestamp());
+  t_ += 1 * half_life_;
+  ASSERT_TRUE(average_.Update(1.0, t_));
+  ASSERT_EQ(0.75, average_.current());
+  ASSERT_EQ(t_, average_.latest_timestamp());
+  t_ += 1 * half_life_;
+  ASSERT_TRUE(average_.Update(1.0, t_));
+  ASSERT_EQ(0.875, average_.current());
+  ASSERT_EQ(t_, average_.latest_timestamp());
+  t_ += 1 * half_life_;
+  ASSERT_TRUE(average_.Update(1.0, t_));
+  ASSERT_EQ(0.9375, average_.current());
+  ASSERT_EQ(t_, average_.latest_timestamp());
+
+  // Step two half-life intervals per update.
+  average_.Reset(0.0, t_);
+  ASSERT_EQ(0.0, average_.current());
+  ASSERT_EQ(t_, average_.latest_timestamp());
+  t_ += 2 * half_life_;
+  ASSERT_TRUE(average_.Update(1.0, t_));
+  ASSERT_NEAR(0.666666667, average_.current(), 0.000000001);
+  ASSERT_EQ(t_, average_.latest_timestamp());
+  t_ += 2 * half_life_;
+  ASSERT_TRUE(average_.Update(1.0, t_));
+  ASSERT_NEAR(0.888888889, average_.current(), 0.000000001);
+  ASSERT_EQ(t_, average_.latest_timestamp());
+  t_ += 2 * half_life_;
+  ASSERT_TRUE(average_.Update(1.0, t_));
+  ASSERT_NEAR(0.962962963, average_.current(), 0.000000001);
+  ASSERT_EQ(t_, average_.latest_timestamp());
+  t_ += 2 * half_life_;
+  ASSERT_TRUE(average_.Update(1.0, t_));
+  ASSERT_NEAR(0.987654321, average_.current(), 0.000000001);
+  ASSERT_EQ(t_, average_.latest_timestamp());
+
+  // Step three half-life intervals per update.
+  average_.Reset(0.0, t_);
+  ASSERT_EQ(0.0, average_.current());
+  ASSERT_EQ(t_, average_.latest_timestamp());
+  t_ += 3 * half_life_;
+  ASSERT_TRUE(average_.Update(1.0, t_));
+  ASSERT_EQ(0.75, average_.current());
+  ASSERT_EQ(t_, average_.latest_timestamp());
+  t_ += 3 * half_life_;
+  ASSERT_TRUE(average_.Update(1.0, t_));
+  ASSERT_EQ(0.9375, average_.current());
+  ASSERT_EQ(t_, average_.latest_timestamp());
+  t_ += 3 * half_life_;
+  ASSERT_TRUE(average_.Update(1.0, t_));
+  ASSERT_EQ(0.984375, average_.current());
+  ASSERT_EQ(t_, average_.latest_timestamp());
+  t_ += 3 * half_life_;
+  ASSERT_TRUE(average_.Update(1.0, t_));
+  ASSERT_EQ(0.99609375, average_.current());
+  ASSERT_EQ(t_, average_.latest_timestamp());
+}
+
+TEST_F(TimeWeightedAverageTest, AccountsForUpdatesThatAreOneStepOutOfOrder) {
+  // Compute results at each step when updates are made in-order.
+  average_.Reset(0.0, t_);
+  ASSERT_EQ(0.0, average_.current());
+  ASSERT_EQ(t_, average_.latest_timestamp());
+  double input_values[5];
+  base::TimeTicks timestamps[5];
+  double results[5];
+  for (int i = 0; i < 5; ++i) {
+    input_values[i] = i + 1;
+    timestamps[i] = t_ + (i + 1) * half_life_;
+    ASSERT_TRUE(average_.Update(input_values[i], timestamps[i]));
+    results[i] = average_.current();
+  }
+
+  // Now reset and update out-of-order, checking for the same results along the
+  // way.
+  average_.Reset(0.0, t_);
+  ASSERT_TRUE(average_.Update(input_values[0], timestamps[0]));
+  ASSERT_EQ(results[0], average_.current());
+  ASSERT_TRUE(average_.Update(input_values[2], timestamps[2]));
+  ASSERT_TRUE(average_.Update(input_values[1], timestamps[1]));
+  ASSERT_EQ(results[2], average_.current());
+  ASSERT_TRUE(average_.Update(input_values[4], timestamps[4]));
+  ASSERT_TRUE(average_.Update(input_values[3], timestamps[3]));
+  ASSERT_EQ(results[4], average_.current());
+}
+
+TEST_F(TimeWeightedAverageTest, IgnoresUpdatesThatAreTwoOrMoreStepsOutOfOrder) {
+  // First, go forward several steps, in order.
+  average_.Reset(0.0, t_);
+  ASSERT_EQ(0.0, average_.current());
+  ASSERT_EQ(t_, average_.latest_timestamp());
+  t_ += 1 * half_life_;
+  ASSERT_TRUE(average_.Update(2.0, t_));
+  ASSERT_EQ(1.0, average_.current());
+  ASSERT_EQ(t_, average_.latest_timestamp());
+  t_ += 1 * half_life_;
+  ASSERT_TRUE(average_.Update(2.0, t_));
+  ASSERT_EQ(1.5, average_.current());
+  ASSERT_EQ(t_, average_.latest_timestamp());
+  t_ += 1 * half_life_;
+  ASSERT_TRUE(average_.Update(2.0, t_));
+  ASSERT_EQ(1.75, average_.current());
+  ASSERT_EQ(t_, average_.latest_timestamp());
+  t_ += 1 * half_life_;
+  ASSERT_TRUE(average_.Update(2.0, t_));
+  ASSERT_EQ(1.875, average_.current());
+  ASSERT_EQ(t_, average_.latest_timestamp());
+
+  // Go back 2 steps, then 2.5, then 3, then 3.5, etc. and expect the update to
+  // fail each time.
+  base::TimeTicks earlier = t_ - 2 * half_life_;
+  for (int i = 0; i < 3; ++i) {
+    ASSERT_FALSE(average_.Update(999.0, earlier));
+    ASSERT_EQ(1.875, average_.current());
+    ASSERT_EQ(t_, average_.latest_timestamp());
+    earlier -= half_life_ / 2;
+  }
+}
+
+}  // namespace content