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