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_subscriber_test.h"
17 #include "stats_log.h"
18 #include <call_manager_inner_type.h>
19 #include <hisysevent.h>
20
21 #include "battery_stats_listener.h"
22 #include "battery_stats_subscriber.h"
23 #include "common_event_data.h"
24 #include "common_event_manager.h"
25 #include "common_event_support.h"
26 #include "hisysevent_operation.h"
27 #include "stats_hisysevent.h"
28 #include "stats_service_test_proxy.h"
29 #include "stats_service_write_event.h"
30
31 using namespace OHOS;
32 using namespace OHOS::AAFwk;
33 using namespace OHOS::EventFwk;
34 using namespace OHOS::HiviewDFX;
35 using namespace OHOS::PowerMgr;
36 using namespace OHOS::Telephony;
37 using namespace std;
38 using namespace testing::ext;
39
40 namespace {
41 static sptr<BatteryStatsService> g_statsService = nullptr;
42 static std::shared_ptr<StatsServiceTestProxy> g_statsServiceProxy = nullptr;
43 const int32_t BATTERY_LEVEL_FULL = 100;
44 } // namespace
45
SetUpTestCase()46 void StatsServiceSubscriberTest::SetUpTestCase()
47 {
48 ParserAveragePowerFile();
49 g_statsService = BatteryStatsService::GetInstance();
50 g_statsService->OnStart();
51
52 if (g_statsService->listenerPtr_ == nullptr) {
53 g_statsService->listenerPtr_ = std::make_shared<BatteryStatsListener>();
54 }
55
56 if (g_statsService->subscriberPtr_ == nullptr) {
57 OHOS::EventFwk::MatchingSkills matchingSkills {};
58 OHOS::EventFwk::CommonEventSubscribeInfo subscribeInfo(matchingSkills);
59 g_statsService->subscriberPtr_ = std::make_shared<BatteryStatsSubscriber>(subscribeInfo);
60 }
61
62 if (g_statsServiceProxy == nullptr) {
63 g_statsServiceProxy = std::make_shared<StatsServiceTestProxy>(g_statsService);
64 }
65 }
66
TearDownTestCase()67 void StatsServiceSubscriberTest::TearDownTestCase()
68 {
69 g_statsService->listenerPtr_ = nullptr;
70 g_statsService->subscriberPtr_ = nullptr;
71 g_statsService->OnStop();
72 }
73
SetUp()74 void StatsServiceSubscriberTest::SetUp()
75 {
76 auto statsService = BatteryStatsService::GetInstance();
77 statsService->SetOnBattery(true);
78 }
79
TearDown()80 void StatsServiceSubscriberTest::TearDown()
81 {
82 auto statsService = BatteryStatsService::GetInstance();
83 statsService->SetOnBattery(false);
84 }
85
PublishChangedEvent(const sptr<BatteryStatsService> & service,const std::string & action)86 void StatsServiceSubscriberTest::PublishChangedEvent(const sptr<BatteryStatsService>& service,
87 const std::string& action)
88 {
89 Want want;
90 want.SetParam(BatteryInfo::COMMON_EVENT_KEY_CAPACITY, capacity_);
91 want.SetParam(BatteryInfo::COMMON_EVENT_KEY_PLUGGED_TYPE, static_cast<int>(pluggedType_));
92 want.SetAction(action);
93 CommonEventData data;
94 data.SetWant(want);
95 if (service->subscriberPtr_ != nullptr) {
96 g_statsService->subscriberPtr_->OnReceiveEvent(data);
97 }
98 }
99
100 namespace {
101 /**
102 * @tc.name: StatsServiceSubscriberTest_001
103 * @tc.desc: test COMMON_EVENT_BATTERY_CHANGED with capacity is BATTERY_LEVEL_FULL(Alarm)
104 * @tc.type: FUNC
105 * @tc.require: issueI663DX
106 */
107 HWTEST_F (StatsServiceSubscriberTest, StatsServiceSubscriberTest_001, TestSize.Level0)
108 {
109 STATS_HILOGI(LABEL_TEST, "StatsServiceSubscriberTest_001 start");
110 ASSERT_NE(g_statsServiceProxy, nullptr);
111 auto statsService = BatteryStatsService::GetInstance();
112 g_statsServiceProxy->ResetIpc();
113 BatteryInfoReset();
114
115 int32_t uid = 10003;
116 int32_t pid = 3458;
117 int16_t count = 10;
118
119 for (int16_t i = 0; i < count; i++) {
120 StatsWriteHiSysEvent(statsService,
121 HiSysEvent::Domain::TIME, StatsHiSysEvent::MISC_TIME_STATISTIC_REPORT, HiSysEvent::EventType::STATISTIC,
122 "CALLER_PID", pid, "CALLER_UID", uid);
123 }
124 int32_t tempError;
125 double powerMahBefore;
126 g_statsServiceProxy->GetAppStatsMahIpc(uid, powerMahBefore, tempError);
127 SetCapacity(BATTERY_LEVEL_FULL);
128 PublishChangedEvent(statsService, CommonEventSupport::COMMON_EVENT_BATTERY_CHANGED);
129 double powerMahAfter;
130 g_statsServiceProxy->GetAppStatsMahIpc(uid, powerMahAfter, tempError);
131 GTEST_LOG_(INFO) << __func__ << ": before consumption = " << powerMahBefore << " mAh";
132 GTEST_LOG_(INFO) << __func__ << ": after consumption = " << powerMahAfter << " mAh";
133 EXPECT_TRUE(powerMahBefore >= StatsUtils::DEFAULT_VALUE && powerMahAfter == StatsUtils::DEFAULT_VALUE);
134 STATS_HILOGI(LABEL_TEST, "StatsServiceSubscriberTest_001 end");
135 }
136
137 /**
138 * @tc.name: StatsServiceSubscriberTest_002
139 * @tc.desc: test COMMON_EVENT_BATTERY_CHANGED with BatteryPluggedType(Alarm)
140 * @tc.type: FUNC
141 * @tc.require: issueI663DX
142 */
143 HWTEST_F (StatsServiceSubscriberTest, StatsServiceSubscriberTest_002, TestSize.Level0)
144 {
145 STATS_HILOGI(LABEL_TEST, "StatsServiceSubscriberTest_002 start");
146 ASSERT_NE(g_statsServiceProxy, nullptr);
147 auto statsService = BatteryStatsService::GetInstance();
148 g_statsServiceProxy->ResetIpc();
149 g_statsServiceProxy->SetOnBatteryIpc(false);
150 BatteryInfoReset();
151
152 double alarmOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_ALARM_ON);
153 int32_t uid = 10003;
154 int32_t pid = 3458;
155
156 SetPluggedType(BatteryPluggedType::PLUGGED_TYPE_NONE);
157 PublishChangedEvent(statsService, CommonEventSupport::COMMON_EVENT_BATTERY_CHANGED);
158 StatsWriteHiSysEvent(statsService,
159 HiSysEvent::Domain::TIME, StatsHiSysEvent::MISC_TIME_STATISTIC_REPORT, HiSysEvent::EventType::STATISTIC,
160 "CALLER_PID", pid, "CALLER_UID", uid);
161
162 SetPluggedType(BatteryPluggedType::PLUGGED_TYPE_USB);
163 PublishChangedEvent(statsService, CommonEventSupport::COMMON_EVENT_BATTERY_CHANGED);
164 StatsWriteHiSysEvent(statsService,
165 HiSysEvent::Domain::TIME, StatsHiSysEvent::MISC_TIME_STATISTIC_REPORT, HiSysEvent::EventType::STATISTIC,
166 "CALLER_PID", pid, "CALLER_UID", uid);
167
168 SetPluggedType(BatteryPluggedType::PLUGGED_TYPE_BUTT);
169 PublishChangedEvent(statsService, CommonEventSupport::COMMON_EVENT_BATTERY_CHANGED);
170 StatsWriteHiSysEvent(statsService,
171 HiSysEvent::Domain::TIME, StatsHiSysEvent::MISC_TIME_STATISTIC_REPORT, HiSysEvent::EventType::STATISTIC,
172 "CALLER_PID", pid, "CALLER_UID", uid);
173 int32_t tempError;
174 double expectedPower = 2 * alarmOnAverageMa;
175 double actualPower;
176 g_statsServiceProxy->GetAppStatsMahIpc(uid, actualPower, tempError);
177 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
178 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
179 EXPECT_EQ(expectedPower, actualPower);
180 g_statsServiceProxy->SetOnBatteryIpc(true);
181 STATS_HILOGI(LABEL_TEST, "StatsServiceSubscriberTest_002 end");
182 }
183
184 /**
185 * @tc.name: StatsServiceSubscriberTest_003
186 * @tc.desc: test COMMON_EVENT_BATTERY_CHANGED with capacity is BATTERY_LEVEL_FULL(Audio)
187 * @tc.type: FUNC
188 * @tc.require: issueI663DX
189 */
190 HWTEST_F (StatsServiceSubscriberTest, StatsServiceSubscriberTest_003, TestSize.Level0)
191 {
192 STATS_HILOGI(LABEL_TEST, "StatsServiceSubscriberTest_003 start");
193 ASSERT_NE(g_statsServiceProxy, nullptr);
194 auto statsService = BatteryStatsService::GetInstance();
195 g_statsServiceProxy->ResetIpc();
196 BatteryInfoReset();
197
198 int32_t uid = 10003;
199 int32_t pid = 3458;
200 int32_t stateRunning = 2;
201 int32_t stateStopped = 3;
202
203 StatsWriteHiSysEvent(statsService,
204 HiSysEvent::Domain::AUDIO, StatsHiSysEvent::STREAM_CHANGE, HiSysEvent::EventType::BEHAVIOR, "PID", pid,
205 "UID", uid, "STATE", stateRunning);
206 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
207 StatsWriteHiSysEvent(statsService,
208 HiSysEvent::Domain::AUDIO, StatsHiSysEvent::STREAM_CHANGE, HiSysEvent::EventType::BEHAVIOR, "PID", pid,
209 "UID", uid, "STATE", stateStopped);
210 int32_t tempError;
211 double powerMahBefore;
212 g_statsServiceProxy->GetAppStatsMahIpc(uid, powerMahBefore, tempError);
213 SetCapacity(BATTERY_LEVEL_FULL);
214 PublishChangedEvent(statsService, CommonEventSupport::COMMON_EVENT_BATTERY_CHANGED);
215 double powerMahAfter;
216 g_statsServiceProxy->GetAppStatsMahIpc(uid, powerMahAfter, tempError);
217 GTEST_LOG_(INFO) << __func__ << ": before consumption = " << powerMahBefore << " mAh";
218 GTEST_LOG_(INFO) << __func__ << ": after consumption = " << powerMahAfter << " mAh";
219 EXPECT_TRUE(powerMahBefore >= StatsUtils::DEFAULT_VALUE && powerMahAfter == StatsUtils::DEFAULT_VALUE);
220 STATS_HILOGI(LABEL_TEST, "StatsServiceSubscriberTest_003 end");
221 }
222
223 /**
224 * @tc.name: StatsServiceSubscriberTest_004
225 * @tc.desc: test COMMON_EVENT_BATTERY_CHANGED with BatteryPluggedType(Audio)
226 * @tc.type: FUNC
227 * @tc.require: issueI663DX
228 */
229 HWTEST_F (StatsServiceSubscriberTest, StatsServiceSubscriberTest_004, TestSize.Level0)
230 {
231 STATS_HILOGI(LABEL_TEST, "StatsServiceSubscriberTest_004 start");
232 ASSERT_NE(g_statsServiceProxy, nullptr);
233 auto statsService = BatteryStatsService::GetInstance();
234 g_statsServiceProxy->ResetIpc();
235 g_statsServiceProxy->SetOnBatteryIpc(false);
236 BatteryInfoReset();
237
238 double audioOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_AUDIO_ON);
239 int32_t uid = 10003;
240 int32_t pid = 3458;
241 int32_t stateRunning = 2;
242 int32_t stateStopped = 3;
243
244 SetPluggedType(BatteryPluggedType::PLUGGED_TYPE_NONE);
245 PublishChangedEvent(statsService, CommonEventSupport::COMMON_EVENT_BATTERY_CHANGED);
246 StatsWriteHiSysEvent(statsService,
247 HiSysEvent::Domain::AUDIO, StatsHiSysEvent::STREAM_CHANGE, HiSysEvent::EventType::BEHAVIOR, "PID", pid,
248 "UID", uid, "STATE", stateRunning);
249 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
250 StatsWriteHiSysEvent(statsService,
251 HiSysEvent::Domain::AUDIO, StatsHiSysEvent::STREAM_CHANGE, HiSysEvent::EventType::BEHAVIOR, "PID", pid,
252 "UID", uid, "STATE", stateStopped);
253
254 SetPluggedType(BatteryPluggedType::PLUGGED_TYPE_AC);
255 PublishChangedEvent(statsService, CommonEventSupport::COMMON_EVENT_BATTERY_CHANGED);
256 StatsWriteHiSysEvent(statsService,
257 HiSysEvent::Domain::AUDIO, StatsHiSysEvent::STREAM_CHANGE, HiSysEvent::EventType::BEHAVIOR, "PID", pid,
258 "UID", uid, "STATE", stateRunning);
259 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
260 StatsWriteHiSysEvent(statsService,
261 HiSysEvent::Domain::AUDIO, StatsHiSysEvent::STREAM_CHANGE, HiSysEvent::EventType::BEHAVIOR, "PID", pid,
262 "UID", uid, "STATE", stateStopped);
263
264 SetPluggedType(BatteryPluggedType::PLUGGED_TYPE_BUTT);
265 PublishChangedEvent(statsService, CommonEventSupport::COMMON_EVENT_BATTERY_CHANGED);
266 StatsWriteHiSysEvent(statsService,
267 HiSysEvent::Domain::AUDIO, StatsHiSysEvent::STREAM_CHANGE, HiSysEvent::EventType::BEHAVIOR, "PID", pid,
268 "UID", uid, "STATE", stateRunning);
269 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
270 StatsWriteHiSysEvent(statsService,
271 HiSysEvent::Domain::AUDIO, StatsHiSysEvent::STREAM_CHANGE, HiSysEvent::EventType::BEHAVIOR, "PID", pid,
272 "UID", uid, "STATE", stateStopped);
273
274 double expectedPower = 2 * SERVICE_POWER_CONSUMPTION_DURATION_US * audioOnAverageMa / US_PER_HOUR;
275 int32_t tempError;
276 double actualPower;
277 g_statsServiceProxy->GetAppStatsMahIpc(uid, actualPower, tempError);
278 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
279 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
280 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
281 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
282 STATS_HILOGI(LABEL_TEST, "StatsServiceSubscriberTest_004 end");
283 }
284
285 /**
286 * @tc.name: StatsServiceSubscriberTest_005
287 * @tc.desc: test COMMON_EVENT_BATTERY_LOW is no use(Audio)
288 * @tc.type: FUNC
289 * @tc.require: issueI663DX
290 */
291 HWTEST_F (StatsServiceSubscriberTest, StatsServiceSubscriberTest_005, TestSize.Level0)
292 {
293 STATS_HILOGI(LABEL_TEST, "StatsServiceSubscriberTest_005 start");
294 ASSERT_NE(g_statsServiceProxy, nullptr);
295 auto statsService = BatteryStatsService::GetInstance();
296 g_statsServiceProxy->ResetIpc();
297 BatteryInfoReset();
298
299 double audioOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_AUDIO_ON);
300 int32_t uid = 10003;
301 int32_t pid = 3458;
302 int32_t stateRunning = 2;
303 int32_t stateStopped = 3;
304
305 StatsWriteHiSysEvent(statsService,
306 HiSysEvent::Domain::AUDIO, StatsHiSysEvent::STREAM_CHANGE, HiSysEvent::EventType::BEHAVIOR, "PID", pid,
307 "UID", uid, "STATE", stateRunning);
308 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
309 StatsWriteHiSysEvent(statsService,
310 HiSysEvent::Domain::AUDIO, StatsHiSysEvent::STREAM_CHANGE, HiSysEvent::EventType::BEHAVIOR, "PID", pid,
311 "UID", uid, "STATE", stateStopped);
312
313 SetPluggedType(BatteryPluggedType::PLUGGED_TYPE_AC);
314 PublishChangedEvent(statsService, CommonEventSupport::COMMON_EVENT_BATTERY_LOW);
315 double expectedPower = SERVICE_POWER_CONSUMPTION_DURATION_US * audioOnAverageMa / US_PER_HOUR;
316 int32_t tempError;
317 double actualPower;
318 g_statsServiceProxy->GetAppStatsMahIpc(uid, actualPower, tempError);
319 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
320 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
321 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
322 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
323 STATS_HILOGI(LABEL_TEST, "StatsServiceSubscriberTest_005 end");
324 }
325
326 /**
327 * @tc.name: StatsServiceSubscriberTest_006
328 * @tc.desc: test COMMON_EVENT_SHUTDOWN(Phone)
329 * @tc.type: FUNC
330 * @tc.require: issueI663DX
331 */
332 HWTEST_F (StatsServiceSubscriberTest, StatsServiceSubscriberTest_006, TestSize.Level0)
333 {
334 STATS_HILOGI(LABEL_TEST, "StatsServiceSubscriberTest_006 start");
335 ASSERT_NE(g_statsServiceProxy, nullptr);
336 auto statsService = BatteryStatsService::GetInstance();
337 g_statsServiceProxy->ResetIpc();
338
339 int32_t stateOn = static_cast<int32_t>(TelCallState::CALL_STATUS_ACTIVE);
340 int32_t stateOff = static_cast<int32_t>(TelCallState::CALL_STATUS_DISCONNECTED);
341 int16_t level = 0;
342 double phoneOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_RADIO_ON, level);
343
344 StatsWriteHiSysEvent(statsService,
345 HiSysEvent::Domain::TELEPHONY, StatsHiSysEvent::CALL_STATE, HiSysEvent::EventType::BEHAVIOR, "STATE", stateOn);
346 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
347 StatsWriteHiSysEvent(statsService,
348 HiSysEvent::Domain::TELEPHONY, StatsHiSysEvent::CALL_STATE, HiSysEvent::EventType::BEHAVIOR, "STATE", stateOff);
349
350 PublishChangedEvent(statsService, CommonEventSupport::COMMON_EVENT_SHUTDOWN);
351 g_statsServiceProxy->ResetIpc();
352
353 auto statsCore = statsService->GetBatteryStatsCore();
354 statsCore->Init();
355 BatteryStatsInfoList statsInfoList {};
356 statsInfoList = statsCore->GetBatteryStats();
357
358 double expectedPower = SERVICE_POWER_CONSUMPTION_DURATION_US * phoneOnAverageMa / US_PER_HOUR;
359 double actualPower = StatsUtils::DEFAULT_VALUE;
360 for (auto it : statsInfoList) {
361 if ((*it).GetConsumptionType() == BatteryStatsInfo::CONSUMPTION_TYPE_PHONE) {
362 actualPower = (*it).GetPower();
363 }
364 }
365
366 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
367 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
368 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
369 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
370 STATS_HILOGI(LABEL_TEST, "StatsServiceSubscriberTest_006 end");
371 }
372 }