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_audio_test.h"
17 #include "stats_log.h"
18
19 #include <hisysevent.h>
20
21 #include "battery_stats_listener.h"
22 #include "battery_stats_service.h"
23 #include "hisysevent_operation.h"
24 #include "stats_hisysevent.h"
25 #include "stats_service_test_proxy.h"
26 #include "stats_service_write_event.h"
27
28 using namespace OHOS;
29 using namespace testing::ext;
30 using namespace OHOS::HiviewDFX;
31 using namespace OHOS::PowerMgr;
32 using namespace std;
33
34 namespace {
35 static sptr<BatteryStatsService> g_statsService = nullptr;
36 static std::shared_ptr<StatsServiceTestProxy> g_statsServiceProxy = nullptr;
37 } // namespace
38
SetUpTestCase()39 void StatsServiceAudioTest::SetUpTestCase()
40 {
41 ParserAveragePowerFile();
42 g_statsService = BatteryStatsService::GetInstance();
43 g_statsService->OnStart();
44
45 if (g_statsService->listenerPtr_ == nullptr) {
46 g_statsService->listenerPtr_ = std::make_shared<BatteryStatsListener>();
47 }
48
49 if (g_statsServiceProxy == nullptr) {
50 g_statsServiceProxy = std::make_shared<StatsServiceTestProxy>(g_statsService);
51 }
52 }
53
TearDownTestCase()54 void StatsServiceAudioTest::TearDownTestCase()
55 {
56 g_statsService->listenerPtr_ = nullptr;
57 g_statsService->OnStop();
58 }
59
SetUp()60 void StatsServiceAudioTest::SetUp()
61 {
62 auto statsService = BatteryStatsService::GetInstance();
63 statsService->SetOnBattery(true);
64 }
65
TearDown()66 void StatsServiceAudioTest::TearDown()
67 {
68 auto statsService = BatteryStatsService::GetInstance();
69 statsService->SetOnBattery(false);
70 }
71
72 namespace {
73 /**
74 * @tc.name: StatsServiceAudioTest_001
75 * @tc.desc: test Reset function(Audio)
76 * @tc.type: FUNC
77 * @tc.require: issueI663DX
78 */
79 HWTEST_F (StatsServiceAudioTest, StatsServiceAudioTest_001, TestSize.Level0)
80 {
81 STATS_HILOGI(LABEL_TEST, "StatsServiceAudioTest_001 start");
82 ASSERT_NE(g_statsServiceProxy, nullptr);
83 auto statsService = BatteryStatsService::GetInstance();
84 g_statsServiceProxy->ResetIpc();
85
86 int32_t uid = 10003;
87 int32_t pid = 3458;
88 int32_t stateRunning = 2;
89 int32_t stateStopped = 3;
90
91 StatsWriteHiSysEvent(statsService,
92 HiSysEvent::Domain::AUDIO, StatsHiSysEvent::STREAM_CHANGE, HiSysEvent::EventType::BEHAVIOR, "PID", pid,
93 "UID", uid, "STATE", stateRunning);
94 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
95 StatsWriteHiSysEvent(statsService,
96 HiSysEvent::Domain::AUDIO, StatsHiSysEvent::STREAM_CHANGE, HiSysEvent::EventType::BEHAVIOR, "PID", pid,
97 "UID", uid, "STATE", stateStopped);
98 int32_t tempError;
99 double powerMahBefore;
100 g_statsServiceProxy->GetAppStatsMahIpc(uid, powerMahBefore, tempError);
101 g_statsServiceProxy->ResetIpc();
102 double powerMahAfter;
103 g_statsServiceProxy->GetAppStatsMahIpc(uid, 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, "StatsServiceAudioTest_001 end");
108 }
109
110 /**
111 * @tc.name: StatsServiceAudioTest_002
112 * @tc.desc: test GetAppStatsMah function(Audio)
113 * @tc.type: FUNC
114 * @tc.require: issueI663DX
115 */
116 HWTEST_F (StatsServiceAudioTest, StatsServiceAudioTest_002, TestSize.Level0)
117 {
118 STATS_HILOGI(LABEL_TEST, "StatsServiceAudioTest_002 start");
119 ASSERT_NE(g_statsServiceProxy, nullptr);
120 auto statsService = BatteryStatsService::GetInstance();
121 g_statsServiceProxy->ResetIpc();
122
123 double audioOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_AUDIO_ON);
124 int32_t uid = 10003;
125 int32_t pid = 3458;
126 int32_t stateRunning = 2;
127 int32_t stateStopped = 3;
128
129 StatsWriteHiSysEvent(statsService,
130 HiSysEvent::Domain::AUDIO, StatsHiSysEvent::STREAM_CHANGE, HiSysEvent::EventType::BEHAVIOR, "PID", pid,
131 "UID", uid, "STATE", stateRunning);
132 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
133 StatsWriteHiSysEvent(statsService,
134 HiSysEvent::Domain::AUDIO, StatsHiSysEvent::STREAM_CHANGE, HiSysEvent::EventType::BEHAVIOR, "PID", pid,
135 "UID", uid, "STATE", stateStopped);
136 int32_t tempError;
137 double expectedPower = SERVICE_POWER_CONSUMPTION_DURATION_US * audioOnAverageMa / US_PER_HOUR;
138 double actualPower;
139 g_statsServiceProxy->GetAppStatsMahIpc(uid, 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 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
144 STATS_HILOGI(LABEL_TEST, "StatsServiceAudioTest_002 end");
145 }
146
147 /**
148 * @tc.name: StatsServiceAudioTest_003
149 * @tc.desc: test GetAppStatsPercent function(Audio)
150 * @tc.type: FUNC
151 * @tc.require: issueI663DX
152 */
153 HWTEST_F (StatsServiceAudioTest, StatsServiceAudioTest_003, TestSize.Level0)
154 {
155 STATS_HILOGI(LABEL_TEST, "StatsServiceAudioTest_003 start");
156 ASSERT_NE(g_statsServiceProxy, nullptr);
157 auto statsService = BatteryStatsService::GetInstance();
158 g_statsServiceProxy->ResetIpc();
159
160 int32_t uid = 10003;
161 int32_t pid = 3458;
162 int32_t stateRunning = 2;
163 int32_t stateStopped = 3;
164 double fullPercent = 1;
165 double zeroPercent = 0;
166
167 StatsWriteHiSysEvent(statsService,
168 HiSysEvent::Domain::AUDIO, StatsHiSysEvent::STREAM_CHANGE, HiSysEvent::EventType::BEHAVIOR, "PID", pid,
169 "UID", uid, "STATE", stateRunning);
170 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
171 StatsWriteHiSysEvent(statsService,
172 HiSysEvent::Domain::AUDIO, StatsHiSysEvent::STREAM_CHANGE, HiSysEvent::EventType::BEHAVIOR, "PID", pid,
173 "UID", uid, "STATE", stateStopped);
174 int32_t tempError;
175 double actualPercent;
176 g_statsServiceProxy->GetAppStatsPercentIpc(uid, actualPercent, tempError);
177 GTEST_LOG_(INFO) << __func__ << ": actual percent = " << actualPercent;
178 EXPECT_TRUE(actualPercent >= zeroPercent && actualPercent <= fullPercent);
179 STATS_HILOGI(LABEL_TEST, "StatsServiceAudioTest_003 end");
180 }
181
182 /**
183 * @tc.name: StatsServiceAudioTest_004
184 * @tc.desc: test GetAppStatsMah function, Audio state composite test
185 * @tc.type: FUNC
186 * @tc.require: issueI663DX
187 */
188 HWTEST_F (StatsServiceAudioTest, StatsServiceAudioTest_004, TestSize.Level0)
189 {
190 STATS_HILOGI(LABEL_TEST, "StatsServiceAudioTest_004 start");
191 ASSERT_NE(g_statsServiceProxy, nullptr);
192 auto statsService = BatteryStatsService::GetInstance();
193 g_statsServiceProxy->ResetIpc();
194
195 double audioOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_AUDIO_ON);
196 int32_t uid = 10003;
197 int32_t pid = 3458;
198 int32_t stateRunning = 2;
199 int32_t stateStopped = 3;
200 int32_t stateReleased = 4;
201 int32_t statePaused = 5;
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
211 StatsWriteHiSysEvent(statsService,
212 HiSysEvent::Domain::AUDIO, StatsHiSysEvent::STREAM_CHANGE, HiSysEvent::EventType::BEHAVIOR, "PID", pid,
213 "UID", uid, "STATE", stateRunning);
214 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
215 StatsWriteHiSysEvent(statsService,
216 HiSysEvent::Domain::AUDIO, StatsHiSysEvent::STREAM_CHANGE, HiSysEvent::EventType::BEHAVIOR, "PID", pid,
217 "UID", uid, "STATE", stateReleased);
218
219 StatsWriteHiSysEvent(statsService,
220 HiSysEvent::Domain::AUDIO, StatsHiSysEvent::STREAM_CHANGE, HiSysEvent::EventType::BEHAVIOR, "PID", pid,
221 "UID", uid, "STATE", stateRunning);
222 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
223 StatsWriteHiSysEvent(statsService,
224 HiSysEvent::Domain::AUDIO, StatsHiSysEvent::STREAM_CHANGE, HiSysEvent::EventType::BEHAVIOR, "PID", pid,
225 "UID", uid, "STATE", statePaused);
226 int32_t tempError;
227 double expectedPower = 3 * SERVICE_POWER_CONSUMPTION_DURATION_US * audioOnAverageMa / US_PER_HOUR;
228 double actualPower;
229 g_statsServiceProxy->GetAppStatsMahIpc(uid, actualPower, tempError);
230 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
231 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
232 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
233 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
234 STATS_HILOGI(LABEL_TEST, "StatsServiceAudioTest_004 end");
235 }
236
237 /**
238 * @tc.name: StatsServiceAudioTest_005
239 * @tc.desc: test GetAppStatsMah function, Audio abnormal state test
240 * @tc.type: FUNC
241 * @tc.require: issueI663DX
242 */
243 HWTEST_F (StatsServiceAudioTest, StatsServiceAudioTest_005, TestSize.Level0)
244 {
245 STATS_HILOGI(LABEL_TEST, "StatsServiceAudioTest_005 start");
246 ASSERT_NE(g_statsServiceProxy, nullptr);
247 auto statsService = BatteryStatsService::GetInstance();
248 g_statsServiceProxy->ResetIpc();
249
250 double audioOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_AUDIO_ON);
251 int32_t uid = 10003;
252 int32_t pid = 3458;
253 int32_t stateRunning = 2;
254 int32_t stateStopped = 3;
255 int32_t stateInvalid = -1;
256 int32_t stateAbnormal = 101;
257
258 StatsWriteHiSysEvent(statsService,
259 HiSysEvent::Domain::AUDIO, StatsHiSysEvent::STREAM_CHANGE, HiSysEvent::EventType::BEHAVIOR, "PID", pid,
260 "UID", uid, "STATE", stateInvalid);
261 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
262 StatsWriteHiSysEvent(statsService,
263 HiSysEvent::Domain::AUDIO, StatsHiSysEvent::STREAM_CHANGE, HiSysEvent::EventType::BEHAVIOR, "PID", pid,
264 "UID", uid, "STATE", stateRunning);
265 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
266 StatsWriteHiSysEvent(statsService,
267 HiSysEvent::Domain::AUDIO, StatsHiSysEvent::STREAM_CHANGE, HiSysEvent::EventType::BEHAVIOR, "PID", pid,
268 "UID", uid, "STATE", stateAbnormal);
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 int32_t tempError;
274 double expectedPower = 2 * SERVICE_POWER_CONSUMPTION_DURATION_US * audioOnAverageMa / US_PER_HOUR;
275 double actualPower;
276 g_statsServiceProxy->GetAppStatsMahIpc(uid, actualPower, tempError);
277 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
278 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
279 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
280 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
281 STATS_HILOGI(LABEL_TEST, "StatsServiceAudioTest_005 end");
282 }
283
284 /**
285 * @tc.name: StatsServiceAudioTest_006
286 * @tc.desc: test GetAppStatsMah(Audio) and GetAppStatsPercent(Sensor) function
287 * @tc.type: FUNC
288 * @tc.require: issueI663DX
289 */
290 HWTEST_F (StatsServiceAudioTest, StatsServiceAudioTest_006, TestSize.Level0)
291 {
292 STATS_HILOGI(LABEL_TEST, "StatsServiceAudioTest_006 start");
293 ASSERT_NE(g_statsServiceProxy, nullptr);
294 auto statsService = BatteryStatsService::GetInstance();
295 g_statsServiceProxy->ResetIpc();
296
297 double audioOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_AUDIO_ON);
298 int32_t uid = 10003;
299 int32_t pid = 3458;
300 int32_t stateRunning = 2;
301 int32_t stateStopped = 3;
302
303 StatsWriteHiSysEvent(statsService,
304 HiSysEvent::Domain::AUDIO, StatsHiSysEvent::STREAM_CHANGE, HiSysEvent::EventType::BEHAVIOR, "PID", pid,
305 "UID", uid, "STATE", stateRunning);
306 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
307 StatsWriteHiSysEvent(statsService,
308 HiSysEvent::Domain::AUDIO, StatsHiSysEvent::STREAM_CHANGE, HiSysEvent::EventType::BEHAVIOR, "PID", pid,
309 "UID", uid, "STATE", stateStopped);
310 int32_t tempError;
311 double expectedPower = SERVICE_POWER_CONSUMPTION_DURATION_US * audioOnAverageMa / US_PER_HOUR;
312 double actualPower;
313 g_statsServiceProxy->GetAppStatsMahIpc(uid, actualPower, tempError);
314 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
315 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
316 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
317 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
318
319 uid = 10004;
320 pid = 3459;
321 int32_t stateOn = 1;
322 int32_t stateOff = 0;
323 double fullPercent = 1;
324 double zeroPercent = 0;
325
326 StatsWriteHiSysEvent(statsService,
327 HiSysEvent::Domain::STATS, StatsHiSysEvent::POWER_SENSOR_GRAVITY, HiSysEvent::EventType::STATISTIC, "PID",
328 pid, "UID", uid, "STATE", stateOn);
329 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
330 StatsWriteHiSysEvent(statsService,
331 HiSysEvent::Domain::STATS, StatsHiSysEvent::POWER_SENSOR_GRAVITY, HiSysEvent::EventType::STATISTIC, "PID",
332 pid, "UID", uid, "STATE", stateOff);
333
334 double actualPercent;
335 g_statsServiceProxy->GetAppStatsPercentIpc(uid, actualPercent, tempError);
336 GTEST_LOG_(INFO) << __func__ << ": actual percent = " << actualPercent;
337 EXPECT_TRUE(actualPercent >= zeroPercent && actualPercent <= fullPercent);
338 STATS_HILOGI(LABEL_TEST, "StatsServiceAudioTest_006 end");
339 }
340
341 /**
342 * @tc.name: StatsServiceAudioTest_007
343 * @tc.desc: test audio entity GetPartStatsMah function(Audio)
344 * @tc.type: FUNC
345 * @tc.require: issueI663DX
346 */
347 HWTEST_F (StatsServiceAudioTest, StatsServiceAudioTest_007, TestSize.Level0)
348 {
349 STATS_HILOGI(LABEL_TEST, "StatsServiceAudioTest_007 start");
350 ASSERT_NE(g_statsServiceProxy, nullptr);
351 auto statsService = BatteryStatsService::GetInstance();
352 g_statsServiceProxy->ResetIpc();
353
354 double audioOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_AUDIO_ON);
355 int32_t uid = 10003;
356 int32_t pid = 3458;
357 int32_t stateRunning = 2;
358 int32_t stateStopped = 3;
359
360 StatsWriteHiSysEvent(statsService,
361 HiSysEvent::Domain::AUDIO, StatsHiSysEvent::STREAM_CHANGE, HiSysEvent::EventType::BEHAVIOR, "PID", pid,
362 "UID", uid, "STATE", stateRunning);
363 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
364 StatsWriteHiSysEvent(statsService,
365 HiSysEvent::Domain::AUDIO, StatsHiSysEvent::STREAM_CHANGE, HiSysEvent::EventType::BEHAVIOR, "PID", pid,
366 "UID", uid, "STATE", stateStopped);
367
368 auto statsCore = statsService->GetBatteryStatsCore();
369 auto audioEntity = statsCore->GetEntity(BatteryStatsInfo::CONSUMPTION_TYPE_AUDIO);
370 statsCore->ComputePower();
371
372 double expectedPower = SERVICE_POWER_CONSUMPTION_DURATION_US * audioOnAverageMa / US_PER_HOUR;
373 double actualPower = audioEntity->GetStatsPowerMah(StatsUtils::STATS_TYPE_AUDIO_ON, uid);
374 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
375 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
376 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
377 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
378
379 EXPECT_EQ(StatsUtils::DEFAULT_VALUE, audioEntity->GetStatsPowerMah(StatsUtils::STATS_TYPE_AUDIO_ON));
380 EXPECT_EQ(StatsUtils::DEFAULT_VALUE, audioEntity->GetStatsPowerMah(StatsUtils::STATS_TYPE_INVALID, uid));
381 STATS_HILOGI(LABEL_TEST, "StatsServiceAudioTest_007 end");
382 }
383
384 /**
385 * @tc.name: StatsServiceAudioTest_008
386 * @tc.desc: test send hisysevent with missing information(Audio)
387 * @tc.type: FUNC
388 * @tc.require: issueI663DX
389 */
390 HWTEST_F (StatsServiceAudioTest, StatsServiceAudioTest_008, TestSize.Level0)
391 {
392 STATS_HILOGI(LABEL_TEST, "StatsServiceAudioTest_008 start");
393 ASSERT_NE(g_statsServiceProxy, nullptr);
394 auto statsService = BatteryStatsService::GetInstance();
395 g_statsServiceProxy->ResetIpc();
396
397 int32_t uid = 10003;
398 StatsWriteHiSysEvent(statsService,
399 HiSysEvent::Domain::AUDIO, StatsHiSysEvent::STREAM_CHANGE, HiSysEvent::EventType::BEHAVIOR);
400 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
401 StatsWriteHiSysEvent(statsService,
402 HiSysEvent::Domain::AUDIO, StatsHiSysEvent::STREAM_CHANGE, HiSysEvent::EventType::BEHAVIOR);
403
404 double expectedPower = StatsUtils::DEFAULT_VALUE;
405 int32_t tempError;
406 double actualPower;
407 g_statsServiceProxy->GetAppStatsMahIpc(uid, actualPower, tempError);
408 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
409 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
410 EXPECT_EQ(expectedPower, actualPower);
411 STATS_HILOGI(LABEL_TEST, "StatsServiceAudioTest_008 end");
412 }
413 }