Adds a couple more measures to the benchmarking app

apps/benchmark/measurements_unittest.cc

 // Copyright 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 "apps/benchmark/measurements.h"
 
 #include <algorithm>
 
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace benchmark {
 namespace {
 
 base::TimeTicks Ticks(int64 value) {
   return base::TimeTicks::FromInternalValue(value);
 }
 
 base::TimeDelta Delta(int64 value) {
   return base::TimeDelta::FromInternalValue(value);
 }
 
 class MeasurementsTest : public ::testing::Test {
  protected:
   void SetUp() override {
-    events_.resize(8);
+    events_.resize(11);
     events_[0] = Event(EventType::COMPLETE, "a", "some", Ticks(10), Delta(2));
     events_[1] = Event(EventType::COMPLETE, "a", "some", Ticks(11), Delta(4));
     events_[2] = Event(EventType::COMPLETE, "a", "other", Ticks(12), Delta(8));
     events_[3] = Event(EventType::COMPLETE, "b", "some", Ticks(3), Delta(16));
     events_[4] = Event(EventType::COMPLETE, "b", "some", Ticks(13), Delta(32));
-    events_[5] =
+
+    events_[5] = Event(EventType::COMPLETE, "c", "some", Ticks(14), Delta(10));
+    events_[6] = Event(EventType::COMPLETE, "c", "some", Ticks(16), Delta(11));
+    events_[7] = Event(EventType::COMPLETE, "c", "some", Ticks(18), Delta(12));
+
+    events_[8] =
         Event(EventType::INSTANT, "instant", "another", Ticks(20), Delta(0));
-    events_[6] = Event(EventType::INSTANT, "multi_occurence", "another",
+    events_[9] = Event(EventType::INSTANT, "multi_occurence", "another",
                        Ticks(30), Delta(0));
-    events_[7] = Event(EventType::INSTANT, "multi_occurence", "another",
-                       Ticks(40), Delta(0));
+    events_[10] = Event(EventType::INSTANT, "multi_occurence", "another",
+                        Ticks(40), Delta(0));
 
     reversed_ = events_;
     reverse(reversed_.begin(), reversed_.end());
   }
 
   std::vector<Event> events_;
   std::vector<Event> reversed_;
 };
 
+static double MeasureSingle(const Measurements& measurements,
+                            const Measurement& measurement) {
+  std::vector<double> result;
+  measurements.Measure(measurement, &result);
+  EXPECT_EQ(1U, result.size());
+  return result[0];
+}
+
 TEST_F(MeasurementsTest, MeasureTimeUntil) {
   // The results should be the same regardless of the order of events.
   Measurements regular(events_, base::TimeTicks::FromInternalValue(2));
   Measurements reversed(reversed_, base::TimeTicks::FromInternalValue(2));
 
-  EXPECT_DOUBLE_EQ(0.008,
-                   regular.Measure(Measurement(MeasurementType::TIME_UNTIL,
-                                               EventSpec("a", "some"))));
-  EXPECT_DOUBLE_EQ(0.008,
-                   reversed.Measure(Measurement(MeasurementType::TIME_UNTIL,
+  EXPECT_DOUBLE_EQ(
+      0.008, MeasureSingle(regular, Measurement(MeasurementType::TIME_UNTIL,
                                                 EventSpec("a", "some"))));
+  EXPECT_DOUBLE_EQ(
+      0.008, MeasureSingle(reversed, Measurement(MeasurementType::TIME_UNTIL,
+                                                 EventSpec("a", "some"))));
 
-  EXPECT_DOUBLE_EQ(0.01,
-                   regular.Measure(Measurement(MeasurementType::TIME_UNTIL,
+  EXPECT_DOUBLE_EQ(
+      0.01, MeasureSingle(regular, Measurement(MeasurementType::TIME_UNTIL,
                                                EventSpec("a", "other"))));
-  EXPECT_DOUBLE_EQ(0.01,
-                   reversed.Measure(Measurement(MeasurementType::TIME_UNTIL,
+  EXPECT_DOUBLE_EQ(
+      0.01, MeasureSingle(reversed, Measurement(MeasurementType::TIME_UNTIL,
                                                 EventSpec("a", "other"))));
 
-  EXPECT_DOUBLE_EQ(0.001,
-                   regular.Measure(Measurement(MeasurementType::TIME_UNTIL,
-                                               EventSpec("b", "some"))));
-  EXPECT_DOUBLE_EQ(0.001,
-                   reversed.Measure(Measurement(MeasurementType::TIME_UNTIL,
+  EXPECT_DOUBLE_EQ(
+      0.001, MeasureSingle(regular, Measurement(MeasurementType::TIME_UNTIL,
                                                 EventSpec("b", "some"))));
+  EXPECT_DOUBLE_EQ(
+      0.001, MeasureSingle(reversed, Measurement(MeasurementType::TIME_UNTIL,
+                                                 EventSpec("b", "some"))));
 }
 
 TEST_F(MeasurementsTest, MeasureTimeBetween) {
   // The results should be the same regardless of the order of events.
   Measurements regular(events_, base::TimeTicks::FromInternalValue(2));
   Measurements reversed(reversed_, base::TimeTicks::FromInternalValue(2));
 
-  EXPECT_DOUBLE_EQ(0.0, regular.Measure(Measurement(
-                            MeasurementType::TIME_BETWEEN,
-                            EventSpec("a", "some"), EventSpec("a", "some"))));
-  EXPECT_DOUBLE_EQ(0.0, reversed.Measure(Measurement(
-                            MeasurementType::TIME_BETWEEN,
-                            EventSpec("a", "some"), EventSpec("a", "some"))));
+  EXPECT_DOUBLE_EQ(
+      0.0, MeasureSingle(regular, Measurement(MeasurementType::TIME_BETWEEN,
+                                              EventSpec("a", "some"),
+                                              EventSpec("a", "some"))));
+  EXPECT_DOUBLE_EQ(
+      0.0, MeasureSingle(reversed, Measurement(MeasurementType::TIME_BETWEEN,
+                                               EventSpec("a", "some"),
+                                               EventSpec("a", "some"))));
 
   EXPECT_DOUBLE_EQ(
-      0.01, regular.Measure(Measurement(
-                MeasurementType::TIME_BETWEEN, EventSpec("instant", "another"),
-                EventSpec("multi_occurence", "another"))));
+      0.01, MeasureSingle(
+                regular, Measurement(MeasurementType::TIME_BETWEEN,
+                                     EventSpec("instant", "another"),
+                                     EventSpec("multi_occurence", "another"))));
   EXPECT_DOUBLE_EQ(
-      0.01, reversed.Measure(Measurement(
-                MeasurementType::TIME_BETWEEN, EventSpec("instant", "another"),
-                EventSpec("multi_occurence", "another"))));
+      0.01, MeasureSingle(reversed, Measurement(MeasurementType::TIME_BETWEEN,
+                                                EventSpec("instant", "another"),
+                                                EventSpec("multi_occurence",
+                                                          "another"))));
 
   EXPECT_DOUBLE_EQ(
-      -1.0, regular.Measure(Measurement(MeasurementType::TIME_BETWEEN,
-                                        EventSpec("multi_occurence", "another"),
-                                        EventSpec("instant", "another"))));
-  EXPECT_DOUBLE_EQ(-1.0, reversed.Measure(Measurement(
-                             MeasurementType::TIME_BETWEEN,
-                             EventSpec("multi_occurence", "another"),
-                             EventSpec("instant", "another"))));
+      -1.0, MeasureSingle(regular,
+                          Measurement(MeasurementType::TIME_BETWEEN,
+                                      EventSpec("multi_occurence", "another"),
+                                      EventSpec("instant", "another"))));
+  EXPECT_DOUBLE_EQ(
+      -1.0, MeasureSingle(reversed,
+                          Measurement(MeasurementType::TIME_BETWEEN,
+                                      EventSpec("multi_occurence", "another"),
+                                      EventSpec("instant", "another"))));
 
   EXPECT_DOUBLE_EQ(
-      0.01, regular.Measure(Measurement(MeasurementType::TIME_BETWEEN,
-                                        EventSpec("a", "some"),
-                                        EventSpec("instant", "another"))));
-  EXPECT_DOUBLE_EQ(
-      0.01, reversed.Measure(Measurement(MeasurementType::TIME_BETWEEN,
+      0.01,
+      MeasureSingle(regular, Measurement(MeasurementType::TIME_BETWEEN,
                                          EventSpec("a", "some"),
                                          EventSpec("instant", "another"))));
+  EXPECT_DOUBLE_EQ(
+      0.01,
+      MeasureSingle(reversed, Measurement(MeasurementType::TIME_BETWEEN,
+                                          EventSpec("a", "some"),
+                                          EventSpec("instant", "another"))));
 }
 
 TEST_F(MeasurementsTest, MeasureAvgDuration) {
   // The results should be the same regardless of the order of events.
   Measurements regular(events_, base::TimeTicks::FromInternalValue(2));
   Measurements reversed(reversed_, base::TimeTicks::FromInternalValue(2));
 
-  EXPECT_DOUBLE_EQ(0.003,
-                   regular.Measure(Measurement(MeasurementType::AVG_DURATION,
-                                               EventSpec("a", "some"))));
-  EXPECT_DOUBLE_EQ(0.003,
-                   reversed.Measure(Measurement(MeasurementType::AVG_DURATION,
+  EXPECT_DOUBLE_EQ(
+      0.003, MeasureSingle(regular, Measurement(MeasurementType::AVG_DURATION,
                                                 EventSpec("a", "some"))));
+  EXPECT_DOUBLE_EQ(
+      0.003, MeasureSingle(reversed, Measurement(MeasurementType::AVG_DURATION,
+                                                 EventSpec("a", "some"))));
 
-  EXPECT_DOUBLE_EQ(0.008,
-                   regular.Measure(Measurement(MeasurementType::AVG_DURATION,
-                                               EventSpec("a", "other"))));
-  EXPECT_DOUBLE_EQ(0.008,
-                   reversed.Measure(Measurement(MeasurementType::AVG_DURATION,
+  EXPECT_DOUBLE_EQ(
+      0.008, MeasureSingle(regular, Measurement(MeasurementType::AVG_DURATION,
                                                 EventSpec("a", "other"))));
+  EXPECT_DOUBLE_EQ(
+      0.008, MeasureSingle(reversed, Measurement(MeasurementType::AVG_DURATION,
+                                                 EventSpec("a", "other"))));
 
-  EXPECT_DOUBLE_EQ(0.024,
-                   regular.Measure(Measurement(MeasurementType::AVG_DURATION,
-                                               EventSpec("b", "some"))));
-  EXPECT_DOUBLE_EQ(0.024,
-                   reversed.Measure(Measurement(MeasurementType::AVG_DURATION,
+  EXPECT_DOUBLE_EQ(
+      0.024, MeasureSingle(regular, Measurement(MeasurementType::AVG_DURATION,
                                                 EventSpec("b", "some"))));
+  EXPECT_DOUBLE_EQ(
+      0.024, MeasureSingle(reversed, Measurement(MeasurementType::AVG_DURATION,
+                                                 EventSpec("b", "some"))));
+}
+
+TEST_F(MeasurementsTest, MeasureMedianDuration) {
+  // The results should be the same regardless of the order of events.
+  Measurements regular(events_, base::TimeTicks::FromInternalValue(2));
+  Measurements reversed(reversed_, base::TimeTicks::FromInternalValue(2));
+
+  EXPECT_DOUBLE_EQ(
+      0.011,
+      MeasureSingle(regular, Measurement(MeasurementType::MEDIAN_DURATION,
+                                         EventSpec("c", "some"))));
+  EXPECT_DOUBLE_EQ(
+      0.011,
+      MeasureSingle(reversed, Measurement(MeasurementType::MEDIAN_DURATION,
+                                          EventSpec("c", "some"))));
+}
+
+TEST_F(MeasurementsTest, MeasureDistDuration) {
+  // The results should be the same regardless of the order of events.
+  Measurements regular(events_, base::TimeTicks::FromInternalValue(2));
+  Measurements reversed(reversed_, base::TimeTicks::FromInternalValue(2));
+
+  std::vector<double> results;
+  regular.Measure(
+      Measurement(MeasurementType::DIST_DURATION, EventSpec("c", "some")),
+      &results);
+  EXPECT_EQ(3U, results.size());
+  EXPECT_DOUBLE_EQ(0.010, results[0]);
+  EXPECT_DOUBLE_EQ(0.011, results[1]);
+  EXPECT_DOUBLE_EQ(0.012, results[2]);
 }
 
 TEST_F(MeasurementsTest, NoMatchingEvent) {
   // The results should be the same regardless of the order of events.
   Measurements empty(std::vector<Event>(),
                      base::TimeTicks::FromInternalValue(0));
   Measurements regular(events_, base::TimeTicks::FromInternalValue(0));
   Measurements reversed(reversed_, base::TimeTicks::FromInternalValue(0));
 
-  EXPECT_DOUBLE_EQ(-1.0,
-                   empty.Measure(Measurement(MeasurementType::AVG_DURATION,
+  EXPECT_DOUBLE_EQ(
+      -1.0, MeasureSingle(empty, Measurement(MeasurementType::AVG_DURATION,
                                              EventSpec("miss", "cat"))));
-  EXPECT_DOUBLE_EQ(-1.0,
-                   regular.Measure(Measurement(MeasurementType::AVG_DURATION,
+  EXPECT_DOUBLE_EQ(
+      -1.0, MeasureSingle(regular, Measurement(MeasurementType::AVG_DURATION,
                                                EventSpec("miss", "cat"))));
-  EXPECT_DOUBLE_EQ(-1.0,
-                   reversed.Measure(Measurement(MeasurementType::AVG_DURATION,
+  EXPECT_DOUBLE_EQ(
+      -1.0, MeasureSingle(reversed, Measurement(MeasurementType::AVG_DURATION,
                                                 EventSpec("miss", "cat"))));
 
-  EXPECT_DOUBLE_EQ(-1.0, empty.Measure(Measurement(MeasurementType::TIME_UNTIL,
-                                                   EventSpec("miss", "cat"))));
   EXPECT_DOUBLE_EQ(-1.0,
-                   regular.Measure(Measurement(MeasurementType::TIME_UNTIL,
+                   MeasureSingle(empty, Measurement(MeasurementType::TIME_UNTIL,
+                                                    EventSpec("miss", "cat"))));
+  EXPECT_DOUBLE_EQ(
+      -1.0, MeasureSingle(regular, Measurement(MeasurementType::TIME_UNTIL,
                                                EventSpec("miss", "cat"))));
-  EXPECT_DOUBLE_EQ(-1.0,
-                   reversed.Measure(Measurement(MeasurementType::TIME_UNTIL,
+  EXPECT_DOUBLE_EQ(
+      -1.0, MeasureSingle(reversed, Measurement(MeasurementType::TIME_UNTIL,
                                                 EventSpec("miss", "cat"))));
 }
 
 }  // namespace
 
 }  // namespace benchmark