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