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