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