1 /*
2 * Copyright (c) 2022-2023 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
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 = DelayedStatsSpSingleton<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 = DelayedStatsSpSingleton<BatteryStatsService>::GetInstance();
77 statsService->SetOnBattery(true);
78 }
79
TearDown()80 void StatsServiceSubscriberTest::TearDown()
81 {
82 auto statsService = DelayedStatsSpSingleton<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 ASSERT_NE(g_statsServiceProxy, nullptr);
110 auto statsService = DelayedStatsSpSingleton<BatteryStatsService>::GetInstance();
111 g_statsServiceProxy->Reset();
112 BatteryInfoReset();
113
114 int32_t uid = 10003;
115 int32_t pid = 3458;
116 int16_t count = 10;
117
118 for (int16_t i = 0; i < count; i++) {
119 StatsWriteHiSysEvent(statsService,
120 HiSysEvent::Domain::TIME, StatsHiSysEvent::MISC_TIME_STATISTIC_REPORT, HiSysEvent::EventType::STATISTIC,
121 "CALLER_PID", pid, "CALLER_UID", uid);
122 }
123
124 double powerMahBefore = g_statsServiceProxy->GetAppStatsMah(uid);
125 SetCapacity(BATTERY_LEVEL_FULL);
126 PublishChangedEvent(statsService, CommonEventSupport::COMMON_EVENT_BATTERY_CHANGED);
127 double powerMahAfter = g_statsServiceProxy->GetAppStatsMah(uid);
128 GTEST_LOG_(INFO) << __func__ << ": before consumption = " << powerMahBefore << " mAh";
129 GTEST_LOG_(INFO) << __func__ << ": after consumption = " << powerMahAfter << " mAh";
130 EXPECT_TRUE(powerMahBefore > StatsUtils::DEFAULT_VALUE && powerMahAfter == StatsUtils::DEFAULT_VALUE);
131 }
132
133 /**
134 * @tc.name: StatsServiceSubscriberTest_002
135 * @tc.desc: test COMMON_EVENT_BATTERY_CHANGED with BatteryPluggedType(Alarm)
136 * @tc.type: FUNC
137 * @tc.require: issueI663DX
138 */
139 HWTEST_F (StatsServiceSubscriberTest, StatsServiceSubscriberTest_002, TestSize.Level0)
140 {
141 ASSERT_NE(g_statsServiceProxy, nullptr);
142 auto statsService = DelayedStatsSpSingleton<BatteryStatsService>::GetInstance();
143 g_statsServiceProxy->Reset();
144 g_statsServiceProxy->SetOnBattery(false);
145 BatteryInfoReset();
146
147 double alarmOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_ALARM_ON);
148 int32_t uid = 10003;
149 int32_t pid = 3458;
150
151 SetPluggedType(BatteryPluggedType::PLUGGED_TYPE_NONE);
152 PublishChangedEvent(statsService, CommonEventSupport::COMMON_EVENT_BATTERY_CHANGED);
153 StatsWriteHiSysEvent(statsService,
154 HiSysEvent::Domain::TIME, StatsHiSysEvent::MISC_TIME_STATISTIC_REPORT, HiSysEvent::EventType::STATISTIC,
155 "CALLER_PID", pid, "CALLER_UID", uid);
156
157 SetPluggedType(BatteryPluggedType::PLUGGED_TYPE_USB);
158 PublishChangedEvent(statsService, CommonEventSupport::COMMON_EVENT_BATTERY_CHANGED);
159 StatsWriteHiSysEvent(statsService,
160 HiSysEvent::Domain::TIME, StatsHiSysEvent::MISC_TIME_STATISTIC_REPORT, HiSysEvent::EventType::STATISTIC,
161 "CALLER_PID", pid, "CALLER_UID", uid);
162
163 SetPluggedType(BatteryPluggedType::PLUGGED_TYPE_BUTT);
164 PublishChangedEvent(statsService, CommonEventSupport::COMMON_EVENT_BATTERY_CHANGED);
165 StatsWriteHiSysEvent(statsService,
166 HiSysEvent::Domain::TIME, StatsHiSysEvent::MISC_TIME_STATISTIC_REPORT, HiSysEvent::EventType::STATISTIC,
167 "CALLER_PID", pid, "CALLER_UID", uid);
168
169 double expectedPower = 2 * alarmOnAverageMa;
170 double actualPower = g_statsServiceProxy->GetAppStatsMah(uid);
171 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
172 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
173 EXPECT_EQ(expectedPower, actualPower);
174 g_statsServiceProxy->SetOnBattery(true);
175 }
176
177 /**
178 * @tc.name: StatsServiceSubscriberTest_003
179 * @tc.desc: test COMMON_EVENT_BATTERY_CHANGED with capacity is BATTERY_LEVEL_FULL(Audio)
180 * @tc.type: FUNC
181 * @tc.require: issueI663DX
182 */
183 HWTEST_F (StatsServiceSubscriberTest, StatsServiceSubscriberTest_003, TestSize.Level0)
184 {
185 ASSERT_NE(g_statsServiceProxy, nullptr);
186 auto statsService = DelayedStatsSpSingleton<BatteryStatsService>::GetInstance();
187 g_statsServiceProxy->Reset();
188 BatteryInfoReset();
189
190 int32_t uid = 10003;
191 int32_t pid = 3458;
192 int32_t stateRunning = 2;
193 int32_t stateStopped = 3;
194
195 StatsWriteHiSysEvent(statsService,
196 HiSysEvent::Domain::AUDIO, StatsHiSysEvent::STREAM_CHANGE, HiSysEvent::EventType::BEHAVIOR, "PID", pid,
197 "UID", uid, "STATE", stateRunning);
198 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
199 StatsWriteHiSysEvent(statsService,
200 HiSysEvent::Domain::AUDIO, StatsHiSysEvent::STREAM_CHANGE, HiSysEvent::EventType::BEHAVIOR, "PID", pid,
201 "UID", uid, "STATE", stateStopped);
202
203 double powerMahBefore = g_statsServiceProxy->GetAppStatsMah(uid);
204 SetCapacity(BATTERY_LEVEL_FULL);
205 PublishChangedEvent(statsService, CommonEventSupport::COMMON_EVENT_BATTERY_CHANGED);
206 double powerMahAfter = g_statsServiceProxy->GetAppStatsMah(uid);
207 GTEST_LOG_(INFO) << __func__ << ": before consumption = " << powerMahBefore << " mAh";
208 GTEST_LOG_(INFO) << __func__ << ": after consumption = " << powerMahAfter << " mAh";
209 EXPECT_TRUE(powerMahBefore > StatsUtils::DEFAULT_VALUE && powerMahAfter == StatsUtils::DEFAULT_VALUE);
210 }
211
212 /**
213 * @tc.name: StatsServiceSubscriberTest_004
214 * @tc.desc: test COMMON_EVENT_BATTERY_CHANGED with BatteryPluggedType(Audio)
215 * @tc.type: FUNC
216 * @tc.require: issueI663DX
217 */
218 HWTEST_F (StatsServiceSubscriberTest, StatsServiceSubscriberTest_004, TestSize.Level0)
219 {
220 ASSERT_NE(g_statsServiceProxy, nullptr);
221 auto statsService = DelayedStatsSpSingleton<BatteryStatsService>::GetInstance();
222 g_statsServiceProxy->Reset();
223 g_statsServiceProxy->SetOnBattery(false);
224 BatteryInfoReset();
225
226 double audioOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_AUDIO_ON);
227 int32_t uid = 10003;
228 int32_t pid = 3458;
229 int32_t stateRunning = 2;
230 int32_t stateStopped = 3;
231
232 SetPluggedType(BatteryPluggedType::PLUGGED_TYPE_NONE);
233 PublishChangedEvent(statsService, CommonEventSupport::COMMON_EVENT_BATTERY_CHANGED);
234 StatsWriteHiSysEvent(statsService,
235 HiSysEvent::Domain::AUDIO, StatsHiSysEvent::STREAM_CHANGE, HiSysEvent::EventType::BEHAVIOR, "PID", pid,
236 "UID", uid, "STATE", stateRunning);
237 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
238 StatsWriteHiSysEvent(statsService,
239 HiSysEvent::Domain::AUDIO, StatsHiSysEvent::STREAM_CHANGE, HiSysEvent::EventType::BEHAVIOR, "PID", pid,
240 "UID", uid, "STATE", stateStopped);
241
242 SetPluggedType(BatteryPluggedType::PLUGGED_TYPE_AC);
243 PublishChangedEvent(statsService, CommonEventSupport::COMMON_EVENT_BATTERY_CHANGED);
244 StatsWriteHiSysEvent(statsService,
245 HiSysEvent::Domain::AUDIO, StatsHiSysEvent::STREAM_CHANGE, HiSysEvent::EventType::BEHAVIOR, "PID", pid,
246 "UID", uid, "STATE", stateRunning);
247 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
248 StatsWriteHiSysEvent(statsService,
249 HiSysEvent::Domain::AUDIO, StatsHiSysEvent::STREAM_CHANGE, HiSysEvent::EventType::BEHAVIOR, "PID", pid,
250 "UID", uid, "STATE", stateStopped);
251
252 SetPluggedType(BatteryPluggedType::PLUGGED_TYPE_BUTT);
253 PublishChangedEvent(statsService, CommonEventSupport::COMMON_EVENT_BATTERY_CHANGED);
254 StatsWriteHiSysEvent(statsService,
255 HiSysEvent::Domain::AUDIO, StatsHiSysEvent::STREAM_CHANGE, HiSysEvent::EventType::BEHAVIOR, "PID", pid,
256 "UID", uid, "STATE", stateRunning);
257 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
258 StatsWriteHiSysEvent(statsService,
259 HiSysEvent::Domain::AUDIO, StatsHiSysEvent::STREAM_CHANGE, HiSysEvent::EventType::BEHAVIOR, "PID", pid,
260 "UID", uid, "STATE", stateStopped);
261
262 double expectedPower = 2 * SERVICE_POWER_CONSUMPTION_DURATION_US * audioOnAverageMa / US_PER_HOUR;
263 double actualPower = g_statsServiceProxy->GetAppStatsMah(uid);
264 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
265 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
266 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
267 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
268 }
269
270 /**
271 * @tc.name: StatsServiceSubscriberTest_005
272 * @tc.desc: test COMMON_EVENT_BATTERY_LOW is no use(Audio)
273 * @tc.type: FUNC
274 * @tc.require: issueI663DX
275 */
276 HWTEST_F (StatsServiceSubscriberTest, StatsServiceSubscriberTest_005, TestSize.Level0)
277 {
278 ASSERT_NE(g_statsServiceProxy, nullptr);
279 auto statsService = DelayedStatsSpSingleton<BatteryStatsService>::GetInstance();
280 g_statsServiceProxy->Reset();
281 BatteryInfoReset();
282
283 double audioOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_AUDIO_ON);
284 int32_t uid = 10003;
285 int32_t pid = 3458;
286 int32_t stateRunning = 2;
287 int32_t stateStopped = 3;
288
289 StatsWriteHiSysEvent(statsService,
290 HiSysEvent::Domain::AUDIO, StatsHiSysEvent::STREAM_CHANGE, HiSysEvent::EventType::BEHAVIOR, "PID", pid,
291 "UID", uid, "STATE", stateRunning);
292 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
293 StatsWriteHiSysEvent(statsService,
294 HiSysEvent::Domain::AUDIO, StatsHiSysEvent::STREAM_CHANGE, HiSysEvent::EventType::BEHAVIOR, "PID", pid,
295 "UID", uid, "STATE", stateStopped);
296
297 SetPluggedType(BatteryPluggedType::PLUGGED_TYPE_AC);
298 PublishChangedEvent(statsService, CommonEventSupport::COMMON_EVENT_BATTERY_LOW);
299 double expectedPower = SERVICE_POWER_CONSUMPTION_DURATION_US * audioOnAverageMa / US_PER_HOUR;
300 double actualPower = g_statsServiceProxy->GetAppStatsMah(uid);
301 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
302 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
303 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
304 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
305 }
306
307 /**
308 * @tc.name: StatsServiceSubscriberTest_006
309 * @tc.desc: test COMMON_EVENT_SHUTDOWN(Phone)
310 * @tc.type: FUNC
311 * @tc.require: issueI663DX
312 */
313 HWTEST_F (StatsServiceSubscriberTest, StatsServiceSubscriberTest_006, TestSize.Level0)
314 {
315 ASSERT_NE(g_statsServiceProxy, nullptr);
316 auto statsService = DelayedStatsSpSingleton<BatteryStatsService>::GetInstance();
317 g_statsServiceProxy->Reset();
318
319 int32_t stateOn = static_cast<int32_t>(TelCallState::CALL_STATUS_ACTIVE);
320 int32_t stateOff = static_cast<int32_t>(TelCallState::CALL_STATUS_DISCONNECTED);
321 int16_t level = 0;
322 double phoneOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_RADIO_ON, level);
323
324 StatsWriteHiSysEvent(statsService,
325 HiSysEvent::Domain::TELEPHONY, StatsHiSysEvent::CALL_STATE, HiSysEvent::EventType::BEHAVIOR, "STATE", stateOn);
326 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
327 StatsWriteHiSysEvent(statsService,
328 HiSysEvent::Domain::TELEPHONY, StatsHiSysEvent::CALL_STATE, HiSysEvent::EventType::BEHAVIOR, "STATE", stateOff);
329
330 PublishChangedEvent(statsService, CommonEventSupport::COMMON_EVENT_SHUTDOWN);
331 g_statsServiceProxy->Reset();
332
333 auto statsCore = statsService->GetBatteryStatsCore();
334 statsCore->Init();
335 BatteryStatsInfoList statsInfoList {};
336 statsInfoList = statsCore->GetBatteryStats();
337
338 double expectedPower = SERVICE_POWER_CONSUMPTION_DURATION_US * phoneOnAverageMa / US_PER_HOUR;
339 double actualPower = StatsUtils::DEFAULT_VALUE;
340 for (auto it : statsInfoList) {
341 if ((*it).GetConsumptionType() == BatteryStatsInfo::CONSUMPTION_TYPE_PHONE) {
342 actualPower = (*it).GetPower();
343 }
344 }
345
346 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
347 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
348 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
349 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
350 }
351 }