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_;
 };
 
 TEST_F(MeasurementsTest, MeasureTimeUntil) {
@@ skipping 83 matching lines @@
                                                 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,
                                                 EventSpec("b", "some"))));
 }
 
+TEST_F(MeasurementsTest, MeasurePercentileDuration) {
+  // 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));
+
+  Measurement measurement(MeasurementType::PERCENTILE_DURATION,
+                          EventSpec("c", "some"));
+  measurement.param = 0.10;
+  EXPECT_DOUBLE_EQ(0.010, regular.Measure(measurement));

[ppi, 2015/10/12 19:19:19]

Please make each test on the reversed event list too.

[zra, 2015/10/12 20:38:19]

Done.

+  measurement.param = 0.50;
+  EXPECT_DOUBLE_EQ(0.011, regular.Measure(measurement));
+  measurement.param = 0.90;
+  EXPECT_DOUBLE_EQ(0.012, regular.Measure(measurement));

[ppi, 2015/10/12 19:19:19]

Please test edge cases (0.0 and 1.0) too.

[zra, 2015/10/12 20:38:19]

Added for 1.0. On further reflection 0.0 doesn't make sense, so it is excluded.
(There is no element >= none of the elements).

[ppi, 2015/10/12 20:53:55]

As noted above, I think that we should handle 0.0 (meaning the lowest element)
and 1.0 (meaning the highest element), as long as it is not an abomination of
some universally held definition of percentile.

[zra, 2015/10/12 22:59:33]

Added test for 0.0.

+}
+
 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,
                                              EventSpec("miss", "cat"))));
@@ skipping 10 matching lines @@
                    regular.Measure(Measurement(MeasurementType::TIME_UNTIL,
                                                EventSpec("miss", "cat"))));
   EXPECT_DOUBLE_EQ(-1.0,
                    reversed.Measure(Measurement(MeasurementType::TIME_UNTIL,
                                                 EventSpec("miss", "cat"))));
 }
 
 }  // namespace
 
 }  // namespace benchmark