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_wifi_test.h"
17
18 #include <hisysevent.h>
19 #include "wifi_msg.h"
20 #include "stats_log.h"
21
22 #include "battery_stats_client.h"
23 #include "stats_hisysevent.h"
24
25 using namespace testing::ext;
26 using namespace OHOS::HiviewDFX;
27 using namespace OHOS::PowerMgr;
28 using namespace OHOS;
29 using namespace std;
30
31
SetUpTestCase()32 void StatsWifiTest::SetUpTestCase()
33 {
34 ParserAveragePowerFile();
35 system("hidumper -s 3302 -a -u");
36 }
37
TearDownTestCase()38 void StatsWifiTest::TearDownTestCase()
39 {
40 system("hidumper -s 3302 -a -r");
41 }
42
SetUp()43 void StatsWifiTest::SetUp()
44 {
45 auto& statsClient = BatteryStatsClient::GetInstance();
46 statsClient.SetOnBattery(true);
47 }
48
TearDown()49 void StatsWifiTest::TearDown()
50 {
51 auto& statsClient = BatteryStatsClient::GetInstance();
52 statsClient.SetOnBattery(false);
53 }
54
55 namespace {
56 /**
57 * @tc.name: StatsWifiTest_001
58 * @tc.desc: test Reset function(Wifi connection)
59 * @tc.type: FUNC
60 * @tc.require: issueI5HWJK
61 */
62 HWTEST_F (StatsWifiTest, StatsWifiTest_001, TestSize.Level0)
63 {
64 auto& statsClient = BatteryStatsClient::GetInstance();
65 statsClient.Reset();
66
67 int32_t stateOn = static_cast<int32_t>(Wifi::ConnState::CONNECTED);
68 int32_t stateOff = static_cast<int32_t>(Wifi::ConnState::DISCONNECTED);
69 HiSysEventWrite(HiSysEvent::Domain::COMMUNICATION, StatsHiSysEvent::WIFI_CONNECTION,
70 HiSysEvent::EventType::STATISTIC, "TYPE", stateOn);
71 usleep(POWER_CONSUMPTION_DURATION_US);
72 HiSysEventWrite(HiSysEvent::Domain::COMMUNICATION, StatsHiSysEvent::WIFI_CONNECTION,
73 HiSysEvent::EventType::STATISTIC, "TYPE", stateOff);
74
75 double powerMahBefore = statsClient.GetPartStatsMah(BatteryStatsInfo::CONSUMPTION_TYPE_WIFI);
76 statsClient.Reset();
77 double powerMahAfter = statsClient.GetPartStatsMah(BatteryStatsInfo::CONSUMPTION_TYPE_WIFI);
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: StatsWifiTest_002
85 * @tc.desc: test GetPartStatsMah function(Wifi connection)
86 * @tc.type: FUNC
87 * @tc.require: issueI5HWJK
88 */
89 HWTEST_F (StatsWifiTest, StatsWifiTest_002, TestSize.Level0)
90 {
91 auto& statsClient = BatteryStatsClient::GetInstance();
92 statsClient.Reset();
93
94 double wifiOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_WIFI_ON);
95 int32_t stateOn = static_cast<int32_t>(Wifi::ConnState::CONNECTED);
96 int32_t stateOff = static_cast<int32_t>(Wifi::ConnState::DISCONNECTED);
97 HiSysEventWrite(HiSysEvent::Domain::COMMUNICATION, StatsHiSysEvent::WIFI_CONNECTION,
98 HiSysEvent::EventType::STATISTIC, "TYPE", stateOn);
99 usleep(POWER_CONSUMPTION_DURATION_US);
100 HiSysEventWrite(HiSysEvent::Domain::COMMUNICATION, StatsHiSysEvent::WIFI_CONNECTION,
101 HiSysEvent::EventType::STATISTIC, "TYPE", stateOff);
102
103 double expectedPower = POWER_CONSUMPTION_DURATION_US * wifiOnAverageMa / US_PER_HOUR;
104 double actualPower = statsClient.GetPartStatsMah(BatteryStatsInfo::CONSUMPTION_TYPE_WIFI);
105 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
106 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
107 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
108 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
109 }
110
111 /**
112 * @tc.name: StatsWifiTest_003
113 * @tc.desc: test GetPartStatsPercent function(Wifi connection)
114 * @tc.type: FUNC
115 * @tc.require: issueI5HWJK
116 */
117 HWTEST_F (StatsWifiTest, StatsWifiTest_003, TestSize.Level0)
118 {
119 auto& statsClient = BatteryStatsClient::GetInstance();
120 statsClient.Reset();
121
122 int32_t stateOn = static_cast<int32_t>(Wifi::ConnState::CONNECTED);
123 int32_t stateOff = static_cast<int32_t>(Wifi::ConnState::DISCONNECTED);
124 double fullPercent = 1;
125 double zeroPercent = 0;
126
127 HiSysEventWrite(HiSysEvent::Domain::COMMUNICATION, StatsHiSysEvent::WIFI_CONNECTION,
128 HiSysEvent::EventType::STATISTIC, "TYPE", stateOn);
129 usleep(POWER_CONSUMPTION_DURATION_US);
130 HiSysEventWrite(HiSysEvent::Domain::COMMUNICATION, StatsHiSysEvent::WIFI_CONNECTION,
131 HiSysEvent::EventType::STATISTIC, "TYPE", stateOff);
132
133 double actualPercent = statsClient.GetPartStatsPercent(BatteryStatsInfo::CONSUMPTION_TYPE_WIFI);
134 GTEST_LOG_(INFO) << __func__ << ": actual percent = " << actualPercent;
135 EXPECT_TRUE(actualPercent >= zeroPercent && actualPercent <= fullPercent);
136 }
137
138 /**
139 * @tc.name: StatsWifiTest_004
140 * @tc.desc: test GetBatteryStats function
141 * @tc.type: FUNC
142 * @tc.require: issueI5HWJK
143 */
144 HWTEST_F (StatsWifiTest, StatsWifiTest_004, TestSize.Level0)
145 {
146 auto& statsClient = BatteryStatsClient::GetInstance();
147 statsClient.Reset();
148
149 double wifiOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_WIFI_ON);
150 int32_t stateOn = static_cast<int32_t>(Wifi::ConnState::CONNECTED);
151 int32_t stateOff = static_cast<int32_t>(Wifi::ConnState::DISCONNECTED);
152
153 HiSysEventWrite(HiSysEvent::Domain::COMMUNICATION, StatsHiSysEvent::WIFI_CONNECTION,
154 HiSysEvent::EventType::STATISTIC, "TYPE", stateOn);
155 usleep(POWER_CONSUMPTION_DURATION_US);
156 HiSysEventWrite(HiSysEvent::Domain::COMMUNICATION, StatsHiSysEvent::WIFI_CONNECTION,
157 HiSysEvent::EventType::STATISTIC, "TYPE", stateOff);
158
159 double expectedPower = POWER_CONSUMPTION_DURATION_US * wifiOnAverageMa / US_PER_HOUR;
160 double actualPower = StatsUtils::DEFAULT_VALUE;
161 auto list = statsClient.GetBatteryStats();
162 for (auto it : list) {
163 if ((*it).GetConsumptionType() == BatteryStatsInfo::CONSUMPTION_TYPE_WIFI) {
164 actualPower = (*it).GetPower();
165 }
166 }
167 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
168 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
169 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
170 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
171 }
172
173 /**
174 * @tc.name: StatsWifiTest_005
175 * @tc.desc: test WIFI_CONNECTION event are sent repeatedly, wifi on power consumption(Wifi connection)
176 * @tc.type: FUNC
177 * @tc.require: issueI5HWJK
178 */
179 HWTEST_F (StatsWifiTest, StatsWifiTest_005, TestSize.Level0)
180 {
181 auto& statsClient = BatteryStatsClient::GetInstance();
182 statsClient.Reset();
183
184 double wifiOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_WIFI_ON);
185 int32_t stateOn = static_cast<int32_t>(Wifi::ConnState::CONNECTED);
186 int32_t stateOff = static_cast<int32_t>(Wifi::ConnState::DISCONNECTED);
187
188 HiSysEventWrite(HiSysEvent::Domain::COMMUNICATION, StatsHiSysEvent::WIFI_CONNECTION,
189 HiSysEvent::EventType::STATISTIC, "TYPE", stateOn);
190 usleep(POWER_CONSUMPTION_DURATION_US);
191 HiSysEventWrite(HiSysEvent::Domain::COMMUNICATION, StatsHiSysEvent::WIFI_CONNECTION,
192 HiSysEvent::EventType::STATISTIC, "TYPE", stateOn);
193 usleep(POWER_CONSUMPTION_DURATION_US);
194 HiSysEventWrite(HiSysEvent::Domain::COMMUNICATION, StatsHiSysEvent::WIFI_CONNECTION,
195 HiSysEvent::EventType::STATISTIC, "TYPE", stateOff);
196 usleep(POWER_CONSUMPTION_DURATION_US);
197 HiSysEventWrite(HiSysEvent::Domain::COMMUNICATION, StatsHiSysEvent::WIFI_CONNECTION,
198 HiSysEvent::EventType::STATISTIC, "TYPE", stateOff);
199
200 double expectedPower = 2 * POWER_CONSUMPTION_DURATION_US * wifiOnAverageMa / US_PER_HOUR;
201 double actualPower = statsClient.GetPartStatsMah(BatteryStatsInfo::CONSUMPTION_TYPE_WIFI);
202 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
203 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
204 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
205 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
206 }
207
208 /**
209 * @tc.name: StatsWifiTest_006
210 * @tc.desc: test test GetAppStatsMah function, Wifi connection abnormal state test(Wifi is off)
211 * @tc.type: FUNC
212 * @tc.require: issueI5HWJK
213 */
214 HWTEST_F (StatsWifiTest, StatsWifiTest_006, TestSize.Level0)
215 {
216 auto& statsClient = BatteryStatsClient::GetInstance();
217 statsClient.Reset();
218
219 int32_t stateOn = 3;
220 int32_t stateOff = static_cast<int32_t>(Wifi::ConnState::DISCONNECTED);
221
222 HiSysEventWrite(HiSysEvent::Domain::COMMUNICATION, StatsHiSysEvent::WIFI_CONNECTION,
223 HiSysEvent::EventType::STATISTIC, "TYPE", stateOn);
224 usleep(POWER_CONSUMPTION_DURATION_US);
225 HiSysEventWrite(HiSysEvent::Domain::COMMUNICATION, StatsHiSysEvent::WIFI_CONNECTION,
226 HiSysEvent::EventType::STATISTIC, "TYPE", stateOff);
227
228 double expectedPower = StatsUtils::DEFAULT_VALUE;
229 double actualPower = statsClient.GetPartStatsMah(BatteryStatsInfo::CONSUMPTION_TYPE_WIFI);
230 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
231 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
232 EXPECT_EQ(expectedPower, actualPower);
233 }
234
235 /**
236 * @tc.name: StatsWifiTest_007
237 * @tc.desc: test test GetAppStatsMah function, Wifi connection abnormal state test(Wifi is on)
238 * @tc.type: FUNC
239 * @tc.require: issueI5HWJK
240 */
241 HWTEST_F (StatsWifiTest, StatsWifiTest_007, TestSize.Level0)
242 {
243 auto& statsClient = BatteryStatsClient::GetInstance();
244 statsClient.Reset();
245
246 double wifiOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_WIFI_ON);
247 int32_t stateOn = static_cast<int32_t>(Wifi::ConnState::CONNECTED);
248 int32_t stateOff = static_cast<int32_t>(Wifi::ConnState::DISCONNECTED);
249 int32_t stateInvaildOn = 5;
250 int32_t stateInvaildOff = -1;
251
252 HiSysEventWrite(HiSysEvent::Domain::COMMUNICATION, StatsHiSysEvent::WIFI_CONNECTION,
253 HiSysEvent::EventType::STATISTIC, "TYPE", stateOn);
254 usleep(POWER_CONSUMPTION_DURATION_US);
255 HiSysEventWrite(HiSysEvent::Domain::COMMUNICATION, StatsHiSysEvent::WIFI_CONNECTION,
256 HiSysEvent::EventType::STATISTIC, "TYPE", stateInvaildOn);
257 usleep(POWER_CONSUMPTION_DURATION_US);
258 HiSysEventWrite(HiSysEvent::Domain::COMMUNICATION, StatsHiSysEvent::WIFI_CONNECTION,
259 HiSysEvent::EventType::STATISTIC, "TYPE", stateInvaildOff);
260 usleep(POWER_CONSUMPTION_DURATION_US);
261 HiSysEventWrite(HiSysEvent::Domain::COMMUNICATION, StatsHiSysEvent::WIFI_CONNECTION,
262 HiSysEvent::EventType::STATISTIC, "TYPE", stateOff);
263
264 double expectedPower = 3 * POWER_CONSUMPTION_DURATION_US * wifiOnAverageMa / US_PER_HOUR;
265 double actualPower = statsClient.GetPartStatsMah(BatteryStatsInfo::CONSUMPTION_TYPE_WIFI);
266 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
267 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
268 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
269 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
270 }
271
272 /**
273 * @tc.name: StatsWifiTest_008
274 * @tc.desc: test GetTotalTimeSecond function(Wifi connection)
275 * @tc.type: FUNC
276 * @tc.require: issueI5HWJK
277 */
278 HWTEST_F (StatsWifiTest, StatsWifiTest_008, TestSize.Level0)
279 {
280 auto& statsClient = BatteryStatsClient::GetInstance();
281 statsClient.Reset();
282
283 int32_t stateOn = static_cast<int32_t>(Wifi::ConnState::CONNECTED);
284 int32_t stateOff = static_cast<int32_t>(Wifi::ConnState::DISCONNECTED);
285
286 HiSysEventWrite(HiSysEvent::Domain::COMMUNICATION, StatsHiSysEvent::WIFI_CONNECTION,
287 HiSysEvent::EventType::STATISTIC, "TYPE", stateOn);
288 usleep(POWER_CONSUMPTION_DURATION_US);
289 HiSysEventWrite(HiSysEvent::Domain::COMMUNICATION, StatsHiSysEvent::WIFI_CONNECTION,
290 HiSysEvent::EventType::STATISTIC, "TYPE", stateOff);
291
292 long expectedTime = round(POWER_CONSUMPTION_DURATION_US / US_PER_SECOND);
293 long actualTime = statsClient.GetTotalTimeSecond(StatsUtils::STATS_TYPE_WIFI_ON);
294 GTEST_LOG_(INFO) << __func__ << ": expected time = " << expectedTime << " seconds";
295 GTEST_LOG_(INFO) << __func__ << ": actual time = " << actualTime << " seconds";
296 EXPECT_EQ(expectedTime, actualTime);
297 }
298
299 /**
300 * @tc.name: StatsWifiTest_09
301 * @tc.desc: test Reset function(Wifi scan)
302 * @tc.type: FUNC
303 * @tc.require: issueI5HWJK
304 */
305 HWTEST_F (StatsWifiTest, StatsWifiTest_09, TestSize.Level0)
306 {
307 auto& statsClient = BatteryStatsClient::GetInstance();
308 statsClient.Reset();
309
310 int16_t count = 2;
311
312 for (int16_t i = 0; i < count; i++) {
313 HiSysEventWrite(HiSysEvent::Domain::COMMUNICATION, StatsHiSysEvent::WIFI_SCAN,
314 HiSysEvent::EventType::STATISTIC);
315 usleep(POWER_CONSUMPTION_TRIGGERED_US);
316 }
317
318 double powerMahBefore = statsClient.GetPartStatsMah(BatteryStatsInfo::CONSUMPTION_TYPE_WIFI);
319 statsClient.Reset();
320 double powerMahAfter = statsClient.GetPartStatsMah(BatteryStatsInfo::CONSUMPTION_TYPE_WIFI);
321 GTEST_LOG_(INFO) << __func__ << ": before consumption = " << powerMahBefore << " mAh";
322 GTEST_LOG_(INFO) << __func__ << ": after consumption = " << powerMahAfter << " mAh";
323 EXPECT_TRUE(powerMahBefore >= StatsUtils::DEFAULT_VALUE && powerMahAfter == StatsUtils::DEFAULT_VALUE);
324 }
325
326 /**
327 * @tc.name: StatsWifiTest_010
328 * @tc.desc: test GetPartStatsMah function(Wifi scan)
329 * @tc.type: FUNC
330 * @tc.require: issueI5HWJK
331 */
332 HWTEST_F (StatsWifiTest, StatsWifiTest_010, TestSize.Level0)
333 {
334 auto& statsClient = BatteryStatsClient::GetInstance();
335 statsClient.Reset();
336
337 double wifiScanAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_WIFI_SCAN);
338 int16_t count = 2;
339
340 for (int16_t i = 0; i < count; i++) {
341 HiSysEventWrite(HiSysEvent::Domain::COMMUNICATION, StatsHiSysEvent::WIFI_SCAN,
342 HiSysEvent::EventType::STATISTIC);
343 usleep(POWER_CONSUMPTION_TRIGGERED_US);
344 }
345
346 double expectedPower = count * wifiScanAverageMa;
347 double actualPower = statsClient.GetPartStatsMah(BatteryStatsInfo::CONSUMPTION_TYPE_WIFI);
348 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
349 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
350 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
351 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
352 }
353
354 /**
355 * @tc.name: StatsWifiTest_011
356 * @tc.desc: test GetPartStatsPercent function(Wifi scan)
357 * @tc.type: FUNC
358 * @tc.require: issueI5HWJK
359 */
360 HWTEST_F (StatsWifiTest, StatsWifiTest_011, TestSize.Level0)
361 {
362 auto& statsClient = BatteryStatsClient::GetInstance();
363 statsClient.Reset();
364
365 double fullPercent = 1;
366 double zeroPercent = 0;
367 int16_t count = 2;
368
369 for (int16_t i = 0; i < count; i++) {
370 HiSysEventWrite(HiSysEvent::Domain::COMMUNICATION, StatsHiSysEvent::WIFI_SCAN,
371 HiSysEvent::EventType::STATISTIC);
372 usleep(POWER_CONSUMPTION_TRIGGERED_US);
373 }
374
375 double actualPercent = statsClient.GetPartStatsPercent(BatteryStatsInfo::CONSUMPTION_TYPE_WIFI);
376 GTEST_LOG_(INFO) << __func__ << ": actual percent = " << actualPercent;
377 EXPECT_TRUE(actualPercent >= zeroPercent && actualPercent <= fullPercent);
378 }
379
380 /**
381 * @tc.name: StatsWifiTest_012
382 * @tc.desc: test GetBatteryStats function(Wifi scan)
383 * @tc.type: FUNC
384 * @tc.require: issueI5HWJK
385 */
386 HWTEST_F (StatsWifiTest, StatsWifiTest_012, TestSize.Level0)
387 {
388 auto& statsClient = BatteryStatsClient::GetInstance();
389 statsClient.Reset();
390
391 double wifiScanAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_WIFI_SCAN);
392 int16_t count = 2;
393
394 for (int16_t i = 0; i < count; i++) {
395 HiSysEventWrite(HiSysEvent::Domain::COMMUNICATION, StatsHiSysEvent::WIFI_SCAN,
396 HiSysEvent::EventType::STATISTIC);
397 usleep(POWER_CONSUMPTION_TRIGGERED_US);
398 }
399
400 double expectedPower = count * wifiScanAverageMa;
401 double actualPower = StatsUtils::DEFAULT_VALUE;
402 auto list = statsClient.GetBatteryStats();
403 for (auto it : list) {
404 if ((*it).GetConsumptionType() == BatteryStatsInfo::CONSUMPTION_TYPE_WIFI) {
405 actualPower = (*it).GetPower();
406 }
407 }
408 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
409 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
410 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
411 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
412 }
413
414 /**
415 * @tc.name: StatsWifiTest_013
416 * @tc.desc: test GetTotalDataBytes function (Wifi scan)
417 * @tc.type: FUNC
418 * @tc.require: issueI5HWJK
419 */
420 HWTEST_F (StatsWifiTest, StatsWifiTest_013, TestSize.Level0)
421 {
422 auto& statsClient = BatteryStatsClient::GetInstance();
423 statsClient.Reset();
424
425 int16_t count = 2;
426 for (int16_t i = 0; i < count; i++) {
427 HiSysEventWrite(HiSysEvent::Domain::COMMUNICATION, StatsHiSysEvent::WIFI_SCAN,
428 HiSysEvent::EventType::STATISTIC);
429 usleep(POWER_CONSUMPTION_TRIGGERED_US);
430 }
431
432 long expectValue = StatsUtils::DEFAULT_VALUE;
433 long data = statsClient.GetTotalDataBytes(StatsUtils::STATS_TYPE_WIFI_SCAN);
434 EXPECT_EQ(data, expectValue);
435 }
436
437 /**
438 * @tc.name: StatsWifiTest_014
439 * @tc.desc: test GetPartStatsMah function(Wifi connection & Wifi scan)
440 * @tc.type: FUNC
441 * @tc.require: issueI5HWJK
442 */
443 HWTEST_F (StatsWifiTest, StatsWifiTest_014, TestSize.Level0)
444 {
445 auto& statsClient = BatteryStatsClient::GetInstance();
446 statsClient.Reset();
447
448 double wifiOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_WIFI_ON);
449 double wifiScanAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_WIFI_SCAN);
450 int32_t stateOn = static_cast<int32_t>(Wifi::ConnState::CONNECTED);
451 int32_t stateOff = static_cast<int32_t>(Wifi::ConnState::DISCONNECTED);
452 int16_t count = 2;
453
454 HiSysEventWrite(HiSysEvent::Domain::COMMUNICATION, StatsHiSysEvent::WIFI_CONNECTION,
455 HiSysEvent::EventType::STATISTIC, "TYPE", stateOn);
456 usleep(POWER_CONSUMPTION_DURATION_US);
457 HiSysEventWrite(HiSysEvent::Domain::COMMUNICATION, StatsHiSysEvent::WIFI_CONNECTION,
458 HiSysEvent::EventType::STATISTIC, "TYPE", stateOff);
459
460 for (int16_t i = 0; i < count; i++) {
461 HiSysEventWrite(HiSysEvent::Domain::COMMUNICATION, StatsHiSysEvent::WIFI_SCAN,
462 HiSysEvent::EventType::STATISTIC);
463 usleep(POWER_CONSUMPTION_TRIGGERED_US);
464 }
465
466 double wifiOnPower = POWER_CONSUMPTION_DURATION_US * wifiOnAverageMa / US_PER_HOUR;
467 double wifiScanPower = count * wifiScanAverageMa;
468
469 double expectedPower = wifiOnPower + wifiScanPower;
470 double actualPower = statsClient.GetPartStatsMah(BatteryStatsInfo::CONSUMPTION_TYPE_WIFI);
471 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
472 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
473 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
474 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
475 }
476
477
478 /**
479 * @tc.name: StatsWifiTest_015
480 * @tc.desc: test SetOnBattery function(Wifi connection & Wifi scan)
481 * @tc.type: FUNC
482 * @tc.require: issueI5HWJK
483 */
484 HWTEST_F (StatsWifiTest, StatsWifiTest_015, TestSize.Level0)
485 {
486 auto& statsClient = BatteryStatsClient::GetInstance();
487 statsClient.Reset();
488 statsClient.SetOnBattery(false);
489
490 int32_t stateOn = static_cast<int32_t>(Wifi::ConnState::CONNECTED);
491 int32_t stateOff = static_cast<int32_t>(Wifi::ConnState::DISCONNECTED);
492 int16_t count = 2;
493
494 HiSysEventWrite(HiSysEvent::Domain::COMMUNICATION, StatsHiSysEvent::WIFI_CONNECTION,
495 HiSysEvent::EventType::STATISTIC, "TYPE", stateOn);
496 usleep(POWER_CONSUMPTION_DURATION_US);
497 HiSysEventWrite(HiSysEvent::Domain::COMMUNICATION, StatsHiSysEvent::WIFI_CONNECTION,
498 HiSysEvent::EventType::STATISTIC, "TYPE", stateOff);
499
500 for (int16_t i = 0; i < count; i++) {
501 HiSysEventWrite(HiSysEvent::Domain::COMMUNICATION, StatsHiSysEvent::WIFI_SCAN,
502 HiSysEvent::EventType::STATISTIC);
503 usleep(POWER_CONSUMPTION_TRIGGERED_US);
504 }
505
506 double expectedPower = StatsUtils::DEFAULT_VALUE;
507 double actualPower = statsClient.GetPartStatsMah(BatteryStatsInfo::CONSUMPTION_TYPE_WIFI);
508 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
509 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
510 EXPECT_EQ(expectedPower, actualPower);
511 statsClient.SetOnBattery(true);
512 }
513
514 /**
515 * @tc.name: StatsWifiTest_016
516 * @tc.desc: test GetPartStatsMah function with battery changed(Wifi connection)
517 * @tc.type: FUNC
518 * @tc.require: issueI5HWJK
519 */
520 HWTEST_F (StatsWifiTest, StatsWifiTest_016, TestSize.Level0)
521 {
522 auto& statsClient = BatteryStatsClient::GetInstance();
523 statsClient.Reset();
524
525 double wifiOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_WIFI_ON);
526 int32_t stateOn = static_cast<int32_t>(Wifi::ConnState::CONNECTED);
527 int32_t stateOff = static_cast<int32_t>(Wifi::ConnState::DISCONNECTED);
528
529 HiSysEventWrite(HiSysEvent::Domain::COMMUNICATION, StatsHiSysEvent::WIFI_CONNECTION,
530 HiSysEvent::EventType::STATISTIC, "TYPE", stateOn);
531 usleep(POWER_CONSUMPTION_DURATION_US);
532 statsClient.SetOnBattery(false);
533 usleep(POWER_CONSUMPTION_DURATION_US);
534 statsClient.SetOnBattery(true);
535 usleep(POWER_CONSUMPTION_DURATION_US);
536 HiSysEventWrite(HiSysEvent::Domain::COMMUNICATION, StatsHiSysEvent::WIFI_CONNECTION,
537 HiSysEvent::EventType::STATISTIC, "TYPE", stateOff);
538
539 double expectedPower = 2 * POWER_CONSUMPTION_DURATION_US * wifiOnAverageMa / US_PER_HOUR;
540 double actualPower = statsClient.GetPartStatsMah(BatteryStatsInfo::CONSUMPTION_TYPE_WIFI);
541 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
542 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
543 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
544 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
545 }
546
547 /**
548 * @tc.name: StatsWifiTest_017
549 * @tc.desc: test GetPartStatsMah function with battery changed(Wifi scan)
550 * @tc.type: FUNC
551 * @tc.require: issueI5HWJK
552 */
553 HWTEST_F (StatsWifiTest, StatsWifiTest_017, TestSize.Level0)
554 {
555 STATS_HILOGD(LABEL_TEST, "StatsWifiTest_017 is start");
556 auto& statsClient = BatteryStatsClient::GetInstance();
557 statsClient.Reset();
558
559 double wifiScanAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_WIFI_SCAN);
560 int16_t totalCount = 3;
561 int16_t delayCount = 1;
562 int16_t startDelayPos = 1;
563
564 for (int16_t i = 0; i < totalCount; i++) {
565 auto ret = HiSysEventWrite(HiSysEvent::Domain::COMMUNICATION, StatsHiSysEvent::WIFI_SCAN,
566 HiSysEvent::EventType::STATISTIC);
567 STATS_HILOGD(LABEL_TEST, "HiSysEventWrite return: %{public}d", ret);
568 usleep(POWER_CONSUMPTION_TRIGGERED_US);
569 if (i == startDelayPos) {
570 statsClient.SetOnBattery(false);
571 usleep(POWER_CONSUMPTION_TRIGGERED_US);
572 } else if (i == startDelayPos + delayCount)
573 {
574 statsClient.SetOnBattery(true);
575 usleep(POWER_CONSUMPTION_TRIGGERED_US);
576 }
577 }
578
579 double expectedPower = (totalCount - delayCount) * wifiScanAverageMa;
580 double actualPower = statsClient.GetPartStatsMah(BatteryStatsInfo::CONSUMPTION_TYPE_WIFI);
581 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
582 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
583 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
584 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
585 STATS_HILOGD(LABEL_TEST, "StatsWifiTest_017 is end");
586 }
587
588 /**
589 * @tc.name: StatsWifiTest_018
590 * @tc.desc: test GetPartStatsPercent(Wifi on) and GetAppStatsPercent(Camera) function
591 * @tc.type: FUNC
592 * @tc.require: issueI5HWJK
593 */
594 HWTEST_F (StatsWifiTest, StatsWifiTest_018, TestSize.Level0)
595 {
596 auto& statsClient = BatteryStatsClient::GetInstance();
597 statsClient.Reset();
598
599 int32_t stateOn = static_cast<int32_t>(Wifi::ConnState::CONNECTED);
600 int32_t stateOff = static_cast<int32_t>(Wifi::ConnState::DISCONNECTED);
601 double fullPercent = 1;
602 double zeroPercent = 0;
603
604 HiSysEventWrite(HiSysEvent::Domain::COMMUNICATION, StatsHiSysEvent::WIFI_CONNECTION,
605 HiSysEvent::EventType::STATISTIC, "TYPE", stateOn);
606 usleep(POWER_CONSUMPTION_DURATION_US);
607 HiSysEventWrite(HiSysEvent::Domain::COMMUNICATION, StatsHiSysEvent::WIFI_CONNECTION,
608 HiSysEvent::EventType::STATISTIC, "TYPE", stateOff);
609
610 double actualPercent = statsClient.GetPartStatsPercent(BatteryStatsInfo::CONSUMPTION_TYPE_WIFI);
611 GTEST_LOG_(INFO) << __func__ << ": actual percent = " << actualPercent;
612 EXPECT_TRUE(actualPercent >= zeroPercent && actualPercent <= fullPercent);
613
614 int32_t uid = 10003;
615 int32_t pid = 3458;
616 std::string deviceId = "Camera0";
617
618 HiSysEventWrite(HiSysEvent::Domain::CAMERA, StatsHiSysEvent::CAMERA_CONNECT,
619 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "ID", deviceId);
620 usleep(POWER_CONSUMPTION_DURATION_US);
621 HiSysEventWrite(HiSysEvent::Domain::CAMERA, StatsHiSysEvent::CAMERA_DISCONNECT,
622 HiSysEvent::EventType::STATISTIC, "ID", deviceId);
623 actualPercent = statsClient.GetAppStatsPercent(uid);
624 GTEST_LOG_(INFO) << __func__ << ": actual percent = " << actualPercent;
625 EXPECT_TRUE(actualPercent >= zeroPercent && actualPercent <= fullPercent);
626 }
627 }