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