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) { | |
tdresser
2017/03/27 19:01:46
sadrul: is this naming okay?
| |
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 |