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_camera_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
29
SetUpTestCase()30 void StatsCameraTest::SetUpTestCase()
31 {
32 ParserAveragePowerFile();
33 system("hidumper -s 3302 -a -u");
34 }
35
TearDownTestCase()36 void StatsCameraTest::TearDownTestCase()
37 {
38 system("hidumper -s 3302 -a -r");
39 }
40
SetUp()41 void StatsCameraTest::SetUp()
42 {
43 auto& statsClient = BatteryStatsClient::GetInstance();
44 statsClient.SetOnBattery(true);
45 }
46
TearDown()47 void StatsCameraTest::TearDown()
48 {
49 auto& statsClient = BatteryStatsClient::GetInstance();
50 statsClient.SetOnBattery(false);
51 }
52
53 namespace {
54 /**
55 * @tc.name: StatsCameraTest_001
56 * @tc.desc: test Reset function(Camera)
57 * @tc.type: FUNC
58 */
HWTEST_F(StatsCameraTest, StatsCameraTest_001, TestSize.Level0)59 HWTEST_F (StatsCameraTest, StatsCameraTest_001, TestSize.Level0)
60 {
61 STATS_HILOGI(LABEL_TEST, "StatsCameraTest_001 start");
62 auto& statsClient = BatteryStatsClient::GetInstance();
63 statsClient.Reset();
64
65 int32_t uid = 10003;
66 int32_t pid = 3458;
67 std::string cameraId = "Camera0";
68
69 HiSysEventWrite(HiSysEvent::Domain::CAMERA, StatsHiSysEvent::CAMERA_CONNECT,
70 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "ID", cameraId);
71 usleep(POWER_CONSUMPTION_DURATION_US);
72 HiSysEventWrite(HiSysEvent::Domain::CAMERA, StatsHiSysEvent::CAMERA_DISCONNECT,
73 HiSysEvent::EventType::STATISTIC, "ID", cameraId);
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, "StatsCameraTest_001 end");
82 }
83
84 /**
85 * @tc.name: StatsCameraTest_002
86 * @tc.desc: test GetAppStatsMah function(Camera)
87 * @tc.type: FUNC
88 */
HWTEST_F(StatsCameraTest, StatsCameraTest_002, TestSize.Level0)89 HWTEST_F (StatsCameraTest, StatsCameraTest_002, TestSize.Level0)
90 {
91 STATS_HILOGI(LABEL_TEST, "StatsCameraTest_002 start");
92 auto& statsClient = BatteryStatsClient::GetInstance();
93 statsClient.Reset();
94
95 double cameraOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_CAMERA_ON);
96 int32_t uid = 10003;
97 int32_t pid = 3458;
98 std::string cameraId = "Camera0";
99
100 HiSysEventWrite(HiSysEvent::Domain::CAMERA, StatsHiSysEvent::CAMERA_CONNECT,
101 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "ID", cameraId);
102 usleep(POWER_CONSUMPTION_DURATION_US);
103 HiSysEventWrite(HiSysEvent::Domain::CAMERA, StatsHiSysEvent::CAMERA_DISCONNECT, HiSysEvent::EventType::STATISTIC,
104 "ID", cameraId);
105
106 double expectedPower = POWER_CONSUMPTION_DURATION_US * cameraOnAverageMa / US_PER_HOUR;
107 double actualPower = statsClient.GetAppStatsMah(uid);
108 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
109 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
110 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
111 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
112 STATS_HILOGI(LABEL_TEST, "StatsCameraTest_002 end");
113 }
114
115 /**
116 * @tc.name: StatsCameraTest_003
117 * @tc.desc: test GetAppStatsPercent function(Camera)
118 * @tc.type: FUNC
119 */
HWTEST_F(StatsCameraTest, StatsCameraTest_003, TestSize.Level0)120 HWTEST_F (StatsCameraTest, StatsCameraTest_003, TestSize.Level0)
121 {
122 STATS_HILOGI(LABEL_TEST, "StatsCameraTest_003 start");
123 auto& statsClient = BatteryStatsClient::GetInstance();
124 statsClient.Reset();
125
126 int32_t uid = 10003;
127 int32_t pid = 3458;
128 std::string deviceId = "Camera0";
129 double fullPercent = 1;
130 double zeroPercent = 0;
131
132 HiSysEventWrite(HiSysEvent::Domain::CAMERA, StatsHiSysEvent::CAMERA_CONNECT,
133 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "ID", deviceId);
134 usleep(POWER_CONSUMPTION_DURATION_US);
135 HiSysEventWrite(HiSysEvent::Domain::CAMERA, StatsHiSysEvent::CAMERA_DISCONNECT, HiSysEvent::EventType::STATISTIC,
136 "ID", deviceId);
137 double actualPercent = statsClient.GetAppStatsPercent(uid);
138 GTEST_LOG_(INFO) << __func__ << ": actual percent = " << actualPercent;
139 EXPECT_TRUE(actualPercent >= zeroPercent && actualPercent <= fullPercent);
140 STATS_HILOGI(LABEL_TEST, "StatsCameraTest_003 end");
141 }
142
143 /**
144 * @tc.name: StatsCameraTest_004
145 * @tc.desc: test Reset function(Camera with Flashlight)
146 * @tc.type: FUNC
147 */
HWTEST_F(StatsCameraTest, StatsCameraTest_004, TestSize.Level0)148 HWTEST_F (StatsCameraTest, StatsCameraTest_004, TestSize.Level0)
149 {
150 STATS_HILOGI(LABEL_TEST, "StatsCameraTest_004 start");
151 auto& statsClient = BatteryStatsClient::GetInstance();
152 statsClient.Reset();
153
154 int32_t uid = 10003;
155 int32_t pid = 3458;
156 std::string cameraId = "Camera0";
157
158 HiSysEventWrite(HiSysEvent::Domain::CAMERA, StatsHiSysEvent::CAMERA_CONNECT,
159 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "ID", cameraId);
160 usleep(POWER_CONSUMPTION_DURATION_US);
161 HiSysEventWrite(HiSysEvent::Domain::CAMERA, StatsHiSysEvent::FLASHLIGHT_ON, HiSysEvent::EventType::STATISTIC);
162 usleep(POWER_CONSUMPTION_DURATION_US);
163 HiSysEventWrite(HiSysEvent::Domain::CAMERA, StatsHiSysEvent::FLASHLIGHT_OFF, HiSysEvent::EventType::STATISTIC);
164 usleep(POWER_CONSUMPTION_DURATION_US);
165 HiSysEventWrite(HiSysEvent::Domain::CAMERA, StatsHiSysEvent::CAMERA_DISCONNECT, HiSysEvent::EventType::STATISTIC,
166 "ID", cameraId);
167
168 double powerMahBefore = statsClient.GetAppStatsMah(uid);
169 statsClient.Reset();
170 double powerMahAfter = statsClient.GetAppStatsMah(uid);
171 GTEST_LOG_(INFO) << __func__ << ": before consumption = " << powerMahBefore << " mAh";
172 GTEST_LOG_(INFO) << __func__ << ": after consumption = " << powerMahAfter << " mAh";
173 EXPECT_TRUE(powerMahBefore >= StatsUtils::DEFAULT_VALUE && powerMahAfter == StatsUtils::DEFAULT_VALUE);
174 STATS_HILOGI(LABEL_TEST, "StatsCameraTest_004 end");
175 }
176
177 /**
178 * @tc.name: StatsCameraTest_005
179 * @tc.desc: test GetAppStatsMah function(Camera with Flashlight)
180 * @tc.type: FUNC
181 */
HWTEST_F(StatsCameraTest, StatsCameraTest_005, TestSize.Level0)182 HWTEST_F (StatsCameraTest, StatsCameraTest_005, TestSize.Level0)
183 {
184 STATS_HILOGI(LABEL_TEST, "StatsCameraTest_005 start");
185 auto& statsClient = BatteryStatsClient::GetInstance();
186 statsClient.Reset();
187
188 double cameraOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_CAMERA_ON);
189 double flashlightOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_FLASHLIGHT_ON);
190 int32_t uid = 10003;
191 int32_t pid = 3458;
192 std::string cameraId = "Camera0";
193
194 HiSysEventWrite(HiSysEvent::Domain::CAMERA, StatsHiSysEvent::CAMERA_CONNECT,
195 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "ID", cameraId);
196 usleep(POWER_CONSUMPTION_DURATION_US);
197 HiSysEventWrite(HiSysEvent::Domain::CAMERA, StatsHiSysEvent::FLASHLIGHT_ON, HiSysEvent::EventType::STATISTIC);
198 usleep(POWER_CONSUMPTION_DURATION_US);
199 HiSysEventWrite(HiSysEvent::Domain::CAMERA, StatsHiSysEvent::FLASHLIGHT_OFF, HiSysEvent::EventType::STATISTIC);
200 usleep(POWER_CONSUMPTION_DURATION_US);
201 HiSysEventWrite(HiSysEvent::Domain::CAMERA, StatsHiSysEvent::CAMERA_DISCONNECT, HiSysEvent::EventType::STATISTIC,
202 "ID", cameraId);
203
204 double expectedPower = (3 * POWER_CONSUMPTION_DURATION_US * cameraOnAverageMa / US_PER_HOUR) +
205 (POWER_CONSUMPTION_DURATION_US * flashlightOnAverageMa / US_PER_HOUR);
206 double actualPower = statsClient.GetAppStatsMah(uid);
207 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
208 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
209 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
210 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
211 STATS_HILOGI(LABEL_TEST, "StatsCameraTest_005 end");
212 }
213
214 /**
215 * @tc.name: StatsCameraTest_006
216 * @tc.desc: test GetAppStatsPercent function(Camera with Flashlight)
217 * @tc.type: FUNC
218 */
HWTEST_F(StatsCameraTest, StatsCameraTest_006, TestSize.Level0)219 HWTEST_F (StatsCameraTest, StatsCameraTest_006, TestSize.Level0)
220 {
221 STATS_HILOGI(LABEL_TEST, "StatsCameraTest_006 start");
222 auto& statsClient = BatteryStatsClient::GetInstance();
223 statsClient.Reset();
224
225 int32_t uid = 10003;
226 int32_t pid = 3458;
227 std::string cameraId = "Camera0";
228 double fullPercent = 1;
229 double zeroPercent = 0;
230
231 HiSysEventWrite(HiSysEvent::Domain::CAMERA, StatsHiSysEvent::CAMERA_CONNECT,
232 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "ID", cameraId);
233 usleep(POWER_CONSUMPTION_DURATION_US);
234 HiSysEventWrite(HiSysEvent::Domain::CAMERA, StatsHiSysEvent::FLASHLIGHT_ON, HiSysEvent::EventType::STATISTIC);
235 usleep(POWER_CONSUMPTION_DURATION_US);
236 HiSysEventWrite(HiSysEvent::Domain::CAMERA, StatsHiSysEvent::FLASHLIGHT_OFF, HiSysEvent::EventType::STATISTIC);
237 usleep(POWER_CONSUMPTION_DURATION_US);
238 HiSysEventWrite(HiSysEvent::Domain::CAMERA, StatsHiSysEvent::CAMERA_DISCONNECT, HiSysEvent::EventType::STATISTIC,
239 "ID", cameraId);
240
241 double actualPercent = statsClient.GetAppStatsPercent(uid);
242 GTEST_LOG_(INFO) << __func__ << ": actual percent = " << actualPercent;
243 EXPECT_TRUE(actualPercent >= zeroPercent && actualPercent <= fullPercent);
244 STATS_HILOGI(LABEL_TEST, "StatsCameraTest_006 end");
245 }
246
247 /**
248 * @tc.name: StatsCameraTest_007
249 * @tc.desc: test Reset function, The same Uid triggers the camera(different id) continuously
250 * @tc.type: FUNC
251 */
HWTEST_F(StatsCameraTest, StatsCameraTest_007, TestSize.Level0)252 HWTEST_F (StatsCameraTest, StatsCameraTest_007, TestSize.Level0)
253 {
254 STATS_HILOGI(LABEL_TEST, "StatsCameraTest_007 start");
255 auto& statsClient = BatteryStatsClient::GetInstance();
256 statsClient.Reset();
257
258 int32_t uid = 10003;
259 int32_t pid = 3458;
260 std::string cameraId0 = "Camera0";
261 std::string cameraId1 = "Camera1";
262
263 HiSysEventWrite(HiSysEvent::Domain::CAMERA, StatsHiSysEvent::CAMERA_CONNECT,
264 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "ID", cameraId0);
265 usleep(POWER_CONSUMPTION_DURATION_US);
266 HiSysEventWrite(HiSysEvent::Domain::CAMERA, StatsHiSysEvent::CAMERA_DISCONNECT, HiSysEvent::EventType::STATISTIC,
267 "ID", cameraId0);
268 HiSysEventWrite(HiSysEvent::Domain::CAMERA, StatsHiSysEvent::CAMERA_CONNECT,
269 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "ID", cameraId1);
270 usleep(POWER_CONSUMPTION_DURATION_US);
271 HiSysEventWrite(HiSysEvent::Domain::CAMERA, StatsHiSysEvent::CAMERA_DISCONNECT, HiSysEvent::EventType::STATISTIC,
272 "ID", cameraId1);
273
274 double powerMahBefore = statsClient.GetAppStatsMah(uid);
275 statsClient.Reset();
276 double powerMahAfter = statsClient.GetAppStatsMah(uid);
277 GTEST_LOG_(INFO) << __func__ << ": before consumption = " << powerMahBefore << " mAh";
278 GTEST_LOG_(INFO) << __func__ << ": after consumption = " << powerMahAfter << " mAh";
279 EXPECT_TRUE(powerMahBefore >= StatsUtils::DEFAULT_VALUE && powerMahAfter == StatsUtils::DEFAULT_VALUE);
280 STATS_HILOGI(LABEL_TEST, "StatsCameraTest_007 end");
281 }
282
283 /**
284 * @tc.name: StatsCameraTest_008
285 * @tc.desc: test GetAppStatsMah function, The same Uid triggers the camera(different id) continuously
286 * @tc.type: FUNC
287 */
HWTEST_F(StatsCameraTest, StatsCameraTest_008, TestSize.Level0)288 HWTEST_F (StatsCameraTest, StatsCameraTest_008, TestSize.Level0)
289 {
290 STATS_HILOGI(LABEL_TEST, "StatsCameraTest_008 start");
291 auto& statsClient = BatteryStatsClient::GetInstance();
292 statsClient.Reset();
293
294 double cameraOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_CAMERA_ON);
295 int32_t uid = 10003;
296 int32_t pid = 3458;
297 std::string cameraId0 = "Camera0";
298 std::string cameraId1 = "Camera1";
299
300 HiSysEventWrite(HiSysEvent::Domain::CAMERA, StatsHiSysEvent::CAMERA_CONNECT,
301 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "ID", cameraId0);
302 usleep(POWER_CONSUMPTION_DURATION_US);
303 HiSysEventWrite(HiSysEvent::Domain::CAMERA, StatsHiSysEvent::CAMERA_DISCONNECT, HiSysEvent::EventType::STATISTIC,
304 "ID", cameraId0);
305 HiSysEventWrite(HiSysEvent::Domain::CAMERA, StatsHiSysEvent::CAMERA_CONNECT,
306 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "ID", cameraId1);
307 usleep(POWER_CONSUMPTION_DURATION_US);
308 HiSysEventWrite(HiSysEvent::Domain::CAMERA, StatsHiSysEvent::CAMERA_DISCONNECT, HiSysEvent::EventType::STATISTIC,
309 "ID", cameraId1);
310
311 double expectedPower = 2 * POWER_CONSUMPTION_DURATION_US * cameraOnAverageMa / US_PER_HOUR;
312 double actualPower = statsClient.GetAppStatsMah(uid);
313 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
314 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
315 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
316 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
317 STATS_HILOGI(LABEL_TEST, "StatsCameraTest_008 end");
318 }
319
320 /**
321 * @tc.name: StatsCameraTest_009
322 * @tc.desc: test GetAppStatsPercent function, The same Uid triggers the camera(different id) continuously
323 * @tc.type: FUNC
324 */
HWTEST_F(StatsCameraTest, StatsCameraTest_009, TestSize.Level0)325 HWTEST_F (StatsCameraTest, StatsCameraTest_009, TestSize.Level0)
326 {
327 STATS_HILOGI(LABEL_TEST, "StatsCameraTest_009 start");
328 auto& statsClient = BatteryStatsClient::GetInstance();
329 statsClient.Reset();
330
331 int32_t uid = 10003;
332 int32_t pid = 3458;
333 std::string cameraId0 = "Camera0";
334 std::string cameraId1 = "Camera1";
335 double fullPercent = 1;
336 double zeroPercent = 0;
337
338 HiSysEventWrite(HiSysEvent::Domain::CAMERA, StatsHiSysEvent::CAMERA_CONNECT,
339 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "ID", cameraId0);
340 usleep(POWER_CONSUMPTION_DURATION_US);
341 HiSysEventWrite(HiSysEvent::Domain::CAMERA, StatsHiSysEvent::CAMERA_DISCONNECT, HiSysEvent::EventType::STATISTIC,
342 "ID", cameraId0);
343 HiSysEventWrite(HiSysEvent::Domain::CAMERA, StatsHiSysEvent::CAMERA_CONNECT,
344 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "ID", cameraId1);
345 usleep(POWER_CONSUMPTION_DURATION_US);
346 HiSysEventWrite(HiSysEvent::Domain::CAMERA, StatsHiSysEvent::CAMERA_DISCONNECT, HiSysEvent::EventType::STATISTIC,
347 "ID", cameraId1);
348
349 double actualPercent = statsClient.GetAppStatsPercent(uid);
350 GTEST_LOG_(INFO) << __func__ << ": actual percent = " << actualPercent;
351 EXPECT_TRUE(actualPercent >= zeroPercent && actualPercent <= fullPercent);
352 STATS_HILOGI(LABEL_TEST, "StatsCameraTest_009 end");
353 }
354
355 /**
356 * @tc.name: StatsCameraTest_010
357 * @tc.desc: test GetAppStatsMah function
358 * @tc.type: FUNC
359 */
HWTEST_F(StatsCameraTest, StatsCameraTest_010, TestSize.Level0)360 HWTEST_F (StatsCameraTest, StatsCameraTest_010, TestSize.Level0)
361 {
362 STATS_HILOGI(LABEL_TEST, "StatsCameraTest_010 start");
363 auto& statsClient = BatteryStatsClient::GetInstance();
364 statsClient.Reset();
365
366 double cameraOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_CAMERA_ON);
367 int32_t uid = 10003;
368 int32_t pid = 3458;
369 std::string cameraId0 = "Camera0";
370 std::string cameraId1 = "Camera1";
371
372 HiSysEventWrite(HiSysEvent::Domain::CAMERA, StatsHiSysEvent::CAMERA_CONNECT,
373 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "ID", cameraId0);
374 usleep(POWER_CONSUMPTION_DURATION_US);
375 HiSysEventWrite(HiSysEvent::Domain::CAMERA, StatsHiSysEvent::CAMERA_CONNECT,
376 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "ID", cameraId1);
377 usleep(POWER_CONSUMPTION_DURATION_US);
378 HiSysEventWrite(HiSysEvent::Domain::CAMERA, StatsHiSysEvent::CAMERA_DISCONNECT, HiSysEvent::EventType::STATISTIC,
379 "ID", cameraId1);
380 usleep(POWER_CONSUMPTION_DURATION_US);
381 HiSysEventWrite(HiSysEvent::Domain::CAMERA, StatsHiSysEvent::CAMERA_DISCONNECT, HiSysEvent::EventType::STATISTIC,
382 "ID", cameraId0);
383
384 double expectedPower = 3 * POWER_CONSUMPTION_DURATION_US * cameraOnAverageMa / US_PER_HOUR;
385 double actualPower = statsClient.GetAppStatsMah(uid);
386 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
387 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
388 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
389 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
390 STATS_HILOGI(LABEL_TEST, "StatsCameraTest_010 end");
391 }
392
393 /**
394 * @tc.name: StatsCameraTest_011
395 * @tc.desc: test GetAppStatsMah function
396 * @tc.type: FUNC
397 */
HWTEST_F(StatsCameraTest, StatsCameraTest_011, TestSize.Level0)398 HWTEST_F (StatsCameraTest, StatsCameraTest_011, TestSize.Level0)
399 {
400 STATS_HILOGI(LABEL_TEST, "StatsCameraTest_011 start");
401 auto& statsClient = BatteryStatsClient::GetInstance();
402 statsClient.Reset();
403
404 double cameraOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_CAMERA_ON);
405 int32_t uid1 = 10003;
406 int32_t pid1 = 3458;
407 int32_t uid2 = 10004;
408 int32_t pid2 = 3459;
409 std::string cameraId = "Camera0";
410
411 HiSysEventWrite(HiSysEvent::Domain::CAMERA, StatsHiSysEvent::CAMERA_CONNECT,
412 HiSysEvent::EventType::STATISTIC, "PID", pid1, "UID", uid1, "ID", cameraId);
413 usleep(POWER_CONSUMPTION_DURATION_US);
414 HiSysEventWrite(HiSysEvent::Domain::CAMERA, StatsHiSysEvent::CAMERA_CONNECT,
415 HiSysEvent::EventType::STATISTIC, "PID", pid2, "UID", uid2, "ID", cameraId);
416 usleep(POWER_CONSUMPTION_DURATION_US);
417 HiSysEventWrite(HiSysEvent::Domain::CAMERA, StatsHiSysEvent::CAMERA_DISCONNECT, HiSysEvent::EventType::STATISTIC,
418 "ID", cameraId);
419 usleep(POWER_CONSUMPTION_DURATION_US);
420 HiSysEventWrite(HiSysEvent::Domain::CAMERA, StatsHiSysEvent::CAMERA_DISCONNECT, HiSysEvent::EventType::STATISTIC,
421 "ID", cameraId);
422
423 double expectedPower = 2 * POWER_CONSUMPTION_DURATION_US * cameraOnAverageMa / US_PER_HOUR;
424 double actualPower = statsClient.GetAppStatsMah(uid1);
425 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
426 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
427 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
428 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
429 STATS_HILOGI(LABEL_TEST, "StatsCameraTest_011 end");
430 }
431
432 /**
433 * @tc.name: StatsCameraTest_012
434 * @tc.desc: test GetAppStatsMah function, Camera-Flashlight is opened when camera closed
435 * @tc.type: FUNC
436 */
HWTEST_F(StatsCameraTest, StatsCameraTest_012, TestSize.Level0)437 HWTEST_F (StatsCameraTest, StatsCameraTest_012, TestSize.Level0)
438 {
439 STATS_HILOGI(LABEL_TEST, "StatsCameraTest_012 start");
440 auto& statsClient = BatteryStatsClient::GetInstance();
441 statsClient.Reset();
442
443 int32_t uid = 10003;
444
445 HiSysEventWrite(HiSysEvent::Domain::CAMERA, StatsHiSysEvent::FLASHLIGHT_ON, HiSysEvent::EventType::STATISTIC);
446 usleep(POWER_CONSUMPTION_DURATION_US);
447 HiSysEventWrite(HiSysEvent::Domain::CAMERA, StatsHiSysEvent::FLASHLIGHT_OFF, HiSysEvent::EventType::STATISTIC);
448
449 double actualPower = statsClient.GetAppStatsMah(uid);
450 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
451 EXPECT_TRUE(actualPower >= StatsUtils::DEFAULT_VALUE);
452 STATS_HILOGI(LABEL_TEST, "StatsCameraTest_012 end");
453 }
454
455 /**
456 * @tc.name: StatsCameraTest_013
457 * @tc.desc: test GetAppStatsMah function
458 * @tc.type: FUNC
459 */
HWTEST_F(StatsCameraTest, StatsCameraTest_013, TestSize.Level0)460 HWTEST_F (StatsCameraTest, StatsCameraTest_013, TestSize.Level0)
461 {
462 STATS_HILOGI(LABEL_TEST, "StatsCameraTest_013 start");
463 auto& statsClient = BatteryStatsClient::GetInstance();
464 statsClient.Reset();
465
466 double cameraOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_CAMERA_ON);
467 double flashlightOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_FLASHLIGHT_ON);
468 int32_t uid = 10003;
469 int32_t pid = 3458;
470 std::string cameraId = "Camera0";
471
472 HiSysEventWrite(HiSysEvent::Domain::CAMERA, StatsHiSysEvent::CAMERA_CONNECT,
473 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "ID", cameraId);
474 usleep(POWER_CONSUMPTION_DURATION_US);
475 HiSysEventWrite(HiSysEvent::Domain::CAMERA, StatsHiSysEvent::FLASHLIGHT_ON, HiSysEvent::EventType::STATISTIC);
476 usleep(POWER_CONSUMPTION_DURATION_US);
477 HiSysEventWrite(HiSysEvent::Domain::CAMERA, StatsHiSysEvent::CAMERA_DISCONNECT,
478 HiSysEvent::EventType::STATISTIC, "ID", cameraId);
479 usleep(POWER_CONSUMPTION_DURATION_US);
480
481 double expectedPower = (2 * POWER_CONSUMPTION_DURATION_US * cameraOnAverageMa / US_PER_HOUR) +
482 (POWER_CONSUMPTION_DURATION_US * flashlightOnAverageMa / US_PER_HOUR);
483 double actualPower = statsClient.GetAppStatsMah(uid);
484 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
485 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
486 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
487 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
488 STATS_HILOGI(LABEL_TEST, "StatsCameraTest_013 end");
489 }
490
491 /**
492 * @tc.name: StatsCameraTest_014
493 * @tc.desc: test Reset function(Torch)
494 * @tc.type: FUNC
495 */
HWTEST_F(StatsCameraTest, StatsCameraTest_014, TestSize.Level0)496 HWTEST_F (StatsCameraTest, StatsCameraTest_014, TestSize.Level0)
497 {
498 STATS_HILOGI(LABEL_TEST, "StatsCameraTest_014 start");
499 auto& statsClient = BatteryStatsClient::GetInstance();
500 statsClient.Reset();
501
502 int32_t uid = 10003;
503 int32_t pid = 3458;
504 int32_t stateOn = 1;
505 int32_t stateOff = 0;
506
507 HiSysEventWrite(HiSysEvent::Domain::CAMERA, StatsHiSysEvent::TORCH_STATE,
508 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateOn);
509 usleep(POWER_CONSUMPTION_DURATION_US);
510 HiSysEventWrite(HiSysEvent::Domain::CAMERA, StatsHiSysEvent::TORCH_STATE,
511 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateOff);
512
513 double powerMahBefore = statsClient.GetAppStatsMah(uid);
514 statsClient.Reset();
515 double powerMahAfter = statsClient.GetAppStatsMah(uid);
516 GTEST_LOG_(INFO) << __func__ << ": before consumption = " << powerMahBefore << " mAh";
517 GTEST_LOG_(INFO) << __func__ << ": after consumption = " << powerMahAfter << " mAh";
518 EXPECT_TRUE(powerMahBefore >= StatsUtils::DEFAULT_VALUE && powerMahAfter == StatsUtils::DEFAULT_VALUE);
519 STATS_HILOGI(LABEL_TEST, "StatsCameraTest_014 end");
520 }
521
522 /**
523 * @tc.name: StatsCameraTest_015
524 * @tc.desc: test GetAppStatsMah function(Torch)
525 * @tc.type: FUNC
526 */
HWTEST_F(StatsCameraTest, StatsCameraTest_015, TestSize.Level0)527 HWTEST_F (StatsCameraTest, StatsCameraTest_015, TestSize.Level0)
528 {
529 STATS_HILOGI(LABEL_TEST, "StatsCameraTest_015 start");
530 auto& statsClient = BatteryStatsClient::GetInstance();
531 statsClient.Reset();
532
533 double flashlightOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_FLASHLIGHT_ON);
534 int32_t uid = 10003;
535 int32_t pid = 3458;
536 int32_t stateOn = 1;
537 int32_t stateOff = 0;
538
539 HiSysEventWrite(HiSysEvent::Domain::CAMERA, StatsHiSysEvent::TORCH_STATE,
540 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateOn);
541 usleep(POWER_CONSUMPTION_DURATION_US);
542 HiSysEventWrite(HiSysEvent::Domain::CAMERA, StatsHiSysEvent::TORCH_STATE,
543 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateOff);
544
545 double expectedPower = POWER_CONSUMPTION_DURATION_US * flashlightOnAverageMa / US_PER_HOUR;
546 double actualPower = statsClient.GetAppStatsMah(uid);
547 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
548 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
549 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
550 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
551 STATS_HILOGI(LABEL_TEST, "StatsCameraTest_015 end");
552 }
553
554 /**
555 * @tc.name: StatsCameraTest_016
556 * @tc.desc: test GetAppStatsPercent function(Torch)
557 * @tc.type: FUNC
558 */
HWTEST_F(StatsCameraTest, StatsCameraTest_016, TestSize.Level0)559 HWTEST_F (StatsCameraTest, StatsCameraTest_016, TestSize.Level0)
560 {
561 STATS_HILOGI(LABEL_TEST, "StatsCameraTest_016 start");
562 auto& statsClient = BatteryStatsClient::GetInstance();
563 statsClient.Reset();
564
565 int32_t uid = 10003;
566 int32_t pid = 3458;
567 int32_t stateOn = 1;
568 int32_t stateOff = 0;
569 double fullPercent = 1;
570 double zeroPercent = 0;
571
572 HiSysEventWrite(HiSysEvent::Domain::CAMERA, StatsHiSysEvent::TORCH_STATE,
573 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateOn);
574 usleep(POWER_CONSUMPTION_DURATION_US);
575 HiSysEventWrite(HiSysEvent::Domain::CAMERA, StatsHiSysEvent::TORCH_STATE,
576 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateOff);
577 double actualPercent = statsClient.GetAppStatsPercent(uid);
578 GTEST_LOG_(INFO) << __func__ << ": actual percent = " << actualPercent;
579 EXPECT_TRUE(actualPercent >= zeroPercent && actualPercent <= fullPercent);
580 STATS_HILOGI(LABEL_TEST, "StatsCameraTest_016 end");
581 }
582
583 /**
584 * @tc.name: StatsCameraTest_017
585 * @tc.desc: test GetAppStatsMah(Torch) and GetAppStatsPercent(Camera) function
586 * @tc.type: FUNC
587 */
HWTEST_F(StatsCameraTest, StatsCameraTest_017, TestSize.Level0)588 HWTEST_F (StatsCameraTest, StatsCameraTest_017, TestSize.Level0)
589 {
590 STATS_HILOGI(LABEL_TEST, "StatsCameraTest_017 start");
591 auto& statsClient = BatteryStatsClient::GetInstance();
592 statsClient.Reset();
593
594 double flashlightOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_FLASHLIGHT_ON);
595 int32_t uid = 10003;
596 int32_t pid = 3458;
597 int32_t stateOn = 1;
598 int32_t stateOff = 0;
599
600 HiSysEventWrite(HiSysEvent::Domain::CAMERA, StatsHiSysEvent::TORCH_STATE,
601 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateOn);
602 usleep(POWER_CONSUMPTION_DURATION_US);
603 HiSysEventWrite(HiSysEvent::Domain::CAMERA, StatsHiSysEvent::TORCH_STATE,
604 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "STATE", stateOff);
605
606 double expectedPower = POWER_CONSUMPTION_DURATION_US * flashlightOnAverageMa / US_PER_HOUR;
607 double actualPower = statsClient.GetAppStatsMah(uid);
608 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
609 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
610 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
611 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
612
613 uid = 10004;
614 pid = 3459;
615 std::string deviceId = "Camera0";
616 double fullPercent = 1;
617 double zeroPercent = 0;
618
619 HiSysEventWrite(HiSysEvent::Domain::CAMERA, StatsHiSysEvent::CAMERA_CONNECT,
620 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "ID", deviceId);
621 usleep(POWER_CONSUMPTION_DURATION_US);
622 HiSysEventWrite(HiSysEvent::Domain::CAMERA, StatsHiSysEvent::CAMERA_DISCONNECT, HiSysEvent::EventType::STATISTIC,
623 "ID", deviceId);
624 double actualPercent = statsClient.GetAppStatsPercent(uid);
625 GTEST_LOG_(INFO) << __func__ << ": actual percent = " << actualPercent;
626 EXPECT_TRUE(actualPercent >= zeroPercent && actualPercent <= fullPercent);
627 STATS_HILOGI(LABEL_TEST, "StatsCameraTest_017 end");
628 }
629
630 /**
631 * @tc.name: StatsCameraTest_018
632 * @tc.desc: test GetAppStatsMah(Camera) and GetAppStatsPercent(Audio) function
633 * @tc.type: FUNC
634 */
HWTEST_F(StatsCameraTest, StatsCameraTest_018, TestSize.Level0)635 HWTEST_F (StatsCameraTest, StatsCameraTest_018, TestSize.Level0)
636 {
637 STATS_HILOGI(LABEL_TEST, "StatsCameraTest_018 start");
638 auto& statsClient = BatteryStatsClient::GetInstance();
639 statsClient.Reset();
640
641 double cameraOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_CAMERA_ON);
642 int32_t uid = 10003;
643 int32_t pid = 3458;
644 std::string deviceId = "Camera0";
645
646 HiSysEventWrite(HiSysEvent::Domain::CAMERA, StatsHiSysEvent::CAMERA_CONNECT,
647 HiSysEvent::EventType::STATISTIC, "PID", pid, "UID", uid, "ID", deviceId);
648 usleep(POWER_CONSUMPTION_DURATION_US);
649 HiSysEventWrite(HiSysEvent::Domain::CAMERA, StatsHiSysEvent::CAMERA_DISCONNECT, HiSysEvent::EventType::STATISTIC,
650 "ID", deviceId);
651
652 double expectedPower = POWER_CONSUMPTION_DURATION_US * cameraOnAverageMa / US_PER_HOUR;
653 double actualPower = statsClient.GetAppStatsMah(uid);
654 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
655 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
656 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
657 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
658
659 uid = 10004;
660 pid = 3459;
661 int32_t stateRunning = 2;
662 int32_t stateStopped = 3;
663 double fullPercent = 1;
664 double zeroPercent = 0;
665
666 HiSysEventWrite(HiSysEvent::Domain::AUDIO, StatsHiSysEvent::STREAM_CHANGE,
667 HiSysEvent::EventType::BEHAVIOR, "PID", pid, "UID", uid, "STATE", stateRunning);
668 usleep(POWER_CONSUMPTION_DURATION_US);
669 HiSysEventWrite(HiSysEvent::Domain::AUDIO, StatsHiSysEvent::STREAM_CHANGE,
670 HiSysEvent::EventType::BEHAVIOR, "PID", pid, "UID", uid, "STATE", stateStopped);
671 double actualPercent = statsClient.GetAppStatsPercent(uid);
672 GTEST_LOG_(INFO) << __func__ << ": actual percent = " << actualPercent;
673 EXPECT_TRUE(actualPercent >= zeroPercent && actualPercent <= fullPercent);
674 STATS_HILOGI(LABEL_TEST, "StatsCameraTest_018 end");
675 }
676 }