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_location_test.h"
17 #include "stats_log.h"
18
19 #include <hisysevent.h>
20
21 #include "battery_stats_client.h"
22 #include "stats_hisysevent.h"
23
24 using namespace testing::ext;
25 using namespace OHOS::HiviewDFX;
26 using namespace OHOS::PowerMgr;
27 using namespace std;
28
29
SetUpTestCase()30 void StatsLocationTest::SetUpTestCase()
31 {
32 ParserAveragePowerFile();
33 system("hidumper -s 3302 -a -u");
34 }
35
36
TearDownTestCase()37 void StatsLocationTest::TearDownTestCase()
38 {
39 system("hidumper -s 3302 -a -r");
40 }
41
SetUp()42 void StatsLocationTest::SetUp()
43 {
44 auto& statsClient = BatteryStatsClient::GetInstance();
45 statsClient.SetOnBattery(true);
46 }
47
TearDown()48 void StatsLocationTest::TearDown()
49 {
50 auto& statsClient = BatteryStatsClient::GetInstance();
51 statsClient.SetOnBattery(false);
52 }
53
54 namespace {
55 /**
56 * @tc.name: StatsLocationTest_001
57 * @tc.desc: test Reset function(GNSS)
58 * @tc.type: FUNC
59 * @tc.require: issueI5HWJK
60 */
HWTEST_F(StatsLocationTest, StatsLocationTest_001, TestSize.Level0)61 HWTEST_F (StatsLocationTest, StatsLocationTest_001, TestSize.Level0)
62 {
63 STATS_HILOGI(LABEL_TEST, "StatsLocationTest_001 start");
64 auto& statsClient = BatteryStatsClient::GetInstance();
65 statsClient.Reset();
66
67 int32_t uid = 10003;
68 int32_t pid = 3458;
69 std::string stateOn = "start";
70 std::string stateOff = "stop";
71
72 HiSysEventWrite(HiSysEvent::Domain::LOCATION, StatsHiSysEvent::GNSS_STATE, HiSysEvent::EventType::STATISTIC,
73 "PID", pid, "UID", uid, "STATE", stateOn);
74 usleep(POWER_CONSUMPTION_DURATION_US);
75 HiSysEventWrite(HiSysEvent::Domain::LOCATION, StatsHiSysEvent::GNSS_STATE, HiSysEvent::EventType::STATISTIC,
76 "PID", pid, "UID", uid, "STATE", stateOff);
77
78 double powerMahBefore = statsClient.GetAppStatsMah(uid);
79 statsClient.Reset();
80 double powerMahAfter = statsClient.GetAppStatsMah(uid);
81 GTEST_LOG_(INFO) << __func__ << ": before consumption = " << powerMahBefore << " mAh";
82 GTEST_LOG_(INFO) << __func__ << ": after consumption = " << powerMahAfter << " mAh";
83 EXPECT_TRUE(powerMahBefore >= StatsUtils::DEFAULT_VALUE && powerMahAfter == StatsUtils::DEFAULT_VALUE);
84 STATS_HILOGI(LABEL_TEST, "StatsLocationTest_001 end");
85 }
86
87 /**
88 * @tc.name: StatsLocationTest_002
89 * @tc.desc: test GetAppStatsMah function(Gnss)
90 * @tc.type: FUNC
91 * @tc.require: issueI5HWJK
92 */
HWTEST_F(StatsLocationTest, StatsLocationTest_002, TestSize.Level0)93 HWTEST_F (StatsLocationTest, StatsLocationTest_002, TestSize.Level0)
94 {
95 STATS_HILOGI(LABEL_TEST, "StatsLocationTest_002 start");
96 auto& statsClient = BatteryStatsClient::GetInstance();
97 statsClient.Reset();
98
99 double gnssOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_GNSS_ON);
100 int32_t uid = 10003;
101 int32_t pid = 3458;
102 std::string stateOn = "start";
103 std::string stateOff = "stop";
104
105 HiSysEventWrite(HiSysEvent::Domain::LOCATION, StatsHiSysEvent::GNSS_STATE, HiSysEvent::EventType::STATISTIC,
106 "PID", pid, "UID", uid, "STATE", stateOn);
107 usleep(POWER_CONSUMPTION_DURATION_US);
108 HiSysEventWrite(HiSysEvent::Domain::LOCATION, StatsHiSysEvent::GNSS_STATE, HiSysEvent::EventType::STATISTIC,
109 "PID", pid, "UID", uid, "STATE", stateOff);
110
111 double expectedPower = POWER_CONSUMPTION_DURATION_US * gnssOnAverageMa / US_PER_HOUR;
112 double actualPower = statsClient.GetAppStatsMah(uid);
113 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
114 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
115 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
116 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
117 STATS_HILOGI(LABEL_TEST, "StatsLocationTest_002 end");
118 }
119
120 /**
121 * @tc.name: StatsLocationTest_003
122 * @tc.desc: test GetAppStatsPercent function(GNSS)
123 * @tc.type: FUNC
124 * @tc.require: issueI5HWJK
125 */
HWTEST_F(StatsLocationTest, StatsLocationTest_003, TestSize.Level0)126 HWTEST_F (StatsLocationTest, StatsLocationTest_003, TestSize.Level0)
127 {
128 STATS_HILOGI(LABEL_TEST, "StatsLocationTest_003 start");
129 auto& statsClient = BatteryStatsClient::GetInstance();
130 statsClient.Reset();
131
132 int32_t uid = 10003;
133 int32_t pid = 3458;
134 std::string stateOn = "start";
135 std::string stateOff = "stop";
136 double fullPercent = 1;
137 double zeroPercent = 0;
138
139 HiSysEventWrite(HiSysEvent::Domain::LOCATION, StatsHiSysEvent::GNSS_STATE, HiSysEvent::EventType::STATISTIC,
140 "PID", pid, "UID", uid, "STATE", stateOn);
141 usleep(POWER_CONSUMPTION_DURATION_US);
142 HiSysEventWrite(HiSysEvent::Domain::LOCATION, StatsHiSysEvent::GNSS_STATE, HiSysEvent::EventType::STATISTIC,
143 "PID", pid, "UID", uid, "STATE", stateOff);
144
145 double actualPercent = statsClient.GetAppStatsPercent(uid);
146 GTEST_LOG_(INFO) << __func__ << ": actual percent = " << actualPercent;
147 EXPECT_TRUE(actualPercent >= zeroPercent && actualPercent <= fullPercent);
148 STATS_HILOGI(LABEL_TEST, "StatsLocationTest_003 end");
149 }
150
151 /**
152 * @tc.name: StatsLocationTest_004
153 * @tc.desc: test GNSS_STATE event are sent repeatedly, gnss power consumption(GNSS)
154 * @tc.type: FUNC
155 * @tc.require: issueI5HWJK
156 */
HWTEST_F(StatsLocationTest, StatsLocationTest_004, TestSize.Level0)157 HWTEST_F (StatsLocationTest, StatsLocationTest_004, TestSize.Level0)
158 {
159 STATS_HILOGI(LABEL_TEST, "StatsLocationTest_004 start");
160 auto& statsClient = BatteryStatsClient::GetInstance();
161 statsClient.Reset();
162
163 double gnssOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_GNSS_ON);
164 int32_t uid = 10003;
165 int32_t pid = 3458;
166 std::string stateOn = "start";
167 std::string stateOff = "stop";
168
169 HiSysEventWrite(HiSysEvent::Domain::LOCATION, StatsHiSysEvent::GNSS_STATE, HiSysEvent::EventType::STATISTIC,
170 "PID", pid, "UID", uid, "STATE", stateOn);
171 usleep(POWER_CONSUMPTION_DURATION_US);
172 HiSysEventWrite(HiSysEvent::Domain::LOCATION, StatsHiSysEvent::GNSS_STATE, HiSysEvent::EventType::STATISTIC,
173 "PID", pid, "UID", uid, "STATE", stateOn);
174 usleep(POWER_CONSUMPTION_DURATION_US);
175 HiSysEventWrite(HiSysEvent::Domain::LOCATION, StatsHiSysEvent::GNSS_STATE, HiSysEvent::EventType::STATISTIC,
176 "PID", pid, "UID", uid, "STATE", stateOff);
177 usleep(POWER_CONSUMPTION_DURATION_US);
178 HiSysEventWrite(HiSysEvent::Domain::LOCATION, StatsHiSysEvent::GNSS_STATE, HiSysEvent::EventType::STATISTIC,
179 "PID", pid, "UID", uid, "STATE", stateOff);
180
181 double expectedPower = 2 * POWER_CONSUMPTION_DURATION_US * gnssOnAverageMa / US_PER_HOUR;
182 double actualPower = statsClient.GetAppStatsMah(uid);
183 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
184 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
185 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
186 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
187 STATS_HILOGI(LABEL_TEST, "StatsLocationTest_004 end");
188 }
189
190 /**
191 * @tc.name: StatsLocationTest_005
192 * @tc.desc: test test GetAppStatsMah function, GNSS abnormal state test(GNSS is off)
193 * @tc.type: FUNC
194 * @tc.require: issueI5HWJK
195 */
HWTEST_F(StatsLocationTest, StatsLocationTest_005, TestSize.Level0)196 HWTEST_F (StatsLocationTest, StatsLocationTest_005, TestSize.Level0)
197 {
198 STATS_HILOGI(LABEL_TEST, "StatsLocationTest_005 start");
199 auto& statsClient = BatteryStatsClient::GetInstance();
200 statsClient.Reset();
201
202 int32_t uid = 10003;
203 int32_t pid = 3458;
204 std::string stateInvaildOn = "star";
205 std::string stateOff = "stop";
206
207 HiSysEventWrite(HiSysEvent::Domain::LOCATION, StatsHiSysEvent::GNSS_STATE, HiSysEvent::EventType::STATISTIC,
208 "PID", pid, "UID", uid, "STATE", stateInvaildOn);
209 usleep(POWER_CONSUMPTION_DURATION_US);
210 HiSysEventWrite(HiSysEvent::Domain::LOCATION, StatsHiSysEvent::GNSS_STATE, HiSysEvent::EventType::STATISTIC,
211 "PID", pid, "UID", uid, "STATE", stateOff);
212
213 double expectedPower = StatsUtils::DEFAULT_VALUE;
214 double actualPower = statsClient.GetAppStatsMah(uid);
215 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
216 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
217 EXPECT_EQ(expectedPower, actualPower);
218 STATS_HILOGI(LABEL_TEST, "StatsLocationTest_005 end");
219 }
220
221 /**
222 * @tc.name: StatsLocationTest_006
223 * @tc.desc: test test GetAppStatsMah function, GNSS abnormal state test(GNSS is On)
224 * @tc.type: FUNC
225 * @tc.require: issueI5HWJK
226 */
HWTEST_F(StatsLocationTest, StatsLocationTest_006, TestSize.Level0)227 HWTEST_F (StatsLocationTest, StatsLocationTest_006, TestSize.Level0)
228 {
229 STATS_HILOGI(LABEL_TEST, "StatsLocationTest_006 start");
230 auto& statsClient = BatteryStatsClient::GetInstance();
231 statsClient.Reset();
232
233 double gnssOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_GNSS_ON);
234 int32_t uid = 10003;
235 int32_t pid = 3458;
236 std::string stateOn = "start";
237 std::string stateOff = "stop";
238 std::string stateInvaildOn = "star";
239 std::string stateInvaildOff = "stp";
240
241 HiSysEventWrite(HiSysEvent::Domain::LOCATION, StatsHiSysEvent::GNSS_STATE, HiSysEvent::EventType::STATISTIC,
242 "PID", pid, "UID", uid, "STATE", stateOn);
243 usleep(POWER_CONSUMPTION_DURATION_US);
244 HiSysEventWrite(HiSysEvent::Domain::LOCATION, StatsHiSysEvent::GNSS_STATE, HiSysEvent::EventType::STATISTIC,
245 "PID", pid, "UID", uid, "STATE", stateInvaildOn);
246 usleep(POWER_CONSUMPTION_DURATION_US);
247 HiSysEventWrite(HiSysEvent::Domain::LOCATION, StatsHiSysEvent::GNSS_STATE, HiSysEvent::EventType::STATISTIC,
248 "PID", pid, "UID", uid, "STATE", stateInvaildOff);
249 usleep(POWER_CONSUMPTION_DURATION_US);
250 HiSysEventWrite(HiSysEvent::Domain::LOCATION, StatsHiSysEvent::GNSS_STATE, HiSysEvent::EventType::STATISTIC,
251 "PID", pid, "UID", uid, "STATE", stateOff);
252
253 double expectedPower = 3 * POWER_CONSUMPTION_DURATION_US * gnssOnAverageMa / US_PER_HOUR;
254 double actualPower = statsClient.GetAppStatsMah(uid);
255 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
256 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
257 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
258 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
259 STATS_HILOGI(LABEL_TEST, "StatsLocationTest_006 end");
260 }
261
262 /**
263 * @tc.name: StatsLocationTest_007
264 * @tc.desc: test GetTotalTimeSecond function(GNSS)
265 * @tc.type: FUNC
266 * @tc.require: issueI5HWJK
267 */
HWTEST_F(StatsLocationTest, StatsLocationTest_007, TestSize.Level0)268 HWTEST_F (StatsLocationTest, StatsLocationTest_007, TestSize.Level0)
269 {
270 STATS_HILOGI(LABEL_TEST, "StatsLocationTest_007 start");
271 auto& statsClient = BatteryStatsClient::GetInstance();
272 statsClient.Reset();
273
274 std::string stateOn = "start";
275 std::string stateOff = "stop";
276 int32_t uid = 10003;
277 int32_t pid = 3458;
278
279 HiSysEventWrite(HiSysEvent::Domain::LOCATION, StatsHiSysEvent::GNSS_STATE, HiSysEvent::EventType::STATISTIC,
280 "PID", pid, "UID", uid, "STATE", stateOn);
281 usleep(POWER_CONSUMPTION_DURATION_US);
282 HiSysEventWrite(HiSysEvent::Domain::LOCATION, StatsHiSysEvent::GNSS_STATE, HiSysEvent::EventType::STATISTIC,
283 "PID", pid, "UID", uid, "STATE", stateOff);
284
285 long expectedTime = round(POWER_CONSUMPTION_DURATION_US / US_PER_SECOND);
286 long actualTime = statsClient.GetTotalTimeSecond(StatsUtils::STATS_TYPE_GNSS_ON, uid);
287 GTEST_LOG_(INFO) << __func__ << ": expected time = " << expectedTime << " seconds";
288 GTEST_LOG_(INFO) << __func__ << ": actual time = " << actualTime << " seconds";
289 EXPECT_EQ(expectedTime, actualTime);
290 STATS_HILOGI(LABEL_TEST, "StatsLocationTest_007 end");
291 }
292
293 /**
294 * @tc.name: StatsLocationTest_008
295 * @tc.desc: test test GetAppStatsMah function with different UID(GNSS)
296 * @tc.type: FUNC
297 * @tc.require: issueI5HWJK
298 */
HWTEST_F(StatsLocationTest, StatsLocationTest_008, TestSize.Level0)299 HWTEST_F (StatsLocationTest, StatsLocationTest_008, TestSize.Level0)
300 {
301 STATS_HILOGI(LABEL_TEST, "StatsLocationTest_008 start");
302 auto& statsClient = BatteryStatsClient::GetInstance();
303 statsClient.Reset();
304
305 double gnssOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_GNSS_ON);
306 std::string stateOn = "start";
307 std::string stateOff = "stop";
308 int32_t uidOne = 10003;
309 int32_t pidOne = 3458;
310 int32_t uidTwo = 10004;
311 int32_t pidTwo = 3459;
312
313 HiSysEventWrite(HiSysEvent::Domain::LOCATION, StatsHiSysEvent::GNSS_STATE, HiSysEvent::EventType::STATISTIC,
314 "PID", pidOne, "UID", uidOne, "STATE", stateOn);
315 usleep(POWER_CONSUMPTION_DURATION_US);
316 HiSysEventWrite(HiSysEvent::Domain::LOCATION, StatsHiSysEvent::GNSS_STATE, HiSysEvent::EventType::STATISTIC,
317 "PID", pidTwo, "UID", uidTwo, "STATE", stateOn);
318 usleep(POWER_CONSUMPTION_DURATION_US);
319 HiSysEventWrite(HiSysEvent::Domain::LOCATION, StatsHiSysEvent::GNSS_STATE, HiSysEvent::EventType::STATISTIC,
320 "PID", pidTwo, "UID", uidTwo, "STATE", stateOff);
321 usleep(POWER_CONSUMPTION_DURATION_US);
322 HiSysEventWrite(HiSysEvent::Domain::LOCATION, StatsHiSysEvent::GNSS_STATE, HiSysEvent::EventType::STATISTIC,
323 "PID", pidOne, "UID", uidOne, "STATE", stateOff);
324
325 double expectedPower = 3 * POWER_CONSUMPTION_DURATION_US * gnssOnAverageMa / US_PER_HOUR;
326 double actualPower = statsClient.GetAppStatsMah(uidOne);
327 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
328 GTEST_LOG_(INFO) << __func__ << ": expected first uid consumption = " << expectedPower << " mAh";
329 GTEST_LOG_(INFO) << __func__ << ": actual first uid consumption = " << actualPower << " mAh";
330 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
331
332 expectedPower = POWER_CONSUMPTION_DURATION_US * gnssOnAverageMa / US_PER_HOUR;
333 actualPower = statsClient.GetAppStatsMah(uidTwo);
334 devPrecent = abs(expectedPower - actualPower) / expectedPower;
335 GTEST_LOG_(INFO) << __func__ << ": expected second uid consumption = " << expectedPower << " mAh";
336 GTEST_LOG_(INFO) << __func__ << ": actual second uid consumption = " << actualPower << " mAh";
337 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
338 STATS_HILOGI(LABEL_TEST, "StatsLocationTest_008 end");
339 }
340
341 /**
342 * @tc.name: StatsLocationTest_009
343 * @tc.desc: test SetOnBattery function(GNSS)
344 * @tc.type: FUNC
345 * @tc.require: issueI5HWJK
346 */
HWTEST_F(StatsLocationTest, StatsLocationTest_009, TestSize.Level0)347 HWTEST_F (StatsLocationTest, StatsLocationTest_009, TestSize.Level0)
348 {
349 STATS_HILOGI(LABEL_TEST, "StatsLocationTest_009 start");
350 auto& statsClient = BatteryStatsClient::GetInstance();
351 statsClient.Reset();
352 statsClient.SetOnBattery(false);
353
354 int32_t uid = 10003;
355 int32_t pid = 3458;
356 std::string stateOn = "start";
357 std::string stateOff = "stop";
358
359 HiSysEventWrite(HiSysEvent::Domain::LOCATION, StatsHiSysEvent::GNSS_STATE, HiSysEvent::EventType::STATISTIC,
360 "PID", pid, "UID", uid, "STATE", stateOn);
361 usleep(POWER_CONSUMPTION_DURATION_US);
362 HiSysEventWrite(HiSysEvent::Domain::LOCATION, StatsHiSysEvent::GNSS_STATE, HiSysEvent::EventType::STATISTIC,
363 "PID", pid, "UID", uid, "STATE", stateOff);
364
365 double expectedPower = StatsUtils::DEFAULT_VALUE;
366 double actualPower = statsClient.GetAppStatsMah(uid);
367 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
368 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
369 EXPECT_EQ(expectedPower, actualPower);
370 statsClient.SetOnBattery(true);
371 STATS_HILOGI(LABEL_TEST, "StatsLocationTest_009 end");
372 }
373
374 /**
375 * @tc.name: StatsLocationTest_010
376 * @tc.desc: test GetPartStatsMah function with battery changed(GNSS)
377 * @tc.type: FUNC
378 * @tc.require: issueI5HWJK
379 */
HWTEST_F(StatsLocationTest, StatsLocationTest_010, TestSize.Level0)380 HWTEST_F (StatsLocationTest, StatsLocationTest_010, TestSize.Level0)
381 {
382 STATS_HILOGI(LABEL_TEST, "StatsLocationTest_010 start");
383 auto& statsClient = BatteryStatsClient::GetInstance();
384 statsClient.Reset();
385
386 double gnssOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_GNSS_ON);
387 int32_t uid = 10003;
388 int32_t pid = 3458;
389 std::string stateOn = "start";
390 std::string stateOff = "stop";
391
392 HiSysEventWrite(HiSysEvent::Domain::LOCATION, StatsHiSysEvent::GNSS_STATE, HiSysEvent::EventType::STATISTIC,
393 "PID", pid, "UID", uid, "STATE", stateOn);
394 usleep(POWER_CONSUMPTION_DURATION_US);
395 statsClient.SetOnBattery(false);
396 usleep(POWER_CONSUMPTION_DURATION_US);
397 statsClient.SetOnBattery(true);
398 usleep(POWER_CONSUMPTION_DURATION_US);
399 HiSysEventWrite(HiSysEvent::Domain::LOCATION, StatsHiSysEvent::GNSS_STATE, HiSysEvent::EventType::STATISTIC,
400 "PID", pid, "UID", uid, "STATE", stateOff);
401
402 double expectedPower = 2 * POWER_CONSUMPTION_DURATION_US * gnssOnAverageMa / US_PER_HOUR;
403 double actualPower = statsClient.GetAppStatsMah(uid);
404 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
405 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
406 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
407 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
408 STATS_HILOGI(LABEL_TEST, "StatsLocationTest_010 end");
409 }
410 }