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