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