OLD | NEW |
(Empty) | |
| 1 // Copyright 2017 The Chromium Authors. All rights reserved. |
| 2 // Use of this source code is governed by a BSD-style license that can be |
| 3 // found in the LICENSE file. |
| 4 |
| 5 #include "ui/events/fraction_of_time_without_user_input_recorder.h" |
| 6 |
| 7 #include "base/test/histogram_tester.h" |
| 8 #include "testing/gmock/include/gmock/gmock.h" |
| 9 #include "testing/gtest/include/gtest/gtest.h" |
| 10 #include "ui/events/base_event_utils.h" |
| 11 |
| 12 namespace ui { |
| 13 |
| 14 namespace { |
| 15 |
| 16 using base::Bucket; |
| 17 using testing::ElementsAre; |
| 18 using testing::Pair; |
| 19 |
| 20 const char* kHistogram = "Event.FractionOfTimeWithoutUserInput"; |
| 21 |
| 22 class TestFractionOfTimeWithoutUserInputRecorder |
| 23 : public FractionOfTimeWithoutUserInputRecorder { |
| 24 public: |
| 25 void RecordActiveInterval(base::TimeTicks start_time, |
| 26 base::TimeTicks end_time) override { |
| 27 active_intervals_.push_back(std::make_pair(start_time, end_time)); |
| 28 FractionOfTimeWithoutUserInputRecorder::RecordActiveInterval(start_time, |
| 29 end_time); |
| 30 } |
| 31 |
| 32 void set_window_size_for_test(base::TimeDelta window_size) { |
| 33 set_window_size(window_size); |
| 34 } |
| 35 |
| 36 void set_idle_timeout_for_test(base::TimeDelta idle_timeout) { |
| 37 set_idle_timeout(idle_timeout); |
| 38 } |
| 39 |
| 40 const std::vector<std::pair<base::TimeTicks, base::TimeTicks>>& |
| 41 active_intervals() { |
| 42 return active_intervals_; |
| 43 } |
| 44 |
| 45 private: |
| 46 std::vector<std::pair<base::TimeTicks, base::TimeTicks>> active_intervals_; |
| 47 }; |
| 48 |
| 49 TEST(FractionOfTimeWithoutUserInputRecorderTest, IntervalIncludesIdleTimeout) { |
| 50 TestFractionOfTimeWithoutUserInputRecorder idle_fraction_recorder; |
| 51 idle_fraction_recorder.set_idle_timeout_for_test( |
| 52 base::TimeDelta::FromSecondsD(0.1)); |
| 53 |
| 54 idle_fraction_recorder.RecordEventAtTime(EventTimeStampFromSeconds(0.5)); |
| 55 |
| 56 // Flush the previous event. |
| 57 idle_fraction_recorder.RecordEventAtTime(EventTimeStampFromSeconds(100)); |
| 58 |
| 59 // We observed a single event, so the we consider it to have lasted a duration |
| 60 // of one idle timeout. |
| 61 EXPECT_THAT(idle_fraction_recorder.active_intervals(), |
| 62 ElementsAre(Pair(EventTimeStampFromSeconds(0.5), |
| 63 EventTimeStampFromSeconds(0.6)))); |
| 64 } |
| 65 |
| 66 TEST(FractionOfTimeWithoutUserInputRecorderTest, TwoLongIntervals) { |
| 67 TestFractionOfTimeWithoutUserInputRecorder idle_fraction_recorder; |
| 68 idle_fraction_recorder.set_idle_timeout_for_test( |
| 69 base::TimeDelta::FromSecondsD(0.1)); |
| 70 |
| 71 // Send events regularly between 0.1 seconds and 0.1 + 20 * 0.05 = 1.10 |
| 72 // seconds. |
| 73 base::TimeTicks time = base::TimeTicks() + base::TimeDelta::FromSecondsD(0.1); |
| 74 idle_fraction_recorder.RecordEventAtTime(time); |
| 75 |
| 76 for (int i = 0; i < 20; ++i) { |
| 77 time += base::TimeDelta::FromSecondsD(0.05); |
| 78 idle_fraction_recorder.RecordEventAtTime(time); |
| 79 } |
| 80 |
| 81 // Send events regularly between 2.2 seconds and 2.2 + 20 * 0.05 = 3.20 |
| 82 // seconds. |
| 83 time = base::TimeTicks() + base::TimeDelta::FromSecondsD(2.2); |
| 84 idle_fraction_recorder.RecordEventAtTime(time); |
| 85 |
| 86 for (int i = 0; i < 20; ++i) { |
| 87 time += base::TimeDelta::FromSecondsD(0.05); |
| 88 idle_fraction_recorder.RecordEventAtTime(time); |
| 89 } |
| 90 |
| 91 // Flush the previous event. |
| 92 idle_fraction_recorder.RecordEventAtTime(EventTimeStampFromSeconds(100)); |
| 93 |
| 94 // Interval end times include idle timeout. |
| 95 EXPECT_THAT(idle_fraction_recorder.active_intervals(), |
| 96 ElementsAre(Pair(EventTimeStampFromSeconds(0.1), |
| 97 EventTimeStampFromSeconds(1.2)), |
| 98 Pair(EventTimeStampFromSeconds(2.2), |
| 99 EventTimeStampFromSeconds(3.3)))); |
| 100 } |
| 101 |
| 102 TEST(FractionOfTimeWithoutUserInputRecorderTest, SingleShortRange) { |
| 103 TestFractionOfTimeWithoutUserInputRecorder idle_fraction_recorder; |
| 104 idle_fraction_recorder.set_window_size_for_test( |
| 105 base::TimeDelta::FromSecondsD(1)); |
| 106 |
| 107 base::HistogramTester tester; |
| 108 // Start window at 1 second. |
| 109 idle_fraction_recorder.RecordActiveInterval(EventTimeStampFromSeconds(1), |
| 110 EventTimeStampFromSeconds(1)); |
| 111 |
| 112 idle_fraction_recorder.RecordActiveInterval(EventTimeStampFromSeconds(1.1), |
| 113 EventTimeStampFromSeconds(1.6)); |
| 114 |
| 115 // Flush the previous interval. |
| 116 idle_fraction_recorder.RecordActiveInterval(EventTimeStampFromSeconds(2), |
| 117 EventTimeStampFromSeconds(2)); |
| 118 |
| 119 EXPECT_THAT(tester.GetAllSamples(kHistogram), ElementsAre(Bucket(50, 1))); |
| 120 } |
| 121 |
| 122 TEST(FractionOfTimeWithoutUserInputRecorderTest, SingleLongRange) { |
| 123 TestFractionOfTimeWithoutUserInputRecorder idle_fraction_recorder; |
| 124 idle_fraction_recorder.set_window_size_for_test( |
| 125 base::TimeDelta::FromSecondsD(1)); |
| 126 |
| 127 base::HistogramTester tester; |
| 128 |
| 129 // Start window at 1 second. |
| 130 idle_fraction_recorder.RecordActiveInterval(EventTimeStampFromSeconds(1), |
| 131 EventTimeStampFromSeconds(1)); |
| 132 |
| 133 idle_fraction_recorder.RecordActiveInterval(EventTimeStampFromSeconds(1.1), |
| 134 EventTimeStampFromSeconds(4.2)); |
| 135 |
| 136 // Flush the previous interval. |
| 137 idle_fraction_recorder.RecordActiveInterval(EventTimeStampFromSeconds(5), |
| 138 EventTimeStampFromSeconds(5)); |
| 139 |
| 140 // The windows contain: [1.1, 2], [2, 3], [3, 4], [4, 4.2]. |
| 141 EXPECT_THAT(tester.GetAllSamples(kHistogram), |
| 142 ElementsAre(Bucket(0, 2), Bucket(10, 1), Bucket(80, 1))); |
| 143 } |
| 144 |
| 145 TEST(FractionOfTimeWithoutUserInputRecorderTest, TwoLongRanges) { |
| 146 TestFractionOfTimeWithoutUserInputRecorder idle_fraction_recorder; |
| 147 idle_fraction_recorder.set_window_size_for_test( |
| 148 base::TimeDelta::FromSecondsD(1)); |
| 149 |
| 150 base::HistogramTester tester; |
| 151 |
| 152 // Start window at 1 second. |
| 153 idle_fraction_recorder.RecordActiveInterval(EventTimeStampFromSeconds(1), |
| 154 EventTimeStampFromSeconds(1)); |
| 155 |
| 156 idle_fraction_recorder.RecordActiveInterval(EventTimeStampFromSeconds(1.1), |
| 157 EventTimeStampFromSeconds(2.2)); |
| 158 |
| 159 idle_fraction_recorder.RecordActiveInterval(EventTimeStampFromSeconds(2.6), |
| 160 EventTimeStampFromSeconds(3.2)); |
| 161 |
| 162 // Flush the previous interval. |
| 163 idle_fraction_recorder.RecordActiveInterval(EventTimeStampFromSeconds(4), |
| 164 EventTimeStampFromSeconds(4)); |
| 165 |
| 166 // The windows contain: |
| 167 // 1: 1.1 - 2.0 |
| 168 // 2: 2.0 - 2.2, 2.6 - 3.0 |
| 169 // 3: 3.0 - 3.2 |
| 170 EXPECT_THAT(tester.GetAllSamples(kHistogram), |
| 171 ElementsAre(Bucket(10, 1), Bucket(40, 1), Bucket(80, 1))); |
| 172 } |
| 173 |
| 174 } // namespace |
| 175 |
| 176 } // namespace ui |
OLD | NEW |