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 "testing/gmock/include/gmock/gmock.h" | |
8 #include "testing/gtest/include/gtest/gtest.h" | |
9 #include "ui/events/base_event_utils.h" | |
10 | |
11 namespace ui { | |
12 | |
13 namespace { | |
14 | |
15 using testing::ElementsAre; | |
16 using testing::Pair; | |
17 | |
18 class TestFractionOfTimeWithoutUserInputRecorder | |
19 : public FractionOfTimeWithoutUserInputRecorder { | |
20 public: | |
21 void RecordActiveInterval(base::TimeTicks start_time, | |
22 base::TimeTicks end_time) override { | |
23 active_intervals_.push_back(std::make_pair(start_time, end_time)); | |
24 FractionOfTimeWithoutUserInputRecorder::RecordActiveInterval(start_time, | |
25 end_time); | |
26 } | |
27 | |
28 void RecordToUma(float idle_fraction) override { | |
sadrul
2017/03/19 00:38:51
Instead of making this virtual (and override from
tdresser
2017/03/24 14:56:31
Done.
| |
29 idle_fractions_.push_back(idle_fraction); | |
30 FractionOfTimeWithoutUserInputRecorder::RecordToUma(idle_fraction); | |
31 } | |
32 | |
33 void SetWindowSize(base::TimeDelta window_size) { | |
sadrul
2017/03/19 00:38:52
set_window_size
tdresser
2017/03/24 14:56:31
Done.
| |
34 window_size_ = window_size; | |
35 } | |
36 | |
37 void SetIdleTimeout(base::TimeDelta idle_timeout) { | |
sadrul
2017/03/19 00:38:52
set_idle_timeout
tdresser
2017/03/24 14:56:31
Done.
| |
38 idle_timeout_ = idle_timeout; | |
39 } | |
40 | |
41 std::vector<std::pair<base::TimeTicks, base::TimeTicks>> active_intervals() { | |
sadrul
2017/03/19 00:38:52
const&
tdresser
2017/03/24 14:56:31
Done.
| |
42 return active_intervals_; | |
43 } | |
44 | |
45 std::vector<float> idle_fractions() { return idle_fractions_; } | |
sadrul
2017/03/19 00:38:52
ditto
tdresser
2017/03/24 14:56:31
Removed.
| |
46 | |
47 private: | |
48 std::vector<std::pair<base::TimeTicks, base::TimeTicks>> active_intervals_; | |
49 std::vector<float> idle_fractions_; | |
50 }; | |
51 | |
52 TEST(FractionOfTimeWithoutUserInputRecorderTest, IntervalIncludesIdleTimeout) { | |
53 TestFractionOfTimeWithoutUserInputRecorder idle_fraction_recorder; | |
54 idle_fraction_recorder.SetIdleTimeout(base::TimeDelta::FromSecondsD(0.1)); | |
55 | |
56 idle_fraction_recorder.RecordEventAtTime(EventTimeStampFromSeconds(0.5)); | |
57 | |
58 // Flush the previous event. | |
59 idle_fraction_recorder.RecordEventAtTime(EventTimeStampFromSeconds(100)); | |
60 | |
61 // We observed a single event, so the we consider it to have lasted a duration | |
62 // of one idle timeout. | |
63 EXPECT_THAT(idle_fraction_recorder.active_intervals(), | |
64 ElementsAre(Pair(EventTimeStampFromSeconds(0.5), | |
65 EventTimeStampFromSeconds(0.6)))); | |
66 } | |
67 | |
68 TEST(FractionOfTimeWithoutUserInputRecorderTest, TwoLongIntervals) { | |
69 TestFractionOfTimeWithoutUserInputRecorder idle_fraction_recorder; | |
70 idle_fraction_recorder.SetIdleTimeout(base::TimeDelta::FromSecondsD(0.1)); | |
71 | |
72 // Send events regularly between 0.1 seconds and 0.1 + 20 * 0.05 = 1.10 | |
73 // seconds. | |
74 base::TimeTicks time = base::TimeTicks() + base::TimeDelta::FromSecondsD(0.1); | |
75 idle_fraction_recorder.RecordEventAtTime(time); | |
76 | |
77 for (int i = 0; i < 20; ++i) { | |
78 time += base::TimeDelta::FromSecondsD(0.05); | |
79 idle_fraction_recorder.RecordEventAtTime(time); | |
80 } | |
81 | |
82 // Send events regularly between 2.2 seconds and 2.2 + 20 * 0.05 = 3.20 | |
83 // seconds. | |
84 time = base::TimeTicks() + base::TimeDelta::FromSecondsD(2.2); | |
85 idle_fraction_recorder.RecordEventAtTime(time); | |
86 | |
87 for (int i = 0; i < 20; ++i) { | |
88 time += base::TimeDelta::FromSecondsD(0.05); | |
89 idle_fraction_recorder.RecordEventAtTime(time); | |
90 } | |
91 | |
92 // Flush the previous event. | |
93 idle_fraction_recorder.RecordEventAtTime(EventTimeStampFromSeconds(100)); | |
94 | |
95 // Interval end times include idle timeout. | |
96 EXPECT_THAT(idle_fraction_recorder.active_intervals(), | |
97 ElementsAre(Pair(EventTimeStampFromSeconds(0.1), | |
98 EventTimeStampFromSeconds(1.2)), | |
99 Pair(EventTimeStampFromSeconds(2.2), | |
100 EventTimeStampFromSeconds(3.3)))); | |
101 } | |
102 | |
103 TEST(FractionOfTimeWithoutUserInputRecorderTest, SingleShortRange) { | |
104 TestFractionOfTimeWithoutUserInputRecorder idle_fraction_recorder; | |
105 idle_fraction_recorder.SetWindowSize(base::TimeDelta::FromSecondsD(1)); | |
106 | |
107 // Start window at 1 second. | |
108 idle_fraction_recorder.RecordActiveInterval(EventTimeStampFromSeconds(1), | |
109 EventTimeStampFromSeconds(1)); | |
110 | |
111 idle_fraction_recorder.RecordActiveInterval(EventTimeStampFromSeconds(1.1), | |
112 EventTimeStampFromSeconds(1.6)); | |
113 | |
114 // Flush the previous interval. | |
115 idle_fraction_recorder.RecordActiveInterval(EventTimeStampFromSeconds(2), | |
116 EventTimeStampFromSeconds(2)); | |
117 | |
118 EXPECT_THAT(idle_fraction_recorder.idle_fractions(), ElementsAre(0.5)); | |
119 } | |
120 | |
121 TEST(FractionOfTimeWithoutUserInputRecorderTest, SingleLongRange) { | |
122 TestFractionOfTimeWithoutUserInputRecorder idle_fraction_recorder; | |
123 idle_fraction_recorder.SetWindowSize(base::TimeDelta::FromSecondsD(1)); | |
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(idle_fraction_recorder.idle_fractions(), | |
138 ElementsAre(0.9, 1, 1, 0.2)); | |
139 } | |
140 | |
141 TEST(FractionOfTimeWithoutUserInputRecorderTest, TwoLongRanges) { | |
142 TestFractionOfTimeWithoutUserInputRecorder idle_fraction_recorder; | |
143 idle_fraction_recorder.SetWindowSize(base::TimeDelta::FromSecondsD(1)); | |
144 | |
145 // Start window at 1 second. | |
146 idle_fraction_recorder.RecordActiveInterval(EventTimeStampFromSeconds(1), | |
147 EventTimeStampFromSeconds(1)); | |
148 | |
149 idle_fraction_recorder.RecordActiveInterval(EventTimeStampFromSeconds(1.1), | |
150 EventTimeStampFromSeconds(2.2)); | |
151 | |
152 idle_fraction_recorder.RecordActiveInterval(EventTimeStampFromSeconds(2.6), | |
153 EventTimeStampFromSeconds(3.2)); | |
154 | |
155 // Flush the previous interval. | |
156 idle_fraction_recorder.RecordActiveInterval(EventTimeStampFromSeconds(4), | |
157 EventTimeStampFromSeconds(4)); | |
158 | |
159 // The windows contain: | |
160 // 1: 1.1 - 2.0 | |
161 // 2: 2.0 - 2.2, 2.6 - 3.0 | |
162 // 3: 3.0 - 3.2 | |
163 EXPECT_THAT(idle_fraction_recorder.idle_fractions(), | |
164 ElementsAre(0.9, 0.6, 0.2)); | |
165 } | |
166 | |
167 } // namespace | |
168 | |
169 } // namespace ui | |
OLD | NEW |