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