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