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