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