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