1 /*
2 * Copyright (c) 2022-2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "stats_util_test.h"
17 #include "stats_log.h"
18
19 #include "battery_stats_parser.h"
20 #include "stats_helper.h"
21 #include "stats_hisysevent.h"
22 #include "stats_utils.h"
23
24 using namespace testing::ext;
25 using namespace OHOS::PowerMgr;
26 using namespace std;
27
SetUpTestCase()28 void StatsUtilTest::SetUpTestCase()
29 {
30 }
31
TearDownTestCase()32 void StatsUtilTest::TearDownTestCase()
33 {
34 }
35
SetUp()36 void StatsUtilTest::SetUp()
37 {
38 StatsHelper::SetOnBattery(true);
39 }
40
TearDown()41 void StatsUtilTest::TearDown()
42 {
43 StatsHelper::SetOnBattery(false);
44 }
45
46 namespace {
47 /**
48 * @tc.name: StatsHiSysEvent_001
49 * @tc.desc: test StatsHiSysEvent function
50 * @tc.type: FUNC
51 * @tc.require: issueI5X13X
52 */
53 HWTEST_F (StatsUtilTest, StatsHiSysEvent_001, TestSize.Level0)
54 {
55 STATS_HILOGI(LABEL_TEST, "StatsHiSysEvent_001 start");
56 EXPECT_TRUE(StatsHiSysEvent::CheckHiSysEvent(StatsHiSysEvent::POWER_RUNNINGLOCK));
57 EXPECT_FALSE(StatsHiSysEvent::CheckHiSysEvent("POWER_RUNNINGLOCK_WRONG"));
58 STATS_HILOGI(LABEL_TEST, "StatsHiSysEvent_001 end");
59 }
60
61 /**
62 * @tc.name: StatsUtils_001
63 * @tc.desc: test class StatsUtils ConvertStatsType function
64 * @tc.type: FUNC
65 * @tc.require: issueI5X13X
66 */
67 HWTEST_F (StatsUtilTest, StatsUtils_001, TestSize.Level0)
68 {
69 STATS_HILOGI(LABEL_TEST, "StatsUtils_001 start");
70 EXPECT_EQ("", StatsUtils::ConvertStatsType(StatsUtils::StatsType::STATS_TYPE_INVALID));
71 EXPECT_EQ(GET_VARIABLE_NAME(STATS_TYPE_BLUETOOTH_BR_ON),
72 StatsUtils::ConvertStatsType(StatsUtils::StatsType::STATS_TYPE_BLUETOOTH_BR_ON));
73 EXPECT_EQ(GET_VARIABLE_NAME(STATS_TYPE_BLUETOOTH_BR_SCAN),
74 StatsUtils::ConvertStatsType(StatsUtils::StatsType::STATS_TYPE_BLUETOOTH_BR_SCAN));
75 EXPECT_EQ(GET_VARIABLE_NAME(STATS_TYPE_BLUETOOTH_BLE_ON),
76 StatsUtils::ConvertStatsType(StatsUtils::StatsType::STATS_TYPE_BLUETOOTH_BLE_ON));
77 EXPECT_EQ(GET_VARIABLE_NAME(STATS_TYPE_BLUETOOTH_BLE_SCAN),
78 StatsUtils::ConvertStatsType(StatsUtils::StatsType::STATS_TYPE_BLUETOOTH_BLE_SCAN));
79 EXPECT_EQ(GET_VARIABLE_NAME(STATS_TYPE_WIFI_ON),
80 StatsUtils::ConvertStatsType(StatsUtils::StatsType::STATS_TYPE_WIFI_ON));
81 EXPECT_EQ(GET_VARIABLE_NAME(STATS_TYPE_WIFI_SCAN),
82 StatsUtils::ConvertStatsType(StatsUtils::StatsType::STATS_TYPE_WIFI_SCAN));
83 EXPECT_EQ(GET_VARIABLE_NAME(STATS_TYPE_PHONE_ACTIVE),
84 StatsUtils::ConvertStatsType(StatsUtils::StatsType::STATS_TYPE_PHONE_ACTIVE));
85 EXPECT_EQ(GET_VARIABLE_NAME(STATS_TYPE_PHONE_DATA),
86 StatsUtils::ConvertStatsType(StatsUtils::StatsType::STATS_TYPE_PHONE_DATA));
87 EXPECT_EQ(GET_VARIABLE_NAME(STATS_TYPE_BATTERY),
88 StatsUtils::ConvertStatsType(StatsUtils::StatsType::STATS_TYPE_BATTERY));
89 EXPECT_EQ(GET_VARIABLE_NAME(STATS_TYPE_WORKSCHEDULER),
90 StatsUtils::ConvertStatsType(StatsUtils::StatsType::STATS_TYPE_WORKSCHEDULER));
91 EXPECT_EQ(GET_VARIABLE_NAME(STATS_TYPE_THERMAL),
92 StatsUtils::ConvertStatsType(StatsUtils::StatsType::STATS_TYPE_THERMAL));
93 EXPECT_EQ(GET_VARIABLE_NAME(STATS_TYPE_DISTRIBUTEDSCHEDULER),
94 StatsUtils::ConvertStatsType(StatsUtils::StatsType::STATS_TYPE_DISTRIBUTEDSCHEDULER));
95 STATS_HILOGI(LABEL_TEST, "StatsUtils_001 end");
96 }
97
98 /**
99 * @tc.name: StatsUtils_002
100 * @tc.desc: test class StatsUtils ConvertStatsType function
101 * @tc.type: FUNC
102 * @tc.require: issueI5X13X
103 */
104 HWTEST_F (StatsUtilTest, StatsUtils_002, TestSize.Level0)
105 {
106 STATS_HILOGI(LABEL_TEST, "StatsUtils_002 start");
107 EXPECT_EQ(GET_VARIABLE_NAME(STATS_TYPE_CAMERA_ON),
108 StatsUtils::ConvertStatsType(StatsUtils::StatsType::STATS_TYPE_CAMERA_ON));
109 EXPECT_EQ(GET_VARIABLE_NAME(STATS_TYPE_CAMERA_FLASHLIGHT_ON),
110 StatsUtils::ConvertStatsType(StatsUtils::StatsType::STATS_TYPE_CAMERA_FLASHLIGHT_ON));
111 EXPECT_EQ(GET_VARIABLE_NAME(STATS_TYPE_FLASHLIGHT_ON),
112 StatsUtils::ConvertStatsType(StatsUtils::StatsType::STATS_TYPE_FLASHLIGHT_ON));
113 EXPECT_EQ(GET_VARIABLE_NAME(STATS_TYPE_GNSS_ON),
114 StatsUtils::ConvertStatsType(StatsUtils::StatsType::STATS_TYPE_GNSS_ON));
115 EXPECT_EQ(GET_VARIABLE_NAME(STATS_TYPE_SENSOR_GRAVITY_ON),
116 StatsUtils::ConvertStatsType(StatsUtils::StatsType::STATS_TYPE_SENSOR_GRAVITY_ON));
117 EXPECT_EQ(GET_VARIABLE_NAME(STATS_TYPE_SENSOR_PROXIMITY_ON),
118 StatsUtils::ConvertStatsType(StatsUtils::StatsType::STATS_TYPE_SENSOR_PROXIMITY_ON));
119 EXPECT_EQ(GET_VARIABLE_NAME(STATS_TYPE_AUDIO_ON),
120 StatsUtils::ConvertStatsType(StatsUtils::StatsType::STATS_TYPE_AUDIO_ON));
121 EXPECT_EQ(GET_VARIABLE_NAME(STATS_TYPE_SCREEN_ON),
122 StatsUtils::ConvertStatsType(StatsUtils::StatsType::STATS_TYPE_SCREEN_ON));
123 EXPECT_EQ(GET_VARIABLE_NAME(STATS_TYPE_SCREEN_BRIGHTNESS),
124 StatsUtils::ConvertStatsType(StatsUtils::StatsType::STATS_TYPE_SCREEN_BRIGHTNESS));
125 EXPECT_EQ(GET_VARIABLE_NAME(STATS_TYPE_ALARM),
126 StatsUtils::ConvertStatsType(StatsUtils::StatsType::STATS_TYPE_ALARM));
127 EXPECT_EQ(GET_VARIABLE_NAME(STATS_TYPE_WAKELOCK_HOLD),
128 StatsUtils::ConvertStatsType(StatsUtils::StatsType::STATS_TYPE_WAKELOCK_HOLD));
129 EXPECT_EQ(GET_VARIABLE_NAME(STATS_TYPE_PHONE_IDLE),
130 StatsUtils::ConvertStatsType(StatsUtils::StatsType::STATS_TYPE_PHONE_IDLE));
131 EXPECT_EQ(GET_VARIABLE_NAME(STATS_TYPE_CPU_CLUSTER),
132 StatsUtils::ConvertStatsType(StatsUtils::StatsType::STATS_TYPE_CPU_CLUSTER));
133 EXPECT_EQ(GET_VARIABLE_NAME(STATS_TYPE_CPU_SPEED),
134 StatsUtils::ConvertStatsType(StatsUtils::StatsType::STATS_TYPE_CPU_SPEED));
135 EXPECT_EQ(GET_VARIABLE_NAME(STATS_TYPE_CPU_ACTIVE),
136 StatsUtils::ConvertStatsType(StatsUtils::StatsType::STATS_TYPE_CPU_ACTIVE));
137 EXPECT_EQ(GET_VARIABLE_NAME(STATS_TYPE_CPU_SUSPEND),
138 StatsUtils::ConvertStatsType(StatsUtils::StatsType::STATS_TYPE_CPU_SUSPEND));
139 STATS_HILOGI(LABEL_TEST, "StatsUtils_002 end");
140 }
141
142 /**
143 * @tc.name: StatsUtils_003
144 * @tc.desc: test ParseStrtollResult
145 * @tc.type: FUNC
146 */
147 HWTEST_F(StatsUtilTest, StatsUtils_003, TestSize.Level0)
148 {
149 STATS_HILOGI(LABEL_TEST, "StatsUtils_003 function start!");
150 int64_t result = 0;
151 std::string strfirst = "";
152 EXPECT_EQ(false, StatsUtils::ParseStrtollResult(strfirst, result));
153 result = 0;
154 std::string strsecond = "abc";
155 EXPECT_EQ(false, StatsUtils::ParseStrtollResult(strsecond, result));
156 result = 0;
157 std::string strthird = "abc123";
158 EXPECT_EQ(false, StatsUtils::ParseStrtollResult(strthird, result));
159 result = 0;
160 std::string strfourth = "123abc";
161 EXPECT_EQ(true, StatsUtils::ParseStrtollResult(strfourth, result));
162 result = 0;
163 std::string strfifth = "123";
164 EXPECT_EQ(true, StatsUtils::ParseStrtollResult(strfifth, result));
165 result = 0;
166 std::string strsixth = "12345678999987654321";
167 EXPECT_EQ(false, StatsUtils::ParseStrtollResult(strsixth, result));
168 STATS_HILOGI(LABEL_TEST, "StatsUtils_003 function end!");
169 }
170
171 /**
172 * @tc.name: StatsHelper_001
173 * @tc.desc: test class ActiveTimer function
174 * @tc.type: FUNC
175 * @tc.require: issueI5X13X
176 */
177 HWTEST_F (StatsUtilTest, StatsHelper_001, TestSize.Level0)
178 {
179 STATS_HILOGI(LABEL_TEST, "StatsHelper_001 start");
180 int64_t activeTimeMs = StatsUtils::DEFAULT_VALUE;
181 int64_t devTimeMs = StatsUtils::DEFAULT_VALUE;
182 std::shared_ptr<StatsHelper::ActiveTimer> timer = std::make_shared<StatsHelper::ActiveTimer>();
183 EXPECT_TRUE(timer != nullptr);
184
185 timer->StartRunning();
186 usleep(TIMER_DURATION_MS * US_PER_MS);
187 timer->StopRunning();
188 activeTimeMs = timer->GetRunningTimeMs();
189 devTimeMs = abs(activeTimeMs - TIMER_DURATION_MS);
190 EXPECT_LE(devTimeMs, DEVIATION_TIMER_THRESHOLD);
191
192 int64_t addTimeMs = 20;
193 timer->AddRunningTimeMs(addTimeMs);
194 activeTimeMs = timer->GetRunningTimeMs();
195 devTimeMs = abs(activeTimeMs - TIMER_DURATION_MS - addTimeMs);
196 EXPECT_LE(devTimeMs, DEVIATION_TIMER_THRESHOLD);
197
198 timer->AddRunningTimeMs(StatsUtils::DEFAULT_VALUE);
199 EXPECT_EQ(timer->GetRunningTimeMs(), activeTimeMs);
200
201 timer->Reset();
202 activeTimeMs = timer->GetRunningTimeMs();
203 EXPECT_EQ(activeTimeMs, StatsUtils::DEFAULT_VALUE);
204 STATS_HILOGI(LABEL_TEST, "StatsHelper_001 end");
205 }
206
207 /**
208 * @tc.name: StatsHelper_002
209 * @tc.desc: test class ActiveTimer function
210 * @tc.type: FUNC
211 * @tc.require: issueI5X13X
212 */
213 HWTEST_F (StatsUtilTest, StatsHelper_002, TestSize.Level0)
214 {
215 STATS_HILOGI(LABEL_TEST, "StatsHelper_002 start");
216 int64_t activeTimeMs = StatsUtils::DEFAULT_VALUE;
217 int64_t devTimeMs = StatsUtils::DEFAULT_VALUE;
218 std::shared_ptr<StatsHelper::ActiveTimer> timer = std::make_shared<StatsHelper::ActiveTimer>();
219 EXPECT_TRUE(timer != nullptr);
220
221 timer->StartRunning();
222 usleep(TIMER_DURATION_MS * US_PER_MS);
223 activeTimeMs = timer->GetRunningTimeMs();
224 devTimeMs = abs(activeTimeMs - TIMER_DURATION_MS);
225 EXPECT_LE(devTimeMs, DEVIATION_TIMER_THRESHOLD);
226 timer->StopRunning();
227
228 timer->Reset();
229 activeTimeMs = timer->GetRunningTimeMs();
230 EXPECT_EQ(activeTimeMs, StatsUtils::DEFAULT_VALUE);
231 STATS_HILOGI(LABEL_TEST, "StatsHelper_002 end");
232 }
233
234 /**
235 * @tc.name: StatsHelper_003
236 * @tc.desc: test class ActiveTimer function
237 * @tc.type: FUNC
238 * @tc.require: issueI5X13X
239 */
240 HWTEST_F (StatsUtilTest, StatsHelper_003, TestSize.Level0)
241 {
242 STATS_HILOGI(LABEL_TEST, "StatsHelper_003 start");
243 int64_t activeTimeMs = StatsUtils::DEFAULT_VALUE;
244 int64_t devTimeMs = StatsUtils::DEFAULT_VALUE;
245 std::shared_ptr<StatsHelper::ActiveTimer> timer = std::make_shared<StatsHelper::ActiveTimer>();
246 EXPECT_TRUE(timer != nullptr);
247
248 StatsHelper::SetOnBattery(false);
249 EXPECT_FALSE(StatsHelper::IsOnBattery());
250 timer->StartRunning();
251 usleep(TIMER_DURATION_MS * US_PER_MS);
252 StatsHelper::SetOnBattery(true);
253 EXPECT_TRUE(StatsHelper::IsOnBattery());
254 usleep(TIMER_DURATION_MS * US_PER_MS);
255 timer->StopRunning();
256
257 activeTimeMs = timer->GetRunningTimeMs();
258 devTimeMs = abs(activeTimeMs - TIMER_DURATION_MS);
259 EXPECT_LE(devTimeMs, DEVIATION_TIMER_THRESHOLD);
260
261 timer->Reset();
262 activeTimeMs = timer->GetRunningTimeMs();
263 EXPECT_EQ(activeTimeMs, StatsUtils::DEFAULT_VALUE);
264 STATS_HILOGI(LABEL_TEST, "StatsHelper_003 end");
265 }
266
267 /**
268 * @tc.name: StatsHelper_004
269 * @tc.desc: test class Counter function
270 * @tc.type: FUNC
271 * @tc.require: issueI5X13X
272 */
273 HWTEST_F (StatsUtilTest, StatsHelper_004, TestSize.Level0)
274 {
275 STATS_HILOGI(LABEL_TEST, "StatsHelper_004 start");
276 int64_t activeCount = StatsUtils::DEFAULT_VALUE;
277 int64_t addCount = 20;
278 std::shared_ptr<StatsHelper::Counter> counter = std::make_shared<StatsHelper::Counter>();
279 EXPECT_TRUE(counter != nullptr);
280
281 StatsHelper::SetOnBattery(false);
282 EXPECT_FALSE(StatsHelper::IsOnBattery());
283 counter->AddCount(addCount);
284 counter->AddCount(StatsUtils::DEFAULT_VALUE);
285 StatsHelper::SetOnBattery(true);
286 EXPECT_TRUE(StatsHelper::IsOnBattery());
287 counter->AddCount(addCount);
288
289 activeCount = counter->GetCount();
290 EXPECT_EQ(activeCount, addCount);
291
292 counter->Reset();
293 activeCount = counter->GetCount();
294 EXPECT_EQ(activeCount, StatsUtils::DEFAULT_VALUE);
295 STATS_HILOGI(LABEL_TEST, "StatsHelper_004 end");
296 }
297
298 /**
299 * @tc.name: StatsHelper_005
300 * @tc.desc: test class Counter function
301 * @tc.type: FUNC
302 * @tc.require: issueI5X13X
303 */
304 HWTEST_F (StatsUtilTest, StatsHelper_005, TestSize.Level0)
305 {
306 STATS_HILOGI(LABEL_TEST, "StatsHelper_005 start");
307 StatsHelper::SetOnBattery(false);
308 EXPECT_FALSE(StatsHelper::IsOnBattery());
309 StatsHelper::SetScreenOff(false);
310 EXPECT_FALSE(StatsHelper::IsOnBatteryScreenOff());
311
312 StatsHelper::SetOnBattery(false);
313 EXPECT_FALSE(StatsHelper::IsOnBattery());
314 StatsHelper::SetScreenOff(true);
315 EXPECT_FALSE(StatsHelper::IsOnBatteryScreenOff());
316
317 StatsHelper::SetOnBattery(true);
318 EXPECT_TRUE(StatsHelper::IsOnBattery());
319 StatsHelper::SetScreenOff(false);
320 EXPECT_FALSE(StatsHelper::IsOnBatteryScreenOff());
321
322 StatsHelper::SetOnBattery(true);
323 EXPECT_TRUE(StatsHelper::IsOnBattery());
324 StatsHelper::SetScreenOff(true);
325 EXPECT_TRUE(StatsHelper::IsOnBatteryScreenOff());
326
327 StatsHelper::SetScreenOff(false);
328 STATS_HILOGI(LABEL_TEST, "StatsHelper_005 end");
329 }
330
331 /**
332 * @tc.name: StatsHelper_006
333 * @tc.desc: test class Counter function
334 * @tc.type: FUNC
335 * @tc.require: issueI5X13X
336 */
337 HWTEST_F (StatsUtilTest, StatsHelper_006, TestSize.Level0)
338 {
339 STATS_HILOGI(LABEL_TEST, "StatsHelper_006 start");
340 int64_t timeMs = StatsUtils::DEFAULT_VALUE;
341 int64_t durationTimeMs = StatsUtils::DEFAULT_VALUE;
342 int64_t devTimeMs = StatsUtils::DEFAULT_VALUE;
343 StatsHelper::SetOnBattery(false);
344 EXPECT_FALSE(StatsHelper::IsOnBattery());
345 timeMs = StatsHelper::GetOnBatteryUpTimeMs();
346 usleep(TIMER_DURATION_MS * US_PER_MS);
347 durationTimeMs = abs(StatsHelper::GetOnBatteryUpTimeMs() - timeMs);
348 EXPECT_EQ(durationTimeMs, 0);
349
350 StatsHelper::SetOnBattery(true);
351 EXPECT_TRUE(StatsHelper::IsOnBattery());
352 timeMs = StatsHelper::GetOnBatteryUpTimeMs();
353 usleep(TIMER_DURATION_MS * US_PER_MS);
354 durationTimeMs = abs(StatsHelper::GetOnBatteryUpTimeMs() - timeMs);
355 devTimeMs = abs(durationTimeMs - TIMER_DURATION_MS);
356 EXPECT_LE(devTimeMs, DEVIATION_TIMER_THRESHOLD);
357 STATS_HILOGI(LABEL_TEST, "StatsHelper_006 end");
358 }
359
360 /**
361 * @tc.name: StatsParserTest_001
362 * @tc.desc: test Init
363 * @tc.type: FUNC
364 */
365 HWTEST_F (StatsUtilTest, StatsParserTest_001, TestSize.Level0)
366 {
367 STATS_HILOGI(LABEL_TEST, "StatsParserTest_001 start");
368 auto parser = std::make_shared<BatteryStatsParser>();
369 EXPECT_TRUE(parser != nullptr);
370 bool ret = parser->Init();
371 EXPECT_TRUE(ret);
372 STATS_HILOGI(LABEL_TEST, "StatsParserTest_001 end");
373 }
374 }