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