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