1 /*
2 * Copyright (c) 2022-2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "stats_service_powermgr_test.h"
17 #include "stats_log.h"
18 #include <call_manager_inner_type.h>
19 #include <hisysevent.h>
20 #include <running_lock_info.h>
21
22 #include "battery_stats_listener.h"
23 #include "battery_stats_service.h"
24 #include "hisysevent_operation.h"
25 #include "stats_hisysevent.h"
26 #include "stats_service_test_proxy.h"
27 #include "stats_service_write_event.h"
28
29 using namespace testing::ext;
30 using namespace OHOS::HiviewDFX;
31 using namespace OHOS::PowerMgr;
32 using namespace OHOS::Telephony;
33 using namespace OHOS;
34 using namespace std;
35
36 namespace {
37 static sptr<BatteryStatsService> g_statsService = nullptr;
38 static std::shared_ptr<StatsServiceTestProxy> g_statsServiceProxy = nullptr;
39 } // namespace
40
SetUpTestCase()41 void StatsServicePowerMgrTest::SetUpTestCase()
42 {
43 ParserAveragePowerFile();
44 g_statsService = BatteryStatsService::GetInstance();
45 g_statsService->OnStart();
46
47 if (g_statsService->listenerPtr_ == nullptr) {
48 g_statsService->listenerPtr_ = std::make_shared<BatteryStatsListener>();
49 }
50
51 if (g_statsServiceProxy == nullptr) {
52 g_statsServiceProxy = std::make_shared<StatsServiceTestProxy>(g_statsService);
53 }
54 }
55
TearDownTestCase()56 void StatsServicePowerMgrTest::TearDownTestCase()
57 {
58 g_statsService->listenerPtr_ = nullptr;
59 g_statsService->OnStop();
60 }
61
SetUp()62 void StatsServicePowerMgrTest::SetUp()
63 {
64 auto statsService = BatteryStatsService::GetInstance();
65 statsService->SetOnBattery(true);
66 }
67
TearDown()68 void StatsServicePowerMgrTest::TearDown()
69 {
70 auto statsService = BatteryStatsService::GetInstance();
71 statsService->SetOnBattery(false);
72 }
73
74 namespace {
75 /**
76 * @tc.name: StatsServicePowerMgrTest_001
77 * @tc.desc: test GetTotalTimeSecond function(Sensor Gravity)
78 * @tc.type: FUNC
79 * @tc.require: issueI663DX
80 */
81 HWTEST_F (StatsServicePowerMgrTest, StatsServicePowerMgrTest_001, TestSize.Level0)
82 {
83 STATS_HILOGI(LABEL_TEST, "StatsServicePowerMgrTest_001 start");
84 ASSERT_NE(g_statsServiceProxy, nullptr);
85 auto statsService = BatteryStatsService::GetInstance();
86 g_statsServiceProxy->ResetIpc();
87
88 int32_t stateOn = 1;
89 int32_t stateOff = 0;
90 int32_t uid = 10003;
91 int32_t pid = 3458;
92
93 StatsWriteHiSysEvent(statsService,
94 HiSysEvent::Domain::STATS, StatsHiSysEvent::POWER_SENSOR_GRAVITY,
95 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateOn);
96 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
97 StatsWriteHiSysEvent(statsService,
98 HiSysEvent::Domain::STATS, StatsHiSysEvent::POWER_SENSOR_GRAVITY,
99 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateOff);
100
101 uint64_t expectedTime = round(SERVICE_POWER_CONSUMPTION_DURATION_US / US_PER_SECOND);
102 uint64_t actualTime;
103 g_statsServiceProxy->GetTotalTimeSecondIpc(StatsUtils::STATS_TYPE_SENSOR_GRAVITY_ON, uid, actualTime);
104 GTEST_LOG_(INFO) << __func__ << ": expected time = " << expectedTime << " seconds";
105 GTEST_LOG_(INFO) << __func__ << ": actual time = " << actualTime << " seconds";
106 EXPECT_EQ(expectedTime, actualTime);
107 STATS_HILOGI(LABEL_TEST, "StatsServicePowerMgrTest_001 end");
108 }
109
110 /**
111 * @tc.name: StatsServicePowerMgrTest_002
112 * @tc.desc: test GetAppStatsMah function(Sensor Gravity)
113 * @tc.type: FUNC
114 * @tc.require: issueI663DX
115 */
116 HWTEST_F (StatsServicePowerMgrTest, StatsServicePowerMgrTest_002, TestSize.Level0)
117 {
118 STATS_HILOGI(LABEL_TEST, "StatsServicePowerMgrTest_002 start");
119 ASSERT_NE(g_statsServiceProxy, nullptr);
120 auto statsService = BatteryStatsService::GetInstance();
121 g_statsServiceProxy->ResetIpc();
122
123 double sensorGravityOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_SENSOR_GRAVITY);
124 int32_t uid = 10003;
125 int32_t pid = 3458;
126 int32_t stateOn = 1;
127 int32_t stateOff = 0;
128
129 StatsWriteHiSysEvent(statsService,
130 HiSysEvent::Domain::STATS, StatsHiSysEvent::POWER_SENSOR_GRAVITY, HiSysEvent::EventType::STATISTIC, "PID",
131 pid, "UID", uid, "STATE", stateOn);
132 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
133 StatsWriteHiSysEvent(statsService,
134 HiSysEvent::Domain::STATS, StatsHiSysEvent::POWER_SENSOR_GRAVITY, HiSysEvent::EventType::STATISTIC, "PID",
135 pid, "UID", uid, "STATE", stateOff);
136
137 double expectedPower = SERVICE_POWER_CONSUMPTION_DURATION_US * sensorGravityOnAverageMa / US_PER_HOUR;
138 int32_t tempError;
139 double actualPower;
140 g_statsServiceProxy->GetAppStatsMahIpc(uid, actualPower, tempError);
141 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
142 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
143 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
144 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
145 STATS_HILOGI(LABEL_TEST, "StatsServicePowerMgrTest_002 end");
146 }
147
148 /**
149 * @tc.name: StatsServicePowerMgrTest_003
150 * @tc.desc: test GetAppStatsPercent function(Sensor Gravity)
151 * @tc.type: FUNC
152 * @tc.require: issueI663DX
153 */
154 HWTEST_F (StatsServicePowerMgrTest, StatsServicePowerMgrTest_003, TestSize.Level0)
155 {
156 STATS_HILOGI(LABEL_TEST, "StatsServicePowerMgrTest_003 start");
157 ASSERT_NE(g_statsServiceProxy, nullptr);
158 auto statsService = BatteryStatsService::GetInstance();
159 g_statsServiceProxy->ResetIpc();
160
161 int32_t uid = 10003;
162 int32_t pid = 3458;
163 int32_t stateOn = 1;
164 int32_t stateOff = 0;
165 double fullPercent = 1;
166 double zeroPercent = 0;
167
168 StatsWriteHiSysEvent(statsService,
169 HiSysEvent::Domain::STATS, StatsHiSysEvent::POWER_SENSOR_GRAVITY, HiSysEvent::EventType::STATISTIC, "PID",
170 pid, "UID", uid, "STATE", stateOn);
171 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
172 StatsWriteHiSysEvent(statsService,
173 HiSysEvent::Domain::STATS, StatsHiSysEvent::POWER_SENSOR_GRAVITY, HiSysEvent::EventType::STATISTIC, "PID",
174 pid, "UID", uid, "STATE", stateOff);
175 int32_t tempError;
176 double actualPercent;
177 g_statsServiceProxy->GetAppStatsPercentIpc(uid, actualPercent, tempError);
178 GTEST_LOG_(INFO) << __func__ << ": actual percent = " << actualPercent;
179 EXPECT_TRUE(actualPercent >= zeroPercent && actualPercent <= fullPercent);
180 STATS_HILOGI(LABEL_TEST, "StatsServicePowerMgrTest_003 end");
181 }
182
183 /**
184 * @tc.name: StatsServicePowerMgrTest_004
185 * @tc.desc: test GetAppStatsMah(Sensor Gravity) and GetAppStatsPercent(Sensor Proximity) function
186 * @tc.type: FUNC
187 * @tc.require: issueI663DX
188 */
189 HWTEST_F (StatsServicePowerMgrTest, StatsServicePowerMgrTest_004, TestSize.Level0)
190 {
191 STATS_HILOGI(LABEL_TEST, "StatsServicePowerMgrTest_004 start");
192 ASSERT_NE(g_statsServiceProxy, nullptr);
193 auto statsService = BatteryStatsService::GetInstance();
194 g_statsServiceProxy->ResetIpc();
195
196 double sensorGravityOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_SENSOR_GRAVITY);
197 int32_t uid = 10003;
198 int32_t pid = 3458;
199 int32_t stateOn = 1;
200 int32_t stateOff = 0;
201
202 StatsWriteHiSysEvent(statsService,
203 HiSysEvent::Domain::STATS, StatsHiSysEvent::POWER_SENSOR_GRAVITY, HiSysEvent::EventType::STATISTIC, "PID",
204 pid, "UID", uid, "STATE", stateOn);
205 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
206 StatsWriteHiSysEvent(statsService,
207 HiSysEvent::Domain::STATS, StatsHiSysEvent::POWER_SENSOR_GRAVITY, HiSysEvent::EventType::STATISTIC, "PID",
208 pid, "UID", uid, "STATE", stateOff);
209
210 double expectedPower = SERVICE_POWER_CONSUMPTION_DURATION_US * sensorGravityOnAverageMa / US_PER_HOUR;
211 int32_t tempError;
212 double actualPower;
213 g_statsServiceProxy->GetAppStatsMahIpc(uid, actualPower, tempError);
214 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
215 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
216 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
217 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
218
219 uid = 10004;
220 pid = 3459;
221 stateOn = 1;
222 stateOff = 0;
223 double fullPercent = 1;
224 double zeroPercent = 0;
225
226 StatsWriteHiSysEvent(statsService,
227 HiSysEvent::Domain::STATS, StatsHiSysEvent::POWER_SENSOR_PROXIMITY, HiSysEvent::EventType::STATISTIC, "PID",
228 pid, "UID", uid, "STATE", stateOn);
229 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
230 StatsWriteHiSysEvent(statsService,
231 HiSysEvent::Domain::STATS, StatsHiSysEvent::POWER_SENSOR_PROXIMITY, HiSysEvent::EventType::STATISTIC, "PID",
232 pid, "UID", uid, "STATE", stateOff);
233 double actualPercent;
234 g_statsServiceProxy->GetAppStatsPercentIpc(uid, actualPercent, tempError);
235 GTEST_LOG_(INFO) << __func__ << ": actual percent = " << actualPercent;
236 EXPECT_TRUE(actualPercent >= zeroPercent && actualPercent <= fullPercent);
237 STATS_HILOGI(LABEL_TEST, "StatsServicePowerMgrTest_004 end");
238 }
239
240 /**
241 * @tc.name: StatsServicePowerMgrTest_005
242 * @tc.desc: test GetTotalTimeSecond function(Sensor Proximity)
243 * @tc.type: FUNC
244 * @tc.require: issueI663DX
245 */
246 HWTEST_F (StatsServicePowerMgrTest, StatsServicePowerMgrTest_005, TestSize.Level0)
247 {
248 STATS_HILOGI(LABEL_TEST, "StatsServicePowerMgrTest_005 start");
249 ASSERT_NE(g_statsServiceProxy, nullptr);
250 auto statsService = BatteryStatsService::GetInstance();
251 g_statsServiceProxy->ResetIpc();
252
253 int32_t stateOn = 1;
254 int32_t stateOff = 0;
255 int32_t uid = 10003;
256 int32_t pid = 3458;
257
258 StatsWriteHiSysEvent(statsService,
259 HiSysEvent::Domain::STATS, StatsHiSysEvent::POWER_SENSOR_PROXIMITY, HiSysEvent::EventType::STATISTIC, "PID",
260 pid, "UID", uid, "STATE", stateOn);
261 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
262 StatsWriteHiSysEvent(statsService,
263 HiSysEvent::Domain::STATS, StatsHiSysEvent::POWER_SENSOR_PROXIMITY, HiSysEvent::EventType::STATISTIC, "PID",
264 pid, "UID", uid, "STATE", stateOff);
265
266 uint64_t expectedPower = StatsUtils::DEFAULT_VALUE;
267 uint64_t actualPower;
268 g_statsServiceProxy->GetTotalTimeSecondIpc(StatsUtils::STATS_TYPE_SENSOR_PROXIMITY_ON, uid, actualPower);
269 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
270 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
271 EXPECT_EQ(expectedPower, actualPower);
272 STATS_HILOGI(LABEL_TEST, "StatsServicePowerMgrTest_005 end");
273 }
274
275 /**
276 * @tc.name: StatsServicePowerMgrTest_006
277 * @tc.desc: test GetAppStatsMah function(Sensor Proximity)
278 * @tc.type: FUNC
279 * @tc.require: issueI663DX
280 */
281 HWTEST_F (StatsServicePowerMgrTest, StatsServicePowerMgrTest_006, TestSize.Level0)
282 {
283 STATS_HILOGI(LABEL_TEST, "StatsServicePowerMgrTest_006 start");
284 ASSERT_NE(g_statsServiceProxy, nullptr);
285 auto statsService = BatteryStatsService::GetInstance();
286 g_statsServiceProxy->ResetIpc();
287
288 double sensorProximityOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_SENSOR_PROXIMITY);
289 int32_t uid = 10003;
290 int32_t pid = 3458;
291 int32_t stateOn = 1;
292 int32_t stateOff = 0;
293
294 StatsWriteHiSysEvent(statsService,
295 HiSysEvent::Domain::STATS, StatsHiSysEvent::POWER_SENSOR_PROXIMITY, HiSysEvent::EventType::STATISTIC, "PID",
296 pid, "UID", uid, "STATE", stateOn);
297 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
298 StatsWriteHiSysEvent(statsService,
299 HiSysEvent::Domain::STATS, StatsHiSysEvent::POWER_SENSOR_PROXIMITY, HiSysEvent::EventType::STATISTIC, "PID",
300 pid, "UID", uid, "STATE", stateOff);
301
302 double expectedPower = SERVICE_POWER_CONSUMPTION_DURATION_US * sensorProximityOnAverageMa / US_PER_HOUR;
303 int32_t tempError;
304 double actualPower;
305 g_statsServiceProxy->GetAppStatsMahIpc(uid, actualPower, tempError);
306 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
307 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
308 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
309 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
310 STATS_HILOGI(LABEL_TEST, "StatsServicePowerMgrTest_006 end");
311 }
312
313 /**
314 * @tc.name: StatsServicePowerMgrTest_007
315 * @tc.desc: test GetAppStatsPercent function(Sensor Proximity)
316 * @tc.type: FUNC
317 * @tc.require: issueI663DX
318 */
319 HWTEST_F (StatsServicePowerMgrTest, StatsServicePowerMgrTest_007, TestSize.Level0)
320 {
321 STATS_HILOGI(LABEL_TEST, "StatsServicePowerMgrTest_007 start");
322 ASSERT_NE(g_statsServiceProxy, nullptr);
323 auto statsService = BatteryStatsService::GetInstance();
324 g_statsServiceProxy->ResetIpc();
325
326 int32_t uid = 10003;
327 int32_t pid = 3458;
328 int32_t stateOn = 1;
329 int32_t stateOff = 0;
330 double fullPercent = 1;
331 double zeroPercent = 0;
332
333 StatsWriteHiSysEvent(statsService,
334 HiSysEvent::Domain::STATS, StatsHiSysEvent::POWER_SENSOR_PROXIMITY, HiSysEvent::EventType::STATISTIC, "PID",
335 pid, "UID", uid, "STATE", stateOn);
336 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
337 StatsWriteHiSysEvent(statsService,
338 HiSysEvent::Domain::STATS, StatsHiSysEvent::POWER_SENSOR_PROXIMITY, HiSysEvent::EventType::STATISTIC, "PID",
339 pid, "UID", uid, "STATE", stateOff);
340 int32_t tempError;
341 double actualPercent;
342 g_statsServiceProxy->GetAppStatsPercentIpc(uid, actualPercent, tempError);
343 GTEST_LOG_(INFO) << __func__ << ": actual percent = " << actualPercent;
344 EXPECT_TRUE(actualPercent >= zeroPercent && actualPercent <= fullPercent);
345 STATS_HILOGI(LABEL_TEST, "StatsServicePowerMgrTest_007 end");
346 }
347
348 /**
349 * @tc.name: StatsServicePowerMgrTest_008
350 * @tc.desc: test GetAppStatsMah(Sensor Proximity) and GetAppStatsPercent(Torch) function
351 * @tc.type: FUNC
352 * @tc.require: issueI663DX
353 */
354 HWTEST_F (StatsServicePowerMgrTest, StatsServicePowerMgrTest_008, TestSize.Level0)
355 {
356 STATS_HILOGI(LABEL_TEST, "StatsServicePowerMgrTest_008 start");
357 ASSERT_NE(g_statsServiceProxy, nullptr);
358 auto statsService = BatteryStatsService::GetInstance();
359 g_statsServiceProxy->ResetIpc();
360
361 double sensorProximityOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_SENSOR_PROXIMITY);
362 int32_t uid = 10003;
363 int32_t pid = 3458;
364 int32_t stateOn = 1;
365 int32_t stateOff = 0;
366
367 StatsWriteHiSysEvent(statsService,
368 HiSysEvent::Domain::STATS, StatsHiSysEvent::POWER_SENSOR_PROXIMITY, HiSysEvent::EventType::STATISTIC, "PID",
369 pid, "UID", uid, "STATE", stateOn);
370 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
371 StatsWriteHiSysEvent(statsService,
372 HiSysEvent::Domain::STATS, StatsHiSysEvent::POWER_SENSOR_PROXIMITY, HiSysEvent::EventType::STATISTIC, "PID",
373 pid, "UID", uid, "STATE", stateOff);
374
375 double expectedPower = SERVICE_POWER_CONSUMPTION_DURATION_US * sensorProximityOnAverageMa / US_PER_HOUR;
376 int32_t tempError;
377 double actualPower;
378 g_statsServiceProxy->GetAppStatsMahIpc(uid, actualPower, tempError);
379 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
380 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
381 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
382 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
383
384 uid = 10004;
385 pid = 3459;
386 stateOn = 1;
387 stateOff = 0;
388 double fullPercent = 1;
389 double zeroPercent = 0;
390
391 StatsWriteHiSysEvent(statsService,
392 HiSysEvent::Domain::CAMERA, StatsHiSysEvent::TORCH_STATE, HiSysEvent::EventType::STATISTIC, "PID", pid,
393 "UID", uid, "STATE", stateOn);
394 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
395 StatsWriteHiSysEvent(statsService,
396 HiSysEvent::Domain::CAMERA, StatsHiSysEvent::TORCH_STATE, HiSysEvent::EventType::STATISTIC, "PID", pid,
397 "UID", uid, "STATE", stateOff);
398 double actualPercent;
399 g_statsServiceProxy->GetAppStatsPercentIpc(uid, actualPercent, tempError);
400 GTEST_LOG_(INFO) << __func__ << ": actual percent = " << actualPercent;
401 EXPECT_TRUE(actualPercent >= zeroPercent && actualPercent <= fullPercent);
402 STATS_HILOGI(LABEL_TEST, "StatsServicePowerMgrTest_008 end");
403 }
404
405 /**
406 * @tc.name: StatsServicePowerMgrTest_009
407 * @tc.desc: test sensor entity GetPartStatsMah function(Sensor)
408 * @tc.type: FUNC
409 * @tc.require: issueI663DX
410 */
411 HWTEST_F (StatsServicePowerMgrTest, StatsServicePowerMgrTest_009, TestSize.Level0)
412 {
413 STATS_HILOGI(LABEL_TEST, "StatsServicePowerMgrTest_009 start");
414 ASSERT_NE(g_statsServiceProxy, nullptr);
415 auto statsService = BatteryStatsService::GetInstance();
416 g_statsServiceProxy->ResetIpc();
417
418 double sensorGravityOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_SENSOR_GRAVITY);
419 double sensorProximityOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_SENSOR_PROXIMITY);
420 int32_t uid = 10003;
421 int32_t pid = 3458;
422 int32_t stateOn = 1;
423 int32_t stateOff = 0;
424
425 StatsWriteHiSysEvent(statsService,
426 HiSysEvent::Domain::STATS, StatsHiSysEvent::POWER_SENSOR_GRAVITY, HiSysEvent::EventType::STATISTIC, "PID",
427 pid, "UID", uid, "STATE", stateOn);
428 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
429 StatsWriteHiSysEvent(statsService,
430 HiSysEvent::Domain::STATS, StatsHiSysEvent::POWER_SENSOR_GRAVITY, HiSysEvent::EventType::STATISTIC, "PID",
431 pid, "UID", uid, "STATE", stateOff);
432
433 StatsWriteHiSysEvent(statsService,
434 HiSysEvent::Domain::STATS, StatsHiSysEvent::POWER_SENSOR_PROXIMITY, HiSysEvent::EventType::STATISTIC, "PID",
435 pid, "UID", uid, "STATE", stateOn);
436 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
437 StatsWriteHiSysEvent(statsService,
438 HiSysEvent::Domain::STATS, StatsHiSysEvent::POWER_SENSOR_PROXIMITY, HiSysEvent::EventType::STATISTIC, "PID",
439 pid, "UID", uid, "STATE", stateOff);
440
441 auto statsCore = statsService->GetBatteryStatsCore();
442 auto sensorEntity = statsCore->GetEntity(BatteryStatsInfo::CONSUMPTION_TYPE_SENSOR);
443 statsCore->ComputePower();
444
445 double expectedPower = SERVICE_POWER_CONSUMPTION_DURATION_US *
446 (sensorGravityOnAverageMa + sensorProximityOnAverageMa)/ US_PER_HOUR;
447 double actualPower = sensorEntity->GetStatsPowerMah(StatsUtils::STATS_TYPE_SENSOR_GRAVITY_ON, uid) +
448 sensorEntity->GetStatsPowerMah(StatsUtils::STATS_TYPE_SENSOR_PROXIMITY_ON, uid);
449 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
450 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
451 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
452 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
453
454 EXPECT_EQ(StatsUtils::DEFAULT_VALUE, sensorEntity->GetStatsPowerMah(StatsUtils::STATS_TYPE_SENSOR_GRAVITY_ON));
455 EXPECT_EQ(StatsUtils::DEFAULT_VALUE, sensorEntity->GetStatsPowerMah(StatsUtils::STATS_TYPE_SENSOR_PROXIMITY_ON));
456 EXPECT_EQ(StatsUtils::DEFAULT_VALUE, sensorEntity->GetStatsPowerMah(StatsUtils::STATS_TYPE_INVALID, uid));
457 STATS_HILOGI(LABEL_TEST, "StatsServicePowerMgrTest_009 end");
458 }
459
460 /**
461 *
462 * @tc.name: StatsServicePowerMgrTest_010
463 * @tc.desc: test wakelock entity GetPartStatsMah function(Wakelock)
464 * @tc.type: FUNC
465 * @tc.require: issueI663DX
466 */
467 HWTEST_F (StatsServicePowerMgrTest, StatsServicePowerMgrTest_010, TestSize.Level0)
468 {
469 STATS_HILOGI(LABEL_TEST, "StatsServicePowerMgrTest_010 start");
470 ASSERT_NE(g_statsServiceProxy, nullptr);
471 auto statsService = BatteryStatsService::GetInstance();
472 g_statsServiceProxy->ResetIpc();
473
474 double wakelockAverage = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_CPU_AWAKE);
475 int32_t uid = 10001;
476 int32_t pid = 3456;
477 int32_t stateLock = 1;
478 int32_t stateUnlock = 0;
479 int32_t type = static_cast<int32_t>(RunningLockType::RUNNINGLOCK_SCREEN);
480 std::string name = " StatsServicePowerMgrTest_010";
481
482 StatsWriteHiSysEvent(statsService,
483 HiSysEvent::Domain::POWER, StatsHiSysEvent::POWER_RUNNINGLOCK, HiSysEvent::EventType::STATISTIC, "PID", pid,
484 "UID", uid, "STATE", stateLock, "TYPE", type, "NAME", name);
485 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
486 StatsWriteHiSysEvent(statsService,
487 HiSysEvent::Domain::POWER, StatsHiSysEvent::POWER_RUNNINGLOCK, HiSysEvent::EventType::STATISTIC, "PID", pid,
488 "UID", uid, "STATE", stateUnlock, "TYPE", type, "NAME", name);
489
490 auto statsCore = statsService->GetBatteryStatsCore();
491 auto wakelockEntity = statsCore->GetEntity(BatteryStatsInfo::CONSUMPTION_TYPE_WAKELOCK);
492 statsCore->ComputePower();
493
494 double expectedPower = wakelockAverage * SERVICE_POWER_CONSUMPTION_DURATION_US / US_PER_HOUR;
495 double actualPower = wakelockEntity->GetStatsPowerMah(StatsUtils::STATS_TYPE_WAKELOCK_HOLD, uid);
496 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
497 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
498 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
499 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
500
501 EXPECT_EQ(StatsUtils::DEFAULT_VALUE, wakelockEntity->GetStatsPowerMah(StatsUtils::STATS_TYPE_WAKELOCK_HOLD));
502 EXPECT_EQ(StatsUtils::DEFAULT_VALUE, wakelockEntity->GetStatsPowerMah(StatsUtils::STATS_TYPE_INVALID, uid));
503 STATS_HILOGI(LABEL_TEST, "StatsServicePowerMgrTest_010 end");
504 }
505
506 /**
507 * @tc.name: StatsServicePowerMgrTest_011
508 * @tc.desc: test send hisysevent with missing information(Sensor)
509 * @tc.type: FUNC
510 * @tc.require: issueI663DX
511 */
512 HWTEST_F (StatsServicePowerMgrTest, StatsServicePowerMgrTest_011, TestSize.Level0)
513 {
514 STATS_HILOGI(LABEL_TEST, "StatsServicePowerMgrTest_011 start");
515 ASSERT_NE(g_statsServiceProxy, nullptr);
516 auto statsService = BatteryStatsService::GetInstance();
517 g_statsServiceProxy->ResetIpc();
518
519 int32_t uid = 10003;
520
521 StatsWriteHiSysEvent(statsService,
522 HiSysEvent::Domain::STATS, StatsHiSysEvent::POWER_SENSOR_GRAVITY, HiSysEvent::EventType::STATISTIC);
523 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
524 StatsWriteHiSysEvent(statsService,
525 HiSysEvent::Domain::STATS, StatsHiSysEvent::POWER_SENSOR_GRAVITY, HiSysEvent::EventType::STATISTIC);
526
527 StatsWriteHiSysEvent(statsService,
528 HiSysEvent::Domain::STATS, StatsHiSysEvent::POWER_SENSOR_PROXIMITY, HiSysEvent::EventType::STATISTIC);
529 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
530 StatsWriteHiSysEvent(statsService,
531 HiSysEvent::Domain::STATS, StatsHiSysEvent::POWER_SENSOR_PROXIMITY, HiSysEvent::EventType::STATISTIC);
532 int32_t tempError;
533 double expectedPower = StatsUtils::DEFAULT_VALUE;
534 double actualPower;
535 g_statsServiceProxy->GetAppStatsMahIpc(uid, actualPower, tempError);
536 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
537 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
538 EXPECT_EQ(expectedPower, actualPower);
539 STATS_HILOGI(LABEL_TEST, "StatsServicePowerMgrTest_011 end");
540 }
541
542 /**
543 * @tc.name: StatsServicePowerMgrTest_012
544 * @tc.desc: test batteryStatics Start
545 * @tc.type: FUNC
546 * @tc.require: issueI663DX
547 */
548 HWTEST_F (StatsServicePowerMgrTest, StatsServicePowerMgrTest_012, TestSize.Level0)
549 {
550 STATS_HILOGI(LABEL_TEST, "StatsServicePowerMgrTest_012 start");
551 auto statsService = BatteryStatsService::GetInstance();
552 EXPECT_TRUE(statsService != nullptr);
553 statsService->OnStart();
554 statsService->RegisterBootCompletedCallback();
555 statsService->OnStop();
556 statsService->DestroyInstance();
557 STATS_HILOGI(LABEL_TEST, "StatsServicePowerMgrTest_012 end");
558 }
559
560 }