OLD | NEW |
---|---|
(Empty) | |
1 // Copyright (c) 2010 The Chromium OS 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 "metrics_daemon.h" | |
6 | |
7 #include <sys/file.h> | |
8 | |
9 #include <base/eintr_wrapper.h> | |
10 #include <base/file_util.h> | |
11 #include <base/logging.h> | |
12 #include <base/string_util.h> | |
13 #include <gtest/gtest.h> | |
14 | |
15 static const char kTestDailyUseRecordFile[] = "/tmp/daily-usage-test"; | |
16 static const char kDoesNotExistFile[] = "/does/not/exist"; | |
17 | |
18 static const int kSecondsPerDay = 24 * 60 * 60; | |
19 | |
20 class MetricsDaemonTest : public testing::Test { | |
21 protected: | |
22 virtual void SetUp() { | |
23 daemon_.Init(true); | |
24 daemon_.daily_use_record_file_ = kTestDailyUseRecordFile; | |
25 | |
26 // The test fixture object will be used by the log message handler. | |
27 daemon_test_ = this; | |
28 logging::SetLogMessageHandler(LogMessageHandler); | |
29 } | |
30 | |
31 virtual void TearDown() { | |
32 logging::SetLogMessageHandler(NULL); | |
33 daemon_test_ = NULL; | |
34 file_util::Delete(FilePath(kTestDailyUseRecordFile), false); | |
35 } | |
36 | |
37 // Collects log messages in the |daemon_log_| member string so that | |
38 // they can be analyzed for errors and expected behavior. | |
39 static bool LogMessageHandler(int severity, const std::string& str) { | |
40 daemon_test_->daemon_log_.append(str); | |
41 daemon_test_->daemon_log_.append("\n"); | |
42 | |
43 // Returning true would mute the log. | |
44 return false; | |
45 } | |
46 | |
47 // Returns true if the daemon log contains |pattern|, false otherwise. | |
48 bool LogContains(const std::string& pattern) { | |
49 return daemon_log_.find(pattern) != std::string::npos; | |
50 } | |
51 | |
52 // Resets the daemon log history to empty. | |
53 void LogReset() { | |
54 daemon_log_.clear(); | |
55 } | |
56 | |
57 // Returns true if the specified metric is found in the generated | |
58 // log so far, false otherwise. | |
59 bool AssertMetricGenerated(const std::string& name, int sample, | |
60 int min, int max, int buckets) { | |
61 return LogContains(StringPrintf("received metric: %s %d %d %d %d", | |
62 name.c_str(), sample, min, max, buckets)); | |
63 } | |
64 | |
65 // Returns true if the specified daily use time metric is found in | |
66 // the generated log so far, false otherwise. | |
67 bool AssertDailyUseTimeMetric(int sample) { | |
68 return AssertMetricGenerated( | |
69 MetricsDaemon::kMetricDailyUseTimeName, sample, | |
70 MetricsDaemon::kMetricDailyUseTimeMin, | |
71 MetricsDaemon::kMetricDailyUseTimeMax, | |
72 MetricsDaemon::kMetricDailyUseTimeBuckets); | |
73 } | |
74 | |
75 // Returns true if the specified time to network drop metric is | |
76 // found in the generated log so far, false otherwise. | |
77 bool AssertTimeToNetworkDropMetric(int sample) { | |
78 return AssertMetricGenerated( | |
79 MetricsDaemon::kMetricTimeToNetworkDropName, sample, | |
80 MetricsDaemon::kMetricTimeToNetworkDropMin, | |
81 MetricsDaemon::kMetricTimeToNetworkDropMax, | |
82 MetricsDaemon::kMetricTimeToNetworkDropBuckets); | |
83 } | |
84 | |
85 // Returns true if no metric can be found in the generated log so | |
86 // far, false otherwise. | |
87 bool NoMetricGenerated() { | |
88 return !LogContains("received metric"); | |
89 } | |
90 | |
91 // Asserts that the daily use record file contains the specified | |
92 // contents. | |
93 testing::AssertionResult AssertDailyUseRecord(const char* expr_day, | |
94 const char* expr_seconds, | |
95 int expected_day, | |
96 int expected_seconds) { | |
97 int fd = HANDLE_EINTR(open(daemon_.daily_use_record_file_, O_RDONLY)); | |
98 if (fd < 0) { | |
99 testing::Message msg; | |
100 msg << "Unable to open " << daemon_.daily_use_record_file_; | |
101 return testing::AssertionFailure(msg); | |
102 } | |
103 | |
104 MetricsDaemon::UseRecord record; | |
105 if (!file_util::ReadFromFD(fd, reinterpret_cast<char*>(&record), | |
106 sizeof(record))) { | |
107 testing::Message msg; | |
108 msg << "Unable to read " << sizeof(record) << " bytes from " | |
109 << daemon_.daily_use_record_file_; | |
110 HANDLE_EINTR(close(fd)); | |
111 return testing::AssertionFailure(msg); | |
112 } | |
113 | |
114 if (record.day_ != expected_day || record.seconds_ != expected_seconds) { | |
115 testing::Message msg; | |
116 msg << "actual use record (" << record.day_ << ", " << record.seconds_ | |
117 << ") expected (" << expected_day << ", " << expected_seconds << ")"; | |
118 HANDLE_EINTR(close(fd)); | |
119 return testing::AssertionFailure(msg); | |
120 } | |
121 | |
122 HANDLE_EINTR(close(fd)); | |
123 return testing::AssertionSuccess(); | |
124 } | |
125 | |
126 bool NoOrEmptyUseRecordFile() { | |
kmixter1
2010/05/10 19:06:31
Function names should start with verb
| |
127 FilePath record_file(daemon_.daily_use_record_file_); | |
128 int64 record_file_size; | |
129 return !file_util::PathExists(record_file) || | |
130 (file_util::GetFileSize(record_file, &record_file_size) && | |
131 record_file_size == 0); | |
132 } | |
133 | |
134 // Pointer to the current test fixture. | |
135 static MetricsDaemonTest* daemon_test_; | |
136 | |
137 // The MetricsDaemon under test. | |
138 MetricsDaemon daemon_; | |
139 | |
140 // The accumulated metrics daemon log. | |
141 std::string daemon_log_; | |
142 }; | |
143 | |
144 // static | |
145 MetricsDaemonTest* MetricsDaemonTest::daemon_test_ = NULL; | |
146 | |
147 TEST_F(MetricsDaemonTest, LogDailyUseRecord) { | |
148 EXPECT_EQ(0, daemon_.daily_use_day_last_); | |
149 EXPECT_TRUE(NoOrEmptyUseRecordFile()); | |
150 | |
151 daemon_.LogDailyUseRecord(/* day */ 5, /* seconds */ 120); | |
152 EXPECT_PRED_FORMAT2(AssertDailyUseRecord, /* day */ 5, /* seconds */ 120); | |
153 EXPECT_EQ(5, daemon_.daily_use_day_last_); | |
154 | |
155 daemon_.LogDailyUseRecord(/* day */ 5, /* seconds */ 0); | |
156 EXPECT_PRED_FORMAT2(AssertDailyUseRecord, /* day */ 5, /* seconds */ 120); | |
157 EXPECT_EQ(5, daemon_.daily_use_day_last_); | |
158 | |
159 daemon_.LogDailyUseRecord(/* day */ 5, /* seconds */ 240); | |
160 EXPECT_PRED_FORMAT2(AssertDailyUseRecord, /* day */ 5, /* seconds */ 360); | |
161 EXPECT_EQ(5, daemon_.daily_use_day_last_); | |
162 | |
163 EXPECT_TRUE(NoMetricGenerated()); | |
164 | |
165 LogReset(); | |
166 daemon_.LogDailyUseRecord(/* day */ 6, /* seconds */ 0); | |
167 EXPECT_TRUE(NoOrEmptyUseRecordFile()); | |
168 EXPECT_TRUE(AssertDailyUseTimeMetric(/* sample */ 6)); | |
169 EXPECT_EQ(6, daemon_.daily_use_day_last_); | |
170 | |
171 // Tests rounding use time to the closest minute. | |
172 daemon_.LogDailyUseRecord(/* day */ 6, /* seconds */ 90); | |
173 EXPECT_PRED_FORMAT2(AssertDailyUseRecord, /* day */ 6, /* seconds */ 90); | |
174 EXPECT_EQ(6, daemon_.daily_use_day_last_); | |
175 | |
176 LogReset(); | |
177 daemon_.LogDailyUseRecord(/* day */ 7, /* seconds */ 89); | |
178 EXPECT_PRED_FORMAT2(AssertDailyUseRecord, /* day */ 7, /* seconds */ 89); | |
179 EXPECT_TRUE(AssertDailyUseTimeMetric(/* sample */ 2)); | |
180 EXPECT_EQ(7, daemon_.daily_use_day_last_); | |
181 | |
182 LogReset(); | |
183 daemon_.LogDailyUseRecord(/* day */ 6, /* seconds */ 15); | |
184 EXPECT_PRED_FORMAT2(AssertDailyUseRecord, /* day */ 6, /* seconds */ 15); | |
185 EXPECT_TRUE(AssertDailyUseTimeMetric(/* sample */ 1)); | |
186 EXPECT_EQ(6, daemon_.daily_use_day_last_); | |
187 | |
188 // Checks that the daemon doesn't die badly if the file can't be | |
189 // created. | |
190 LogReset(); | |
191 daemon_.daily_use_record_file_ = kDoesNotExistFile; | |
192 daemon_.LogDailyUseRecord(10, 20); | |
193 EXPECT_TRUE(LogContains("Unable to open the daily use file: " | |
194 "No such file or directory")); | |
195 EXPECT_EQ(6, daemon_.daily_use_day_last_); | |
196 file_util::Delete(FilePath(kDoesNotExistFile), false); | |
197 } | |
198 | |
199 TEST_F(MetricsDaemonTest, LookupNetworkState) { | |
200 EXPECT_EQ(MetricsDaemon::kNetworkStateOnline, | |
201 daemon_.LookupNetworkState("online")); | |
202 EXPECT_EQ(MetricsDaemon::kNetworkStateOffline, | |
203 daemon_.LookupNetworkState("offline")); | |
204 EXPECT_EQ(MetricsDaemon::kUnknownNetworkState, | |
205 daemon_.LookupNetworkState("somestate")); | |
206 } | |
207 | |
208 TEST_F(MetricsDaemonTest, LookupPowerState) { | |
209 EXPECT_EQ(MetricsDaemon::kPowerStateOn, | |
210 daemon_.LookupPowerState("on")); | |
211 EXPECT_EQ(MetricsDaemon::kPowerStateMem, | |
212 daemon_.LookupPowerState("mem")); | |
213 EXPECT_EQ(MetricsDaemon::kUnknownPowerState, | |
214 daemon_.LookupPowerState("somestate")); | |
215 } | |
216 | |
217 TEST_F(MetricsDaemonTest, LookupScreenSaverState) { | |
218 EXPECT_EQ(MetricsDaemon::kScreenSaverStateLocked, | |
219 daemon_.LookupScreenSaverState("locked")); | |
220 EXPECT_EQ(MetricsDaemon::kScreenSaverStateUnlocked, | |
221 daemon_.LookupScreenSaverState("unlocked")); | |
222 EXPECT_EQ(MetricsDaemon::kUnknownScreenSaverState, | |
223 daemon_.LookupScreenSaverState("somestate")); | |
224 } | |
225 | |
226 TEST_F(MetricsDaemonTest, LookupSessionState) { | |
227 EXPECT_EQ(MetricsDaemon::kSessionStateStarted, | |
228 daemon_.LookupSessionState("started")); | |
229 EXPECT_EQ(MetricsDaemon::kSessionStateStopped, | |
230 daemon_.LookupSessionState("stopped")); | |
231 EXPECT_EQ(MetricsDaemon::kUnknownSessionState, | |
232 daemon_.LookupSessionState("somestate")); | |
233 } | |
234 | |
235 TEST_F(MetricsDaemonTest, NetStateChanged) { | |
236 EXPECT_EQ(MetricsDaemon::kUnknownNetworkState, daemon_.network_state_); | |
237 EXPECT_EQ(0, daemon_.network_state_last_); | |
238 EXPECT_EQ(MetricsDaemon::kUnknownPowerState, daemon_.power_state_); | |
239 | |
240 daemon_.NetStateChanged("online", /* now */ 10); | |
241 EXPECT_EQ(MetricsDaemon::kNetworkStateOnline, daemon_.network_state_); | |
242 EXPECT_EQ(10, daemon_.network_state_last_); | |
243 | |
244 EXPECT_TRUE(NoMetricGenerated()); | |
245 | |
246 daemon_.NetStateChanged("offline", /* now */ 30); | |
247 EXPECT_EQ(MetricsDaemon::kNetworkStateOffline, daemon_.network_state_); | |
248 EXPECT_EQ(30, daemon_.network_state_last_); | |
249 EXPECT_TRUE(AssertTimeToNetworkDropMetric(/* sample */ 20)); | |
250 | |
251 LogReset(); | |
252 daemon_.NetStateChanged("online", /* now */ 60); | |
253 EXPECT_EQ(MetricsDaemon::kNetworkStateOnline, daemon_.network_state_); | |
254 EXPECT_EQ(60, daemon_.network_state_last_); | |
255 | |
256 daemon_.PowerStateChanged("mem", /* now */ 80); | |
257 EXPECT_EQ(MetricsDaemon::kPowerStateMem, daemon_.power_state_); | |
258 EXPECT_EQ(MetricsDaemon::kNetworkStateOnline, daemon_.network_state_); | |
259 EXPECT_EQ(60, daemon_.network_state_last_); | |
260 | |
261 daemon_.NetStateChanged("offline", /* now */ 85); | |
262 EXPECT_EQ(MetricsDaemon::kNetworkStateOffline, daemon_.network_state_); | |
263 EXPECT_EQ(85, daemon_.network_state_last_); | |
264 | |
265 daemon_.NetStateChanged("somestate", /* now */ 90); | |
266 EXPECT_EQ(MetricsDaemon::kUnknownNetworkState, daemon_.network_state_); | |
267 EXPECT_EQ(90, daemon_.network_state_last_); | |
268 | |
269 daemon_.NetStateChanged("offline", /* now */ 95); | |
270 EXPECT_EQ(MetricsDaemon::kNetworkStateOffline, daemon_.network_state_); | |
271 EXPECT_EQ(95, daemon_.network_state_last_); | |
272 | |
273 daemon_.PowerStateChanged("on", /* now */ 100); | |
274 EXPECT_EQ(MetricsDaemon::kPowerStateOn, daemon_.power_state_); | |
275 EXPECT_EQ(MetricsDaemon::kNetworkStateOffline, daemon_.network_state_); | |
276 EXPECT_EQ(95, daemon_.network_state_last_); | |
277 | |
278 daemon_.NetStateChanged("online", /* now */ 105); | |
279 EXPECT_EQ(MetricsDaemon::kNetworkStateOnline, daemon_.network_state_); | |
280 EXPECT_EQ(105, daemon_.network_state_last_); | |
281 | |
282 EXPECT_TRUE(NoMetricGenerated()); | |
283 | |
284 daemon_.NetStateChanged("offline", /* now */ 108); | |
285 EXPECT_EQ(MetricsDaemon::kNetworkStateOffline, daemon_.network_state_); | |
286 EXPECT_EQ(108, daemon_.network_state_last_); | |
287 EXPECT_TRUE(AssertTimeToNetworkDropMetric(/* sample */ 3)); | |
288 } | |
289 | |
290 TEST_F(MetricsDaemonTest, PowerStateChanged) { | |
291 EXPECT_EQ(MetricsDaemon::kUnknownPowerState, daemon_.power_state_); | |
292 EXPECT_FALSE(daemon_.user_active_); | |
293 EXPECT_EQ(0, daemon_.user_active_last_); | |
294 EXPECT_EQ(0, daemon_.daily_use_day_last_); | |
295 EXPECT_TRUE(NoOrEmptyUseRecordFile()); | |
296 | |
297 daemon_.SetUserActiveState(/* active */ true, 7 * kSecondsPerDay + 15); | |
298 EXPECT_TRUE(daemon_.user_active_); | |
299 EXPECT_EQ(7 * kSecondsPerDay + 15, daemon_.user_active_last_); | |
300 EXPECT_EQ(7, daemon_.daily_use_day_last_); | |
301 EXPECT_TRUE(NoOrEmptyUseRecordFile()); | |
302 | |
303 daemon_.PowerStateChanged("mem", 7 * kSecondsPerDay + 45); | |
304 EXPECT_EQ(MetricsDaemon::kPowerStateMem, daemon_.power_state_); | |
305 EXPECT_FALSE(daemon_.user_active_); | |
306 EXPECT_EQ(7 * kSecondsPerDay + 45, daemon_.user_active_last_); | |
307 EXPECT_PRED_FORMAT2(AssertDailyUseRecord, /* day */ 7, /* seconds */ 30); | |
308 | |
309 daemon_.PowerStateChanged("on", 7 * kSecondsPerDay + 85); | |
310 EXPECT_EQ(MetricsDaemon::kPowerStateOn, daemon_.power_state_); | |
311 EXPECT_FALSE(daemon_.user_active_); | |
312 EXPECT_EQ(7 * kSecondsPerDay + 45, daemon_.user_active_last_); | |
313 EXPECT_PRED_FORMAT2(AssertDailyUseRecord, /* day */ 7, /* seconds */ 30); | |
314 | |
315 daemon_.PowerStateChanged("otherstate", 7 * kSecondsPerDay + 185); | |
316 EXPECT_EQ(MetricsDaemon::kUnknownPowerState, daemon_.power_state_); | |
317 EXPECT_FALSE(daemon_.user_active_); | |
318 EXPECT_EQ(7 * kSecondsPerDay + 185, daemon_.user_active_last_); | |
319 EXPECT_PRED_FORMAT2(AssertDailyUseRecord, /* day */ 7, /* seconds */ 30); | |
320 | |
321 EXPECT_TRUE(NoMetricGenerated()); | |
322 } | |
323 | |
324 TEST_F(MetricsDaemonTest, PublishMetric) { | |
325 daemon_.PublishMetric("Dummy.Metric", /* sample */ 3, | |
326 /* min */ 1, /* max */ 100, /* buckets */ 50); | |
327 EXPECT_TRUE(AssertMetricGenerated("Dummy.Metric", 3, 1, 100, 50)); | |
328 } | |
329 | |
330 TEST_F(MetricsDaemonTest, ScreenSaverStateChanged) { | |
331 EXPECT_EQ(MetricsDaemon::kUnknownScreenSaverState, | |
332 daemon_.screensaver_state_); | |
333 EXPECT_FALSE(daemon_.user_active_); | |
334 EXPECT_EQ(0, daemon_.user_active_last_); | |
335 EXPECT_EQ(0, daemon_.daily_use_day_last_); | |
336 EXPECT_TRUE(NoOrEmptyUseRecordFile()); | |
337 | |
338 daemon_.ScreenSaverStateChanged("locked", 5 * kSecondsPerDay + 10); | |
339 EXPECT_EQ(MetricsDaemon::kScreenSaverStateLocked, | |
340 daemon_.screensaver_state_); | |
341 EXPECT_FALSE(daemon_.user_active_); | |
342 EXPECT_EQ(5 * kSecondsPerDay + 10, daemon_.user_active_last_); | |
343 EXPECT_EQ(5, daemon_.daily_use_day_last_); | |
344 EXPECT_TRUE(NoOrEmptyUseRecordFile()); | |
345 | |
346 daemon_.ScreenSaverStateChanged("unlocked", 5 * kSecondsPerDay + 100); | |
347 EXPECT_EQ(MetricsDaemon::kScreenSaverStateUnlocked, | |
348 daemon_.screensaver_state_); | |
349 EXPECT_TRUE(daemon_.user_active_); | |
350 EXPECT_EQ(5 * kSecondsPerDay + 100, daemon_.user_active_last_); | |
351 EXPECT_TRUE(NoOrEmptyUseRecordFile()); | |
352 | |
353 daemon_.ScreenSaverStateChanged("otherstate", 5 * kSecondsPerDay + 300); | |
354 EXPECT_EQ(MetricsDaemon::kUnknownScreenSaverState, | |
355 daemon_.screensaver_state_); | |
356 EXPECT_FALSE(daemon_.user_active_); | |
357 EXPECT_EQ(5 * kSecondsPerDay + 300, daemon_.user_active_last_); | |
358 EXPECT_PRED_FORMAT2(AssertDailyUseRecord, /* day */ 5, /* seconds */ 200); | |
359 | |
360 EXPECT_TRUE(NoMetricGenerated()); | |
361 } | |
362 | |
363 TEST_F(MetricsDaemonTest, SessionStateChanged) { | |
364 EXPECT_EQ(MetricsDaemon::kUnknownSessionState, daemon_.session_state_); | |
365 EXPECT_FALSE(daemon_.user_active_); | |
366 EXPECT_EQ(0, daemon_.user_active_last_); | |
367 EXPECT_EQ(0, daemon_.daily_use_day_last_); | |
368 EXPECT_TRUE(NoOrEmptyUseRecordFile()); | |
369 | |
370 daemon_.SessionStateChanged("started", 15 * kSecondsPerDay + 20); | |
371 EXPECT_EQ(MetricsDaemon::kSessionStateStarted, daemon_.session_state_); | |
372 EXPECT_TRUE(daemon_.user_active_); | |
373 EXPECT_EQ(15 * kSecondsPerDay + 20, daemon_.user_active_last_); | |
374 EXPECT_EQ(15, daemon_.daily_use_day_last_); | |
375 EXPECT_TRUE(NoOrEmptyUseRecordFile()); | |
376 | |
377 daemon_.SessionStateChanged("stopped", 15 * kSecondsPerDay + 150); | |
378 EXPECT_EQ(MetricsDaemon::kSessionStateStopped, daemon_.session_state_); | |
379 EXPECT_FALSE(daemon_.user_active_); | |
380 EXPECT_EQ(15 * kSecondsPerDay + 150, daemon_.user_active_last_); | |
381 EXPECT_PRED_FORMAT2(AssertDailyUseRecord, /* day */ 15, /* seconds */ 130); | |
382 | |
383 daemon_.SessionStateChanged("otherstate", 15 * kSecondsPerDay + 300); | |
384 EXPECT_EQ(MetricsDaemon::kUnknownSessionState, daemon_.session_state_); | |
385 EXPECT_FALSE(daemon_.user_active_); | |
386 EXPECT_EQ(15 * kSecondsPerDay + 300, daemon_.user_active_last_); | |
387 EXPECT_PRED_FORMAT2(AssertDailyUseRecord, /* day */ 15, /* seconds */ 130); | |
388 | |
389 EXPECT_TRUE(NoMetricGenerated()); | |
390 } | |
391 | |
392 TEST_F(MetricsDaemonTest, SetUserActiveState) { | |
393 EXPECT_FALSE(daemon_.user_active_); | |
394 EXPECT_EQ(0, daemon_.user_active_last_); | |
395 EXPECT_EQ(0, daemon_.daily_use_day_last_); | |
396 EXPECT_TRUE(NoOrEmptyUseRecordFile()); | |
397 | |
398 daemon_.SetUserActiveState(/* active */ false, 5 * kSecondsPerDay + 10); | |
399 EXPECT_FALSE(daemon_.user_active_); | |
400 EXPECT_EQ(5 * kSecondsPerDay + 10, daemon_.user_active_last_); | |
401 EXPECT_EQ(5, daemon_.daily_use_day_last_); | |
402 EXPECT_TRUE(NoOrEmptyUseRecordFile()); | |
403 | |
404 daemon_.SetUserActiveState(/* active */ true, 6 * kSecondsPerDay + 20); | |
405 EXPECT_TRUE(daemon_.user_active_); | |
406 EXPECT_EQ(6 * kSecondsPerDay + 20, daemon_.user_active_last_); | |
407 EXPECT_EQ(6, daemon_.daily_use_day_last_); | |
408 EXPECT_TRUE(NoOrEmptyUseRecordFile()); | |
409 | |
410 daemon_.SetUserActiveState(/* active */ true, 6 * kSecondsPerDay + 120); | |
411 EXPECT_TRUE(daemon_.user_active_); | |
412 EXPECT_EQ(6 * kSecondsPerDay + 120, daemon_.user_active_last_); | |
413 EXPECT_EQ(6, daemon_.daily_use_day_last_); | |
414 EXPECT_PRED_FORMAT2(AssertDailyUseRecord, /* day */ 6, /* seconds */ 100); | |
415 | |
416 daemon_.SetUserActiveState(/* active */ false, 6 * kSecondsPerDay + 220); | |
417 EXPECT_FALSE(daemon_.user_active_); | |
418 EXPECT_EQ(6 * kSecondsPerDay + 220, daemon_.user_active_last_); | |
419 EXPECT_EQ(6, daemon_.daily_use_day_last_); | |
420 EXPECT_PRED_FORMAT2(AssertDailyUseRecord, /* day */ 6, /* seconds */ 200); | |
421 | |
422 EXPECT_TRUE(NoMetricGenerated()); | |
423 | |
424 LogReset(); | |
425 daemon_.SetUserActiveState(/* active */ true, 8 * kSecondsPerDay - 300); | |
426 EXPECT_TRUE(daemon_.user_active_); | |
427 EXPECT_EQ(8 * kSecondsPerDay - 300, daemon_.user_active_last_); | |
428 EXPECT_EQ(7, daemon_.daily_use_day_last_); | |
429 EXPECT_TRUE(NoOrEmptyUseRecordFile()); | |
430 EXPECT_TRUE(AssertDailyUseTimeMetric(/* sample */ 3)); | |
431 | |
432 LogReset(); | |
433 daemon_.SetUserActiveState(/* active */ false, 8 * kSecondsPerDay + 300); | |
434 EXPECT_FALSE(daemon_.user_active_); | |
435 EXPECT_EQ(8 * kSecondsPerDay + 300, daemon_.user_active_last_); | |
436 EXPECT_EQ(8, daemon_.daily_use_day_last_); | |
437 EXPECT_PRED_FORMAT2(AssertDailyUseRecord, /* day */ 8, /* seconds */ 600); | |
438 | |
439 daemon_.SetUserActiveState(/* active */ true, 9 * kSecondsPerDay - 400); | |
440 EXPECT_TRUE(daemon_.user_active_); | |
441 EXPECT_EQ(9 * kSecondsPerDay - 400, daemon_.user_active_last_); | |
442 EXPECT_EQ(8, daemon_.daily_use_day_last_); | |
443 EXPECT_PRED_FORMAT2(AssertDailyUseRecord, /* day */ 8, /* seconds */ 600); | |
444 | |
445 EXPECT_TRUE(NoMetricGenerated()); | |
446 | |
447 LogReset(); | |
448 daemon_.SetUserActiveState(/* active */ true, 9 * kSecondsPerDay + 400); | |
449 EXPECT_TRUE(daemon_.user_active_); | |
450 EXPECT_EQ(9 * kSecondsPerDay + 400, daemon_.user_active_last_); | |
451 EXPECT_EQ(9, daemon_.daily_use_day_last_); | |
452 EXPECT_PRED_FORMAT2(AssertDailyUseRecord, /* day */ 9, /* seconds */ 800); | |
453 EXPECT_TRUE(AssertDailyUseTimeMetric(/* sample */ 10)); | |
454 } | |
455 | |
456 int main(int argc, char **argv) { | |
457 testing::InitGoogleTest(&argc, argv); | |
458 return RUN_ALL_TESTS(); | |
459 } | |
OLD | NEW |