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_phone_test.h"
17 
18 #include <call_manager_inner_type.h>
19 #include <hisysevent.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 OHOS;
29 using namespace testing::ext;
30 using namespace OHOS::HiviewDFX;
31 using namespace OHOS::PowerMgr;
32 using namespace OHOS::Telephony;
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 StatsServicePhoneTest::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 StatsServicePhoneTest::TearDownTestCase()
56 {
57     g_statsService->listenerPtr_ = nullptr;
58     g_statsService->OnStop();
59 }
60 
SetUp()61 void StatsServicePhoneTest::SetUp()
62 {
63     auto statsService = BatteryStatsService::GetInstance();
64     statsService->SetOnBattery(true);
65 }
66 
TearDown()67 void StatsServicePhoneTest::TearDown()
68 {
69     auto statsService = BatteryStatsService::GetInstance();
70     statsService->SetOnBattery(false);
71 }
72 
73 namespace {
74 /**
75  * @tc.name: StatsServicePhoneTest_001
76  * @tc.desc: test Reset function(Phone Call)
77  * @tc.type: FUNC
78  * @tc.require: issueI663DX
79  */
80 HWTEST_F (StatsServicePhoneTest, StatsServicePhoneTest_001, TestSize.Level0)
81 {
82     ASSERT_NE(g_statsServiceProxy, nullptr);
83     auto statsService = BatteryStatsService::GetInstance();
84     g_statsServiceProxy->Reset();
85 
86     int32_t stateOn = static_cast<int32_t>(TelCallState::CALL_STATUS_ACTIVE);
87     int32_t stateOff = static_cast<int32_t>(TelCallState::CALL_STATUS_DISCONNECTED);
88 
89     StatsWriteHiSysEvent(statsService,
90         HiSysEvent::Domain::TELEPHONY, StatsHiSysEvent::CALL_STATE,
91         HiSysEvent::EventType::BEHAVIOR, "STATE", stateOn);
92     usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
93     StatsWriteHiSysEvent(statsService,
94         HiSysEvent::Domain::TELEPHONY, StatsHiSysEvent::CALL_STATE,
95         HiSysEvent::EventType::BEHAVIOR, "STATE", stateOff);
96 
97     double powerMahBefore = g_statsServiceProxy->GetPartStatsMah(BatteryStatsInfo::CONSUMPTION_TYPE_PHONE);
98     g_statsServiceProxy->Reset();
99     double powerMahAfter = g_statsServiceProxy->GetPartStatsMah(BatteryStatsInfo::CONSUMPTION_TYPE_PHONE);
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 }
104 
105 /**
106  * @tc.name: StatsServicePhoneTest_002
107  * @tc.desc: test GetPartStatsMah function(Phone Call)
108  * @tc.type: FUNC
109  * @tc.require: issueI663DX
110  */
111 HWTEST_F (StatsServicePhoneTest, StatsServicePhoneTest_002, TestSize.Level0)
112 {
113     ASSERT_NE(g_statsServiceProxy, nullptr);
114     auto statsService = BatteryStatsService::GetInstance();
115     g_statsServiceProxy->Reset();
116 
117     int32_t stateOn = static_cast<int32_t>(TelCallState::CALL_STATUS_ACTIVE);
118     int32_t stateOff = static_cast<int32_t>(TelCallState::CALL_STATUS_DISCONNECTED);
119     int16_t level = 0;
120     double phoneOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_RADIO_ON, level);
121 
122     StatsWriteHiSysEvent(statsService,
123         HiSysEvent::Domain::TELEPHONY, StatsHiSysEvent::CALL_STATE,
124         HiSysEvent::EventType::BEHAVIOR, "STATE", stateOn);
125     usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
126     StatsWriteHiSysEvent(statsService,
127         HiSysEvent::Domain::TELEPHONY, StatsHiSysEvent::CALL_STATE,
128         HiSysEvent::EventType::BEHAVIOR, "STATE", stateOff);
129 
130     double expectedPower = SERVICE_POWER_CONSUMPTION_DURATION_US * phoneOnAverageMa / US_PER_HOUR;
131     double actualPower = g_statsServiceProxy->GetPartStatsMah(BatteryStatsInfo::CONSUMPTION_TYPE_PHONE);
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 
136     EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
137 }
138 
139 /**
140  * @tc.name: StatsServicePhoneTest_003
141  * @tc.desc: test GetPartStatsPercent function(Phone Call)
142  * @tc.type: FUNC
143  * @tc.require: issueI663DX
144  */
145 HWTEST_F (StatsServicePhoneTest, StatsServicePhoneTest_003, TestSize.Level0)
146 {
147     ASSERT_NE(g_statsServiceProxy, nullptr);
148     auto statsService = BatteryStatsService::GetInstance();
149     g_statsServiceProxy->Reset();
150 
151     int32_t stateOn = static_cast<int32_t>(TelCallState::CALL_STATUS_ACTIVE);
152     int32_t stateOff = static_cast<int32_t>(TelCallState::CALL_STATUS_DISCONNECTED);
153     double fullPercent = 1;
154     double zeroPercent = 0;
155 
156     StatsWriteHiSysEvent(statsService,
157         HiSysEvent::Domain::TELEPHONY, StatsHiSysEvent::CALL_STATE,
158         HiSysEvent::EventType::BEHAVIOR, "STATE", stateOn);
159     usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
160     StatsWriteHiSysEvent(statsService,
161         HiSysEvent::Domain::TELEPHONY, StatsHiSysEvent::CALL_STATE,
162         HiSysEvent::EventType::BEHAVIOR, "STATE", stateOff);
163 
164     double actualPercent = g_statsServiceProxy->GetPartStatsPercent(BatteryStatsInfo::CONSUMPTION_TYPE_PHONE);
165     GTEST_LOG_(INFO) << __func__ << ": actual percent = " << actualPercent;
166     EXPECT_TRUE(actualPercent >= zeroPercent && actualPercent <= fullPercent);
167 }
168 
169 /**
170  * @tc.name: StatsServicePhoneTest_004
171  * @tc.desc: test GetBatteryStats function(Phone Call)
172  * @tc.type: FUNC
173  * @tc.require: issueI663DX
174  */
175 HWTEST_F (StatsServicePhoneTest, StatsServicePhoneTest_004, TestSize.Level0)
176 {
177     ASSERT_NE(g_statsServiceProxy, nullptr);
178     auto statsService = BatteryStatsService::GetInstance();
179     g_statsServiceProxy->Reset();
180 
181     int32_t stateOn = static_cast<int32_t>(TelCallState::CALL_STATUS_ACTIVE);
182     int32_t stateOff = static_cast<int32_t>(TelCallState::CALL_STATUS_DISCONNECTED);
183     int16_t level = 0;
184     double phoneOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_RADIO_ON, level);
185 
186     StatsWriteHiSysEvent(statsService,
187         HiSysEvent::Domain::TELEPHONY, StatsHiSysEvent::CALL_STATE,
188         HiSysEvent::EventType::BEHAVIOR, "STATE", stateOn);
189     usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
190     StatsWriteHiSysEvent(statsService,
191         HiSysEvent::Domain::TELEPHONY, StatsHiSysEvent::CALL_STATE,
192         HiSysEvent::EventType::BEHAVIOR, "STATE", stateOff);
193 
194     double expectedPower = SERVICE_POWER_CONSUMPTION_DURATION_US * phoneOnAverageMa / US_PER_HOUR;
195     double actualPower = StatsUtils::DEFAULT_VALUE;
196     auto list = g_statsServiceProxy->GetBatteryStats();
197     for (auto it : list) {
198         if ((*it).GetConsumptionType() == BatteryStatsInfo::CONSUMPTION_TYPE_PHONE) {
199             actualPower = (*it).GetPower();
200         }
201     }
202     double devPrecent = abs(expectedPower - actualPower) / expectedPower;
203     GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
204     GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
205     EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
206 }
207 
208 /**
209  * @tc.name: StatsServicePhoneTest_005
210  * @tc.desc: test CALL_STATE event are sent repeatedly, phone power consumption(Phone Call)
211  * @tc.type: FUNC
212  * @tc.require: issueI663DX
213  */
214 HWTEST_F (StatsServicePhoneTest, StatsServicePhoneTest_005, TestSize.Level0)
215 {
216     ASSERT_NE(g_statsServiceProxy, nullptr);
217     auto statsService = BatteryStatsService::GetInstance();
218     g_statsServiceProxy->Reset();
219 
220     int32_t stateOn = static_cast<int32_t>(TelCallState::CALL_STATUS_ACTIVE);
221     int32_t stateOff = static_cast<int32_t>(TelCallState::CALL_STATUS_DISCONNECTED);
222     int16_t level = 0;
223     double phoneOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_RADIO_ON, level);
224 
225     StatsWriteHiSysEvent(statsService,
226         HiSysEvent::Domain::TELEPHONY, StatsHiSysEvent::CALL_STATE,
227         HiSysEvent::EventType::BEHAVIOR, "STATE", stateOn);
228     usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
229     StatsWriteHiSysEvent(statsService,
230         HiSysEvent::Domain::TELEPHONY, StatsHiSysEvent::CALL_STATE,
231         HiSysEvent::EventType::BEHAVIOR, "STATE", stateOn);
232     usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
233     StatsWriteHiSysEvent(statsService,
234         HiSysEvent::Domain::TELEPHONY, StatsHiSysEvent::CALL_STATE,
235         HiSysEvent::EventType::BEHAVIOR, "STATE", stateOff);
236     usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
237     StatsWriteHiSysEvent(statsService,
238         HiSysEvent::Domain::TELEPHONY, StatsHiSysEvent::CALL_STATE,
239         HiSysEvent::EventType::BEHAVIOR, "STATE", stateOff);
240 
241     double expectedPower = 2 * SERVICE_POWER_CONSUMPTION_DURATION_US * phoneOnAverageMa / US_PER_HOUR;
242     double actualPower = g_statsServiceProxy->GetPartStatsMah(BatteryStatsInfo::CONSUMPTION_TYPE_PHONE);
243     double devPrecent = abs(expectedPower - actualPower) / expectedPower;
244     GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
245     GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
246     EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
247 }
248 
249 /**
250  * @tc.name: StatsServicePhoneTest_006
251  * @tc.desc: test GetAppStatsMah function, Phone call on state composite test
252  * @tc.type: FUNC
253  * @tc.require: issueI663DX
254  */
255 HWTEST_F (StatsServicePhoneTest, StatsServicePhoneTest_006, TestSize.Level0)
256 {
257     ASSERT_NE(g_statsServiceProxy, nullptr);
258     auto statsService = BatteryStatsService::GetInstance();
259     g_statsServiceProxy->Reset();
260 
261     int32_t stateOn = static_cast<int32_t>(TelCallState::CALL_STATUS_ACTIVE);
262     int32_t stateOff = static_cast<int32_t>(TelCallState::CALL_STATUS_DISCONNECTED);
263     int32_t stateHolding = static_cast<int32_t>(TelCallState::CALL_STATUS_HOLDING);
264     int32_t stateDisconnecting = static_cast<int32_t>(TelCallState::CALL_STATUS_DISCONNECTING);
265     int16_t level = 0;
266     double phoneOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_RADIO_ON, level);
267 
268     StatsWriteHiSysEvent(statsService,
269         HiSysEvent::Domain::TELEPHONY, StatsHiSysEvent::CALL_STATE,
270         HiSysEvent::EventType::BEHAVIOR, "STATE", stateOn);
271     usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
272     StatsWriteHiSysEvent(statsService,
273         HiSysEvent::Domain::TELEPHONY, StatsHiSysEvent::CALL_STATE,
274         HiSysEvent::EventType::BEHAVIOR, "STATE", stateHolding);
275     usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
276     StatsWriteHiSysEvent(statsService,
277         HiSysEvent::Domain::TELEPHONY, StatsHiSysEvent::CALL_STATE,
278         HiSysEvent::EventType::BEHAVIOR, "STATE", stateDisconnecting);
279     usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
280     StatsWriteHiSysEvent(statsService,
281         HiSysEvent::Domain::TELEPHONY, StatsHiSysEvent::CALL_STATE,
282         HiSysEvent::EventType::BEHAVIOR, "STATE", stateOff);
283 
284     double expectedPower = 3 * SERVICE_POWER_CONSUMPTION_DURATION_US * phoneOnAverageMa / US_PER_HOUR;
285     double actualPower = g_statsServiceProxy->GetPartStatsMah(BatteryStatsInfo::CONSUMPTION_TYPE_PHONE);
286     double devPrecent = abs(expectedPower - actualPower) / expectedPower;
287     GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
288     GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
289     EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
290 }
291 
292 /**
293  * @tc.name: StatsServicePhoneTest_007
294  * @tc.desc: test test GetAppStatsMah function, Phone call on abnormal state test(Phone call is off)
295  * @tc.type: FUNC
296  * @tc.require: issueI663DX
297  */
298 HWTEST_F (StatsServicePhoneTest, StatsServicePhoneTest_007, TestSize.Level0)
299 {
300     ASSERT_NE(g_statsServiceProxy, nullptr);
301     auto statsService = BatteryStatsService::GetInstance();
302     g_statsServiceProxy->Reset();
303 
304     int32_t stateOn = 10;
305     int32_t stateOff = static_cast<int32_t>(TelCallState::CALL_STATUS_DISCONNECTED);
306 
307     StatsWriteHiSysEvent(statsService,
308         HiSysEvent::Domain::TELEPHONY, StatsHiSysEvent::CALL_STATE,
309         HiSysEvent::EventType::BEHAVIOR, "STATE", stateOn);
310     usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
311     StatsWriteHiSysEvent(statsService,
312         HiSysEvent::Domain::TELEPHONY, StatsHiSysEvent::CALL_STATE,
313         HiSysEvent::EventType::BEHAVIOR, "STATE", stateOff);
314 
315     double expectedPower = StatsUtils::DEFAULT_VALUE;
316     double actualPower = g_statsServiceProxy->GetPartStatsMah(BatteryStatsInfo::CONSUMPTION_TYPE_PHONE);
317     GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
318     GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
319     EXPECT_EQ(expectedPower, actualPower);
320 }
321 
322 /**
323  * @tc.name: StatsServicePhoneTest_008
324  * @tc.desc: test test GetAppStatsMah function, Phone call on abnormal state test(Phone call is on)
325  * @tc.type: FUNC
326  * @tc.require: issueI663DX
327  */
328 HWTEST_F (StatsServicePhoneTest, StatsServicePhoneTest_008, TestSize.Level0)
329 {
330     ASSERT_NE(g_statsServiceProxy, nullptr);
331     auto statsService = BatteryStatsService::GetInstance();
332     g_statsServiceProxy->Reset();
333 
334     int32_t stateOn = static_cast<int32_t>(TelCallState::CALL_STATUS_ACTIVE);
335     int32_t stateOff = static_cast<int32_t>(TelCallState::CALL_STATUS_DISCONNECTED);
336     int32_t stateInvaildOn = 5;
337     int32_t stateInvaildOff = -1;
338     int16_t level = 0;
339     double phoneOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_RADIO_ON, level);
340 
341     StatsWriteHiSysEvent(statsService,
342         HiSysEvent::Domain::TELEPHONY, StatsHiSysEvent::CALL_STATE,
343         HiSysEvent::EventType::BEHAVIOR, "STATE", stateOn);
344     usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
345     StatsWriteHiSysEvent(statsService,
346         HiSysEvent::Domain::TELEPHONY, StatsHiSysEvent::CALL_STATE,
347         HiSysEvent::EventType::BEHAVIOR, "STATE", stateInvaildOn);
348     usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
349     StatsWriteHiSysEvent(statsService,
350         HiSysEvent::Domain::TELEPHONY, StatsHiSysEvent::CALL_STATE,
351         HiSysEvent::EventType::BEHAVIOR, "STATE", stateInvaildOff);
352     usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
353     StatsWriteHiSysEvent(statsService,
354         HiSysEvent::Domain::TELEPHONY, StatsHiSysEvent::CALL_STATE,
355         HiSysEvent::EventType::BEHAVIOR, "STATE", stateOff);
356 
357     double expectedPower = 3 * SERVICE_POWER_CONSUMPTION_DURATION_US * phoneOnAverageMa / US_PER_HOUR;
358     double actualPower = g_statsServiceProxy->GetPartStatsMah(BatteryStatsInfo::CONSUMPTION_TYPE_PHONE);
359     double devPrecent = abs(expectedPower - actualPower) / expectedPower;
360     GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
361     GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
362     EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
363 }
364 
365 /**
366  * @tc.name: StatsServicePhoneTest_009
367  * @tc.desc: test Reset function(Phone Data)
368  * @tc.type: FUNC
369  * @tc.require: issueI663DX
370  */
371 HWTEST_F (StatsServicePhoneTest, StatsServicePhoneTest_009, TestSize.Level0)
372 {
373     ASSERT_NE(g_statsServiceProxy, nullptr);
374     auto statsService = BatteryStatsService::GetInstance();
375     g_statsServiceProxy->Reset();
376 
377     int32_t stateOn = 1;
378     int32_t stateOff = 0;
379 
380     StatsWriteHiSysEvent(statsService,
381         HiSysEvent::Domain::TELEPHONY, StatsHiSysEvent::DATA_CONNECTION_STATE,
382         HiSysEvent::EventType::BEHAVIOR, "STATE", stateOn);
383     usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
384     StatsWriteHiSysEvent(statsService,
385         HiSysEvent::Domain::TELEPHONY, StatsHiSysEvent::DATA_CONNECTION_STATE,
386         HiSysEvent::EventType::BEHAVIOR, "STATE", stateOff);
387 
388     double powerMahBefore = g_statsServiceProxy->GetPartStatsMah(BatteryStatsInfo::CONSUMPTION_TYPE_PHONE);
389     g_statsServiceProxy->Reset();
390     double powerMahAfter = g_statsServiceProxy->GetPartStatsMah(BatteryStatsInfo::CONSUMPTION_TYPE_PHONE);
391     GTEST_LOG_(INFO) << __func__ << ": before consumption = " << powerMahBefore << " mAh";
392     GTEST_LOG_(INFO) << __func__ << ": after consumption = " << powerMahAfter << " mAh";
393     EXPECT_TRUE(powerMahBefore >= StatsUtils::DEFAULT_VALUE && powerMahAfter == StatsUtils::DEFAULT_VALUE);
394 }
395 
396 /**
397  * @tc.name: StatsServicePhoneTest_010
398  * @tc.desc: test GetPartStatsMah function(Phone Data)
399  * @tc.type: FUNC
400  * @tc.require: issueI663DX
401  */
402 HWTEST_F (StatsServicePhoneTest, StatsServicePhoneTest_010, TestSize.Level0)
403 {
404     ASSERT_NE(g_statsServiceProxy, nullptr);
405     auto statsService = BatteryStatsService::GetInstance();
406     g_statsServiceProxy->Reset();
407 
408     int32_t stateOn = 1;
409     int32_t stateOff = 0;
410     int16_t level = 0;
411     double phoneDataAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_RADIO_DATA, level);
412 
413     StatsWriteHiSysEvent(statsService,
414         HiSysEvent::Domain::TELEPHONY, StatsHiSysEvent::DATA_CONNECTION_STATE,
415         HiSysEvent::EventType::BEHAVIOR, "STATE", stateOn);
416     usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
417     StatsWriteHiSysEvent(statsService,
418         HiSysEvent::Domain::TELEPHONY, StatsHiSysEvent::DATA_CONNECTION_STATE,
419         HiSysEvent::EventType::BEHAVIOR, "STATE", stateOff);
420 
421     double expectedPower = SERVICE_POWER_CONSUMPTION_DURATION_US * phoneDataAverageMa / US_PER_HOUR;
422     double actualPower = g_statsServiceProxy->GetPartStatsMah(BatteryStatsInfo::CONSUMPTION_TYPE_PHONE);
423     double devPrecent = abs(expectedPower - actualPower) / expectedPower;
424     GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
425     GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
426     EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
427 }
428 
429 /**
430  * @tc.name: StatsServicePhoneTest_011
431  * @tc.desc: test GetPartStatsPercent function(Phone Data)
432  * @tc.type: FUNC
433  * @tc.require: issueI663DX
434  */
435 HWTEST_F (StatsServicePhoneTest, StatsServicePhoneTest_011, TestSize.Level0)
436 {
437     ASSERT_NE(g_statsServiceProxy, nullptr);
438     auto statsService = BatteryStatsService::GetInstance();
439     g_statsServiceProxy->Reset();
440 
441     int32_t stateOn = 1;
442     int32_t stateOff = 0;
443     double fullPercent = 1;
444     double zeroPercent = 0;
445 
446     StatsWriteHiSysEvent(statsService,
447         HiSysEvent::Domain::TELEPHONY, StatsHiSysEvent::DATA_CONNECTION_STATE,
448         HiSysEvent::EventType::BEHAVIOR, "STATE", stateOn);
449     usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
450     StatsWriteHiSysEvent(statsService,
451         HiSysEvent::Domain::TELEPHONY, StatsHiSysEvent::DATA_CONNECTION_STATE,
452         HiSysEvent::EventType::BEHAVIOR, "STATE", stateOff);
453 
454     double actualPercent = g_statsServiceProxy->GetPartStatsPercent(BatteryStatsInfo::CONSUMPTION_TYPE_PHONE);
455     GTEST_LOG_(INFO) << __func__ << ": actual percent = " << actualPercent;
456     EXPECT_TRUE(actualPercent >= zeroPercent && actualPercent <= fullPercent);
457 }
458 
459 /**
460  * @tc.name: StatsServicePhoneTest_012
461  * @tc.desc: test GetBatteryStats function(Phone Data)
462  * @tc.type: FUNC
463  * @tc.require: issueI663DX
464  */
465 HWTEST_F (StatsServicePhoneTest, StatsServicePhoneTest_012, TestSize.Level0)
466 {
467     ASSERT_NE(g_statsServiceProxy, nullptr);
468     auto statsService = BatteryStatsService::GetInstance();
469     g_statsServiceProxy->Reset();
470 
471     int32_t stateOn = 1;
472     int32_t stateOff = 0;
473     int16_t level = 0;
474     double phoneDataAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_RADIO_DATA, level);
475 
476     StatsWriteHiSysEvent(statsService,
477         HiSysEvent::Domain::TELEPHONY, StatsHiSysEvent::DATA_CONNECTION_STATE,
478         HiSysEvent::EventType::BEHAVIOR, "STATE", stateOn);
479     usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
480     StatsWriteHiSysEvent(statsService,
481         HiSysEvent::Domain::TELEPHONY, StatsHiSysEvent::DATA_CONNECTION_STATE,
482         HiSysEvent::EventType::BEHAVIOR, "STATE", stateOff);
483 
484     double expectedPower = SERVICE_POWER_CONSUMPTION_DURATION_US * phoneDataAverageMa / US_PER_HOUR;
485     double actualPower = StatsUtils::DEFAULT_VALUE;
486     auto list = g_statsServiceProxy->GetBatteryStats();
487     for (auto it : list) {
488         if ((*it).GetConsumptionType() == BatteryStatsInfo::CONSUMPTION_TYPE_PHONE) {
489             actualPower = (*it).GetPower();
490         }
491     }
492     double devPrecent = abs(expectedPower - actualPower) / expectedPower;
493     GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
494     GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
495     EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
496 }
497 
498 /**
499  * @tc.name: StatsServicePhoneTest_013
500  * @tc.desc: test CALL_STATE event are sent repeatedly, phone power consumption(Phone Data)
501  * @tc.type: FUNC
502  * @tc.require: issueI663DX
503  */
504 HWTEST_F (StatsServicePhoneTest, StatsServicePhoneTest_013, TestSize.Level0)
505 {
506     ASSERT_NE(g_statsServiceProxy, nullptr);
507     auto statsService = BatteryStatsService::GetInstance();
508     g_statsServiceProxy->Reset();
509 
510     int32_t stateOn = 1;
511     int32_t stateOff = 0;
512     int16_t level = 0;
513     double phoneDataAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_RADIO_DATA, level);
514 
515     StatsWriteHiSysEvent(statsService,
516         HiSysEvent::Domain::TELEPHONY, StatsHiSysEvent::DATA_CONNECTION_STATE,
517         HiSysEvent::EventType::BEHAVIOR, "STATE", stateOn);
518     usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
519     StatsWriteHiSysEvent(statsService,
520         HiSysEvent::Domain::TELEPHONY, StatsHiSysEvent::DATA_CONNECTION_STATE,
521         HiSysEvent::EventType::BEHAVIOR, "STATE", stateOn);
522     usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
523     StatsWriteHiSysEvent(statsService,
524         HiSysEvent::Domain::TELEPHONY, StatsHiSysEvent::DATA_CONNECTION_STATE,
525         HiSysEvent::EventType::BEHAVIOR, "STATE", stateOff);
526     usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
527     StatsWriteHiSysEvent(statsService,
528         HiSysEvent::Domain::TELEPHONY, StatsHiSysEvent::DATA_CONNECTION_STATE,
529         HiSysEvent::EventType::BEHAVIOR, "STATE", stateOff);
530 
531     double expectedPower = 2 * SERVICE_POWER_CONSUMPTION_DURATION_US * phoneDataAverageMa / US_PER_HOUR;
532     double actualPower = g_statsServiceProxy->GetPartStatsMah(BatteryStatsInfo::CONSUMPTION_TYPE_PHONE);
533     double devPrecent = abs(expectedPower - actualPower) / expectedPower;
534     GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
535     GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
536     EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
537 }
538 
539 /**
540  * @tc.name: StatsServicePhoneTest_014
541  * @tc.desc: test test GetAppStatsMah function, Phone data on abnormal state test(Phone data is off)
542  * @tc.type: FUNC
543  * @tc.require: issueI663DX
544  */
545 HWTEST_F (StatsServicePhoneTest, StatsServicePhoneTest_014, TestSize.Level0)
546 {
547     ASSERT_NE(g_statsServiceProxy, nullptr);
548     auto statsService = BatteryStatsService::GetInstance();
549     g_statsServiceProxy->Reset();
550 
551     int32_t stateOn = 5;
552     int32_t stateOff = 0;
553 
554     StatsWriteHiSysEvent(statsService,
555         HiSysEvent::Domain::TELEPHONY, StatsHiSysEvent::DATA_CONNECTION_STATE,
556         HiSysEvent::EventType::BEHAVIOR, "STATE", stateOn);
557     usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
558     StatsWriteHiSysEvent(statsService,
559         HiSysEvent::Domain::TELEPHONY, StatsHiSysEvent::DATA_CONNECTION_STATE,
560         HiSysEvent::EventType::BEHAVIOR, "STATE", stateOff);
561 
562     double expectedPower = StatsUtils::DEFAULT_VALUE;
563     double actualPower = g_statsServiceProxy->GetPartStatsMah(BatteryStatsInfo::CONSUMPTION_TYPE_PHONE);
564     GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
565     GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
566     EXPECT_EQ(expectedPower, actualPower);
567 }
568 
569 /**
570  * @tc.name: StatsServicePhoneTest_015
571  * @tc.desc: test test GetAppStatsMah function, Phone data on abnormal state test(Phone data is on)
572  * @tc.type: FUNC
573  * @tc.require: issueI663DX
574  */
575 HWTEST_F (StatsServicePhoneTest, StatsServicePhoneTest_015, TestSize.Level0)
576 {
577     ASSERT_NE(g_statsServiceProxy, nullptr);
578     auto statsService = BatteryStatsService::GetInstance();
579     g_statsServiceProxy->Reset();
580 
581     int32_t stateOn = 1;
582     int32_t stateOff = 0;
583     int32_t stateInvaildOn = 5;
584     int32_t stateInvaildOff = -1;
585     int16_t level = 0;
586     double phoneDataAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_RADIO_DATA, level);
587 
588     StatsWriteHiSysEvent(statsService,
589         HiSysEvent::Domain::TELEPHONY, StatsHiSysEvent::DATA_CONNECTION_STATE,
590         HiSysEvent::EventType::BEHAVIOR, "STATE", stateOn);
591     usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
592     StatsWriteHiSysEvent(statsService,
593         HiSysEvent::Domain::TELEPHONY, StatsHiSysEvent::DATA_CONNECTION_STATE,
594         HiSysEvent::EventType::BEHAVIOR,
595         "STATE", stateInvaildOn);
596     usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
597     StatsWriteHiSysEvent(statsService,
598         HiSysEvent::Domain::TELEPHONY, StatsHiSysEvent::DATA_CONNECTION_STATE,
599         HiSysEvent::EventType::BEHAVIOR,
600         "STATE", stateInvaildOff);
601     usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
602     StatsWriteHiSysEvent(statsService,
603         HiSysEvent::Domain::TELEPHONY, StatsHiSysEvent::DATA_CONNECTION_STATE,
604         HiSysEvent::EventType::BEHAVIOR, "STATE", stateOff);
605 
606     double expectedPower = 3 * SERVICE_POWER_CONSUMPTION_DURATION_US * phoneDataAverageMa / US_PER_HOUR;
607     double actualPower = g_statsServiceProxy->GetPartStatsMah(BatteryStatsInfo::CONSUMPTION_TYPE_PHONE);
608     double devPrecent = abs(expectedPower - actualPower) / expectedPower;
609     GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
610     GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
611     EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
612 }
613 
614 /**
615  * @tc.name: StatsServicePhoneTest_016
616  * @tc.desc: test CALL_STATE and TELEPHONY event are sent repeatedly, power consumption(Func:GetPartStatsMah)
617  * @tc.type: FUNC
618  * @tc.require: issueI663DX
619  */
620 HWTEST_F (StatsServicePhoneTest, StatsServicePhoneTest_016, TestSize.Level0)
621 {
622     ASSERT_NE(g_statsServiceProxy, nullptr);
623     auto statsService = BatteryStatsService::GetInstance();
624     g_statsServiceProxy->Reset();
625 
626     int32_t callStateOn = static_cast<int32_t>(TelCallState::CALL_STATUS_ACTIVE);
627     int32_t callStateOff = static_cast<int32_t>(TelCallState::CALL_STATUS_DISCONNECTED);
628     int32_t dataStateOn = 1;
629     int32_t dataStateOff = 0;
630     int16_t level = 0;
631     double phoneOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_RADIO_ON, level);
632     double phoneDataAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_RADIO_DATA, level);
633 
634     StatsWriteHiSysEvent(statsService,
635         HiSysEvent::Domain::TELEPHONY, StatsHiSysEvent::CALL_STATE,
636         HiSysEvent::EventType::BEHAVIOR, "STATE", callStateOn);
637     usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
638     StatsWriteHiSysEvent(statsService,
639         HiSysEvent::Domain::TELEPHONY, StatsHiSysEvent::DATA_CONNECTION_STATE,
640         HiSysEvent::EventType::BEHAVIOR, "STATE", dataStateOn);
641     usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
642     StatsWriteHiSysEvent(statsService,
643         HiSysEvent::Domain::TELEPHONY, StatsHiSysEvent::CALL_STATE,
644         HiSysEvent::EventType::BEHAVIOR, "STATE", callStateOn);
645     usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
646     StatsWriteHiSysEvent(statsService,
647         HiSysEvent::Domain::TELEPHONY, StatsHiSysEvent::CALL_STATE,
648         HiSysEvent::EventType::BEHAVIOR, "STATE", callStateOff);
649     usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
650     StatsWriteHiSysEvent(statsService,
651         HiSysEvent::Domain::TELEPHONY, StatsHiSysEvent::DATA_CONNECTION_STATE,
652         HiSysEvent::EventType::BEHAVIOR, "STATE", dataStateOn);
653     usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
654     StatsWriteHiSysEvent(statsService,
655         HiSysEvent::Domain::TELEPHONY, StatsHiSysEvent::DATA_CONNECTION_STATE,
656         HiSysEvent::EventType::BEHAVIOR, "STATE", dataStateOff);
657 
658     double phoneOnPower = 3 * SERVICE_POWER_CONSUMPTION_DURATION_US * phoneOnAverageMa / US_PER_HOUR;
659     double phoneDataPower = 4 * SERVICE_POWER_CONSUMPTION_DURATION_US * phoneDataAverageMa / US_PER_HOUR;
660     double expectedPower = phoneOnPower + phoneDataPower;
661     double actualPower = g_statsServiceProxy->GetPartStatsMah(BatteryStatsInfo::CONSUMPTION_TYPE_PHONE);
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 }
667 
668 /**
669  * @tc.name: StatsServicePhoneTest_017
670  * @tc.desc: test CALL_STATE and TELEPHONY event are sent repeatedly, power consumption(Func:GetBatteryStats)
671  * @tc.type: FUNC
672  * @tc.require: issueI663DX
673  */
674 HWTEST_F (StatsServicePhoneTest, StatsServicePhoneTest_017, TestSize.Level0)
675 {
676     ASSERT_NE(g_statsServiceProxy, nullptr);
677     auto statsService = BatteryStatsService::GetInstance();
678     g_statsServiceProxy->Reset();
679 
680     int32_t callStateOn = static_cast<int32_t>(TelCallState::CALL_STATUS_ACTIVE);
681     int32_t callStateOff = static_cast<int32_t>(TelCallState::CALL_STATUS_DISCONNECTED);
682     int32_t dataStateOn = 1;
683     int32_t dataStateOff = 0;
684     int16_t level = 0;
685     double phoneOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_RADIO_ON, level);
686     double phoneDataAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_RADIO_DATA, level);
687 
688     StatsWriteHiSysEvent(statsService,
689         HiSysEvent::Domain::TELEPHONY, StatsHiSysEvent::CALL_STATE,
690         HiSysEvent::EventType::BEHAVIOR, "STATE", callStateOn);
691     usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
692     StatsWriteHiSysEvent(statsService,
693         HiSysEvent::Domain::TELEPHONY, StatsHiSysEvent::DATA_CONNECTION_STATE, HiSysEvent::EventType::BEHAVIOR,
694         "STATE", dataStateOn);
695     usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
696     StatsWriteHiSysEvent(statsService,
697         HiSysEvent::Domain::TELEPHONY, StatsHiSysEvent::CALL_STATE,
698         HiSysEvent::EventType::BEHAVIOR, "STATE", callStateOn);
699     usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
700     StatsWriteHiSysEvent(statsService,
701         HiSysEvent::Domain::TELEPHONY, StatsHiSysEvent::CALL_STATE,
702         HiSysEvent::EventType::BEHAVIOR, "STATE", callStateOff);
703     usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
704     StatsWriteHiSysEvent(statsService,
705         HiSysEvent::Domain::TELEPHONY, StatsHiSysEvent::DATA_CONNECTION_STATE, HiSysEvent::EventType::BEHAVIOR,
706         "STATE", dataStateOn);
707     usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
708     StatsWriteHiSysEvent(statsService,
709         HiSysEvent::Domain::TELEPHONY, StatsHiSysEvent::DATA_CONNECTION_STATE, HiSysEvent::EventType::BEHAVIOR,
710         "STATE", dataStateOff);
711 
712     double phoneOnPower = 3 * SERVICE_POWER_CONSUMPTION_DURATION_US * phoneOnAverageMa / US_PER_HOUR;
713     double phoneDataPower = 4 * SERVICE_POWER_CONSUMPTION_DURATION_US * phoneDataAverageMa / US_PER_HOUR;
714     double expectedPower = phoneOnPower + phoneDataPower;
715     double actualPower = StatsUtils::DEFAULT_VALUE;
716     auto list = g_statsServiceProxy->GetBatteryStats();
717     for (auto it : list) {
718         if ((*it).GetConsumptionType() == BatteryStatsInfo::CONSUMPTION_TYPE_PHONE) {
719             actualPower = (*it).GetPower();
720         }
721     }
722     double devPrecent = abs(expectedPower - actualPower) / expectedPower;
723     GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
724     GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
725     EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
726 }
727 
728 /**
729  * @tc.name: StatsServicePhoneTest_018
730  * @tc.desc: test SetOnBattery function(Phone Call & Phone Data)
731  * @tc.type: FUNC
732  * @tc.require: issueI663DX
733  */
734 HWTEST_F (StatsServicePhoneTest, StatsServicePhoneTest_018, TestSize.Level0)
735 {
736     ASSERT_NE(g_statsServiceProxy, nullptr);
737     auto statsService = BatteryStatsService::GetInstance();
738     g_statsServiceProxy->Reset();
739     g_statsServiceProxy->SetOnBattery(false);
740 
741     int32_t callStateOn = static_cast<int32_t>(TelCallState::CALL_STATUS_ACTIVE);
742     int32_t callStateOff = static_cast<int32_t>(TelCallState::CALL_STATUS_DISCONNECTED);
743     int32_t dataStateOn = 1;
744     int32_t dataStateOff = 0;
745 
746     StatsWriteHiSysEvent(statsService,
747         HiSysEvent::Domain::TELEPHONY, StatsHiSysEvent::CALL_STATE,
748         HiSysEvent::EventType::BEHAVIOR, "STATE", callStateOn);
749     usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
750     StatsWriteHiSysEvent(statsService,
751         HiSysEvent::Domain::TELEPHONY, StatsHiSysEvent::CALL_STATE,
752         HiSysEvent::EventType::BEHAVIOR, "STATE", callStateOff);
753 
754     StatsWriteHiSysEvent(statsService,
755         HiSysEvent::Domain::TELEPHONY, StatsHiSysEvent::DATA_CONNECTION_STATE, HiSysEvent::EventType::BEHAVIOR,
756         "STATE", dataStateOn);
757     usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
758     StatsWriteHiSysEvent(statsService,
759         HiSysEvent::Domain::TELEPHONY, StatsHiSysEvent::DATA_CONNECTION_STATE, HiSysEvent::EventType::BEHAVIOR,
760         "STATE", dataStateOff);
761 
762     double expectedPower = StatsUtils::DEFAULT_VALUE;
763     double actualPower = g_statsServiceProxy->GetPartStatsMah(BatteryStatsInfo::CONSUMPTION_TYPE_PHONE);
764     GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
765     GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
766     EXPECT_EQ(expectedPower, actualPower);
767     g_statsServiceProxy->SetOnBattery(true);
768 }
769 
770 /**
771  * @tc.name: StatsServicePhoneTest_019
772  * @tc.desc: test GetPartStatsMah function with battery changed(Phone call on)
773  * @tc.type: FUNC
774  * @tc.require: issueI663DX
775  */
776 HWTEST_F (StatsServicePhoneTest, StatsServicePhoneTest_019, TestSize.Level0)
777 {
778     ASSERT_NE(g_statsServiceProxy, nullptr);
779     auto statsService = BatteryStatsService::GetInstance();
780     g_statsServiceProxy->Reset();
781 
782     int32_t stateOn = static_cast<int32_t>(TelCallState::CALL_STATUS_ACTIVE);
783     int32_t stateOff = static_cast<int32_t>(TelCallState::CALL_STATUS_DISCONNECTED);
784     int16_t level = 0;
785     double phoneOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_RADIO_ON, level);
786 
787     StatsWriteHiSysEvent(statsService,
788         HiSysEvent::Domain::TELEPHONY, StatsHiSysEvent::CALL_STATE,
789         HiSysEvent::EventType::BEHAVIOR, "STATE", stateOn);
790     usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
791     g_statsServiceProxy->SetOnBattery(false);
792     usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
793     g_statsServiceProxy->SetOnBattery(true);
794     usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
795     StatsWriteHiSysEvent(statsService,
796         HiSysEvent::Domain::TELEPHONY, StatsHiSysEvent::CALL_STATE,
797         HiSysEvent::EventType::BEHAVIOR, "STATE", stateOff);
798 
799     double expectedPower = 2 * SERVICE_POWER_CONSUMPTION_DURATION_US * phoneOnAverageMa / US_PER_HOUR;
800     double actualPower = g_statsServiceProxy->GetPartStatsMah(BatteryStatsInfo::CONSUMPTION_TYPE_PHONE);
801     double devPrecent = abs(expectedPower - actualPower) / expectedPower;
802     GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
803     GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
804     EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
805 }
806 
807 /**
808  * @tc.name: StatsServicePhoneTest_020
809  * @tc.desc: test GetPartStatsMah(Phone Data) and GetAppStatsMah(Audio) function
810  * @tc.type: FUNC
811  * @tc.require: issueI663DX
812  */
813 HWTEST_F (StatsServicePhoneTest, StatsServicePhoneTest_020, TestSize.Level0)
814 {
815     ASSERT_NE(g_statsServiceProxy, nullptr);
816     auto statsService = BatteryStatsService::GetInstance();
817     g_statsServiceProxy->Reset();
818 
819     int32_t stateOn = 1;
820     int32_t stateOff = 0;
821     int16_t level = 0;
822     double phoneDataAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_RADIO_DATA, level);
823 
824     StatsWriteHiSysEvent(statsService,
825         HiSysEvent::Domain::TELEPHONY, StatsHiSysEvent::DATA_CONNECTION_STATE,
826         HiSysEvent::EventType::BEHAVIOR, "STATE", stateOn);
827     usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
828     StatsWriteHiSysEvent(statsService,
829         HiSysEvent::Domain::TELEPHONY, StatsHiSysEvent::DATA_CONNECTION_STATE,
830         HiSysEvent::EventType::BEHAVIOR, "STATE", stateOff);
831 
832     double expectedPower = SERVICE_POWER_CONSUMPTION_DURATION_US * phoneDataAverageMa / US_PER_HOUR;
833     double actualPower = g_statsServiceProxy->GetPartStatsMah(BatteryStatsInfo::CONSUMPTION_TYPE_PHONE);
834     double devPrecent = abs(expectedPower - actualPower) / expectedPower;
835     GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
836     GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
837     EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
838 
839     double audioOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_AUDIO_ON);
840     int32_t uid = 10003;
841     int32_t pid = 3458;
842     int32_t stateRunning = 2;
843     int32_t stateStopped = 3;
844 
845     StatsWriteHiSysEvent(statsService,
846         HiSysEvent::Domain::AUDIO, StatsHiSysEvent::STREAM_CHANGE, HiSysEvent::EventType::BEHAVIOR, "PID", pid,
847         "UID", uid, "STATE", stateRunning);
848     usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
849     StatsWriteHiSysEvent(statsService,
850         HiSysEvent::Domain::AUDIO, StatsHiSysEvent::STREAM_CHANGE, HiSysEvent::EventType::BEHAVIOR, "PID", pid,
851         "UID", uid, "STATE", stateStopped);
852 
853     expectedPower = SERVICE_POWER_CONSUMPTION_DURATION_US * audioOnAverageMa / US_PER_HOUR;
854     actualPower = g_statsServiceProxy->GetAppStatsMah(uid);
855     devPrecent = abs(expectedPower - actualPower) / expectedPower;
856     GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
857     GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
858     EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
859 }
860 
861 /**
862  * @tc.name: StatsServicePhoneTest_021
863  * @tc.desc: test GetTotalTimeSecond function(Phone Call)
864  * @tc.type: FUNC
865  * @tc.require: issueI663DX
866  */
867 HWTEST_F (StatsServicePhoneTest, StatsServicePhoneTest_021, TestSize.Level0)
868 {
869     ASSERT_NE(g_statsServiceProxy, nullptr);
870     auto statsService = BatteryStatsService::GetInstance();
871     g_statsServiceProxy->Reset();
872 
873     int32_t stateOn = static_cast<int32_t>(TelCallState::CALL_STATUS_ACTIVE);
874     int32_t stateOff = static_cast<int32_t>(TelCallState::CALL_STATUS_DISCONNECTED);
875 
876     StatsWriteHiSysEvent(statsService,
877         HiSysEvent::Domain::TELEPHONY, StatsHiSysEvent::CALL_STATE,
878         HiSysEvent::EventType::BEHAVIOR, "STATE", stateOn);
879     usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
880     StatsWriteHiSysEvent(statsService,
881         HiSysEvent::Domain::TELEPHONY, StatsHiSysEvent::CALL_STATE,
882         HiSysEvent::EventType::BEHAVIOR, "STATE", stateOff);
883 
884     long expectedTime = round(SERVICE_POWER_CONSUMPTION_DURATION_US / US_PER_SECOND);
885     long actualTime = g_statsServiceProxy->GetTotalTimeSecond(StatsUtils::STATS_TYPE_PHONE_ACTIVE);
886     GTEST_LOG_(INFO) << __func__ << ": expected time = " << expectedTime << " seconds";
887     GTEST_LOG_(INFO) << __func__ << ": actual time = " <<  actualTime << " seconds";
888     EXPECT_EQ(expectedTime, actualTime);
889 }
890 
891 /**
892  * @tc.name: StatsServicePhoneTest_022
893  * @tc.desc: test GetTotalTimeSecond function(Phone Data)
894  * @tc.type: FUNC
895  * @tc.require: issueI663DX
896  */
897 HWTEST_F (StatsServicePhoneTest, StatsServicePhoneTest_022, TestSize.Level0)
898 {
899     ASSERT_NE(g_statsServiceProxy, nullptr);
900     auto statsService = BatteryStatsService::GetInstance();
901     g_statsServiceProxy->Reset();
902 
903     int32_t stateOn = 1;
904     int32_t stateOff = 0;
905 
906     StatsWriteHiSysEvent(statsService,
907         HiSysEvent::Domain::TELEPHONY, StatsHiSysEvent::DATA_CONNECTION_STATE,
908         HiSysEvent::EventType::BEHAVIOR, "STATE", stateOn);
909     usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
910     StatsWriteHiSysEvent(statsService,
911         HiSysEvent::Domain::TELEPHONY, StatsHiSysEvent::DATA_CONNECTION_STATE,
912         HiSysEvent::EventType::BEHAVIOR, "STATE", stateOff);
913 
914     long expectedTime = round(SERVICE_POWER_CONSUMPTION_DURATION_US / US_PER_SECOND);
915     long actualTime = g_statsServiceProxy->GetTotalTimeSecond(StatsUtils::STATS_TYPE_PHONE_DATA);
916     GTEST_LOG_(INFO) << __func__ << ": expected time = " << expectedTime << " seconds";
917     GTEST_LOG_(INFO) << __func__ << ": actual time = " <<  actualTime << " seconds";
918     EXPECT_EQ(expectedTime, actualTime);
919 }
920 
921 /**
922  * @tc.name: StatsServicePhoneTest_023
923  * @tc.desc: test send hisysevent with missing information(Phone Call & Phone Data)
924  * @tc.type: FUNC
925  * @tc.require: issueI663DX
926  */
927 HWTEST_F (StatsServicePhoneTest, StatsServicePhoneTest_023, TestSize.Level0)
928 {
929     ASSERT_NE(g_statsServiceProxy, nullptr);
930     auto statsService = BatteryStatsService::GetInstance();
931     g_statsServiceProxy->Reset();
932 
933     StatsWriteHiSysEvent(statsService,
934         HiSysEvent::Domain::TELEPHONY, StatsHiSysEvent::CALL_STATE, HiSysEvent::EventType::BEHAVIOR);
935     usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
936     StatsWriteHiSysEvent(statsService,
937         HiSysEvent::Domain::TELEPHONY, StatsHiSysEvent::CALL_STATE, HiSysEvent::EventType::BEHAVIOR);
938 
939     StatsWriteHiSysEvent(statsService,
940         HiSysEvent::Domain::TELEPHONY, StatsHiSysEvent::DATA_CONNECTION_STATE, HiSysEvent::EventType::BEHAVIOR);
941     usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
942     StatsWriteHiSysEvent(statsService,
943         HiSysEvent::Domain::TELEPHONY, StatsHiSysEvent::DATA_CONNECTION_STATE, HiSysEvent::EventType::BEHAVIOR);
944 
945     double expectedPower = StatsUtils::DEFAULT_VALUE;
946     double actualPower = g_statsServiceProxy->GetPartStatsMah(BatteryStatsInfo::CONSUMPTION_TYPE_PHONE);
947     GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
948     GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
949     EXPECT_EQ(expectedPower, actualPower);
950 }
951 }