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