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_service_wifi_test.h"
17 #include "stats_log.h"
18
19 #include <hisysevent.h>
20 #include "wifi_msg.h"
21
22 #include "battery_stats_listener.h"
23 #include "battery_stats_service.h"
24 #include "hisysevent_operation.h"
25 #include "stats_hisysevent.h"
26 #include "stats_service_test_proxy.h"
27 #include "stats_service_write_event.h"
28
29 using namespace testing::ext;
30 using namespace OHOS::HiviewDFX;
31 using namespace OHOS::PowerMgr;
32 using namespace OHOS;
33 using namespace std;
34
35 namespace {
36 static sptr<BatteryStatsService> g_statsService = nullptr;
37 static std::shared_ptr<StatsServiceTestProxy> g_statsServiceProxy = nullptr;
38 } // namespace
39
SetUpTestCase()40 void StatsServiceWifiTest::SetUpTestCase()
41 {
42 ParserAveragePowerFile();
43 g_statsService = BatteryStatsService::GetInstance();
44 g_statsService->OnStart();
45
46 if (g_statsService->listenerPtr_ == nullptr) {
47 g_statsService->listenerPtr_ = std::make_shared<BatteryStatsListener>();
48 }
49
50 if (g_statsServiceProxy == nullptr) {
51 g_statsServiceProxy = std::make_shared<StatsServiceTestProxy>(g_statsService);
52 }
53 }
54
TearDownTestCase()55 void StatsServiceWifiTest::TearDownTestCase()
56 {
57 g_statsService->listenerPtr_ = nullptr;
58 g_statsService->OnStop();
59 }
60
SetUp()61 void StatsServiceWifiTest::SetUp()
62 {
63 auto statsService = BatteryStatsService::GetInstance();
64 statsService->SetOnBattery(true);
65 }
66
TearDown()67 void StatsServiceWifiTest::TearDown()
68 {
69 auto statsService = BatteryStatsService::GetInstance();
70 statsService->SetOnBattery(false);
71 }
72
73 namespace {
74 /**
75 * @tc.name: StatsServiceWifiTest_001
76 * @tc.desc: test Reset function(Wifi connection)
77 * @tc.type: FUNC
78 * @tc.require: issueI663DX
79 */
80 HWTEST_F (StatsServiceWifiTest, StatsServiceWifiTest_001, TestSize.Level0)
81 {
82 STATS_HILOGI(LABEL_TEST, "StatsServiceWifiTest_001 start");
83 ASSERT_NE(g_statsServiceProxy, nullptr);
84 auto statsService = BatteryStatsService::GetInstance();
85 g_statsServiceProxy->ResetIpc();
86
87 int32_t stateOn = static_cast<int32_t>(Wifi::ConnState::CONNECTED);
88 int32_t stateOff = static_cast<int32_t>(Wifi::ConnState::DISCONNECTED);
89 StatsWriteHiSysEvent(statsService,
90 HiSysEvent::Domain::COMMUNICATION, StatsHiSysEvent::WIFI_CONNECTION,
91 HiSysEvent::EventType::STATISTIC, "TYPE", stateOn);
92 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
93 StatsWriteHiSysEvent(statsService,
94 HiSysEvent::Domain::COMMUNICATION, StatsHiSysEvent::WIFI_CONNECTION,
95 HiSysEvent::EventType::STATISTIC, "TYPE", stateOff);
96 int32_t tempError;
97 double powerMahBefore;
98 g_statsServiceProxy->GetPartStatsMahIpc(BatteryStatsInfo::CONSUMPTION_TYPE_WIFI, powerMahBefore, tempError);
99 g_statsServiceProxy->ResetIpc();
100 double powerMahAfter;
101 g_statsServiceProxy->GetPartStatsMahIpc(BatteryStatsInfo::CONSUMPTION_TYPE_WIFI, powerMahAfter, tempError);
102 GTEST_LOG_(INFO) << __func__ << ": before consumption = " << powerMahBefore << " mAh";
103 GTEST_LOG_(INFO) << __func__ << ": after consumption = " << powerMahAfter << " mAh";
104 EXPECT_TRUE(powerMahBefore >= StatsUtils::DEFAULT_VALUE && powerMahAfter == StatsUtils::DEFAULT_VALUE);
105 STATS_HILOGI(LABEL_TEST, "StatsServiceWifiTest_001 end");
106 }
107
108 /**
109 * @tc.name: StatsServiceWifiTest_002
110 * @tc.desc: test GetPartStatsMah function(Wifi connection)
111 * @tc.type: FUNC
112 * @tc.require: issueI663DX
113 */
114 HWTEST_F (StatsServiceWifiTest, StatsServiceWifiTest_002, TestSize.Level0)
115 {
116 STATS_HILOGI(LABEL_TEST, "StatsServiceWifiTest_002 start");
117 ASSERT_NE(g_statsServiceProxy, nullptr);
118 auto statsService = BatteryStatsService::GetInstance();
119 g_statsServiceProxy->ResetIpc();
120
121 double wifiOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_WIFI_ON);
122 int32_t stateOn = static_cast<int32_t>(Wifi::ConnState::CONNECTED);
123 int32_t stateOff = static_cast<int32_t>(Wifi::ConnState::DISCONNECTED);
124 StatsWriteHiSysEvent(statsService,
125 HiSysEvent::Domain::COMMUNICATION, StatsHiSysEvent::WIFI_CONNECTION,
126 HiSysEvent::EventType::STATISTIC, "TYPE", stateOn);
127 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
128 StatsWriteHiSysEvent(statsService,
129 HiSysEvent::Domain::COMMUNICATION, StatsHiSysEvent::WIFI_CONNECTION,
130 HiSysEvent::EventType::STATISTIC, "TYPE", stateOff);
131
132 double expectedPower = SERVICE_POWER_CONSUMPTION_DURATION_US * wifiOnAverageMa / US_PER_HOUR;
133 int32_t tempError;
134 double actualPower;
135 g_statsServiceProxy->GetPartStatsMahIpc(BatteryStatsInfo::CONSUMPTION_TYPE_WIFI, actualPower, tempError);
136 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
137 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
138 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
139 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
140 STATS_HILOGI(LABEL_TEST, "StatsServiceWifiTest_002 end");
141 }
142
143 /**
144 * @tc.name: StatsServiceWifiTest_003
145 * @tc.desc: test GetPartStatsPercent function(Wifi connection)
146 * @tc.type: FUNC
147 * @tc.require: issueI663DX
148 */
149 HWTEST_F (StatsServiceWifiTest, StatsServiceWifiTest_003, TestSize.Level0)
150 {
151 STATS_HILOGI(LABEL_TEST, "StatsServiceWifiTest_003 start");
152 ASSERT_NE(g_statsServiceProxy, nullptr);
153 auto statsService = BatteryStatsService::GetInstance();
154 g_statsServiceProxy->ResetIpc();
155
156 int32_t stateOn = static_cast<int32_t>(Wifi::ConnState::CONNECTED);
157 int32_t stateOff = static_cast<int32_t>(Wifi::ConnState::DISCONNECTED);
158 double fullPercent = 1;
159 double zeroPercent = 0;
160
161 StatsWriteHiSysEvent(statsService,
162 HiSysEvent::Domain::COMMUNICATION, StatsHiSysEvent::WIFI_CONNECTION,
163 HiSysEvent::EventType::STATISTIC, "TYPE", stateOn);
164 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
165 StatsWriteHiSysEvent(statsService,
166 HiSysEvent::Domain::COMMUNICATION, StatsHiSysEvent::WIFI_CONNECTION,
167 HiSysEvent::EventType::STATISTIC, "TYPE", stateOff);
168 int32_t tempError;
169 double actualPercent;
170 g_statsServiceProxy->GetPartStatsPercentIpc(BatteryStatsInfo::CONSUMPTION_TYPE_WIFI, actualPercent, tempError);
171 GTEST_LOG_(INFO) << __func__ << ": actual percent = " << actualPercent;
172 EXPECT_TRUE(actualPercent >= zeroPercent && actualPercent <= fullPercent);
173 STATS_HILOGI(LABEL_TEST, "StatsServiceWifiTest_003 end");
174 }
175
176 /**
177 * @tc.name: StatsServiceWifiTest_004
178 * @tc.desc: test GetBatteryStats function
179 * @tc.type: FUNC
180 * @tc.require: issueI663DX
181 */
182 HWTEST_F (StatsServiceWifiTest, StatsServiceWifiTest_004, TestSize.Level0)
183 {
184 STATS_HILOGI(LABEL_TEST, "StatsServiceWifiTest_004 start");
185 ASSERT_NE(g_statsServiceProxy, nullptr);
186 auto statsService = BatteryStatsService::GetInstance();
187 g_statsServiceProxy->ResetIpc();
188
189 double wifiOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_WIFI_ON);
190 int32_t stateOn = static_cast<int32_t>(Wifi::ConnState::CONNECTED);
191 int32_t stateOff = static_cast<int32_t>(Wifi::ConnState::DISCONNECTED);
192
193 StatsWriteHiSysEvent(statsService,
194 HiSysEvent::Domain::COMMUNICATION, StatsHiSysEvent::WIFI_CONNECTION,
195 HiSysEvent::EventType::STATISTIC, "TYPE", stateOn);
196 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
197 StatsWriteHiSysEvent(statsService,
198 HiSysEvent::Domain::COMMUNICATION, StatsHiSysEvent::WIFI_CONNECTION,
199 HiSysEvent::EventType::STATISTIC, "TYPE", stateOff);
200
201 double expectedPower = SERVICE_POWER_CONSUMPTION_DURATION_US * wifiOnAverageMa / US_PER_HOUR;
202 double actualPower = StatsUtils::DEFAULT_VALUE;
203 ParcelableBatteryStatsList parcelableEntityList;
204 int32_t tempError;
205 g_statsServiceProxy->GetBatteryStatsIpc(parcelableEntityList, tempError);
206 auto list = parcelableEntityList.statsList_;
207 for (auto it : list) {
208 if ((*it).GetConsumptionType() == BatteryStatsInfo::CONSUMPTION_TYPE_WIFI) {
209 actualPower = (*it).GetPower();
210 }
211 }
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, "StatsServiceWifiTest_004 end");
217 }
218
219 /**
220 * @tc.name: StatsServiceWifiTest_005
221 * @tc.desc: test WIFI_CONNECTION event are sent repeatedly, wifi on power consumption(Wifi connection)
222 * @tc.type: FUNC
223 * @tc.require: issueI663DX
224 */
225 HWTEST_F (StatsServiceWifiTest, StatsServiceWifiTest_005, TestSize.Level0)
226 {
227 STATS_HILOGI(LABEL_TEST, "StatsServiceWifiTest_005 start");
228 ASSERT_NE(g_statsServiceProxy, nullptr);
229 auto statsService = BatteryStatsService::GetInstance();
230 g_statsServiceProxy->ResetIpc();
231
232 double wifiOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_WIFI_ON);
233 int32_t stateOn = static_cast<int32_t>(Wifi::ConnState::CONNECTED);
234 int32_t stateOff = static_cast<int32_t>(Wifi::ConnState::DISCONNECTED);
235
236 StatsWriteHiSysEvent(statsService,
237 HiSysEvent::Domain::COMMUNICATION, StatsHiSysEvent::WIFI_CONNECTION,
238 HiSysEvent::EventType::STATISTIC, "TYPE", stateOn);
239 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
240 StatsWriteHiSysEvent(statsService,
241 HiSysEvent::Domain::COMMUNICATION, StatsHiSysEvent::WIFI_CONNECTION,
242 HiSysEvent::EventType::STATISTIC, "TYPE", stateOn);
243 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
244 StatsWriteHiSysEvent(statsService,
245 HiSysEvent::Domain::COMMUNICATION, StatsHiSysEvent::WIFI_CONNECTION,
246 HiSysEvent::EventType::STATISTIC, "TYPE", stateOff);
247 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
248 StatsWriteHiSysEvent(statsService,
249 HiSysEvent::Domain::COMMUNICATION, StatsHiSysEvent::WIFI_CONNECTION,
250 HiSysEvent::EventType::STATISTIC, "TYPE", stateOff);
251
252 double expectedPower = 2 * SERVICE_POWER_CONSUMPTION_DURATION_US * wifiOnAverageMa / US_PER_HOUR;
253 int32_t tempError;
254 double actualPower;
255 g_statsServiceProxy->GetPartStatsMahIpc(BatteryStatsInfo::CONSUMPTION_TYPE_WIFI, actualPower, tempError);
256 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
257 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
258 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
259 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
260 STATS_HILOGI(LABEL_TEST, "StatsServiceWifiTest_005 end");
261 }
262
263 /**
264 * @tc.name: StatsServiceWifiTest_006
265 * @tc.desc: test test GetAppStatsMah function, Wifi connection abnormal state test(Wifi is off)
266 * @tc.type: FUNC
267 * @tc.require: issueI663DX
268 */
269 HWTEST_F (StatsServiceWifiTest, StatsServiceWifiTest_006, TestSize.Level0)
270 {
271 STATS_HILOGI(LABEL_TEST, "StatsServiceWifiTest_006 start");
272 ASSERT_NE(g_statsServiceProxy, nullptr);
273 auto statsService = BatteryStatsService::GetInstance();
274 g_statsServiceProxy->ResetIpc();
275
276 int32_t stateOn = 3;
277 int32_t stateOff = static_cast<int32_t>(Wifi::ConnState::DISCONNECTED);
278
279 StatsWriteHiSysEvent(statsService,
280 HiSysEvent::Domain::COMMUNICATION, StatsHiSysEvent::WIFI_CONNECTION,
281 HiSysEvent::EventType::STATISTIC, "TYPE", stateOn);
282 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
283 StatsWriteHiSysEvent(statsService,
284 HiSysEvent::Domain::COMMUNICATION, StatsHiSysEvent::WIFI_CONNECTION,
285 HiSysEvent::EventType::STATISTIC, "TYPE", stateOff);
286
287 double expectedPower = StatsUtils::DEFAULT_VALUE;
288 int32_t tempError;
289 double actualPower;
290 g_statsServiceProxy->GetPartStatsMahIpc(BatteryStatsInfo::CONSUMPTION_TYPE_WIFI, actualPower, tempError);
291 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
292 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
293 EXPECT_EQ(expectedPower, actualPower);
294 STATS_HILOGI(LABEL_TEST, "StatsServiceWifiTest_006 end");
295 }
296
297 /**
298 * @tc.name: StatsServiceWifiTest_007
299 * @tc.desc: test test GetAppStatsMah function, Wifi connection abnormal state test(Wifi is on)
300 * @tc.type: FUNC
301 * @tc.require: issueI663DX
302 */
303 HWTEST_F (StatsServiceWifiTest, StatsServiceWifiTest_007, TestSize.Level0)
304 {
305 STATS_HILOGI(LABEL_TEST, "StatsServiceWifiTest_007 start");
306 ASSERT_NE(g_statsServiceProxy, nullptr);
307 auto statsService = BatteryStatsService::GetInstance();
308 g_statsServiceProxy->ResetIpc();
309
310 double wifiOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_WIFI_ON);
311 int32_t stateOn = static_cast<int32_t>(Wifi::ConnState::CONNECTED);
312 int32_t stateOff = static_cast<int32_t>(Wifi::ConnState::DISCONNECTED);
313 int32_t stateInvaildOn = 5;
314 int32_t stateInvaildOff = -1;
315
316 StatsWriteHiSysEvent(statsService,
317 HiSysEvent::Domain::COMMUNICATION, StatsHiSysEvent::WIFI_CONNECTION,
318 HiSysEvent::EventType::STATISTIC, "TYPE", stateOn);
319 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
320 StatsWriteHiSysEvent(statsService,
321 HiSysEvent::Domain::COMMUNICATION, StatsHiSysEvent::WIFI_CONNECTION,
322 HiSysEvent::EventType::STATISTIC, "TYPE", stateInvaildOn);
323 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
324 StatsWriteHiSysEvent(statsService, HiSysEvent::Domain::COMMUNICATION,
325 StatsHiSysEvent::WIFI_CONNECTION,
326 HiSysEvent::EventType::STATISTIC, "TYPE", stateInvaildOff);
327 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
328 StatsWriteHiSysEvent(statsService,
329 HiSysEvent::Domain::COMMUNICATION, StatsHiSysEvent::WIFI_CONNECTION,
330 HiSysEvent::EventType::STATISTIC, "TYPE", stateOff);
331
332 double expectedPower = 3 * SERVICE_POWER_CONSUMPTION_DURATION_US * wifiOnAverageMa / US_PER_HOUR;
333 int32_t tempError;
334 double actualPower;
335 g_statsServiceProxy->GetPartStatsMahIpc(BatteryStatsInfo::CONSUMPTION_TYPE_WIFI, actualPower, tempError);
336 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
337 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
338 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
339 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
340 STATS_HILOGI(LABEL_TEST, "StatsServiceWifiTest_007 end");
341 }
342
343 /**
344 * @tc.name: StatsServiceWifiTest_008
345 * @tc.desc: test GetTotalTimeSecond function(Wifi connection)
346 * @tc.type: FUNC
347 * @tc.require: issueI663DX
348 */
349 HWTEST_F (StatsServiceWifiTest, StatsServiceWifiTest_008, TestSize.Level0)
350 {
351 STATS_HILOGI(LABEL_TEST, "StatsServiceWifiTest_008 start");
352 ASSERT_NE(g_statsServiceProxy, nullptr);
353 auto statsService = BatteryStatsService::GetInstance();
354 g_statsServiceProxy->ResetIpc();
355
356 int32_t stateOn = static_cast<int32_t>(Wifi::ConnState::CONNECTED);
357 int32_t stateOff = static_cast<int32_t>(Wifi::ConnState::DISCONNECTED);
358
359 StatsWriteHiSysEvent(statsService,
360 HiSysEvent::Domain::COMMUNICATION, StatsHiSysEvent::WIFI_CONNECTION,
361 HiSysEvent::EventType::STATISTIC, "TYPE", stateOn);
362 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
363 StatsWriteHiSysEvent(statsService,
364 HiSysEvent::Domain::COMMUNICATION, StatsHiSysEvent::WIFI_CONNECTION,
365 HiSysEvent::EventType::STATISTIC, "TYPE", stateOff);
366
367 uint64_t expectedTime = round(SERVICE_POWER_CONSUMPTION_DURATION_US / US_PER_SECOND);
368 uint64_t actualTime;
369 g_statsServiceProxy->GetTotalTimeSecondIpc(StatsUtils::STATS_TYPE_WIFI_ON, -1, actualTime);
370 GTEST_LOG_(INFO) << __func__ << ": expected time = " << expectedTime << " seconds";
371 GTEST_LOG_(INFO) << __func__ << ": actual time = " << actualTime << " seconds";
372 EXPECT_EQ(expectedTime, actualTime);
373 STATS_HILOGI(LABEL_TEST, "StatsServiceWifiTest_008 end");
374 }
375
376 /**
377 * @tc.name: StatsServiceWifiTest_009
378 * @tc.desc: test Reset function(Wifi scan)
379 * @tc.type: FUNC
380 * @tc.require: issueI663DX
381 */
382 HWTEST_F (StatsServiceWifiTest, StatsServiceWifiTest_009, TestSize.Level0)
383 {
384 STATS_HILOGI(LABEL_TEST, "StatsServiceWifiTest_009 start");
385 ASSERT_NE(g_statsServiceProxy, nullptr);
386 auto statsService = BatteryStatsService::GetInstance();
387 g_statsServiceProxy->ResetIpc();
388
389 int16_t count = 10;
390
391 for (int16_t i = 0; i < count; i++) {
392 StatsWriteHiSysEvent(statsService,
393 HiSysEvent::Domain::COMMUNICATION, StatsHiSysEvent::WIFI_SCAN, HiSysEvent::EventType::STATISTIC);
394 }
395
396 int32_t tempError;
397 double powerMahBefore;
398 g_statsServiceProxy->GetPartStatsMahIpc(BatteryStatsInfo::CONSUMPTION_TYPE_WIFI, powerMahBefore, tempError);
399 g_statsServiceProxy->ResetIpc();
400 double powerMahAfter;
401 g_statsServiceProxy->GetPartStatsMahIpc(BatteryStatsInfo::CONSUMPTION_TYPE_WIFI, powerMahAfter, tempError);
402 GTEST_LOG_(INFO) << __func__ << ": before consumption = " << powerMahBefore << " mAh";
403 GTEST_LOG_(INFO) << __func__ << ": after consumption = " << powerMahAfter << " mAh";
404 EXPECT_TRUE(powerMahBefore >= StatsUtils::DEFAULT_VALUE && powerMahAfter == StatsUtils::DEFAULT_VALUE);
405 STATS_HILOGI(LABEL_TEST, "StatsServiceWifiTest_009 end");
406 }
407
408 /**
409 * @tc.name: StatsServiceWifiTest_010
410 * @tc.desc: test GetPartStatsMah function(Wifi scan)
411 * @tc.type: FUNC
412 * @tc.require: issueI663DX
413 */
414 HWTEST_F (StatsServiceWifiTest, StatsServiceWifiTest_010, TestSize.Level0)
415 {
416 STATS_HILOGI(LABEL_TEST, "StatsServiceWifiTest_010 start");
417 ASSERT_NE(g_statsServiceProxy, nullptr);
418 auto statsService = BatteryStatsService::GetInstance();
419 g_statsServiceProxy->ResetIpc();
420
421 double wifiScanAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_WIFI_SCAN);
422 int16_t count = 10;
423
424 for (int16_t i = 0; i < count; i++) {
425 StatsWriteHiSysEvent(statsService,
426 HiSysEvent::Domain::COMMUNICATION, StatsHiSysEvent::WIFI_SCAN, HiSysEvent::EventType::STATISTIC);
427 }
428
429 double expectedPower = count * wifiScanAverageMa;
430 int32_t tempError;
431 double actualPower;
432 g_statsServiceProxy->GetPartStatsMahIpc(BatteryStatsInfo::CONSUMPTION_TYPE_WIFI, actualPower, tempError);
433 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
434 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
435 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
436 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
437 STATS_HILOGI(LABEL_TEST, "StatsServiceWifiTest_010 end");
438 }
439
440 /**
441 * @tc.name: StatsServiceWifiTest_011
442 * @tc.desc: test GetPartStatsPercent function(Wifi scan)
443 * @tc.type: FUNC
444 * @tc.require: issueI663DX
445 */
446 HWTEST_F (StatsServiceWifiTest, StatsServiceWifiTest_011, TestSize.Level0)
447 {
448 STATS_HILOGI(LABEL_TEST, "StatsServiceWifiTest_011 start");
449 ASSERT_NE(g_statsServiceProxy, nullptr);
450 auto statsService = BatteryStatsService::GetInstance();
451 g_statsServiceProxy->ResetIpc();
452
453 double fullPercent = 1;
454 double zeroPercent = 0;
455 int16_t count = 10;
456
457 for (int16_t i = 0; i < count; i++) {
458 StatsWriteHiSysEvent(statsService,
459 HiSysEvent::Domain::COMMUNICATION, StatsHiSysEvent::WIFI_SCAN, HiSysEvent::EventType::STATISTIC);
460 }
461
462 int32_t tempError;
463 double actualPercent;
464 g_statsServiceProxy->GetPartStatsPercentIpc(BatteryStatsInfo::CONSUMPTION_TYPE_WIFI, actualPercent, tempError);
465 GTEST_LOG_(INFO) << __func__ << ": actual percent = " << actualPercent;
466 EXPECT_TRUE(actualPercent >= zeroPercent && actualPercent <= fullPercent);
467 STATS_HILOGI(LABEL_TEST, "StatsServiceWifiTest_011 end");
468 }
469
470 /**
471 * @tc.name: StatsServiceWifiTest_012
472 * @tc.desc: test GetBatteryStats function(Wifi scan)
473 * @tc.type: FUNC
474 * @tc.require: issueI663DX
475 */
476 HWTEST_F (StatsServiceWifiTest, StatsServiceWifiTest_012, TestSize.Level0)
477 {
478 STATS_HILOGI(LABEL_TEST, "StatsServiceWifiTest_012 start");
479 ASSERT_NE(g_statsServiceProxy, nullptr);
480 auto statsService = BatteryStatsService::GetInstance();
481 g_statsServiceProxy->ResetIpc();
482
483 double wifiScanAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_WIFI_SCAN);
484 int16_t count = 10;
485
486 for (int16_t i = 0; i < count; i++) {
487 StatsWriteHiSysEvent(statsService,
488 HiSysEvent::Domain::COMMUNICATION, StatsHiSysEvent::WIFI_SCAN, HiSysEvent::EventType::STATISTIC);
489 }
490
491 double expectedPower = count * wifiScanAverageMa;
492 double actualPower = StatsUtils::DEFAULT_VALUE;
493 ParcelableBatteryStatsList parcelableEntityList;
494 int32_t tempError;
495 g_statsServiceProxy->GetBatteryStatsIpc(parcelableEntityList, tempError);
496 auto list = parcelableEntityList.statsList_;
497 for (auto it : list) {
498 if ((*it).GetConsumptionType() == BatteryStatsInfo::CONSUMPTION_TYPE_WIFI) {
499 actualPower = (*it).GetPower();
500 }
501 }
502 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
503 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
504 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
505 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
506 STATS_HILOGI(LABEL_TEST, "StatsServiceWifiTest_012 end");
507 }
508
509 /**
510 * @tc.name: StatsServiceWifiTest_013
511 * @tc.desc: test GetTotalDataBytes function (Wifi scan)
512 * @tc.type: FUNC
513 * @tc.require: issueI663DX
514 */
515 HWTEST_F (StatsServiceWifiTest, StatsServiceWifiTest_013, TestSize.Level0)
516 {
517 STATS_HILOGI(LABEL_TEST, "StatsServiceWifiTest_013 start");
518 ASSERT_NE(g_statsServiceProxy, nullptr);
519 auto statsService = BatteryStatsService::GetInstance();
520 g_statsServiceProxy->ResetIpc();
521
522 int16_t count = 10;
523 for (int16_t i = 0; i < count; i++) {
524 StatsWriteHiSysEvent(statsService,
525 HiSysEvent::Domain::COMMUNICATION, StatsHiSysEvent::WIFI_SCAN, HiSysEvent::EventType::STATISTIC);
526 }
527
528 uint64_t expectValue = StatsUtils::DEFAULT_VALUE;
529 uint64_t data;
530 g_statsServiceProxy->GetTotalDataBytesIpc(StatsUtils::STATS_TYPE_WIFI_SCAN, -1, data);
531 EXPECT_EQ(data, expectValue);
532 STATS_HILOGI(LABEL_TEST, "StatsServiceWifiTest_013 end");
533 }
534
535 /**
536 * @tc.name: StatsServiceWifiTest_014
537 * @tc.desc: test GetPartStatsMah function(Wifi connection & Wifi scan)
538 * @tc.type: FUNC
539 * @tc.require: issueI663DX
540 */
541 HWTEST_F (StatsServiceWifiTest, StatsServiceWifiTest_014, TestSize.Level0)
542 {
543 STATS_HILOGI(LABEL_TEST, "StatsServiceWifiTest_014 start");
544 ASSERT_NE(g_statsServiceProxy, nullptr);
545 auto statsService = BatteryStatsService::GetInstance();
546 g_statsServiceProxy->ResetIpc();
547
548 double wifiOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_WIFI_ON);
549 double wifiScanAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_WIFI_SCAN);
550 int32_t stateOn = static_cast<int32_t>(Wifi::ConnState::CONNECTED);
551 int32_t stateOff = static_cast<int32_t>(Wifi::ConnState::DISCONNECTED);
552 int16_t count = 10;
553
554 StatsWriteHiSysEvent(statsService,
555 HiSysEvent::Domain::COMMUNICATION, StatsHiSysEvent::WIFI_CONNECTION,
556 HiSysEvent::EventType::STATISTIC, "TYPE", stateOn);
557 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
558 StatsWriteHiSysEvent(statsService,
559 HiSysEvent::Domain::COMMUNICATION, StatsHiSysEvent::WIFI_CONNECTION,
560 HiSysEvent::EventType::STATISTIC, "TYPE", stateOff);
561
562 for (int16_t i = 0; i < count; i++) {
563 StatsWriteHiSysEvent(statsService,
564 HiSysEvent::Domain::COMMUNICATION, StatsHiSysEvent::WIFI_SCAN, HiSysEvent::EventType::STATISTIC);
565 }
566
567 double wifiOnPower = SERVICE_POWER_CONSUMPTION_DURATION_US * wifiOnAverageMa / US_PER_HOUR;
568 double wifiScanPower = count * wifiScanAverageMa;
569
570 double expectedPower = wifiOnPower + wifiScanPower;
571 int32_t tempError;
572 double actualPower;
573 g_statsServiceProxy->GetPartStatsMahIpc(BatteryStatsInfo::CONSUMPTION_TYPE_WIFI, actualPower, tempError);
574 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
575 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
576 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
577 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
578 STATS_HILOGI(LABEL_TEST, "StatsServiceWifiTest_014 end");
579 }
580
581 /**
582 * @tc.name: StatsServiceWifiTest_015
583 * @tc.desc: test SetOnBattery function(Wifi connection & Wifi scan)
584 * @tc.type: FUNC
585 * @tc.require: issueI663DX
586 */
587 HWTEST_F (StatsServiceWifiTest, StatsServiceWifiTest_015, TestSize.Level0)
588 {
589 STATS_HILOGI(LABEL_TEST, "StatsServiceWifiTest_015 start");
590 ASSERT_NE(g_statsServiceProxy, nullptr);
591 auto statsService = BatteryStatsService::GetInstance();
592 g_statsServiceProxy->ResetIpc();
593 g_statsServiceProxy->SetOnBatteryIpc(false);
594
595 int32_t stateOn = static_cast<int32_t>(Wifi::ConnState::CONNECTED);
596 int32_t stateOff = static_cast<int32_t>(Wifi::ConnState::DISCONNECTED);
597 int16_t count = 10;
598
599 StatsWriteHiSysEvent(statsService,
600 HiSysEvent::Domain::COMMUNICATION, StatsHiSysEvent::WIFI_CONNECTION,
601 HiSysEvent::EventType::STATISTIC, "TYPE", stateOn);
602 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
603 StatsWriteHiSysEvent(statsService,
604 HiSysEvent::Domain::COMMUNICATION, StatsHiSysEvent::WIFI_CONNECTION,
605 HiSysEvent::EventType::STATISTIC, "TYPE", stateOff);
606
607 for (int16_t i = 0; i < count; i++) {
608 StatsWriteHiSysEvent(statsService,
609 HiSysEvent::Domain::COMMUNICATION, StatsHiSysEvent::WIFI_SCAN, HiSysEvent::EventType::STATISTIC);
610 }
611
612 double expectedPower = StatsUtils::DEFAULT_VALUE;
613 int32_t tempError;
614 double actualPower;
615 g_statsServiceProxy->GetPartStatsMahIpc(BatteryStatsInfo::CONSUMPTION_TYPE_WIFI, actualPower, tempError);
616 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
617 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
618 EXPECT_EQ(expectedPower, actualPower);
619 g_statsServiceProxy->SetOnBatteryIpc(true);
620 STATS_HILOGI(LABEL_TEST, "StatsServiceWifiTest_015 end");
621 }
622
623 /**
624 * @tc.name: StatsServiceWifiTest_016
625 * @tc.desc: test GetPartStatsMah function with battery changed(Wifi connection)
626 * @tc.type: FUNC
627 * @tc.require: issueI663DX
628 */
629 HWTEST_F (StatsServiceWifiTest, StatsServiceWifiTest_016, TestSize.Level0)
630 {
631 STATS_HILOGI(LABEL_TEST, "StatsServiceWifiTest_016 start");
632 ASSERT_NE(g_statsServiceProxy, nullptr);
633 auto statsService = BatteryStatsService::GetInstance();
634 g_statsServiceProxy->ResetIpc();
635
636 double wifiOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_WIFI_ON);
637 int32_t stateOn = static_cast<int32_t>(Wifi::ConnState::CONNECTED);
638 int32_t stateOff = static_cast<int32_t>(Wifi::ConnState::DISCONNECTED);
639
640 StatsWriteHiSysEvent(statsService,
641 HiSysEvent::Domain::COMMUNICATION, StatsHiSysEvent::WIFI_CONNECTION,
642 HiSysEvent::EventType::STATISTIC, "TYPE", stateOn);
643 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
644 g_statsServiceProxy->SetOnBatteryIpc(false);
645 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
646 g_statsServiceProxy->SetOnBatteryIpc(true);
647 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
648 StatsWriteHiSysEvent(statsService,
649 HiSysEvent::Domain::COMMUNICATION, StatsHiSysEvent::WIFI_CONNECTION,
650 HiSysEvent::EventType::STATISTIC, "TYPE", stateOff);
651
652 double expectedPower = 2 * SERVICE_POWER_CONSUMPTION_DURATION_US * wifiOnAverageMa / US_PER_HOUR;
653 int32_t tempError;
654 double actualPower;
655 g_statsServiceProxy->GetPartStatsMahIpc(BatteryStatsInfo::CONSUMPTION_TYPE_WIFI, actualPower, tempError);
656 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
657 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
658 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
659 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
660 STATS_HILOGI(LABEL_TEST, "StatsServiceWifiTest_016 end");
661 }
662
663 /**
664 * @tc.name: StatsServiceWifiTest_017
665 * @tc.desc: test GetPartStatsMah function with battery changed(Wifi scan)
666 * @tc.type: FUNC
667 * @tc.require: issueI663DX
668 */
669 HWTEST_F (StatsServiceWifiTest, StatsServiceWifiTest_017, TestSize.Level0)
670 {
671 STATS_HILOGI(LABEL_TEST, "StatsServiceWifiTest_017 start");
672 ASSERT_NE(g_statsServiceProxy, nullptr);
673 auto statsService = BatteryStatsService::GetInstance();
674 g_statsServiceProxy->ResetIpc();
675
676 double wifiScanAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_WIFI_SCAN);
677 int16_t totalCount = 20;
678 int16_t delayCount = 10;
679 int16_t startDelayPos = 5;
680
681 for (int16_t i = 0; i < totalCount; i++) {
682 StatsWriteHiSysEvent(statsService,
683 HiSysEvent::Domain::COMMUNICATION, StatsHiSysEvent::WIFI_SCAN, HiSysEvent::EventType::STATISTIC);
684 if (i == startDelayPos) {
685 g_statsServiceProxy->SetOnBatteryIpc(false);
686 } else if (i == startDelayPos + delayCount)
687 {
688 g_statsServiceProxy->SetOnBatteryIpc(true);
689 }
690 }
691
692 double expectedPower = (totalCount - delayCount) * wifiScanAverageMa;
693 int32_t tempError;
694 double actualPower;
695 g_statsServiceProxy->GetPartStatsMahIpc(BatteryStatsInfo::CONSUMPTION_TYPE_WIFI, actualPower, tempError);
696 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
697 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
698 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
699 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
700 STATS_HILOGI(LABEL_TEST, "StatsServiceWifiTest_017 end");
701 }
702
703 /**
704 * @tc.name: StatsServiceWifiTest_018
705 * @tc.desc: test GetPartStatsPercent(Wifi on) and GetAppStatsPercent(Camera) function
706 * @tc.type: FUNC
707 * @tc.require: issueI663DX
708 */
709 HWTEST_F (StatsServiceWifiTest, StatsServiceWifiTest_018, TestSize.Level0)
710 {
711 STATS_HILOGI(LABEL_TEST, "StatsServiceWifiTest_018 start");
712 ASSERT_NE(g_statsServiceProxy, nullptr);
713 auto statsService = BatteryStatsService::GetInstance();
714 g_statsServiceProxy->ResetIpc();
715
716 int32_t stateOn = static_cast<int32_t>(Wifi::ConnState::CONNECTED);
717 int32_t stateOff = static_cast<int32_t>(Wifi::ConnState::DISCONNECTED);
718 double fullPercent = 1;
719 double zeroPercent = 0;
720
721 StatsWriteHiSysEvent(statsService,
722 HiSysEvent::Domain::COMMUNICATION, StatsHiSysEvent::WIFI_CONNECTION,
723 HiSysEvent::EventType::STATISTIC, "TYPE", stateOn);
724 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
725 StatsWriteHiSysEvent(statsService,
726 HiSysEvent::Domain::COMMUNICATION, StatsHiSysEvent::WIFI_CONNECTION,
727 HiSysEvent::EventType::STATISTIC, "TYPE", stateOff);
728
729 int32_t tempError;
730 double actualPercent;
731 g_statsServiceProxy->GetPartStatsPercentIpc(BatteryStatsInfo::CONSUMPTION_TYPE_WIFI, actualPercent, tempError);
732 GTEST_LOG_(INFO) << __func__ << ": actual percent = " << actualPercent;
733 EXPECT_TRUE(actualPercent >= zeroPercent && actualPercent <= fullPercent);
734
735 int32_t uid = 10003;
736 int32_t pid = 3458;
737 std::string deviceId = "Camera0";
738
739 StatsWriteHiSysEvent(statsService,
740 HiSysEvent::Domain::CAMERA, StatsHiSysEvent::CAMERA_CONNECT, HiSysEvent::EventType::STATISTIC, "PID", pid,
741 "UID", uid, "ID", deviceId);
742 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
743 StatsWriteHiSysEvent(statsService,
744 HiSysEvent::Domain::CAMERA, StatsHiSysEvent::CAMERA_DISCONNECT, HiSysEvent::EventType::STATISTIC,
745 "ID", deviceId);
746 g_statsServiceProxy->GetAppStatsPercentIpc(uid, actualPercent, tempError);
747 GTEST_LOG_(INFO) << __func__ << ": actual percent = " << actualPercent;
748 EXPECT_TRUE(actualPercent >= zeroPercent && actualPercent <= fullPercent);
749 STATS_HILOGI(LABEL_TEST, "StatsServiceWifiTest_018 end");
750 }
751
752 /**
753 * @tc.name: StatsServiceWifiTest_019
754 * @tc.desc: test send hisysevent with missing information(Wifi connection)
755 * @tc.type: FUNC
756 * @tc.require: issueI663DX
757 */
758 HWTEST_F (StatsServiceWifiTest, StatsServiceWifiTest_019, TestSize.Level0)
759 {
760 STATS_HILOGI(LABEL_TEST, "StatsServiceWifiTest_019 start");
761 ASSERT_NE(g_statsServiceProxy, nullptr);
762 auto statsService = BatteryStatsService::GetInstance();
763 g_statsServiceProxy->ResetIpc();
764
765 StatsWriteHiSysEvent(statsService,
766 HiSysEvent::Domain::COMMUNICATION, StatsHiSysEvent::WIFI_CONNECTION, HiSysEvent::EventType::STATISTIC);
767 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
768 StatsWriteHiSysEvent(statsService,
769 HiSysEvent::Domain::COMMUNICATION, StatsHiSysEvent::WIFI_CONNECTION, HiSysEvent::EventType::STATISTIC);
770
771 double expectedPower = StatsUtils::DEFAULT_VALUE;
772 int32_t tempError;
773 double actualPower;
774 g_statsServiceProxy->GetPartStatsMahIpc(BatteryStatsInfo::CONSUMPTION_TYPE_WIFI, actualPower, tempError);
775 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
776 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
777 EXPECT_EQ(expectedPower, actualPower);
778 STATS_HILOGI(LABEL_TEST, "StatsServiceWifiTest_019 end");
779 }
780 }