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