1 /*
2  * Copyright (c) 2022-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 "stats_service_powermgr_test.h"
17 
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     ASSERT_NE(g_statsServiceProxy, nullptr);
84     auto statsService = BatteryStatsService::GetInstance();
85     g_statsServiceProxy->Reset();
86 
87     int32_t stateOn = 1;
88     int32_t stateOff = 0;
89     int32_t uid = 10003;
90     int32_t pid = 3458;
91 
92     StatsWriteHiSysEvent(statsService,
93         HiSysEvent::Domain::STATS, StatsHiSysEvent::POWER_SENSOR_GRAVITY,
94         HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateOn);
95     usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
96     StatsWriteHiSysEvent(statsService,
97         HiSysEvent::Domain::STATS, StatsHiSysEvent::POWER_SENSOR_GRAVITY,
98         HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateOff);
99 
100     long expectedTime = round(SERVICE_POWER_CONSUMPTION_DURATION_US / US_PER_SECOND);
101     long actualTime = g_statsServiceProxy->GetTotalTimeSecond(StatsUtils::STATS_TYPE_SENSOR_GRAVITY_ON, uid);
102     GTEST_LOG_(INFO) << __func__ << ": expected time = " << expectedTime << " seconds";
103     GTEST_LOG_(INFO) << __func__ << ": actual time = " <<  actualTime << " seconds";
104     EXPECT_EQ(expectedTime, actualTime);
105 }
106 
107 /**
108  * @tc.name: StatsServicePowerMgrTest_002
109  * @tc.desc: test GetAppStatsMah function(Sensor Gravity)
110  * @tc.type: FUNC
111  * @tc.require: issueI663DX
112  */
113 HWTEST_F (StatsServicePowerMgrTest, StatsServicePowerMgrTest_002, TestSize.Level0)
114 {
115     ASSERT_NE(g_statsServiceProxy, nullptr);
116     auto statsService = BatteryStatsService::GetInstance();
117     g_statsServiceProxy->Reset();
118 
119     double sensorGravityOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_SENSOR_GRAVITY);
120     int32_t uid = 10003;
121     int32_t pid = 3458;
122     int32_t stateOn = 1;
123     int32_t stateOff = 0;
124 
125     StatsWriteHiSysEvent(statsService,
126         HiSysEvent::Domain::STATS, StatsHiSysEvent::POWER_SENSOR_GRAVITY, HiSysEvent::EventType::STATISTIC, "PID",
127         pid, "UID", uid, "STATE", stateOn);
128     usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
129     StatsWriteHiSysEvent(statsService,
130         HiSysEvent::Domain::STATS, StatsHiSysEvent::POWER_SENSOR_GRAVITY, HiSysEvent::EventType::STATISTIC, "PID",
131         pid, "UID", uid, "STATE", stateOff);
132 
133     double expectedPower = SERVICE_POWER_CONSUMPTION_DURATION_US * sensorGravityOnAverageMa / US_PER_HOUR;
134     double actualPower = g_statsServiceProxy->GetAppStatsMah(uid);
135     double devPrecent = abs(expectedPower - actualPower) / expectedPower;
136     GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
137     GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
138     EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
139 }
140 
141 /**
142  * @tc.name: StatsServicePowerMgrTest_003
143  * @tc.desc: test GetAppStatsPercent function(Sensor Gravity)
144  * @tc.type: FUNC
145  * @tc.require: issueI663DX
146  */
147 HWTEST_F (StatsServicePowerMgrTest, StatsServicePowerMgrTest_003, TestSize.Level0)
148 {
149     ASSERT_NE(g_statsServiceProxy, nullptr);
150     auto statsService = BatteryStatsService::GetInstance();
151     g_statsServiceProxy->Reset();
152 
153     int32_t uid = 10003;
154     int32_t pid = 3458;
155     int32_t stateOn = 1;
156     int32_t stateOff = 0;
157     double fullPercent = 1;
158     double zeroPercent = 0;
159 
160     StatsWriteHiSysEvent(statsService,
161         HiSysEvent::Domain::STATS, StatsHiSysEvent::POWER_SENSOR_GRAVITY, HiSysEvent::EventType::STATISTIC, "PID",
162         pid, "UID", uid, "STATE", stateOn);
163     usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
164     StatsWriteHiSysEvent(statsService,
165         HiSysEvent::Domain::STATS, StatsHiSysEvent::POWER_SENSOR_GRAVITY, HiSysEvent::EventType::STATISTIC, "PID",
166         pid, "UID", uid, "STATE", stateOff);
167     double actualPercent = g_statsServiceProxy->GetAppStatsPercent(uid);
168     GTEST_LOG_(INFO) << __func__ << ": actual percent = " << actualPercent;
169     EXPECT_TRUE(actualPercent >= zeroPercent && actualPercent <= fullPercent);
170 }
171 
172 /**
173  * @tc.name: StatsServicePowerMgrTest_004
174  * @tc.desc: test GetAppStatsMah(Sensor Gravity) and GetAppStatsPercent(Sensor Proximity) function
175  * @tc.type: FUNC
176  * @tc.require: issueI663DX
177  */
178 HWTEST_F (StatsServicePowerMgrTest, StatsServicePowerMgrTest_004, TestSize.Level0)
179 {
180     ASSERT_NE(g_statsServiceProxy, nullptr);
181     auto statsService = BatteryStatsService::GetInstance();
182     g_statsServiceProxy->Reset();
183 
184     double sensorGravityOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_SENSOR_GRAVITY);
185     int32_t uid = 10003;
186     int32_t pid = 3458;
187     int32_t stateOn = 1;
188     int32_t stateOff = 0;
189 
190     StatsWriteHiSysEvent(statsService,
191         HiSysEvent::Domain::STATS, StatsHiSysEvent::POWER_SENSOR_GRAVITY, HiSysEvent::EventType::STATISTIC, "PID",
192         pid, "UID", uid, "STATE", stateOn);
193     usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
194     StatsWriteHiSysEvent(statsService,
195         HiSysEvent::Domain::STATS, StatsHiSysEvent::POWER_SENSOR_GRAVITY, HiSysEvent::EventType::STATISTIC, "PID",
196         pid, "UID", uid, "STATE", stateOff);
197 
198     double expectedPower = SERVICE_POWER_CONSUMPTION_DURATION_US * sensorGravityOnAverageMa / US_PER_HOUR;
199     double actualPower = g_statsServiceProxy->GetAppStatsMah(uid);
200     double devPrecent = abs(expectedPower - actualPower) / expectedPower;
201     GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
202     GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
203     EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
204 
205     uid = 10004;
206     pid = 3459;
207     stateOn = 1;
208     stateOff = 0;
209     double fullPercent = 1;
210     double zeroPercent = 0;
211 
212     StatsWriteHiSysEvent(statsService,
213         HiSysEvent::Domain::STATS, StatsHiSysEvent::POWER_SENSOR_PROXIMITY, HiSysEvent::EventType::STATISTIC, "PID",
214         pid, "UID", uid, "STATE", stateOn);
215     usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
216     StatsWriteHiSysEvent(statsService,
217         HiSysEvent::Domain::STATS, StatsHiSysEvent::POWER_SENSOR_PROXIMITY, HiSysEvent::EventType::STATISTIC, "PID",
218         pid, "UID", uid, "STATE", stateOff);
219     double actualPercent = g_statsServiceProxy->GetAppStatsPercent(uid);
220     GTEST_LOG_(INFO) << __func__ << ": actual percent = " << actualPercent;
221     EXPECT_TRUE(actualPercent >= zeroPercent && actualPercent <= fullPercent);
222 }
223 
224 /**
225  * @tc.name: StatsServicePowerMgrTest_005
226  * @tc.desc: test GetTotalTimeSecond function(Sensor Proximity)
227  * @tc.type: FUNC
228  * @tc.require: issueI663DX
229  */
230 HWTEST_F (StatsServicePowerMgrTest, StatsServicePowerMgrTest_005, TestSize.Level0)
231 {
232     ASSERT_NE(g_statsServiceProxy, nullptr);
233     auto statsService = BatteryStatsService::GetInstance();
234     g_statsServiceProxy->Reset();
235 
236     int32_t stateOn = 1;
237     int32_t stateOff = 0;
238     int32_t uid = 10003;
239     int32_t pid = 3458;
240 
241     StatsWriteHiSysEvent(statsService,
242         HiSysEvent::Domain::STATS, StatsHiSysEvent::POWER_SENSOR_PROXIMITY, HiSysEvent::EventType::STATISTIC, "PID",
243         pid, "UID", uid, "STATE", stateOn);
244     usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
245     StatsWriteHiSysEvent(statsService,
246         HiSysEvent::Domain::STATS, StatsHiSysEvent::POWER_SENSOR_PROXIMITY, HiSysEvent::EventType::STATISTIC, "PID",
247         pid, "UID", uid, "STATE", stateOff);
248 
249     double expectedPower = StatsUtils::DEFAULT_VALUE;
250     double actualPower = g_statsServiceProxy->GetTotalTimeSecond(StatsUtils::STATS_TYPE_SENSOR_PROXIMITY_ON, uid);
251     GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
252     GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
253     EXPECT_EQ(expectedPower, actualPower);
254 }
255 
256 /**
257  * @tc.name: StatsServicePowerMgrTest_006
258  * @tc.desc: test GetAppStatsMah function(Sensor Proximity)
259  * @tc.type: FUNC
260  * @tc.require: issueI663DX
261  */
262 HWTEST_F (StatsServicePowerMgrTest, StatsServicePowerMgrTest_006, TestSize.Level0)
263 {
264     ASSERT_NE(g_statsServiceProxy, nullptr);
265     auto statsService = BatteryStatsService::GetInstance();
266     g_statsServiceProxy->Reset();
267 
268     double sensorProximityOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_SENSOR_PROXIMITY);
269     int32_t uid = 10003;
270     int32_t pid = 3458;
271     int32_t stateOn = 1;
272     int32_t stateOff = 0;
273 
274     StatsWriteHiSysEvent(statsService,
275         HiSysEvent::Domain::STATS, StatsHiSysEvent::POWER_SENSOR_PROXIMITY, HiSysEvent::EventType::STATISTIC, "PID",
276         pid, "UID", uid, "STATE", stateOn);
277     usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
278     StatsWriteHiSysEvent(statsService,
279         HiSysEvent::Domain::STATS, StatsHiSysEvent::POWER_SENSOR_PROXIMITY, HiSysEvent::EventType::STATISTIC, "PID",
280         pid, "UID", uid, "STATE", stateOff);
281 
282     double expectedPower = SERVICE_POWER_CONSUMPTION_DURATION_US * sensorProximityOnAverageMa / US_PER_HOUR;
283     double actualPower = g_statsServiceProxy->GetAppStatsMah(uid);
284     double devPrecent = abs(expectedPower - actualPower) / expectedPower;
285     GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
286     GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
287     EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
288 }
289 
290 /**
291  * @tc.name: StatsServicePowerMgrTest_007
292  * @tc.desc: test GetAppStatsPercent function(Sensor Proximity)
293  * @tc.type: FUNC
294  * @tc.require: issueI663DX
295  */
296 HWTEST_F (StatsServicePowerMgrTest, StatsServicePowerMgrTest_007, TestSize.Level0)
297 {
298     ASSERT_NE(g_statsServiceProxy, nullptr);
299     auto statsService = BatteryStatsService::GetInstance();
300     g_statsServiceProxy->Reset();
301 
302     int32_t uid = 10003;
303     int32_t pid = 3458;
304     int32_t stateOn = 1;
305     int32_t stateOff = 0;
306     double fullPercent = 1;
307     double zeroPercent = 0;
308 
309     StatsWriteHiSysEvent(statsService,
310         HiSysEvent::Domain::STATS, StatsHiSysEvent::POWER_SENSOR_PROXIMITY, HiSysEvent::EventType::STATISTIC, "PID",
311         pid, "UID", uid, "STATE", stateOn);
312     usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
313     StatsWriteHiSysEvent(statsService,
314         HiSysEvent::Domain::STATS, StatsHiSysEvent::POWER_SENSOR_PROXIMITY, HiSysEvent::EventType::STATISTIC, "PID",
315         pid, "UID", uid, "STATE", stateOff);
316     double actualPercent = g_statsServiceProxy->GetAppStatsPercent(uid);
317     GTEST_LOG_(INFO) << __func__ << ": actual percent = " << actualPercent;
318     EXPECT_TRUE(actualPercent >= zeroPercent && actualPercent <= fullPercent);
319 }
320 
321 /**
322  * @tc.name: StatsServicePowerMgrTest_008
323  * @tc.desc: test GetAppStatsMah(Sensor Proximity) and GetAppStatsPercent(Torch) function
324  * @tc.type: FUNC
325  * @tc.require: issueI663DX
326  */
327 HWTEST_F (StatsServicePowerMgrTest, StatsServicePowerMgrTest_008, TestSize.Level0)
328 {
329     ASSERT_NE(g_statsServiceProxy, nullptr);
330     auto statsService = BatteryStatsService::GetInstance();
331     g_statsServiceProxy->Reset();
332 
333     double sensorProximityOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_SENSOR_PROXIMITY);
334     int32_t uid = 10003;
335     int32_t pid = 3458;
336     int32_t stateOn = 1;
337     int32_t stateOff = 0;
338 
339     StatsWriteHiSysEvent(statsService,
340         HiSysEvent::Domain::STATS, StatsHiSysEvent::POWER_SENSOR_PROXIMITY, HiSysEvent::EventType::STATISTIC, "PID",
341         pid, "UID", uid, "STATE", stateOn);
342     usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
343     StatsWriteHiSysEvent(statsService,
344         HiSysEvent::Domain::STATS, StatsHiSysEvent::POWER_SENSOR_PROXIMITY, HiSysEvent::EventType::STATISTIC, "PID",
345         pid, "UID", uid, "STATE", stateOff);
346 
347     double expectedPower = SERVICE_POWER_CONSUMPTION_DURATION_US * sensorProximityOnAverageMa / US_PER_HOUR;
348     double actualPower = g_statsServiceProxy->GetAppStatsMah(uid);
349     double devPrecent = abs(expectedPower - actualPower) / expectedPower;
350     GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
351     GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
352     EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
353 
354     uid = 10004;
355     pid = 3459;
356     stateOn = 1;
357     stateOff = 0;
358     double fullPercent = 1;
359     double zeroPercent = 0;
360 
361     StatsWriteHiSysEvent(statsService,
362         HiSysEvent::Domain::CAMERA, StatsHiSysEvent::TORCH_STATE, HiSysEvent::EventType::STATISTIC, "PID", pid,
363         "UID", uid, "STATE", stateOn);
364     usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
365     StatsWriteHiSysEvent(statsService,
366         HiSysEvent::Domain::CAMERA, StatsHiSysEvent::TORCH_STATE, HiSysEvent::EventType::STATISTIC, "PID", pid,
367         "UID", uid, "STATE", stateOff);
368     double actualPercent = g_statsServiceProxy->GetAppStatsPercent(uid);
369     GTEST_LOG_(INFO) << __func__ << ": actual percent = " << actualPercent;
370     EXPECT_TRUE(actualPercent >= zeroPercent && actualPercent <= fullPercent);
371 }
372 
373 /**
374  * @tc.name: StatsServicePowerMgrTest_009
375  * @tc.desc: test sensor entity GetPartStatsMah function(Sensor)
376  * @tc.type: FUNC
377  * @tc.require: issueI663DX
378  */
379 HWTEST_F (StatsServicePowerMgrTest, StatsServicePowerMgrTest_009, TestSize.Level0)
380 {
381     ASSERT_NE(g_statsServiceProxy, nullptr);
382     auto statsService = BatteryStatsService::GetInstance();
383     g_statsServiceProxy->Reset();
384 
385     double sensorGravityOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_SENSOR_GRAVITY);
386     double sensorProximityOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_SENSOR_PROXIMITY);
387     int32_t uid = 10003;
388     int32_t pid = 3458;
389     int32_t stateOn = 1;
390     int32_t stateOff = 0;
391 
392     StatsWriteHiSysEvent(statsService,
393         HiSysEvent::Domain::STATS, StatsHiSysEvent::POWER_SENSOR_GRAVITY, HiSysEvent::EventType::STATISTIC, "PID",
394         pid, "UID", uid, "STATE", stateOn);
395     usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
396     StatsWriteHiSysEvent(statsService,
397         HiSysEvent::Domain::STATS, StatsHiSysEvent::POWER_SENSOR_GRAVITY, HiSysEvent::EventType::STATISTIC, "PID",
398         pid, "UID", uid, "STATE", stateOff);
399 
400     StatsWriteHiSysEvent(statsService,
401         HiSysEvent::Domain::STATS, StatsHiSysEvent::POWER_SENSOR_PROXIMITY, HiSysEvent::EventType::STATISTIC, "PID",
402         pid, "UID", uid, "STATE", stateOn);
403     usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
404     StatsWriteHiSysEvent(statsService,
405         HiSysEvent::Domain::STATS, StatsHiSysEvent::POWER_SENSOR_PROXIMITY, HiSysEvent::EventType::STATISTIC, "PID",
406         pid, "UID", uid, "STATE", stateOff);
407 
408     auto statsCore = statsService->GetBatteryStatsCore();
409     auto sensorEntity = statsCore->GetEntity(BatteryStatsInfo::CONSUMPTION_TYPE_SENSOR);
410     statsCore->ComputePower();
411 
412     double expectedPower = SERVICE_POWER_CONSUMPTION_DURATION_US *
413         (sensorGravityOnAverageMa + sensorProximityOnAverageMa)/ US_PER_HOUR;
414     double actualPower = sensorEntity->GetStatsPowerMah(StatsUtils::STATS_TYPE_SENSOR_GRAVITY_ON, uid) +
415         sensorEntity->GetStatsPowerMah(StatsUtils::STATS_TYPE_SENSOR_PROXIMITY_ON, uid);
416     double devPrecent = abs(expectedPower - actualPower) / expectedPower;
417     GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
418     GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
419     EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
420 
421     EXPECT_EQ(StatsUtils::DEFAULT_VALUE, sensorEntity->GetStatsPowerMah(StatsUtils::STATS_TYPE_SENSOR_GRAVITY_ON));
422     EXPECT_EQ(StatsUtils::DEFAULT_VALUE, sensorEntity->GetStatsPowerMah(StatsUtils::STATS_TYPE_SENSOR_PROXIMITY_ON));
423     EXPECT_EQ(StatsUtils::DEFAULT_VALUE, sensorEntity->GetStatsPowerMah(StatsUtils::STATS_TYPE_INVALID, uid));
424 }
425 
426 /**
427  *
428  * @tc.name: StatsServicePowerMgrTest_010
429  * @tc.desc: test wakelock entity GetPartStatsMah function(Wakelock)
430  * @tc.type: FUNC
431  * @tc.require: issueI663DX
432  */
433 HWTEST_F (StatsServicePowerMgrTest,  StatsServicePowerMgrTest_010, TestSize.Level0)
434 {
435     ASSERT_NE(g_statsServiceProxy, nullptr);
436     auto statsService = BatteryStatsService::GetInstance();
437     g_statsServiceProxy->Reset();
438 
439     double wakelockAverage = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_CPU_AWAKE);
440     int32_t uid = 10001;
441     int32_t pid = 3456;
442     int32_t stateLock = 1;
443     int32_t stateUnlock = 0;
444     int32_t type = static_cast<int32_t>(RunningLockType::RUNNINGLOCK_SCREEN);
445     std::string name = " StatsServicePowerMgrTest_010";
446 
447     StatsWriteHiSysEvent(statsService,
448         HiSysEvent::Domain::POWER, StatsHiSysEvent::POWER_RUNNINGLOCK, HiSysEvent::EventType::STATISTIC, "PID", pid,
449         "UID", uid, "STATE", stateLock, "TYPE", type, "NAME", name);
450     usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
451     StatsWriteHiSysEvent(statsService,
452         HiSysEvent::Domain::POWER, StatsHiSysEvent::POWER_RUNNINGLOCK, HiSysEvent::EventType::STATISTIC, "PID", pid,
453         "UID", uid, "STATE", stateUnlock, "TYPE", type, "NAME", name);
454 
455     auto statsCore = statsService->GetBatteryStatsCore();
456     auto wakelockEntity = statsCore->GetEntity(BatteryStatsInfo::CONSUMPTION_TYPE_WAKELOCK);
457     statsCore->ComputePower();
458 
459     double expectedPower = wakelockAverage * SERVICE_POWER_CONSUMPTION_DURATION_US / US_PER_HOUR;
460     double actualPower = wakelockEntity->GetStatsPowerMah(StatsUtils::STATS_TYPE_WAKELOCK_HOLD, uid);
461     double devPrecent = abs(expectedPower - actualPower) / expectedPower;
462     GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
463     GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
464     EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
465 
466     EXPECT_EQ(StatsUtils::DEFAULT_VALUE, wakelockEntity->GetStatsPowerMah(StatsUtils::STATS_TYPE_WAKELOCK_HOLD));
467     EXPECT_EQ(StatsUtils::DEFAULT_VALUE, wakelockEntity->GetStatsPowerMah(StatsUtils::STATS_TYPE_INVALID, uid));
468 }
469 
470 /**
471  * @tc.name: StatsServicePowerMgrTest_011
472  * @tc.desc: test send hisysevent with missing information(Sensor)
473  * @tc.type: FUNC
474  * @tc.require: issueI663DX
475  */
476 HWTEST_F (StatsServicePowerMgrTest, StatsServicePowerMgrTest_011, TestSize.Level0)
477 {
478     ASSERT_NE(g_statsServiceProxy, nullptr);
479     auto statsService = BatteryStatsService::GetInstance();
480     g_statsServiceProxy->Reset();
481 
482     int32_t uid = 10003;
483 
484     StatsWriteHiSysEvent(statsService,
485         HiSysEvent::Domain::STATS, StatsHiSysEvent::POWER_SENSOR_GRAVITY, HiSysEvent::EventType::STATISTIC);
486     usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
487     StatsWriteHiSysEvent(statsService,
488         HiSysEvent::Domain::STATS, StatsHiSysEvent::POWER_SENSOR_GRAVITY, HiSysEvent::EventType::STATISTIC);
489 
490     StatsWriteHiSysEvent(statsService,
491         HiSysEvent::Domain::STATS, StatsHiSysEvent::POWER_SENSOR_PROXIMITY, HiSysEvent::EventType::STATISTIC);
492     usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
493     StatsWriteHiSysEvent(statsService,
494         HiSysEvent::Domain::STATS, StatsHiSysEvent::POWER_SENSOR_PROXIMITY, HiSysEvent::EventType::STATISTIC);
495 
496     double expectedPower = StatsUtils::DEFAULT_VALUE;
497     double actualPower = g_statsServiceProxy->GetAppStatsMah(uid);
498     GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
499     GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
500     EXPECT_EQ(expectedPower, actualPower);
501 }
502 }