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