1 /*
2 * Copyright (c) 2021-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 "batterystats_sys_test.h"
17
18 #include <cmath>
19 #include <csignal>
20 #include <iostream>
21 #include <unistd.h>
22
23 #include <bt_def.h>
24 #include <call_manager_inner_type.h>
25 #include <display_power_info.h>
26 #include <hisysevent.h>
27 #include <if_system_ability_manager.h>
28 #include <ipc_skeleton.h>
29 #include <iservice_registry.h>
30 #include <running_lock_info.h>
31 #include <string_ex.h>
32 #include <system_ability_definition.h>
33 #include <wifi_hisysevent.h>
34
35 #include "battery_stats_client.h"
36 #include "battery_stats_parser.h"
37 #include "stats_common.h"
38
39 using namespace std;
40 using namespace testing::ext;
41 using namespace OHOS;
42 using namespace OHOS::HiviewDFX;
43 using namespace OHOS::PowerMgr;
44 using namespace OHOS::Telephony;
45
46 namespace {
47 constexpr int64_t US_PER_HOUR = 3600000000;
48 constexpr int32_t US_PER_SECOND = 1000000;
49 constexpr int32_t POWER_CONSUMPTION_DURATION_US = 300000;
50 constexpr double DEVIATION_PERCENT_THRESHOLD = 0.05;
51 static std::vector<std::string> dumpArgs;
52 static std::shared_ptr<BatteryStatsParser> g_statsParser = nullptr;
53 }
54
ParserAveragePowerFile()55 static void ParserAveragePowerFile()
56 {
57 if (g_statsParser == nullptr) {
58 g_statsParser = std::make_shared<BatteryStatsParser>();
59 if (!g_statsParser->Init()) {
60 GTEST_LOG_(INFO) << __func__ << ": Battery stats parser initialization failed";
61 }
62 }
63 }
64
SetUpTestCase()65 void BatterystatsSysTest::SetUpTestCase()
66 {
67 ParserAveragePowerFile();
68 dumpArgs.push_back("-batterystats");
69 system("hidumper -s 3302 -a -u");
70 }
71
TearDownTestCase()72 void BatterystatsSysTest::TearDownTestCase()
73 {
74 system("hidumper -s 3302 -a -r");
75 }
76
SetUp()77 void BatterystatsSysTest::SetUp()
78 {
79 auto& statsClient = BatteryStatsClient::GetInstance();
80 statsClient.SetOnBattery(true);
81 }
82
TearDown()83 void BatterystatsSysTest::TearDown()
84 {
85 auto& statsClient = BatteryStatsClient::GetInstance();
86 statsClient.SetOnBattery(false);
87 }
88
89 /**
90 *
91 * @tc.name: BatteryStatsSysTest_001
92 * @tc.desc: test Wakelock consumption
93 * @tc.type: FUNC
94 */
95 HWTEST_F (BatterystatsSysTest, BatteryStatsSysTest_001, TestSize.Level0)
96 {
97 auto& statsClient = BatteryStatsClient::GetInstance();
98 statsClient.Reset();
99
100 int32_t uid = 10001;
101 int32_t pid = 3456;
102 int32_t stateLock = 1;
103 int32_t stateUnlock = 0;
104 double wakelockAverage = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_CPU_AWAKE);
105 int32_t type = static_cast<int32_t>(RunningLockType::RUNNINGLOCK_SCREEN);
106 std::string name = " BatteryStatsSysTest_001";
107
108 HiSysEvent::Write("POWER", "POWER_RUNNINGLOCK", HiSysEvent::EventType::STATISTIC, "PID", pid,
109 "UID", uid, "STATE", stateLock, "TYPE", type, "NAME", name);
110 usleep(POWER_CONSUMPTION_DURATION_US);
111 HiSysEvent::Write("POWER", "POWER_RUNNINGLOCK", HiSysEvent::EventType::STATISTIC, "PID", pid,
112 "UID", uid, "STATE", stateUnlock, "TYPE", type, "NAME", name);
113
114 double expectedPowerMah = wakelockAverage * POWER_CONSUMPTION_DURATION_US / US_PER_HOUR;
115 double actualPowerMah = statsClient.GetAppStatsMah(uid);
116 double devPrecent = abs(expectedPowerMah - actualPowerMah) / expectedPowerMah;
117 long expectedTimeSec = round(POWER_CONSUMPTION_DURATION_US / US_PER_SECOND);
118 long actualTimeSec = statsClient.GetTotalTimeSecond(StatsUtils::STATS_TYPE_WAKELOCK_HOLD, uid);
119
120 std::string expectedDebugInfo;
121 expectedDebugInfo.append("UID = ")
122 .append(ToString(uid))
123 .append(", PID = ")
124 .append(ToString(pid))
125 .append(", wakelock type = ")
126 .append(ToString(type))
127 .append(", wakelock name = ")
128 .append(name)
129 .append(", wakelock state = ")
130 .append("UNLOCK");
131
132 std::string actualDebugInfo = statsClient.Dump(dumpArgs);
133
134 auto index = actualDebugInfo.find(expectedDebugInfo);
135
136 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPowerMah << " mAh";
137 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPowerMah << " mAh";
138 GTEST_LOG_(INFO) << __func__ << ": expected time = " << expectedTimeSec << " seconds";
139 GTEST_LOG_(INFO) << __func__ << ": actual time = " << actualTimeSec << " seconds";
140
141 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
142 EXPECT_EQ(expectedTimeSec, actualTimeSec);
143 EXPECT_TRUE(index != string::npos);
144 }
145
146 /**
147 *
148 * @tc.name: BatteryStatsSysTest_002
149 * @tc.desc: test Screen consumption
150 * @tc.type: FUNC
151 */
152 HWTEST_F (BatterystatsSysTest, BatteryStatsSysTest_002, TestSize.Level0)
153 {
154 auto& statsClient = BatteryStatsClient::GetInstance();
155 statsClient.Reset();
156
157 int32_t stateOn = static_cast<int32_t>(DisplayPowerMgr::DisplayState::DISPLAY_ON);
158 int32_t stateOff = static_cast<int32_t>(DisplayPowerMgr::DisplayState::DISPLAY_OFF);
159 int32_t brightness = 150;
160 double screenOnAverage = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_SCREEN_ON);
161 double screenBrightnessAverage = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_SCREEN_BRIGHTNESS);
162
163 HiSysEvent::Write("DISPLAY", "SCREEN_STATE", HiviewDFX::HiSysEvent::EventType::STATISTIC, "STATE", stateOn);
164 HiSysEvent::Write("DISPLAY", "BRIGHTNESS_NIT",
165 HiviewDFX::HiSysEvent::EventType::STATISTIC, "BRIGHTNESS", brightness);
166 usleep(POWER_CONSUMPTION_DURATION_US);
167 HiSysEvent::Write("DISPLAY", "SCREEN_STATE", HiviewDFX::HiSysEvent::EventType::STATISTIC, "STATE", stateOff);
168
169 double average = screenBrightnessAverage * brightness + screenOnAverage;
170
171 double expectedPowerMah = average * POWER_CONSUMPTION_DURATION_US / US_PER_HOUR;
172 double actualPowerMah = statsClient.GetPartStatsMah(BatteryStatsInfo::CONSUMPTION_TYPE_SCREEN);
173 double devPrecent = abs(expectedPowerMah - actualPowerMah) / expectedPowerMah;
174 long expectedTimeSec = round(POWER_CONSUMPTION_DURATION_US / US_PER_SECOND);
175 long actualTimeSec = statsClient.GetTotalTimeSecond(StatsUtils::STATS_TYPE_SCREEN_ON);
176
177 std::string expectedDebugInfo;
178 expectedDebugInfo.append("Additional debug info: ")
179 .append("Event name = ")
180 .append("SCREEN_STATE");
181
182 std::string actualDebugInfo = statsClient.Dump(dumpArgs);
183
184 auto index = actualDebugInfo.find(expectedDebugInfo);
185
186 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPowerMah << " mAh";
187 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPowerMah << " mAh";
188 GTEST_LOG_(INFO) << __func__ << ": expected time = " << expectedTimeSec << " seconds";
189 GTEST_LOG_(INFO) << __func__ << ": actual time = " << actualTimeSec << " seconds";
190
191 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
192 EXPECT_EQ(expectedTimeSec, actualTimeSec);
193 EXPECT_TRUE(index != string::npos);
194 }
195
196 /**
197 *
198 * @tc.name: BatteryStatsSysTest_003
199 * @tc.desc: test Battery stats event
200 * @tc.type: FUNC
201 */
202 HWTEST_F (BatterystatsSysTest, BatteryStatsSysTest_003, TestSize.Level0)
203 {
204 auto& statsClient = BatteryStatsClient::GetInstance();
205 statsClient.Reset();
206
207 int32_t batteryLevel = 60;
208 int32_t batteryChargerType = 2;
209
210 HiSysEvent::Write("BATTERY", "BATTERY_CHANGED", HiSysEvent::EventType::STATISTIC, "LEVEL",
211 batteryLevel, "CHARGER", batteryChargerType);
212
213 std::string expectedDebugInfo;
214 expectedDebugInfo.append("Battery level = ")
215 .append(ToString(batteryLevel))
216 .append(", Charger type = ")
217 .append(ToString(batteryChargerType));
218
219 std::string actualDebugInfo = statsClient.Dump(dumpArgs);
220 auto index = actualDebugInfo.find(expectedDebugInfo);
221 EXPECT_TRUE(index != string::npos);
222 }
223
224 /**
225 *
226 * @tc.name: BatteryStatsSysTest_004
227 * @tc.desc: test Thermal stats event
228 * @tc.type: FUNC
229 */
230 HWTEST_F (BatterystatsSysTest, BatteryStatsSysTest_004, TestSize.Level0)
231 {
232 auto& statsClient = BatteryStatsClient::GetInstance();
233 statsClient.Reset();
234
235 std::string partName = "Battery";
236 int32_t temperature = 40;
237
238 HiSysEvent::Write("THERMAL", "POWER_TEMPERATURE", HiSysEvent::EventType::STATISTIC, "NAME",
239 partName, "TEMPERATURE", temperature);
240
241 std::string expectedDebugInfo;
242 expectedDebugInfo.append("Additional debug info: ")
243 .append("Event name = POWER_TEMPERATURE")
244 .append(" Name = ")
245 .append(partName);
246
247 std::string actualDebugInfo = statsClient.Dump(dumpArgs);
248 auto index = actualDebugInfo.find(expectedDebugInfo);
249 EXPECT_TRUE(index != string::npos);
250 }
251
252 /**
253 *
254 * @tc.name: BatteryStatsSysTest_005
255 * @tc.desc: test WorkScheduler stats event
256 * @tc.type: FUNC
257 */
258 HWTEST_F (BatterystatsSysTest, BatteryStatsSysTest_005, TestSize.Level0)
259 {
260 auto& statsClient = BatteryStatsClient::GetInstance();
261 statsClient.Reset();
262
263 int32_t pid = 3457;
264 int32_t uid = 10002;
265 int32_t type = 1;
266 int32_t interval = 30000;
267 int32_t state = 5;
268
269 HiSysEvent::Write(HiSysEvent::Domain::POWERMGR, "POWER_WORKSCHEDULER", HiSysEvent::EventType::STATISTIC, "PID", pid,
270 "UID", uid, "TYPE", type, "INTERVAL", interval, "STATE", state);
271
272 std::string expectedDebugInfo;
273 expectedDebugInfo.append("UID = ")
274 .append(ToString(uid))
275 .append(", PID = ")
276 .append(ToString(pid))
277 .append(", work type = ")
278 .append(ToString(type))
279 .append(", work interval = ")
280 .append(ToString(interval))
281 .append(", work state = ")
282 .append(ToString(state));
283
284 std::string actualDebugInfo = statsClient.Dump(dumpArgs);
285 auto index = actualDebugInfo.find(expectedDebugInfo);
286 EXPECT_TRUE(index != string::npos);
287 }
288
289 /**
290 *
291 * @tc.name: BatteryStatsSysTest_006
292 * @tc.desc: test Dump function
293 * @tc.type: FUNC
294 */
295 HWTEST_F (BatterystatsSysTest, BatteryStatsSysTest_006, TestSize.Level0)
296 {
297 auto& statsClient = BatteryStatsClient::GetInstance();
298 std::string result;
299 result.clear();
300 result = statsClient.Dump(dumpArgs);
301 EXPECT_TRUE(result != "");
302 statsClient.Reset();
303 }
304
305 /**
306 *
307 * @tc.name: BatteryStatsSysTest_008
308 * @tc.desc: test Bluetooth consumption
309 * @tc.type: FUNC
310 */
311 HWTEST_F (BatterystatsSysTest, BatteryStatsSysTest_008, TestSize.Level0)
312 {
313 auto& statsClient = BatteryStatsClient::GetInstance();
314 statsClient.Reset();
315
316 double bluetoothBrOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_BLUETOOTH_BR_ON);
317 int32_t stateOn = static_cast<int32_t>(bluetooth::BTStateID::STATE_TURN_ON);
318 int32_t stateOff = static_cast<int32_t>(bluetooth::BTStateID::STATE_TURN_OFF);
319 int32_t uid = 10003;
320 int32_t pid = 3458;
321 HiSysEvent::Write("BLUETOOTH", "BLUETOOTH_BR_SWITCH_STATE", HiSysEvent::EventType::STATISTIC,
322 "PID", pid, "UID", uid, "STATE", stateOn);
323 usleep(POWER_CONSUMPTION_DURATION_US);
324 HiSysEvent::Write("BLUETOOTH", "BLUETOOTH_BR_SWITCH_STATE", HiSysEvent::EventType::STATISTIC,
325 "PID", pid, "UID", uid, "STATE", stateOff);
326
327 double expectedPower = POWER_CONSUMPTION_DURATION_US * bluetoothBrOnAverageMa / US_PER_HOUR;
328 double actualPower = statsClient.GetPartStatsMah(BatteryStatsInfo::CONSUMPTION_TYPE_BLUETOOTH);
329 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
330 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
331 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
332 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
333 }
334
335 /**
336 *
337 * @tc.name: BatteryStatsSysTest_009
338 * @tc.desc: test Wifi consumption
339 * @tc.type: FUNC
340 */
341 HWTEST_F (BatterystatsSysTest, BatteryStatsSysTest_009, TestSize.Level0)
342 {
343 auto& statsClient = BatteryStatsClient::GetInstance();
344 statsClient.Reset();
345
346 double wifiOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_WIFI_ON);
347 int32_t stateOn = static_cast<int32_t>(Wifi::WifiConnectionType::CONNECT);
348 int32_t stateOff = static_cast<int32_t>(Wifi::WifiConnectionType::DISCONNECT);
349 HiSysEvent::Write("COMMUNICATION", "WIFI_CONNECTION", HiSysEvent::EventType::STATISTIC, "TYPE", stateOn);
350 usleep(POWER_CONSUMPTION_DURATION_US);
351 HiSysEvent::Write("COMMUNICATION", "WIFI_CONNECTION", HiSysEvent::EventType::STATISTIC, "TYPE", stateOff);
352
353 double expectedPower = POWER_CONSUMPTION_DURATION_US * wifiOnAverageMa / US_PER_HOUR;
354 double actualPower = statsClient.GetPartStatsMah(BatteryStatsInfo::CONSUMPTION_TYPE_WIFI);
355 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
356 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
357 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
358 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
359 }
360
361 /**
362 *
363 * @tc.name: BatteryStatsSysTest_010
364 * @tc.desc: test Phone Call consumption
365 * @tc.type: FUNC
366 */
367 HWTEST_F (BatterystatsSysTest, BatteryStatsSysTest_010, TestSize.Level0)
368 {
369 auto& statsClient = BatteryStatsClient::GetInstance();
370 statsClient.Reset();
371
372 int32_t stateOn = static_cast<int32_t>(TelCallState::CALL_STATUS_ACTIVE);
373 int32_t stateOff = static_cast<int32_t>(TelCallState::CALL_STATUS_DISCONNECTED);
374 int16_t level = 0;
375 double phoneOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_RADIO_ON, level);
376
377 HiSysEvent::Write("TELEPHONY", "CALL_STATE", HiSysEvent::EventType::BEHAVIOR, "STATE", stateOn);
378 usleep(POWER_CONSUMPTION_DURATION_US);
379 HiSysEvent::Write("TELEPHONY", "CALL_STATE", HiSysEvent::EventType::BEHAVIOR, "STATE", stateOff);
380
381 double expectedPower = POWER_CONSUMPTION_DURATION_US * phoneOnAverageMa / US_PER_HOUR;
382 double actualPower = statsClient.GetPartStatsMah(BatteryStatsInfo::CONSUMPTION_TYPE_PHONE);
383 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
384 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
385 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
386 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
387 }
388
389 /**
390 *
391 * @tc.name: BatteryStatsSysTest_011
392 * @tc.desc: test Idle consumption
393 * @tc.type: FUNC
394 */
395 HWTEST_F (BatterystatsSysTest, BatteryStatsSysTest_011, TestSize.Level0)
396 {
397 auto& statsClient = BatteryStatsClient::GetInstance();
398 statsClient.Reset();
399
400 double actualPower = statsClient.GetPartStatsMah(BatteryStatsInfo::CONSUMPTION_TYPE_IDLE);
401 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
402 EXPECT_TRUE(actualPower >= StatsUtils::DEFAULT_VALUE);
403 }
404
405 /**
406 *
407 * @tc.name: BatteryStatsSysTest_012
408 * @tc.desc: test User consumption
409 * @tc.type: FUNC
410 */
411 HWTEST_F (BatterystatsSysTest, BatteryStatsSysTest_012, TestSize.Level0)
412 {
413 auto& statsClient = BatteryStatsClient::GetInstance();
414 statsClient.Reset();
415
416 int32_t uerId = 20003;
417
418 double actualPower = statsClient.GetAppStatsMah(uerId);
419 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
420 EXPECT_TRUE(actualPower >= StatsUtils::DEFAULT_VALUE);
421 }
422
423 /**
424 *
425 * @tc.name: BatteryStatsSysTest_013
426 * @tc.desc: test Audio consumption
427 * @tc.type: FUNC
428 */
429 HWTEST_F (BatterystatsSysTest, BatteryStatsSysTest_013, TestSize.Level0)
430 {
431 auto& statsClient = BatteryStatsClient::GetInstance();
432 statsClient.Reset();
433
434 double audioOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_AUDIO_ON);
435 int32_t uid = 10003;
436 int32_t pid = 3458;
437 int32_t stateRunning = 2;
438 int32_t stateStopped = 3;
439
440 HiSysEvent::Write("AUDIO", "AUDIO_STREAM_CHANGE", HiSysEvent::EventType::BEHAVIOR, "PID", pid,
441 "UID", uid, "STATE", stateRunning);
442 usleep(POWER_CONSUMPTION_DURATION_US);
443 HiSysEvent::Write("AUDIO", "AUDIO_STREAM_CHANGE", HiSysEvent::EventType::BEHAVIOR, "PID", pid,
444 "UID", uid, "STATE", stateStopped);
445
446 double expectedPower = POWER_CONSUMPTION_DURATION_US * audioOnAverageMa / US_PER_HOUR;
447 double actualPower = statsClient.GetAppStatsMah(uid);
448 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
449 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
450 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
451 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
452 }
453
454 /**
455 *
456 * @tc.name: BatteryStatsSysTest_014
457 * @tc.desc: test GNSS consumption
458 * @tc.type: FUNC
459 */
460 HWTEST_F (BatterystatsSysTest, BatteryStatsSysTest_014, TestSize.Level0)
461 {
462 auto& statsClient = BatteryStatsClient::GetInstance();
463 statsClient.Reset();
464
465 double gnssOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_GNSS_ON);
466 int32_t uid = 10003;
467 int32_t pid = 3458;
468 std::string stateOn = "start";
469 std::string stateOff = "stop";
470
471 HiSysEvent::Write("LOCATION", "GNSS_STATE", HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid,
472 "STATE", stateOn);
473 usleep(POWER_CONSUMPTION_DURATION_US);
474 HiSysEvent::Write("LOCATION", "GNSS_STATE", HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid,
475 "STATE", stateOff);
476
477 double expectedPower = POWER_CONSUMPTION_DURATION_US * gnssOnAverageMa / US_PER_HOUR;
478 double actualPower = statsClient.GetAppStatsMah(uid);
479 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
480 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
481 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
482 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
483 }
484
485 /**
486 *
487 * @tc.name: BatteryStatsSysTest_015
488 * @tc.desc: test Sensor consumption
489 * @tc.type: FUNC
490 */
491 HWTEST_F (BatterystatsSysTest, BatteryStatsSysTest_015, TestSize.Level0)
492 {
493 auto& statsClient = BatteryStatsClient::GetInstance();
494 statsClient.Reset();
495
496 double sensorGravityOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_SENSOR_GRAVITY);
497 int32_t uid = 10003;
498 int32_t pid = 3458;
499 int32_t stateOn = 1;
500 int32_t stateOff = 0;
501
502 HiSysEvent::Write(HiSysEvent::Domain::POWERMGR, "POWER_SENSOR_GRAVITY", HiSysEvent::EventType::STATISTIC, "PID",
503 pid, "UID", uid, "STATE", stateOn);
504 usleep(POWER_CONSUMPTION_DURATION_US);
505 HiSysEvent::Write(HiSysEvent::Domain::POWERMGR, "POWER_SENSOR_GRAVITY", HiSysEvent::EventType::STATISTIC, "PID",
506 pid, "UID", uid, "STATE", stateOff);
507
508 double expectedPower = POWER_CONSUMPTION_DURATION_US * sensorGravityOnAverageMa / US_PER_HOUR;
509 double actualPower = statsClient.GetAppStatsMah(uid);
510 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
511 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
512 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
513 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
514 }
515
516 /**
517 *
518 * @tc.name: BatteryStatsSysTest_016
519 * @tc.desc: test Camera consumption
520 * @tc.type: FUNC
521 */
522 HWTEST_F (BatterystatsSysTest, BatteryStatsSysTest_016, TestSize.Level0)
523 {
524 auto& statsClient = BatteryStatsClient::GetInstance();
525 statsClient.Reset();
526
527 double cameraOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_CAMERA_ON);
528 int32_t uid = 10003;
529 int32_t pid = 3458;
530 std::string cameraId = "Camera0";
531
532 HiSysEvent::Write("CAMERA", "CAMERA_CONNECT", HiSysEvent::EventType::STATISTIC, "PID", pid,
533 "UID", uid, "ID", cameraId);
534 usleep(POWER_CONSUMPTION_DURATION_US);
535 HiSysEvent::Write("CAMERA", "CAMERA_DISCONNECT", HiSysEvent::EventType::STATISTIC,
536 "ID", cameraId);
537
538 double expectedPower = POWER_CONSUMPTION_DURATION_US * cameraOnAverageMa / US_PER_HOUR;
539 double actualPower = statsClient.GetAppStatsMah(uid);
540 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
541 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
542 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
543 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
544 }
545
546 /**
547 *
548 * @tc.name: BatteryStatsSysTest_017
549 * @tc.desc: test Flashlight consumption
550 * @tc.type: FUNC
551 */
552 HWTEST_F (BatterystatsSysTest, BatteryStatsSysTest_017, TestSize.Level0)
553 {
554 auto& statsClient = BatteryStatsClient::GetInstance();
555 statsClient.Reset();
556
557 double flashlightOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_FLASHLIGHT_ON);
558 int32_t uid = 10003;
559 int32_t pid = 3458;
560 int32_t stateOn = 1;
561 int32_t stateOff = 0;
562
563 HiSysEvent::Write("CAMERA", "TORCH_STATE", HiSysEvent::EventType::STATISTIC, "PID", pid,
564 "UID", uid, "STATE", stateOn);
565 usleep(POWER_CONSUMPTION_DURATION_US);
566 HiSysEvent::Write("CAMERA", "TORCH_STATE", HiSysEvent::EventType::STATISTIC, "PID", pid,
567 "UID", uid, "STATE", stateOff);
568
569 double expectedPower = POWER_CONSUMPTION_DURATION_US * flashlightOnAverageMa / US_PER_HOUR;
570 double actualPower = statsClient.GetAppStatsMah(uid);
571 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
572 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
573 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
574 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
575 }
576
577 /**
578 *
579 * @tc.name: BatteryStatsSysTest_018
580 * @tc.desc: test Bluetooth and Wifi consumption
581 * @tc.type: FUNC
582 */
583 HWTEST_F (BatterystatsSysTest, BatteryStatsSysTest_018, TestSize.Level0)
584 {
585 auto& statsClient = BatteryStatsClient::GetInstance();
586 statsClient.Reset();
587
588 double bluetoothBleOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_BLUETOOTH_BLE_ON);
589 int32_t stateOn = static_cast<int32_t>(bluetooth::BTStateID::STATE_TURN_ON);
590 int32_t stateOff = static_cast<int32_t>(bluetooth::BTStateID::STATE_TURN_OFF);
591 int32_t uid = 10003;
592 int32_t pid = 3458;
593 HiSysEvent::Write("BLUETOOTH", "BLUETOOTH_BLE_STATE", HiSysEvent::EventType::STATISTIC,
594 "PID", pid, "UID", uid, "STATE", stateOn);
595 usleep(POWER_CONSUMPTION_DURATION_US);
596 HiSysEvent::Write("BLUETOOTH", "BLUETOOTH_BLE_STATE", HiSysEvent::EventType::STATISTIC,
597 "PID", pid, "UID", uid, "STATE", stateOff);
598
599 double expectedPower = POWER_CONSUMPTION_DURATION_US * bluetoothBleOnAverageMa / US_PER_HOUR;
600 double actualPower = statsClient.GetPartStatsMah(BatteryStatsInfo::CONSUMPTION_TYPE_BLUETOOTH);
601 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
602 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
603 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
604 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
605
606 double wifiOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_WIFI_ON);
607 stateOn = static_cast<int32_t>(Wifi::WifiConnectionType::CONNECT);
608 stateOff = static_cast<int32_t>(Wifi::WifiConnectionType::DISCONNECT);
609 HiSysEvent::Write("COMMUNICATION", "WIFI_CONNECTION", HiSysEvent::EventType::STATISTIC, "TYPE", stateOn);
610 usleep(POWER_CONSUMPTION_DURATION_US);
611 HiSysEvent::Write("COMMUNICATION", "WIFI_CONNECTION", HiSysEvent::EventType::STATISTIC, "TYPE", stateOff);
612
613 expectedPower = POWER_CONSUMPTION_DURATION_US * wifiOnAverageMa / US_PER_HOUR;
614 actualPower = statsClient.GetPartStatsMah(BatteryStatsInfo::CONSUMPTION_TYPE_WIFI);
615 devPrecent = abs(expectedPower - actualPower) / expectedPower;
616 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
617 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
618 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
619 }
620
621 /**
622 *
623 * @tc.name: BatteryStatsSysTest_019
624 * @tc.desc: test Flashlight and Camera consumption
625 * @tc.type: FUNC
626 */
627 HWTEST_F (BatterystatsSysTest, BatteryStatsSysTest_019, TestSize.Level0)
628 {
629 auto& statsClient = BatteryStatsClient::GetInstance();
630 statsClient.Reset();
631
632 double flashlightOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_FLASHLIGHT_ON);
633 int32_t uid = 10003;
634 int32_t pid = 3458;
635 int32_t stateOn = 1;
636 int32_t stateOff = 0;
637
638 HiSysEvent::Write("CAMERA", "TORCH_STATE", HiSysEvent::EventType::STATISTIC, "PID", pid,
639 "UID", uid, "STATE", stateOn);
640 usleep(POWER_CONSUMPTION_DURATION_US);
641 HiSysEvent::Write("CAMERA", "TORCH_STATE", HiSysEvent::EventType::STATISTIC, "PID", pid,
642 "UID", uid, "STATE", stateOff);
643
644 double expectedPower = POWER_CONSUMPTION_DURATION_US * flashlightOnAverageMa / US_PER_HOUR;
645 double actualPower = statsClient.GetAppStatsMah(uid);
646 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
647 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
648 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
649 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
650
651 double cameraOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_CAMERA_ON);
652 uid = 10004;
653 pid = 3459;
654 std::string deviceId = "Camera0";
655
656 HiSysEvent::Write("CAMERA", "CAMERA_CONNECT", HiSysEvent::EventType::STATISTIC, "PID", pid,
657 "UID", uid, "ID", deviceId);
658 usleep(POWER_CONSUMPTION_DURATION_US);
659 HiSysEvent::Write("CAMERA", "CAMERA_DISCONNECT", HiSysEvent::EventType::STATISTIC,
660 "ID", deviceId);
661
662 expectedPower = POWER_CONSUMPTION_DURATION_US * cameraOnAverageMa / US_PER_HOUR;
663 actualPower = statsClient.GetAppStatsMah(uid);
664 devPrecent = abs(expectedPower - actualPower) / expectedPower;
665 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
666 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
667 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
668 }
669
670 /**
671 *
672 * @tc.name: BatteryStatsSysTest_020
673 * @tc.desc: test Audio, Sensor and Gnss consumption
674 * @tc.type: FUNC
675 */
676 HWTEST_F (BatterystatsSysTest, BatteryStatsSysTest_020, TestSize.Level0)
677 {
678 auto& statsClient = BatteryStatsClient::GetInstance();
679 statsClient.Reset();
680
681 double audioOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_AUDIO_ON);
682 int32_t uid = 10003;
683 int32_t pid = 3458;
684 int32_t stateOn = 1;
685 int32_t stateOff = 0;
686 int32_t stateRunning = 2;
687 int32_t stateStopped = 3;
688 HiSysEvent::Write("AUDIO", "AUDIO_STREAM_CHANGE", HiSysEvent::EventType::BEHAVIOR, "PID", pid,
689 "UID", uid, "STATE", stateRunning);
690 usleep(POWER_CONSUMPTION_DURATION_US);
691 HiSysEvent::Write("AUDIO", "AUDIO_STREAM_CHANGE", HiSysEvent::EventType::BEHAVIOR, "PID", pid,
692 "UID", uid, "STATE", stateStopped);
693
694 double expectedPower = POWER_CONSUMPTION_DURATION_US * audioOnAverageMa / US_PER_HOUR;
695 double actualPower = statsClient.GetAppStatsMah(uid);
696 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
697 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
698
699 double gnssOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_GNSS_ON);
700 uid = 10004;
701 pid = 3459;
702 std::string gnssStateOn = "start";
703 std::string gnssStateOff = "stop";
704 HiSysEvent::Write("LOCATION", "GNSS_STATE", HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid,
705 "STATE", gnssStateOn);
706 usleep(POWER_CONSUMPTION_DURATION_US);
707 HiSysEvent::Write("LOCATION", "GNSS_STATE", HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid,
708 "STATE", gnssStateOff);
709
710 expectedPower = POWER_CONSUMPTION_DURATION_US * gnssOnAverageMa / US_PER_HOUR;
711 actualPower = statsClient.GetAppStatsMah(uid);
712 devPrecent = abs(expectedPower - actualPower) / expectedPower;
713 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
714 double sensorGravityOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_SENSOR_GRAVITY);
715 uid = 10005;
716 pid = 3457;
717 HiSysEvent::Write(HiSysEvent::Domain::POWERMGR, "POWER_SENSOR_GRAVITY", HiSysEvent::EventType::STATISTIC, "PID",
718 pid, "UID", uid, "STATE", stateOn);
719 usleep(POWER_CONSUMPTION_DURATION_US);
720 HiSysEvent::Write(HiSysEvent::Domain::POWERMGR, "POWER_SENSOR_GRAVITY", HiSysEvent::EventType::STATISTIC, "PID",
721 pid, "UID", uid, "STATE", stateOff);
722
723 expectedPower = POWER_CONSUMPTION_DURATION_US * sensorGravityOnAverageMa / US_PER_HOUR;
724 actualPower = statsClient.GetAppStatsMah(uid);
725 devPrecent = abs(expectedPower - actualPower) / expectedPower;
726 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
727 }
728
729 /**
730 *
731 * @tc.name: BatteryStatsSysTest_021
732 * @tc.desc: test Phone data and Audio consumption
733 * @tc.type: FUNC
734 */
735 HWTEST_F (BatterystatsSysTest, BatteryStatsSysTest_021, TestSize.Level0)
736 {
737 auto& statsClient = BatteryStatsClient::GetInstance();
738 statsClient.Reset();
739
740 int32_t stateOn = 1;
741 int32_t stateOff = 0;
742 int16_t level = 0;
743 double phoneDataAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_RADIO_DATA, level);
744
745 HiSysEvent::Write("TELEPHONY", "DATA_CONNECTION_STATE", HiSysEvent::EventType::BEHAVIOR, "STATE", stateOn);
746 usleep(POWER_CONSUMPTION_DURATION_US);
747 HiSysEvent::Write("TELEPHONY", "DATA_CONNECTION_STATE", HiSysEvent::EventType::BEHAVIOR, "STATE", stateOff);
748
749 double expectedPower = POWER_CONSUMPTION_DURATION_US * phoneDataAverageMa / US_PER_HOUR;
750 double actualPower = statsClient.GetPartStatsMah(BatteryStatsInfo::CONSUMPTION_TYPE_PHONE);
751 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
752 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
753 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
754
755 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
756
757 double audioOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_AUDIO_ON);
758 int32_t uid = 10003;
759 int32_t pid = 3458;
760 int32_t stateRunning = 2;
761 int32_t stateStopped = 3;
762
763 HiSysEvent::Write("AUDIO", "AUDIO_STREAM_CHANGE", HiSysEvent::EventType::BEHAVIOR, "PID", pid,
764 "UID", uid, "STATE", stateRunning);
765 usleep(POWER_CONSUMPTION_DURATION_US);
766 HiSysEvent::Write("AUDIO", "AUDIO_STREAM_CHANGE", HiSysEvent::EventType::BEHAVIOR, "PID", pid,
767 "UID", uid, "STATE", stateStopped);
768
769 expectedPower = POWER_CONSUMPTION_DURATION_US * audioOnAverageMa / US_PER_HOUR;
770 actualPower = statsClient.GetAppStatsMah(uid);
771 devPrecent = abs(expectedPower - actualPower) / expectedPower;
772 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
773 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
774 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
775 }
776
777 /**
778 *
779 * @tc.name: BatteryStatsSysTest_022
780 * @tc.desc: test Idle and consumption, Dump function
781 * @tc.type: FUNC
782 */
783 HWTEST_F (BatterystatsSysTest, BatteryStatsSysTest_022, TestSize.Level0)
784 {
785 auto& statsClient = BatteryStatsClient::GetInstance();
786 statsClient.Reset();
787
788 double actualPower = statsClient.GetPartStatsMah(BatteryStatsInfo::CONSUMPTION_TYPE_IDLE);
789 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
790
791 EXPECT_TRUE(actualPower >= StatsUtils::DEFAULT_VALUE);
792
793 int32_t uerId = 20003;
794
795 actualPower = statsClient.GetAppStatsMah(uerId);
796 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
797 EXPECT_TRUE(actualPower >= StatsUtils::DEFAULT_VALUE);
798
799 std::string result;
800 result.clear();
801 result = statsClient.Dump(dumpArgs);
802 EXPECT_TRUE(result != "");
803 }
804
805 /**
806 *
807 * @tc.name: BatteryStatsSysTest_023
808 * @tc.desc: test Camera and Camera Flashlight consumption
809 * @tc.type: FUNC
810 */
811 HWTEST_F (BatterystatsSysTest, BatteryStatsSysTest_023, TestSize.Level0)
812 {
813 auto& statsClient = BatteryStatsClient::GetInstance();
814 statsClient.Reset();
815
816 double cameraOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_CAMERA_ON);
817 double flashlightOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_FLASHLIGHT_ON);
818 int32_t uid = 10003;
819 int32_t pid = 3458;
820 std::string cameraId = "Camera0";
821
822 HiSysEvent::Write("CAMERA", "CAMERA_CONNECT", HiSysEvent::EventType::STATISTIC, "PID", pid,
823 "UID", uid, "ID", cameraId);
824 usleep(POWER_CONSUMPTION_DURATION_US);
825 HiSysEvent::Write("CAMERA", "FLASHLIGHT_ON", HiSysEvent::EventType::STATISTIC);
826 usleep(POWER_CONSUMPTION_DURATION_US);
827 HiSysEvent::Write("CAMERA", "FLASHLIGHT_OFF", HiSysEvent::EventType::STATISTIC);
828 usleep(POWER_CONSUMPTION_DURATION_US);
829 HiSysEvent::Write("CAMERA", "CAMERA_DISCONNECT", HiSysEvent::EventType::STATISTIC,
830 "ID", cameraId);
831
832 double expectedPower = (3 * POWER_CONSUMPTION_DURATION_US * cameraOnAverageMa / US_PER_HOUR) +
833 (POWER_CONSUMPTION_DURATION_US * flashlightOnAverageMa / US_PER_HOUR);
834 double actualPower = statsClient.GetAppStatsMah(uid);
835 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
836 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
837 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
838 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
839 }
840
841 /**
842 *
843 * @tc.name: BatteryStatsSysTest_024
844 * @tc.desc: test GetLastError interface
845 * @tc.type: FUNC
846 */
847 HWTEST_F (BatterystatsSysTest, BatteryStatsSysTest_024, TestSize.Level0)
848 {
849 auto& statsClient = BatteryStatsClient::GetInstance();
850 StatsError error = statsClient.GetLastError();
851 EXPECT_TRUE(error == StatsError::ERR_OK) << "last error is " << static_cast<int32_t>(error);
852 }
853