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(base::TimeDelta window_size) { |
| 33 window_size_ = window_size; |
| 34 } |
| 35 |
| 36 void set_idle_timeout(base::TimeDelta idle_timeout) { |
| 37 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(base::TimeDelta::FromSecondsD(0.1)); |
| 52 |
| 53 idle_fraction_recorder.RecordEventAtTime(EventTimeStampFromSeconds(0.5)); |
| 54 |
| 55 // Flush the previous event. |
| 56 idle_fraction_recorder.RecordEventAtTime(EventTimeStampFromSeconds(100)); |
| 57 |
| 58 // We observed a single event, so the we consider it to have lasted a duration |
| 59 // of one idle timeout. |
| 60 EXPECT_THAT(idle_fraction_recorder.active_intervals(), |
| 61 ElementsAre(Pair(EventTimeStampFromSeconds(0.5), |
| 62 EventTimeStampFromSeconds(0.6)))); |
| 63 } |
| 64 |
| 65 TEST(FractionOfTimeWithoutUserInputRecorderTest, TwoLongIntervals) { |
| 66 TestFractionOfTimeWithoutUserInputRecorder idle_fraction_recorder; |
| 67 idle_fraction_recorder.set_idle_timeout(base::TimeDelta::FromSecondsD(0.1)); |
| 68 |
| 69 // Send events regularly between 0.1 seconds and 0.1 + 20 * 0.05 = 1.10 |
| 70 // seconds. |
| 71 base::TimeTicks time = base::TimeTicks() + base::TimeDelta::FromSecondsD(0.1); |
| 72 idle_fraction_recorder.RecordEventAtTime(time); |
| 73 |
| 74 for (int i = 0; i < 20; ++i) { |
| 75 time += base::TimeDelta::FromSecondsD(0.05); |
| 76 idle_fraction_recorder.RecordEventAtTime(time); |
| 77 } |
| 78 |
| 79 // Send events regularly between 2.2 seconds and 2.2 + 20 * 0.05 = 3.20 |
| 80 // seconds. |
| 81 time = base::TimeTicks() + base::TimeDelta::FromSecondsD(2.2); |
| 82 idle_fraction_recorder.RecordEventAtTime(time); |
| 83 |
| 84 for (int i = 0; i < 20; ++i) { |
| 85 time += base::TimeDelta::FromSecondsD(0.05); |
| 86 idle_fraction_recorder.RecordEventAtTime(time); |
| 87 } |
| 88 |
| 89 // Flush the previous event. |
| 90 idle_fraction_recorder.RecordEventAtTime(EventTimeStampFromSeconds(100)); |
| 91 |
| 92 // Interval end times include idle timeout. |
| 93 EXPECT_THAT(idle_fraction_recorder.active_intervals(), |
| 94 ElementsAre(Pair(EventTimeStampFromSeconds(0.1), |
| 95 EventTimeStampFromSeconds(1.2)), |
| 96 Pair(EventTimeStampFromSeconds(2.2), |
| 97 EventTimeStampFromSeconds(3.3)))); |
| 98 } |
| 99 |
| 100 TEST(FractionOfTimeWithoutUserInputRecorderTest, SingleShortRange) { |
| 101 TestFractionOfTimeWithoutUserInputRecorder idle_fraction_recorder; |
| 102 idle_fraction_recorder.set_window_size(base::TimeDelta::FromSecondsD(1)); |
| 103 |
| 104 base::HistogramTester tester; |
| 105 // Start window at 1 second. |
| 106 idle_fraction_recorder.RecordActiveInterval(EventTimeStampFromSeconds(1), |
| 107 EventTimeStampFromSeconds(1)); |
| 108 |
| 109 idle_fraction_recorder.RecordActiveInterval(EventTimeStampFromSeconds(1.1), |
| 110 EventTimeStampFromSeconds(1.6)); |
| 111 |
| 112 // Flush the previous interval. |
| 113 idle_fraction_recorder.RecordActiveInterval(EventTimeStampFromSeconds(2), |
| 114 EventTimeStampFromSeconds(2)); |
| 115 |
| 116 EXPECT_THAT(tester.GetAllSamples(kHistogram), ElementsAre(Bucket(50, 1))); |
| 117 } |
| 118 |
| 119 TEST(FractionOfTimeWithoutUserInputRecorderTest, SingleLongRange) { |
| 120 TestFractionOfTimeWithoutUserInputRecorder idle_fraction_recorder; |
| 121 idle_fraction_recorder.set_window_size(base::TimeDelta::FromSecondsD(1)); |
| 122 |
| 123 base::HistogramTester tester; |
| 124 |
| 125 // Start window at 1 second. |
| 126 idle_fraction_recorder.RecordActiveInterval(EventTimeStampFromSeconds(1), |
| 127 EventTimeStampFromSeconds(1)); |
| 128 |
| 129 idle_fraction_recorder.RecordActiveInterval(EventTimeStampFromSeconds(1.1), |
| 130 EventTimeStampFromSeconds(4.2)); |
| 131 |
| 132 // Flush the previous interval. |
| 133 idle_fraction_recorder.RecordActiveInterval(EventTimeStampFromSeconds(5), |
| 134 EventTimeStampFromSeconds(5)); |
| 135 |
| 136 // The windows contain: [1.1, 2], [2, 3], [3, 4], [4, 4.2]. |
| 137 EXPECT_THAT(tester.GetAllSamples(kHistogram), |
| 138 ElementsAre(Bucket(0, 2), Bucket(10, 1), Bucket(80, 1))); |
| 139 } |
| 140 |
| 141 TEST(FractionOfTimeWithoutUserInputRecorderTest, TwoLongRanges) { |
| 142 TestFractionOfTimeWithoutUserInputRecorder idle_fraction_recorder; |
| 143 idle_fraction_recorder.set_window_size(base::TimeDelta::FromSecondsD(1)); |
| 144 |
| 145 base::HistogramTester tester; |
| 146 |
| 147 // Start window at 1 second. |
| 148 idle_fraction_recorder.RecordActiveInterval(EventTimeStampFromSeconds(1), |
| 149 EventTimeStampFromSeconds(1)); |
| 150 |
| 151 idle_fraction_recorder.RecordActiveInterval(EventTimeStampFromSeconds(1.1), |
| 152 EventTimeStampFromSeconds(2.2)); |
| 153 |
| 154 idle_fraction_recorder.RecordActiveInterval(EventTimeStampFromSeconds(2.6), |
| 155 EventTimeStampFromSeconds(3.2)); |
| 156 |
| 157 // Flush the previous interval. |
| 158 idle_fraction_recorder.RecordActiveInterval(EventTimeStampFromSeconds(4), |
| 159 EventTimeStampFromSeconds(4)); |
| 160 |
| 161 // The windows contain: |
| 162 // 1: 1.1 - 2.0 |
| 163 // 2: 2.0 - 2.2, 2.6 - 3.0 |
| 164 // 3: 3.0 - 3.2 |
| 165 EXPECT_THAT(tester.GetAllSamples(kHistogram), |
| 166 ElementsAre(Bucket(10, 1), Bucket(40, 1), Bucket(80, 1))); |
| 167 } |
| 168 |
| 169 } // namespace |
| 170 |
| 171 } // namespace ui |
OLD | NEW |