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