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