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_audio_test.h"
17 
18 #include <hisysevent.h>
19 
20 #include "battery_stats_client.h"
21 #include "stats_hisysevent.h"
22 
23 using namespace testing::ext;
24 using namespace OHOS::HiviewDFX;
25 using namespace OHOS::PowerMgr;
26 using namespace std;
27 
SetUpTestCase()28 void StatsAudioTest::SetUpTestCase()
29 {
30     ParserAveragePowerFile();
31     system("hidumper -s 3302 -a -u");
32 }
33 
TearDownTestCase()34 void StatsAudioTest::TearDownTestCase()
35 {
36     system("hidumper -s 3302 -a -r");
37 }
38 
SetUp()39 void StatsAudioTest::SetUp()
40 {
41     auto& statsClient = BatteryStatsClient::GetInstance();
42     statsClient.SetOnBattery(true);
43 }
44 
TearDown()45 void StatsAudioTest::TearDown()
46 {
47     auto& statsClient = BatteryStatsClient::GetInstance();
48     statsClient.SetOnBattery(false);
49 }
50 
51 namespace {
52 /**
53  * @tc.name: StatsAudioTest_001
54  * @tc.desc: test Reset function(Audio)
55  * @tc.type: FUNC
56  */
57 HWTEST_F (StatsAudioTest, StatsAudioTest_001, TestSize.Level0)
58 {
59     auto& statsClient = BatteryStatsClient::GetInstance();
60     statsClient.Reset();
61 
62     int32_t uid = 10003;
63     int32_t pid = 3458;
64     int32_t stateRunning = 2;
65     int32_t stateStopped = 3;
66 
67     HiSysEventWrite(HiSysEvent::Domain::AUDIO, StatsHiSysEvent::STREAM_CHANGE,
68         HiSysEvent::EventType::BEHAVIOR, "PID", pid, "UID", uid, "STATE", stateRunning);
69     usleep(POWER_CONSUMPTION_DURATION_US);
70     HiSysEventWrite(HiSysEvent::Domain::AUDIO, StatsHiSysEvent::STREAM_CHANGE,
71         HiSysEvent::EventType::BEHAVIOR, "PID", pid, "UID", uid, "STATE", stateStopped);
72 
73     double powerMahBefore = statsClient.GetAppStatsMah(uid);
74     statsClient.Reset();
75     double powerMahAfter = statsClient.GetAppStatsMah(uid);
76     GTEST_LOG_(INFO) << __func__ << ": before consumption = " << powerMahBefore << " mAh";
77     GTEST_LOG_(INFO) << __func__ << ": after consumption = " << powerMahAfter << " mAh";
78     EXPECT_TRUE(powerMahBefore >= StatsUtils::DEFAULT_VALUE && powerMahAfter == StatsUtils::DEFAULT_VALUE);
79 }
80 
81 /**
82  * @tc.name: StatsAudioTest_002
83  * @tc.desc: test GetAppStatsMah function(Audio)
84  * @tc.type: FUNC
85  */
86 HWTEST_F (StatsAudioTest, StatsAudioTest_002, TestSize.Level0)
87 {
88     auto& statsClient = BatteryStatsClient::GetInstance();
89     statsClient.Reset();
90 
91     double audioOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_AUDIO_ON);
92     int32_t uid = 10003;
93     int32_t pid = 3458;
94     int32_t stateRunning = 2;
95     int32_t stateStopped = 3;
96 
97     HiSysEventWrite(HiSysEvent::Domain::AUDIO, StatsHiSysEvent::STREAM_CHANGE,
98         HiSysEvent::EventType::BEHAVIOR, "PID", pid, "UID", uid, "STATE", stateRunning);
99     usleep(POWER_CONSUMPTION_DURATION_US);
100     HiSysEventWrite(HiSysEvent::Domain::AUDIO, StatsHiSysEvent::STREAM_CHANGE,
101         HiSysEvent::EventType::BEHAVIOR, "PID", pid, "UID", uid, "STATE", stateStopped);
102 
103     double expectedPower = POWER_CONSUMPTION_DURATION_US * audioOnAverageMa / US_PER_HOUR;
104     double actualPower = statsClient.GetAppStatsMah(uid);
105     double devPrecent = abs(expectedPower - actualPower) / expectedPower;
106     GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
107     GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
108     EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
109 }
110 
111 /**
112  * @tc.name: StatsAudioTest_003
113  * @tc.desc: test GetAppStatsPercent function(Audio)
114  * @tc.type: FUNC
115  */
116 HWTEST_F (StatsAudioTest, StatsAudioTest_003, TestSize.Level0)
117 {
118     auto& statsClient = BatteryStatsClient::GetInstance();
119     statsClient.Reset();
120 
121     int32_t uid = 10003;
122     int32_t pid = 3458;
123     int32_t stateRunning = 2;
124     int32_t stateStopped = 3;
125     double fullPercent = 1;
126     double zeroPercent = 0;
127 
128     HiSysEventWrite(HiSysEvent::Domain::AUDIO, StatsHiSysEvent::STREAM_CHANGE,
129         HiSysEvent::EventType::BEHAVIOR, "PID", pid, "UID", uid, "STATE", stateRunning);
130     usleep(POWER_CONSUMPTION_DURATION_US);
131     HiSysEventWrite(HiSysEvent::Domain::AUDIO, StatsHiSysEvent::STREAM_CHANGE,
132         HiSysEvent::EventType::BEHAVIOR, "PID", pid, "UID", uid, "STATE", stateStopped);
133 
134     double actualPercent = statsClient.GetAppStatsPercent(uid);
135     GTEST_LOG_(INFO) << __func__ << ": actual percent = " << actualPercent;
136     EXPECT_TRUE(actualPercent >= zeroPercent && actualPercent <= fullPercent);
137 }
138 
139 /**
140  * @tc.name: StatsAudioTest_004
141  * @tc.desc: test GetAppStatsMah function, Audio state composite test
142  * @tc.type: FUNC
143  */
144 HWTEST_F (StatsAudioTest, StatsAudioTest_004, TestSize.Level0)
145 {
146     auto& statsClient = BatteryStatsClient::GetInstance();
147     statsClient.Reset();
148 
149     double audioOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_AUDIO_ON);
150     int32_t uid = 10003;
151     int32_t pid = 3458;
152     int32_t stateRunning = 2;
153     int32_t stateStopped = 3;
154     int32_t stateReleased = 4;
155     int32_t statePaused = 5;
156 
157     HiSysEventWrite(HiSysEvent::Domain::AUDIO, StatsHiSysEvent::STREAM_CHANGE,
158         HiSysEvent::EventType::BEHAVIOR, "PID", pid, "UID", uid, "STATE", stateRunning);
159     usleep(POWER_CONSUMPTION_DURATION_US);
160     HiSysEventWrite(HiSysEvent::Domain::AUDIO, StatsHiSysEvent::STREAM_CHANGE,
161         HiSysEvent::EventType::BEHAVIOR, "PID", pid, "UID", uid, "STATE", stateStopped);
162 
163     HiSysEventWrite(HiSysEvent::Domain::AUDIO, StatsHiSysEvent::STREAM_CHANGE,
164         HiSysEvent::EventType::BEHAVIOR, "PID", pid, "UID", uid, "STATE", stateRunning);
165     usleep(POWER_CONSUMPTION_DURATION_US);
166     HiSysEventWrite(HiSysEvent::Domain::AUDIO, StatsHiSysEvent::STREAM_CHANGE,
167         HiSysEvent::EventType::BEHAVIOR, "PID", pid, "UID", uid, "STATE", stateReleased);
168 
169     HiSysEventWrite(HiSysEvent::Domain::AUDIO, StatsHiSysEvent::STREAM_CHANGE,
170         HiSysEvent::EventType::BEHAVIOR, "PID", pid, "UID", uid, "STATE", stateRunning);
171     usleep(POWER_CONSUMPTION_DURATION_US);
172     HiSysEventWrite(HiSysEvent::Domain::AUDIO, StatsHiSysEvent::STREAM_CHANGE,
173         HiSysEvent::EventType::BEHAVIOR, "PID", pid, "UID", uid, "STATE", statePaused);
174 
175     double expectedPower = 3 * POWER_CONSUMPTION_DURATION_US * audioOnAverageMa / US_PER_HOUR;
176     double actualPower = statsClient.GetAppStatsMah(uid);
177     double devPrecent = abs(expectedPower - actualPower) / expectedPower;
178     GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
179     GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
180     EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
181 }
182 
183 /**
184  * @tc.name: StatsAudioTest_005
185  * @tc.desc: test GetAppStatsMah function, Audio abnormal state test
186  * @tc.type: FUNC
187  */
188 HWTEST_F (StatsAudioTest, StatsAudioTest_005, TestSize.Level0)
189 {
190     auto& statsClient = BatteryStatsClient::GetInstance();
191     statsClient.Reset();
192 
193     double audioOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_AUDIO_ON);
194     int32_t uid = 10003;
195     int32_t pid = 3458;
196     int32_t stateRunning = 2;
197     int32_t stateStopped = 3;
198     int32_t stateInvalid = -1;
199     int32_t stateAbnormal = 101;
200 
201     HiSysEventWrite(HiSysEvent::Domain::AUDIO, StatsHiSysEvent::STREAM_CHANGE,
202         HiSysEvent::EventType::BEHAVIOR, "PID", pid, "UID", uid, "STATE", stateInvalid);
203     usleep(POWER_CONSUMPTION_DURATION_US);
204     HiSysEventWrite(HiSysEvent::Domain::AUDIO, StatsHiSysEvent::STREAM_CHANGE,
205         HiSysEvent::EventType::BEHAVIOR, "PID", pid, "UID", uid, "STATE", stateRunning);
206     usleep(POWER_CONSUMPTION_DURATION_US);
207     HiSysEventWrite(HiSysEvent::Domain::AUDIO, StatsHiSysEvent::STREAM_CHANGE,
208         HiSysEvent::EventType::BEHAVIOR, "PID", pid, "UID", uid, "STATE", stateAbnormal);
209     usleep(POWER_CONSUMPTION_DURATION_US);
210     HiSysEventWrite(HiSysEvent::Domain::AUDIO, StatsHiSysEvent::STREAM_CHANGE,
211         HiSysEvent::EventType::BEHAVIOR, "PID", pid, "UID", uid, "STATE", stateStopped);
212 
213     double expectedPower = 2 * POWER_CONSUMPTION_DURATION_US * audioOnAverageMa / US_PER_HOUR;
214     double actualPower = statsClient.GetAppStatsMah(uid);
215     double devPrecent = abs(expectedPower - actualPower) / expectedPower;
216     GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
217     GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
218     EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
219 }
220 
221 /**
222  * @tc.name: StatsAudioTest_006
223  * @tc.desc: test GetAppStatsMah(Audio) and GetAppStatsPercent(Sensor) function
224  * @tc.type: FUNC
225  */
226 HWTEST_F (StatsAudioTest, StatsAudioTest_006, TestSize.Level0)
227 {
228     auto& statsClient = BatteryStatsClient::GetInstance();
229     statsClient.Reset();
230 
231     double audioOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_AUDIO_ON);
232     int32_t uid = 10003;
233     int32_t pid = 3458;
234     int32_t stateRunning = 2;
235     int32_t stateStopped = 3;
236 
237     HiSysEventWrite(HiSysEvent::Domain::AUDIO, StatsHiSysEvent::STREAM_CHANGE,
238         HiSysEvent::EventType::BEHAVIOR, "PID", pid, "UID", uid, "STATE", stateRunning);
239     usleep(POWER_CONSUMPTION_DURATION_US);
240     HiSysEventWrite(HiSysEvent::Domain::AUDIO, StatsHiSysEvent::STREAM_CHANGE,
241         HiSysEvent::EventType::BEHAVIOR, "PID", pid, "UID", uid, "STATE", stateStopped);
242 
243     double expectedPower = POWER_CONSUMPTION_DURATION_US * audioOnAverageMa / US_PER_HOUR;
244     double actualPower = statsClient.GetAppStatsMah(uid);
245     double devPrecent = abs(expectedPower - actualPower) / expectedPower;
246     GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
247     GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
248     EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
249 
250     uid = 10004;
251     pid = 3459;
252     int32_t stateOn = 1;
253     int32_t stateOff = 0;
254     double fullPercent = 1;
255     double zeroPercent = 0;
256 
257     HiSysEventWrite(HiSysEvent::Domain::STATS, StatsHiSysEvent::POWER_SENSOR_GRAVITY,
258         HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateOn);
259     usleep(POWER_CONSUMPTION_DURATION_US);
260     HiSysEventWrite(HiSysEvent::Domain::STATS, StatsHiSysEvent::POWER_SENSOR_GRAVITY,
261         HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateOff);
262 
263     double actualPercent = statsClient.GetAppStatsPercent(uid);
264     GTEST_LOG_(INFO) << __func__ << ": actual percent = " << actualPercent;
265     EXPECT_TRUE(actualPercent >= zeroPercent && actualPercent <= fullPercent);
266 }
267 }