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