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  */
HWTEST_F(StatsServiceAudioTest, StatsServiceAudioTest_001, TestSize.Level0)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->Reset();
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 
99     double powerMahBefore = g_statsServiceProxy->GetAppStatsMah(uid);
100     g_statsServiceProxy->Reset();
101     double powerMahAfter = g_statsServiceProxy->GetAppStatsMah(uid);
102     GTEST_LOG_(INFO) << __func__ << ": before consumption = " << powerMahBefore << " mAh";
103     GTEST_LOG_(INFO) << __func__ << ": after consumption = " << powerMahAfter << " mAh";
104     EXPECT_TRUE(powerMahBefore >= StatsUtils::DEFAULT_VALUE && powerMahAfter == StatsUtils::DEFAULT_VALUE);
105     STATS_HILOGI(LABEL_TEST, "StatsServiceAudioTest_001 end");
106 }
107 
108 /**
109  * @tc.name: StatsServiceAudioTest_002
110  * @tc.desc: test GetAppStatsMah function(Audio)
111  * @tc.type: FUNC
112  * @tc.require: issueI663DX
113  */
HWTEST_F(StatsServiceAudioTest, StatsServiceAudioTest_002, TestSize.Level0)114 HWTEST_F (StatsServiceAudioTest, StatsServiceAudioTest_002, TestSize.Level0)
115 {
116     STATS_HILOGI(LABEL_TEST, "StatsServiceAudioTest_002 start");
117     ASSERT_NE(g_statsServiceProxy, nullptr);
118     auto statsService = BatteryStatsService::GetInstance();
119     g_statsServiceProxy->Reset();
120 
121     double audioOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_AUDIO_ON);
122     int32_t uid = 10003;
123     int32_t pid = 3458;
124     int32_t stateRunning = 2;
125     int32_t stateStopped = 3;
126 
127     StatsWriteHiSysEvent(statsService,
128         HiSysEvent::Domain::AUDIO, StatsHiSysEvent::STREAM_CHANGE, HiSysEvent::EventType::BEHAVIOR, "PID", pid,
129         "UID", uid, "STATE", stateRunning);
130     usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
131     StatsWriteHiSysEvent(statsService,
132         HiSysEvent::Domain::AUDIO, StatsHiSysEvent::STREAM_CHANGE, HiSysEvent::EventType::BEHAVIOR, "PID", pid,
133         "UID", uid, "STATE", stateStopped);
134 
135     double expectedPower = SERVICE_POWER_CONSUMPTION_DURATION_US * audioOnAverageMa / US_PER_HOUR;
136     double actualPower = g_statsServiceProxy->GetAppStatsMah(uid);
137     double devPrecent = abs(expectedPower - actualPower) / expectedPower;
138     GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
139     GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
140     EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
141     STATS_HILOGI(LABEL_TEST, "StatsServiceAudioTest_002 end");
142 }
143 
144 /**
145  * @tc.name: StatsServiceAudioTest_003
146  * @tc.desc: test GetAppStatsPercent function(Audio)
147  * @tc.type: FUNC
148  * @tc.require: issueI663DX
149  */
HWTEST_F(StatsServiceAudioTest, StatsServiceAudioTest_003, TestSize.Level0)150 HWTEST_F (StatsServiceAudioTest, StatsServiceAudioTest_003, TestSize.Level0)
151 {
152     STATS_HILOGI(LABEL_TEST, "StatsServiceAudioTest_003 start");
153     ASSERT_NE(g_statsServiceProxy, nullptr);
154     auto statsService = BatteryStatsService::GetInstance();
155     g_statsServiceProxy->Reset();
156 
157     int32_t uid = 10003;
158     int32_t pid = 3458;
159     int32_t stateRunning = 2;
160     int32_t stateStopped = 3;
161     double fullPercent = 1;
162     double zeroPercent = 0;
163 
164     StatsWriteHiSysEvent(statsService,
165         HiSysEvent::Domain::AUDIO, StatsHiSysEvent::STREAM_CHANGE, HiSysEvent::EventType::BEHAVIOR, "PID", pid,
166         "UID", uid, "STATE", stateRunning);
167     usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
168     StatsWriteHiSysEvent(statsService,
169         HiSysEvent::Domain::AUDIO, StatsHiSysEvent::STREAM_CHANGE, HiSysEvent::EventType::BEHAVIOR, "PID", pid,
170         "UID", uid, "STATE", stateStopped);
171 
172     double actualPercent = g_statsServiceProxy->GetAppStatsPercent(uid);
173     GTEST_LOG_(INFO) << __func__ << ": actual percent = " << actualPercent;
174     EXPECT_TRUE(actualPercent >= zeroPercent && actualPercent <= fullPercent);
175     STATS_HILOGI(LABEL_TEST, "StatsServiceAudioTest_003 end");
176 }
177 
178 /**
179  * @tc.name: StatsServiceAudioTest_004
180  * @tc.desc: test GetAppStatsMah function, Audio state composite test
181  * @tc.type: FUNC
182  * @tc.require: issueI663DX
183  */
HWTEST_F(StatsServiceAudioTest, StatsServiceAudioTest_004, TestSize.Level0)184 HWTEST_F (StatsServiceAudioTest, StatsServiceAudioTest_004, TestSize.Level0)
185 {
186     STATS_HILOGI(LABEL_TEST, "StatsServiceAudioTest_004 start");
187     ASSERT_NE(g_statsServiceProxy, nullptr);
188     auto statsService = BatteryStatsService::GetInstance();
189     g_statsServiceProxy->Reset();
190 
191     double audioOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_AUDIO_ON);
192     int32_t uid = 10003;
193     int32_t pid = 3458;
194     int32_t stateRunning = 2;
195     int32_t stateStopped = 3;
196     int32_t stateReleased = 4;
197     int32_t statePaused = 5;
198 
199     StatsWriteHiSysEvent(statsService,
200         HiSysEvent::Domain::AUDIO, StatsHiSysEvent::STREAM_CHANGE, HiSysEvent::EventType::BEHAVIOR, "PID", pid,
201         "UID", uid, "STATE", stateRunning);
202     usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
203     StatsWriteHiSysEvent(statsService,
204         HiSysEvent::Domain::AUDIO, StatsHiSysEvent::STREAM_CHANGE, HiSysEvent::EventType::BEHAVIOR, "PID", pid,
205         "UID", uid, "STATE", stateStopped);
206 
207     StatsWriteHiSysEvent(statsService,
208         HiSysEvent::Domain::AUDIO, StatsHiSysEvent::STREAM_CHANGE, HiSysEvent::EventType::BEHAVIOR, "PID", pid,
209         "UID", uid, "STATE", stateRunning);
210     usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
211     StatsWriteHiSysEvent(statsService,
212         HiSysEvent::Domain::AUDIO, StatsHiSysEvent::STREAM_CHANGE, HiSysEvent::EventType::BEHAVIOR, "PID", pid,
213         "UID", uid, "STATE", stateReleased);
214 
215     StatsWriteHiSysEvent(statsService,
216         HiSysEvent::Domain::AUDIO, StatsHiSysEvent::STREAM_CHANGE, HiSysEvent::EventType::BEHAVIOR, "PID", pid,
217         "UID", uid, "STATE", stateRunning);
218     usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
219     StatsWriteHiSysEvent(statsService,
220         HiSysEvent::Domain::AUDIO, StatsHiSysEvent::STREAM_CHANGE, HiSysEvent::EventType::BEHAVIOR, "PID", pid,
221         "UID", uid, "STATE", statePaused);
222 
223     double expectedPower = 3 * SERVICE_POWER_CONSUMPTION_DURATION_US * audioOnAverageMa / US_PER_HOUR;
224     double actualPower = g_statsServiceProxy->GetAppStatsMah(uid);
225     double devPrecent = abs(expectedPower - actualPower) / expectedPower;
226     GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
227     GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
228     EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
229     STATS_HILOGI(LABEL_TEST, "StatsServiceAudioTest_004 end");
230 }
231 
232 /**
233  * @tc.name: StatsServiceAudioTest_005
234  * @tc.desc: test GetAppStatsMah function, Audio abnormal state test
235  * @tc.type: FUNC
236  * @tc.require: issueI663DX
237  */
HWTEST_F(StatsServiceAudioTest, StatsServiceAudioTest_005, TestSize.Level0)238 HWTEST_F (StatsServiceAudioTest, StatsServiceAudioTest_005, TestSize.Level0)
239 {
240     STATS_HILOGI(LABEL_TEST, "StatsServiceAudioTest_005 start");
241     ASSERT_NE(g_statsServiceProxy, nullptr);
242     auto statsService = BatteryStatsService::GetInstance();
243     g_statsServiceProxy->Reset();
244 
245     double audioOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_AUDIO_ON);
246     int32_t uid = 10003;
247     int32_t pid = 3458;
248     int32_t stateRunning = 2;
249     int32_t stateStopped = 3;
250     int32_t stateInvalid = -1;
251     int32_t stateAbnormal = 101;
252 
253     StatsWriteHiSysEvent(statsService,
254         HiSysEvent::Domain::AUDIO, StatsHiSysEvent::STREAM_CHANGE, HiSysEvent::EventType::BEHAVIOR, "PID", pid,
255         "UID", uid, "STATE", stateInvalid);
256     usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
257     StatsWriteHiSysEvent(statsService,
258         HiSysEvent::Domain::AUDIO, StatsHiSysEvent::STREAM_CHANGE, HiSysEvent::EventType::BEHAVIOR, "PID", pid,
259         "UID", uid, "STATE", stateRunning);
260     usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
261     StatsWriteHiSysEvent(statsService,
262         HiSysEvent::Domain::AUDIO, StatsHiSysEvent::STREAM_CHANGE, HiSysEvent::EventType::BEHAVIOR, "PID", pid,
263         "UID", uid, "STATE", stateAbnormal);
264     usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
265     StatsWriteHiSysEvent(statsService,
266         HiSysEvent::Domain::AUDIO, StatsHiSysEvent::STREAM_CHANGE, HiSysEvent::EventType::BEHAVIOR, "PID", pid,
267         "UID", uid, "STATE", stateStopped);
268 
269     double expectedPower = 2 * SERVICE_POWER_CONSUMPTION_DURATION_US * audioOnAverageMa / US_PER_HOUR;
270     double actualPower = g_statsServiceProxy->GetAppStatsMah(uid);
271     double devPrecent = abs(expectedPower - actualPower) / expectedPower;
272     GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
273     GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
274     EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
275     STATS_HILOGI(LABEL_TEST, "StatsServiceAudioTest_005 end");
276 }
277 
278 /**
279  * @tc.name: StatsServiceAudioTest_006
280  * @tc.desc: test GetAppStatsMah(Audio) and GetAppStatsPercent(Sensor) function
281  * @tc.type: FUNC
282  * @tc.require: issueI663DX
283  */
HWTEST_F(StatsServiceAudioTest, StatsServiceAudioTest_006, TestSize.Level0)284 HWTEST_F (StatsServiceAudioTest, StatsServiceAudioTest_006, TestSize.Level0)
285 {
286     STATS_HILOGI(LABEL_TEST, "StatsServiceAudioTest_006 start");
287     ASSERT_NE(g_statsServiceProxy, nullptr);
288     auto statsService = BatteryStatsService::GetInstance();
289     g_statsServiceProxy->Reset();
290 
291     double audioOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_AUDIO_ON);
292     int32_t uid = 10003;
293     int32_t pid = 3458;
294     int32_t stateRunning = 2;
295     int32_t stateStopped = 3;
296 
297     StatsWriteHiSysEvent(statsService,
298         HiSysEvent::Domain::AUDIO, StatsHiSysEvent::STREAM_CHANGE, HiSysEvent::EventType::BEHAVIOR, "PID", pid,
299         "UID", uid, "STATE", stateRunning);
300     usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
301     StatsWriteHiSysEvent(statsService,
302         HiSysEvent::Domain::AUDIO, StatsHiSysEvent::STREAM_CHANGE, HiSysEvent::EventType::BEHAVIOR, "PID", pid,
303         "UID", uid, "STATE", stateStopped);
304 
305     double expectedPower = SERVICE_POWER_CONSUMPTION_DURATION_US * audioOnAverageMa / US_PER_HOUR;
306     double actualPower = g_statsServiceProxy->GetAppStatsMah(uid);
307     double devPrecent = abs(expectedPower - actualPower) / expectedPower;
308     GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
309     GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
310     EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
311 
312     uid = 10004;
313     pid = 3459;
314     int32_t stateOn = 1;
315     int32_t stateOff = 0;
316     double fullPercent = 1;
317     double zeroPercent = 0;
318 
319     StatsWriteHiSysEvent(statsService,
320         HiSysEvent::Domain::STATS, StatsHiSysEvent::POWER_SENSOR_GRAVITY, HiSysEvent::EventType::STATISTIC, "PID",
321         pid, "UID", uid, "STATE", stateOn);
322     usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
323     StatsWriteHiSysEvent(statsService,
324         HiSysEvent::Domain::STATS, StatsHiSysEvent::POWER_SENSOR_GRAVITY, HiSysEvent::EventType::STATISTIC, "PID",
325         pid, "UID", uid, "STATE", stateOff);
326 
327     double actualPercent = g_statsServiceProxy->GetAppStatsPercent(uid);
328     GTEST_LOG_(INFO) << __func__ << ": actual percent = " << actualPercent;
329     EXPECT_TRUE(actualPercent >= zeroPercent && actualPercent <= fullPercent);
330     STATS_HILOGI(LABEL_TEST, "StatsServiceAudioTest_006 end");
331 }
332 
333 /**
334  * @tc.name: StatsServiceAudioTest_007
335  * @tc.desc: test audio entity GetPartStatsMah function(Audio)
336  * @tc.type: FUNC
337  * @tc.require: issueI663DX
338  */
HWTEST_F(StatsServiceAudioTest, StatsServiceAudioTest_007, TestSize.Level0)339 HWTEST_F (StatsServiceAudioTest, StatsServiceAudioTest_007, TestSize.Level0)
340 {
341     STATS_HILOGI(LABEL_TEST, "StatsServiceAudioTest_007 start");
342     ASSERT_NE(g_statsServiceProxy, nullptr);
343     auto statsService = BatteryStatsService::GetInstance();
344     g_statsServiceProxy->Reset();
345 
346     double audioOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_AUDIO_ON);
347     int32_t uid = 10003;
348     int32_t pid = 3458;
349     int32_t stateRunning = 2;
350     int32_t stateStopped = 3;
351 
352     StatsWriteHiSysEvent(statsService,
353         HiSysEvent::Domain::AUDIO, StatsHiSysEvent::STREAM_CHANGE, HiSysEvent::EventType::BEHAVIOR, "PID", pid,
354         "UID", uid, "STATE", stateRunning);
355     usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
356     StatsWriteHiSysEvent(statsService,
357         HiSysEvent::Domain::AUDIO, StatsHiSysEvent::STREAM_CHANGE, HiSysEvent::EventType::BEHAVIOR, "PID", pid,
358         "UID", uid, "STATE", stateStopped);
359 
360     auto statsCore = statsService->GetBatteryStatsCore();
361     auto audioEntity = statsCore->GetEntity(BatteryStatsInfo::CONSUMPTION_TYPE_AUDIO);
362     statsCore->ComputePower();
363 
364     double expectedPower = SERVICE_POWER_CONSUMPTION_DURATION_US * audioOnAverageMa / US_PER_HOUR;
365     double actualPower = audioEntity->GetStatsPowerMah(StatsUtils::STATS_TYPE_AUDIO_ON, uid);
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 
371     EXPECT_EQ(StatsUtils::DEFAULT_VALUE, audioEntity->GetStatsPowerMah(StatsUtils::STATS_TYPE_AUDIO_ON));
372     EXPECT_EQ(StatsUtils::DEFAULT_VALUE, audioEntity->GetStatsPowerMah(StatsUtils::STATS_TYPE_INVALID, uid));
373     STATS_HILOGI(LABEL_TEST, "StatsServiceAudioTest_007 end");
374 }
375 
376 /**
377  * @tc.name: StatsServiceAudioTest_008
378  * @tc.desc: test send hisysevent with missing information(Audio)
379  * @tc.type: FUNC
380  * @tc.require: issueI663DX
381  */
HWTEST_F(StatsServiceAudioTest, StatsServiceAudioTest_008, TestSize.Level0)382 HWTEST_F (StatsServiceAudioTest, StatsServiceAudioTest_008, TestSize.Level0)
383 {
384     STATS_HILOGI(LABEL_TEST, "StatsServiceAudioTest_008 start");
385     ASSERT_NE(g_statsServiceProxy, nullptr);
386     auto statsService = BatteryStatsService::GetInstance();
387     g_statsServiceProxy->Reset();
388 
389     int32_t uid = 10003;
390     StatsWriteHiSysEvent(statsService,
391         HiSysEvent::Domain::AUDIO, StatsHiSysEvent::STREAM_CHANGE, HiSysEvent::EventType::BEHAVIOR);
392     usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
393     StatsWriteHiSysEvent(statsService,
394         HiSysEvent::Domain::AUDIO, StatsHiSysEvent::STREAM_CHANGE, HiSysEvent::EventType::BEHAVIOR);
395 
396     double expectedPower = StatsUtils::DEFAULT_VALUE;
397     double actualPower = g_statsServiceProxy->GetAppStatsMah(uid);
398     GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
399     GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
400     EXPECT_EQ(expectedPower, actualPower);
401     STATS_HILOGI(LABEL_TEST, "StatsServiceAudioTest_008 end");
402 }
403 }