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_powermgr_test.h"
17 #include "stats_log.h"
18 #include <call_manager_inner_type.h>
19 #include <hisysevent.h>
20
21 #include "battery_stats_client.h"
22 #include "stats_hisysevent.h"
23
24 using namespace testing::ext;
25 using namespace OHOS::HiviewDFX;
26 using namespace OHOS::PowerMgr;
27 using namespace OHOS::Telephony;
28 using namespace OHOS;
29 using namespace std;
30
31
SetUpTestCase()32 void StatsPowerMgrTest::SetUpTestCase()
33 {
34 ParserAveragePowerFile();
35 system("hidumper -s 3302 -a -u");
36 }
37
TearDownTestCase()38 void StatsPowerMgrTest::TearDownTestCase()
39 {
40 system("hidumper -s 3302 -a -r");
41 }
42
SetUp()43 void StatsPowerMgrTest::SetUp()
44 {
45 auto& statsClient = BatteryStatsClient::GetInstance();
46 statsClient.SetOnBattery(true);
47 }
48
TearDown()49 void StatsPowerMgrTest::TearDown()
50 {
51 auto& statsClient = BatteryStatsClient::GetInstance();
52 statsClient.SetOnBattery(false);
53 }
54
55 namespace {
56 /**
57 * @tc.name: StatsPowerMgrTest_001
58 * @tc.desc: test GetTotalTimeSecond function(Sensor Gravity)
59 * @tc.type: FUNC
60 */
61 HWTEST_F (StatsPowerMgrTest, StatsPowerMgrTest_001, TestSize.Level0)
62 {
63 STATS_HILOGI(LABEL_TEST, "StatsPowerMgrTest_001 start");
64 auto& statsClient = BatteryStatsClient::GetInstance();
65 statsClient.Reset();
66
67 int32_t stateOn = 1;
68 int32_t stateOff = 0;
69 int32_t uid = 10003;
70 int32_t pid = 3458;
71
72 HiSysEventWrite(HiSysEvent::Domain::STATS, StatsHiSysEvent::POWER_SENSOR_GRAVITY,
73 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateOn);
74 usleep(POWER_CONSUMPTION_DURATION_US);
75 HiSysEventWrite(HiSysEvent::Domain::STATS, StatsHiSysEvent::POWER_SENSOR_GRAVITY,
76 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateOff);
77
78 long expectedTime = round(POWER_CONSUMPTION_DURATION_US / US_PER_SECOND);
79 long actualTime = statsClient.GetTotalTimeSecond(StatsUtils::STATS_TYPE_SENSOR_GRAVITY_ON, uid);
80 GTEST_LOG_(INFO) << __func__ << ": expected time = " << expectedTime << " seconds";
81 GTEST_LOG_(INFO) << __func__ << ": actual time = " << actualTime << " seconds";
82 EXPECT_EQ(expectedTime, actualTime);
83 STATS_HILOGI(LABEL_TEST, "StatsPowerMgrTest_001 end");
84 }
85
86 /**
87 * @tc.name: StatsPowerMgrTest_002
88 * @tc.desc: test GetAppStatsMah function(Sensor Gravity)
89 * @tc.type: FUNC
90 */
91 HWTEST_F (StatsPowerMgrTest, StatsPowerMgrTest_002, TestSize.Level0)
92 {
93 STATS_HILOGI(LABEL_TEST, "StatsPowerMgrTest_002 start");
94 auto& statsClient = BatteryStatsClient::GetInstance();
95 statsClient.Reset();
96
97 double sensorGravityOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_SENSOR_GRAVITY);
98 int32_t uid = 10003;
99 int32_t pid = 3458;
100 int32_t stateOn = 1;
101 int32_t stateOff = 0;
102
103 HiSysEventWrite(HiSysEvent::Domain::STATS, StatsHiSysEvent::POWER_SENSOR_GRAVITY,
104 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateOn);
105 usleep(POWER_CONSUMPTION_DURATION_US);
106 HiSysEventWrite(HiSysEvent::Domain::STATS, StatsHiSysEvent::POWER_SENSOR_GRAVITY,
107 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateOff);
108
109 double expectedPower = POWER_CONSUMPTION_DURATION_US * sensorGravityOnAverageMa / US_PER_HOUR;
110 double actualPower = statsClient.GetAppStatsMah(uid);
111 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
112 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
113 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
114 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
115 STATS_HILOGI(LABEL_TEST, "StatsPowerMgrTest_002 end");
116 }
117
118 /**
119 * @tc.name: StatsPowerMgrTest_003
120 * @tc.desc: test GetAppStatsPercent function(Sensor Gravity)
121 * @tc.type: FUNC
122 */
123 HWTEST_F (StatsPowerMgrTest, StatsPowerMgrTest_003, TestSize.Level0)
124 {
125 STATS_HILOGI(LABEL_TEST, "StatsPowerMgrTest_003 start");
126 auto& statsClient = BatteryStatsClient::GetInstance();
127 statsClient.Reset();
128
129 int32_t uid = 10003;
130 int32_t pid = 3458;
131 int32_t stateOn = 1;
132 int32_t stateOff = 0;
133 double fullPercent = 1;
134 double zeroPercent = 0;
135
136 HiSysEventWrite(HiSysEvent::Domain::STATS, StatsHiSysEvent::POWER_SENSOR_GRAVITY,
137 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateOn);
138 usleep(POWER_CONSUMPTION_DURATION_US);
139 HiSysEventWrite(HiSysEvent::Domain::STATS, StatsHiSysEvent::POWER_SENSOR_GRAVITY,
140 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateOff);
141 double actualPercent = statsClient.GetAppStatsPercent(uid);
142 GTEST_LOG_(INFO) << __func__ << ": actual percent = " << actualPercent;
143 EXPECT_TRUE(actualPercent >= zeroPercent && actualPercent <= fullPercent);
144 STATS_HILOGI(LABEL_TEST, "StatsPowerMgrTest_003 end");
145 }
146
147 /**
148 * @tc.name: StatsPowerMgrTest_004
149 * @tc.desc: test GetAppStatsMah(Sensor Gravity) and GetAppStatsPercent(Sensor Proximity) function
150 * @tc.type: FUNC
151 */
152 HWTEST_F (StatsPowerMgrTest, StatsPowerMgrTest_004, TestSize.Level0)
153 {
154 STATS_HILOGI(LABEL_TEST, "StatsPowerMgrTest_004 start");
155 auto& statsClient = BatteryStatsClient::GetInstance();
156 statsClient.Reset();
157
158 double sensorGravityOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_SENSOR_GRAVITY);
159 int32_t uid = 10003;
160 int32_t pid = 3458;
161 int32_t stateOn = 1;
162 int32_t stateOff = 0;
163
164 HiSysEventWrite(HiSysEvent::Domain::STATS, StatsHiSysEvent::POWER_SENSOR_GRAVITY,
165 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateOn);
166 usleep(POWER_CONSUMPTION_DURATION_US);
167 HiSysEventWrite(HiSysEvent::Domain::STATS, StatsHiSysEvent::POWER_SENSOR_GRAVITY,
168 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateOff);
169
170 double expectedPower = POWER_CONSUMPTION_DURATION_US * sensorGravityOnAverageMa / US_PER_HOUR;
171 double actualPower = statsClient.GetAppStatsMah(uid);
172 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
173 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
174 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
175 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
176
177 uid = 10004;
178 pid = 3459;
179 stateOn = 1;
180 stateOff = 0;
181 double fullPercent = 1;
182 double zeroPercent = 0;
183
184 HiSysEventWrite(HiSysEvent::Domain::STATS, StatsHiSysEvent::POWER_SENSOR_PROXIMITY,
185 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateOn);
186 usleep(POWER_CONSUMPTION_DURATION_US);
187 HiSysEventWrite(HiSysEvent::Domain::STATS, StatsHiSysEvent::POWER_SENSOR_PROXIMITY,
188 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateOff);
189 double actualPercent = statsClient.GetAppStatsPercent(uid);
190 GTEST_LOG_(INFO) << __func__ << ": actual percent = " << actualPercent;
191 EXPECT_TRUE(actualPercent >= zeroPercent && actualPercent <= fullPercent);
192 STATS_HILOGI(LABEL_TEST, "StatsPowerMgrTest_004 end");
193 }
194
195 /**
196 * @tc.name: StatsPowerMgrTest_005
197 * @tc.desc: test GetTotalTimeSecond function(Sensor Proximity)
198 * @tc.type: FUNC
199 */
200 HWTEST_F (StatsPowerMgrTest, StatsPowerMgrTest_005, TestSize.Level0)
201 {
202 STATS_HILOGI(LABEL_TEST, "StatsPowerMgrTest_005 start");
203 auto& statsClient = BatteryStatsClient::GetInstance();
204 statsClient.Reset();
205
206 int32_t stateOn = 1;
207 int32_t stateOff = 0;
208 int32_t uid = 10003;
209 int32_t pid = 3458;
210
211 HiSysEventWrite(HiSysEvent::Domain::STATS, StatsHiSysEvent::POWER_SENSOR_PROXIMITY,
212 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateOn);
213 usleep(POWER_CONSUMPTION_DURATION_US);
214 HiSysEventWrite(HiSysEvent::Domain::STATS, StatsHiSysEvent::POWER_SENSOR_PROXIMITY,
215 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateOff);
216
217 double expectedPower = StatsUtils::DEFAULT_VALUE;
218 double actualPower = statsClient.GetTotalTimeSecond(StatsUtils::STATS_TYPE_SENSOR_PROXIMITY_ON, uid);
219 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
220 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
221 EXPECT_EQ(expectedPower, actualPower);
222 STATS_HILOGI(LABEL_TEST, "StatsPowerMgrTest_005 end");
223 }
224
225 /**
226 * @tc.name: StatsPowerMgrTest_006
227 * @tc.desc: test GetAppStatsMah function(Sensor Proximity)
228 * @tc.type: FUNC
229 */
230 HWTEST_F (StatsPowerMgrTest, StatsPowerMgrTest_006, TestSize.Level0)
231 {
232 STATS_HILOGI(LABEL_TEST, "StatsPowerMgrTest_006 start");
233 auto& statsClient = BatteryStatsClient::GetInstance();
234 statsClient.Reset();
235
236 double sensorProximityOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_SENSOR_PROXIMITY);
237 int32_t uid = 10003;
238 int32_t pid = 3458;
239 int32_t stateOn = 1;
240 int32_t stateOff = 0;
241
242 HiSysEventWrite(HiSysEvent::Domain::STATS, StatsHiSysEvent::POWER_SENSOR_PROXIMITY,
243 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateOn);
244 usleep(POWER_CONSUMPTION_DURATION_US);
245 HiSysEventWrite(HiSysEvent::Domain::STATS, StatsHiSysEvent::POWER_SENSOR_PROXIMITY,
246 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateOff);
247
248 double expectedPower = POWER_CONSUMPTION_DURATION_US * sensorProximityOnAverageMa / US_PER_HOUR;
249 double actualPower = statsClient.GetAppStatsMah(uid);
250 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
251 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
252 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
253 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
254 STATS_HILOGI(LABEL_TEST, "StatsPowerMgrTest_006 end");
255 }
256
257 /**
258 * @tc.name: StatsPowerMgrTest_007
259 * @tc.desc: test GetAppStatsPercent function(Sensor Proximity)
260 * @tc.type: FUNC
261 */
262 HWTEST_F (StatsPowerMgrTest, StatsPowerMgrTest_007, TestSize.Level0)
263 {
264 STATS_HILOGI(LABEL_TEST, "StatsPowerMgrTest_007 start");
265 auto& statsClient = BatteryStatsClient::GetInstance();
266 statsClient.Reset();
267
268 int32_t uid = 10003;
269 int32_t pid = 3458;
270 int32_t stateOn = 1;
271 int32_t stateOff = 0;
272 double fullPercent = 1;
273 double zeroPercent = 0;
274
275 HiSysEventWrite(HiSysEvent::Domain::STATS, StatsHiSysEvent::POWER_SENSOR_PROXIMITY,
276 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateOn);
277 usleep(POWER_CONSUMPTION_DURATION_US);
278 HiSysEventWrite(HiSysEvent::Domain::STATS, StatsHiSysEvent::POWER_SENSOR_PROXIMITY,
279 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateOff);
280 double actualPercent = statsClient.GetAppStatsPercent(uid);
281 GTEST_LOG_(INFO) << __func__ << ": actual percent = " << actualPercent;
282 EXPECT_TRUE(actualPercent >= zeroPercent && actualPercent <= fullPercent);
283 STATS_HILOGI(LABEL_TEST, "StatsPowerMgrTest_007 end");
284 }
285
286 /**
287 * @tc.name: StatsPowerMgrTest_008
288 * @tc.desc: test GetAppStatsMah(Sensor Proximity) and GetAppStatsPercent(Torch) function
289 * @tc.type: FUNC
290 */
291 HWTEST_F (StatsPowerMgrTest, StatsPowerMgrTest_008, TestSize.Level0)
292 {
293 STATS_HILOGI(LABEL_TEST, "StatsPowerMgrTest_008 start");
294 auto& statsClient = BatteryStatsClient::GetInstance();
295 statsClient.Reset();
296
297 double sensorProximityOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_SENSOR_PROXIMITY);
298 int32_t uid = 10003;
299 int32_t pid = 3458;
300 int32_t stateOn = 1;
301 int32_t stateOff = 0;
302
303 HiSysEventWrite(HiSysEvent::Domain::STATS, StatsHiSysEvent::POWER_SENSOR_PROXIMITY,
304 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateOn);
305 usleep(POWER_CONSUMPTION_DURATION_US);
306 HiSysEventWrite(HiSysEvent::Domain::STATS, StatsHiSysEvent::POWER_SENSOR_PROXIMITY,
307 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateOff);
308
309 double expectedPower = POWER_CONSUMPTION_DURATION_US * sensorProximityOnAverageMa / US_PER_HOUR;
310 double actualPower = statsClient.GetAppStatsMah(uid);
311 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
312 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
313 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
314 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
315
316 uid = 10004;
317 pid = 3459;
318 stateOn = 1;
319 stateOff = 0;
320 double fullPercent = 1;
321 double zeroPercent = 0;
322
323 HiSysEventWrite(HiSysEvent::Domain::CAMERA, StatsHiSysEvent::TORCH_STATE,
324 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateOn);
325 usleep(POWER_CONSUMPTION_DURATION_US);
326 HiSysEventWrite(HiSysEvent::Domain::CAMERA, StatsHiSysEvent::TORCH_STATE,
327 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateOff);
328 double actualPercent = statsClient.GetAppStatsPercent(uid);
329 GTEST_LOG_(INFO) << __func__ << ": actual percent = " << actualPercent;
330 EXPECT_TRUE(actualPercent >= zeroPercent && actualPercent <= fullPercent);
331 STATS_HILOGI(LABEL_TEST, "StatsPowerMgrTest_008 end");
332 }
333
334 /**
335 * @tc.name: BatteryStatsInfo_001
336 * @tc.desc: test class BatteryStatsInfo function
337 * @tc.type: FUNC
338 * @tc.require: issueI5X13X
339 */
340 HWTEST_F (StatsPowerMgrTest, BatteryStatsInfo_001, TestSize.Level0)
341 {
342 STATS_HILOGI(LABEL_TEST, "BatteryStatsInfo_001 start");
343 std::shared_ptr<BatteryStatsInfo> sptrStatsInfo = std::make_shared<BatteryStatsInfo>();
344 EXPECT_NE(sptrStatsInfo, nullptr);
345 int32_t uid = 1004;
346 int32_t userId = 10005;
347 BatteryStatsInfo::ConsumptionType consumptionType = BatteryStatsInfo::CONSUMPTION_TYPE_APP;
348 double totalPowerMah = 1000.0;
349 double partPowerMah = 200.0;
350
351 EXPECT_EQ(StatsUtils::INVALID_VALUE, sptrStatsInfo->GetUid());
352 sptrStatsInfo->SetPower(partPowerMah);
353 EXPECT_EQ(partPowerMah, sptrStatsInfo->GetPower());
354
355 sptrStatsInfo->SetUid(uid);
356 sptrStatsInfo->SetUserId(userId);
357 sptrStatsInfo->SetConsumptioType(consumptionType);
358 sptrStatsInfo->SetPower(totalPowerMah);
359 EXPECT_EQ(uid, sptrStatsInfo->GetUid());
360 EXPECT_EQ(userId, sptrStatsInfo->GetUserId());
361 EXPECT_EQ(consumptionType, sptrStatsInfo->GetConsumptionType());
362 EXPECT_EQ(totalPowerMah, sptrStatsInfo->GetPower());
363
364 sptrStatsInfo->SetUid(StatsUtils::INVALID_VALUE);
365 EXPECT_EQ(uid, sptrStatsInfo->GetUid());
366 sptrStatsInfo->SetUserId(StatsUtils::INVALID_VALUE);
367 EXPECT_EQ(userId, sptrStatsInfo->GetUserId());
368
369 Parcel infoParcel = {};
370 EXPECT_EQ(nullptr, sptrStatsInfo->Unmarshalling(infoParcel));
371
372 sptrStatsInfo->Marshalling(infoParcel);
373 auto unmarshalInfo = sptrStatsInfo->Unmarshalling(infoParcel);
374 EXPECT_EQ(uid, unmarshalInfo->GetUid());
375 EXPECT_EQ(consumptionType, unmarshalInfo->GetConsumptionType());
376 EXPECT_EQ(totalPowerMah, unmarshalInfo->GetPower());
377 STATS_HILOGI(LABEL_TEST, "BatteryStatsInfo_001 end");
378 }
379
380 /**
381 * @tc.name: BatteryStatsInfo_002
382 * @tc.desc: test class ConvertConsumptionType function
383 * @tc.type: FUNC
384 * @tc.require: issueI5X13X
385 */
386 HWTEST_F (StatsPowerMgrTest, BatteryStatsInfo_002, TestSize.Level0)
387 {
388 STATS_HILOGI(LABEL_TEST, "BatteryStatsInfo_002 start");
389 EXPECT_EQ("", BatteryStatsInfo::ConvertConsumptionType(BatteryStatsInfo::CONSUMPTION_TYPE_INVALID));
390 EXPECT_EQ(GET_VARIABLE_NAME(CONSUMPTION_TYPE_APP),
391 BatteryStatsInfo::ConvertConsumptionType(BatteryStatsInfo::CONSUMPTION_TYPE_APP));
392 EXPECT_EQ(GET_VARIABLE_NAME(CONSUMPTION_TYPE_BLUETOOTH),
393 BatteryStatsInfo::ConvertConsumptionType(BatteryStatsInfo::CONSUMPTION_TYPE_BLUETOOTH));
394 EXPECT_EQ(GET_VARIABLE_NAME(CONSUMPTION_TYPE_IDLE),
395 BatteryStatsInfo::ConvertConsumptionType(BatteryStatsInfo::CONSUMPTION_TYPE_IDLE));
396 EXPECT_EQ(GET_VARIABLE_NAME(CONSUMPTION_TYPE_PHONE),
397 BatteryStatsInfo::ConvertConsumptionType(BatteryStatsInfo::CONSUMPTION_TYPE_PHONE));
398 EXPECT_EQ(GET_VARIABLE_NAME(CONSUMPTION_TYPE_SCREEN),
399 BatteryStatsInfo::ConvertConsumptionType(BatteryStatsInfo::CONSUMPTION_TYPE_SCREEN));
400 EXPECT_EQ(GET_VARIABLE_NAME(CONSUMPTION_TYPE_USER),
401 BatteryStatsInfo::ConvertConsumptionType(BatteryStatsInfo::CONSUMPTION_TYPE_USER));
402 EXPECT_EQ(GET_VARIABLE_NAME(CONSUMPTION_TYPE_WIFI),
403 BatteryStatsInfo::ConvertConsumptionType(BatteryStatsInfo::CONSUMPTION_TYPE_WIFI));
404 EXPECT_EQ(GET_VARIABLE_NAME(CONSUMPTION_TYPE_CAMERA),
405 BatteryStatsInfo::ConvertConsumptionType(BatteryStatsInfo::CONSUMPTION_TYPE_CAMERA));
406 EXPECT_EQ(GET_VARIABLE_NAME(CONSUMPTION_TYPE_FLASHLIGHT),
407 BatteryStatsInfo::ConvertConsumptionType(BatteryStatsInfo::CONSUMPTION_TYPE_FLASHLIGHT));
408 EXPECT_EQ(GET_VARIABLE_NAME(CONSUMPTION_TYPE_AUDIO),
409 BatteryStatsInfo::ConvertConsumptionType(BatteryStatsInfo::CONSUMPTION_TYPE_AUDIO));
410 EXPECT_EQ(GET_VARIABLE_NAME(CONSUMPTION_TYPE_SENSOR),
411 BatteryStatsInfo::ConvertConsumptionType(BatteryStatsInfo::CONSUMPTION_TYPE_SENSOR));
412 EXPECT_EQ(GET_VARIABLE_NAME(CONSUMPTION_TYPE_GNSS),
413 BatteryStatsInfo::ConvertConsumptionType(BatteryStatsInfo::CONSUMPTION_TYPE_GNSS));
414 EXPECT_EQ(GET_VARIABLE_NAME(CONSUMPTION_TYPE_CPU),
415 BatteryStatsInfo::ConvertConsumptionType(BatteryStatsInfo::CONSUMPTION_TYPE_CPU));
416 EXPECT_EQ(GET_VARIABLE_NAME(CONSUMPTION_TYPE_WAKELOCK),
417 BatteryStatsInfo::ConvertConsumptionType(BatteryStatsInfo::CONSUMPTION_TYPE_WAKELOCK));
418 EXPECT_EQ(GET_VARIABLE_NAME(CONSUMPTION_TYPE_ALARM),
419 BatteryStatsInfo::ConvertConsumptionType(BatteryStatsInfo::CONSUMPTION_TYPE_ALARM));
420 STATS_HILOGI(LABEL_TEST, "BatteryStatsInfo_002 end");
421 }
422
423 /**
424 * @tc.name: BatteryStatsParser_001
425 * @tc.desc: test class BatteryStatsParser function
426 * @tc.type: FUNC
427 * @tc.require: issueI5X13X
428 */
429 HWTEST_F (StatsPowerMgrTest, BatteryStatsParser_001, TestSize.Level0)
430 {
431 STATS_HILOGI(LABEL_TEST, "BatteryStatsParser_001 start");
432 uint16_t normalLevel = 0;
433 uint16_t errorRadioOnLevel = 10;
434 EXPECT_EQ(0.0, g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_INVALID));
435 EXPECT_EQ(0.0, g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_INVALID, normalLevel));
436 EXPECT_EQ(0.0, g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_RADIO_ON, errorRadioOnLevel));
437
438 uint16_t expectClusterNum = 3;
439 EXPECT_EQ(expectClusterNum, g_statsParser->GetClusterNum());
440
441 uint16_t speedClusterZero = 0;
442 uint16_t expectSpeedCluster0Num = 14;
443 uint16_t errorSpeedCluster = 3;
444 EXPECT_EQ(expectSpeedCluster0Num, g_statsParser->GetSpeedNum(speedClusterZero));
445 EXPECT_EQ(StatsUtils::DEFAULT_VALUE, g_statsParser->GetSpeedNum(errorSpeedCluster));
446 STATS_HILOGI(LABEL_TEST, "BatteryStatsParser_001 end");
447 }
448
449 /**
450 * @tc.name: BatteryStatsRadio_001
451 * @tc.desc: test class BatteryStatsClient function with radio type
452 * @tc.type: FUNC
453 * @tc.require: issueI6ZT17
454 */
455 HWTEST_F (StatsPowerMgrTest, BatteryStatsRadio_001, TestSize.Level0)
456 {
457 STATS_HILOGI(LABEL_TEST, "BatteryStatsRadio_001 start");
458 auto& statsClient = BatteryStatsClient::GetInstance();
459 statsClient.Reset();
460
461 double actualPower = statsClient.GetPartStatsMah(BatteryStatsInfo::CONSUMPTION_TYPE_RADIO);
462 double actualPercent = statsClient.GetPartStatsPercent(BatteryStatsInfo::CONSUMPTION_TYPE_RADIO);
463 EXPECT_TRUE(actualPower >= StatsUtils::DEFAULT_VALUE && actualPercent >= StatsUtils::DEFAULT_VALUE);
464 STATS_HILOGI(LABEL_TEST, "BatteryStatsRadio_001 end");
465 }
466 }