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