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