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_service_camera_test.h"
17 #include "stats_log.h"
18
19 #include <hisysevent.h>
20
21 #include "battery_stats_listener.h"
22 #include "battery_stats_service.h"
23 #include "hisysevent_operation.h"
24 #include "stats_hisysevent.h"
25 #include "stats_service_test_proxy.h"
26 #include "stats_service_write_event.h"
27
28 using namespace OHOS;
29 using namespace testing::ext;
30 using namespace OHOS::HiviewDFX;
31 using namespace OHOS::PowerMgr;
32 using namespace std;
33
34 namespace {
35 static sptr<BatteryStatsService> g_statsService = nullptr;
36 static std::shared_ptr<StatsServiceTestProxy> g_statsServiceProxy = nullptr;
37 } // namespace
38
SetUpTestCase()39 void StatsServiceCameraTest::SetUpTestCase()
40 {
41 ParserAveragePowerFile();
42 g_statsService = BatteryStatsService::GetInstance();
43 g_statsService->OnStart();
44
45 if (g_statsService->listenerPtr_ == nullptr) {
46 g_statsService->listenerPtr_ = std::make_shared<BatteryStatsListener>();
47 }
48
49 if (g_statsServiceProxy == nullptr) {
50 g_statsServiceProxy = std::make_shared<StatsServiceTestProxy>(g_statsService);
51 }
52 }
53
TearDownTestCase()54 void StatsServiceCameraTest::TearDownTestCase()
55 {
56 g_statsService->listenerPtr_ = nullptr;
57 g_statsService->OnStop();
58 }
59
SetUp()60 void StatsServiceCameraTest::SetUp()
61 {
62 auto statsService = BatteryStatsService::GetInstance();
63 statsService->SetOnBattery(true);
64 }
65
TearDown()66 void StatsServiceCameraTest::TearDown()
67 {
68 auto statsService = BatteryStatsService::GetInstance();
69 statsService->SetOnBattery(false);
70 }
71
72 namespace {
73 /**
74 * @tc.name: StatsServiceCameraTest_001
75 * @tc.desc: test Reset function(Camera)
76 * @tc.type: FUNC
77 * @tc.require: issueI663DX
78 */
79 HWTEST_F (StatsServiceCameraTest, StatsServiceCameraTest_001, TestSize.Level0)
80 {
81 STATS_HILOGI(LABEL_TEST, "StatsServiceCameraTest_001 start");
82 ASSERT_NE(g_statsServiceProxy, nullptr);
83 auto statsService = BatteryStatsService::GetInstance();
84 g_statsServiceProxy->ResetIpc();
85
86 int32_t uid = 10003;
87 int32_t pid = 3458;
88 std::string cameraId = "Camera0";
89
90 StatsWriteHiSysEvent(statsService,
91 HiSysEvent::Domain::CAMERA, StatsHiSysEvent::CAMERA_CONNECT, HiSysEvent::EventType::STATISTIC, "PID", pid,
92 "UID", uid, "ID", cameraId);
93 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
94 StatsWriteHiSysEvent(statsService,
95 HiSysEvent::Domain::CAMERA, StatsHiSysEvent::CAMERA_DISCONNECT, HiSysEvent::EventType::STATISTIC,
96 "ID", cameraId);
97 int32_t tempError;
98 double powerMahBefore;
99 g_statsServiceProxy->GetAppStatsMahIpc(uid, powerMahBefore, tempError);
100 g_statsServiceProxy->ResetIpc();
101 double powerMahAfter;
102 g_statsServiceProxy->GetAppStatsMahIpc(uid, powerMahAfter, tempError);
103 GTEST_LOG_(INFO) << __func__ << ": before consumption = " << powerMahBefore << " mAh";
104 GTEST_LOG_(INFO) << __func__ << ": after consumption = " << powerMahAfter << " mAh";
105 EXPECT_TRUE(powerMahBefore >= StatsUtils::DEFAULT_VALUE && powerMahAfter == StatsUtils::DEFAULT_VALUE);
106 STATS_HILOGI(LABEL_TEST, "StatsServiceCameraTest_001 end");
107 }
108
109 /**
110 * @tc.name: StatsServiceCameraTest_002
111 * @tc.desc: test GetAppStatsMah function(Camera)
112 * @tc.type: FUNC
113 * @tc.require: issueI663DX
114 */
115 HWTEST_F (StatsServiceCameraTest, StatsServiceCameraTest_002, TestSize.Level0)
116 {
117 STATS_HILOGI(LABEL_TEST, "StatsServiceCameraTest_002 start");
118 ASSERT_NE(g_statsServiceProxy, nullptr);
119 auto statsService = BatteryStatsService::GetInstance();
120 g_statsServiceProxy->ResetIpc();
121
122 double cameraOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_CAMERA_ON);
123 int32_t uid = 10003;
124 int32_t pid = 3458;
125 std::string cameraId = "Camera0";
126
127 StatsWriteHiSysEvent(statsService,
128 HiSysEvent::Domain::CAMERA, StatsHiSysEvent::CAMERA_CONNECT, HiSysEvent::EventType::STATISTIC, "PID", pid,
129 "UID", uid, "ID", cameraId);
130 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
131 StatsWriteHiSysEvent(statsService,
132 HiSysEvent::Domain::CAMERA, StatsHiSysEvent::CAMERA_DISCONNECT, HiSysEvent::EventType::STATISTIC,
133 "ID", cameraId);
134
135 double expectedPower = SERVICE_POWER_CONSUMPTION_DURATION_US * cameraOnAverageMa / US_PER_HOUR;
136 int32_t tempError;
137 double actualPower;
138 g_statsServiceProxy->GetAppStatsMahIpc(uid, actualPower, tempError);
139 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
140 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
141 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
142 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
143 STATS_HILOGI(LABEL_TEST, "StatsServiceCameraTest_002 end");
144 }
145
146 /**
147 * @tc.name: StatsServiceCameraTest_003
148 * @tc.desc: test GetAppStatsPercent function(Camera)
149 * @tc.type: FUNC
150 * @tc.require: issueI663DX
151 */
152 HWTEST_F (StatsServiceCameraTest, StatsServiceCameraTest_003, TestSize.Level0)
153 {
154 STATS_HILOGI(LABEL_TEST, "StatsServiceCameraTest_003 start");
155 ASSERT_NE(g_statsServiceProxy, nullptr);
156 auto statsService = BatteryStatsService::GetInstance();
157 g_statsServiceProxy->ResetIpc();
158
159 int32_t uid = 10003;
160 int32_t pid = 3458;
161 std::string deviceId = "Camera0";
162 double fullPercent = 1;
163 double zeroPercent = 0;
164
165 StatsWriteHiSysEvent(statsService,
166 HiSysEvent::Domain::CAMERA, StatsHiSysEvent::CAMERA_CONNECT, HiSysEvent::EventType::STATISTIC, "PID", pid,
167 "UID", uid, "ID", deviceId);
168 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
169 StatsWriteHiSysEvent(statsService,
170 HiSysEvent::Domain::CAMERA, StatsHiSysEvent::CAMERA_DISCONNECT, HiSysEvent::EventType::STATISTIC,
171 "ID", deviceId);
172 int32_t tempError;
173 double actualPercent;
174 g_statsServiceProxy->GetAppStatsPercentIpc(uid, actualPercent, tempError);
175 GTEST_LOG_(INFO) << __func__ << ": actual percent = " << actualPercent;
176 EXPECT_TRUE(actualPercent >= zeroPercent && actualPercent <= fullPercent);
177 STATS_HILOGI(LABEL_TEST, "StatsServiceCameraTest_003 end");
178 }
179
180 /**
181 * @tc.name: StatsServiceCameraTest_004
182 * @tc.desc: test Reset function(Camera with Flashlight)
183 * @tc.type: FUNC
184 * @tc.require: issueI663DX
185 */
186 HWTEST_F (StatsServiceCameraTest, StatsServiceCameraTest_004, TestSize.Level0)
187 {
188 STATS_HILOGI(LABEL_TEST, "StatsServiceCameraTest_004 start");
189 ASSERT_NE(g_statsServiceProxy, nullptr);
190 auto statsService = BatteryStatsService::GetInstance();
191 g_statsServiceProxy->ResetIpc();
192
193 int32_t uid = 10003;
194 int32_t pid = 3458;
195 std::string cameraId = "Camera0";
196
197 StatsWriteHiSysEvent(statsService,
198 HiSysEvent::Domain::CAMERA, StatsHiSysEvent::CAMERA_CONNECT, HiSysEvent::EventType::STATISTIC, "PID", pid,
199 "UID", uid, "ID", cameraId);
200 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
201 StatsWriteHiSysEvent(statsService,
202 HiSysEvent::Domain::CAMERA, StatsHiSysEvent::FLASHLIGHT_ON, HiSysEvent::EventType::STATISTIC);
203 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
204 StatsWriteHiSysEvent(statsService,
205 HiSysEvent::Domain::CAMERA, StatsHiSysEvent::FLASHLIGHT_OFF, HiSysEvent::EventType::STATISTIC);
206 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
207 StatsWriteHiSysEvent(statsService,
208 HiSysEvent::Domain::CAMERA, StatsHiSysEvent::CAMERA_DISCONNECT, HiSysEvent::EventType::STATISTIC,
209 "ID", cameraId);
210 int32_t tempError;
211 double powerMahBefore;
212 g_statsServiceProxy->GetAppStatsMahIpc(uid, powerMahBefore, tempError);
213 g_statsServiceProxy->ResetIpc();
214 double powerMahAfter;
215 g_statsServiceProxy->GetAppStatsMahIpc(uid, powerMahAfter, tempError);
216 GTEST_LOG_(INFO) << __func__ << ": before consumption = " << powerMahBefore << " mAh";
217 GTEST_LOG_(INFO) << __func__ << ": after consumption = " << powerMahAfter << " mAh";
218 EXPECT_TRUE(powerMahBefore >= StatsUtils::DEFAULT_VALUE && powerMahAfter == StatsUtils::DEFAULT_VALUE);
219 STATS_HILOGI(LABEL_TEST, "StatsServiceCameraTest_004 end");
220 }
221
222 /**
223 * @tc.name: StatsServiceCameraTest_005
224 * @tc.desc: test GetAppStatsMah function(Camera with Flashlight)
225 * @tc.type: FUNC
226 * @tc.require: issueI663DX
227 */
228 HWTEST_F (StatsServiceCameraTest, StatsServiceCameraTest_005, TestSize.Level0)
229 {
230 STATS_HILOGI(LABEL_TEST, "StatsServiceCameraTest_005 start");
231 ASSERT_NE(g_statsServiceProxy, nullptr);
232 auto statsService = BatteryStatsService::GetInstance();
233 g_statsServiceProxy->ResetIpc();
234
235 double cameraOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_CAMERA_ON);
236 double flashlightOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_FLASHLIGHT_ON);
237 int32_t uid = 10003;
238 int32_t pid = 3458;
239 std::string cameraId = "Camera0";
240
241 StatsWriteHiSysEvent(statsService,
242 HiSysEvent::Domain::CAMERA, StatsHiSysEvent::CAMERA_CONNECT, HiSysEvent::EventType::STATISTIC, "PID", pid,
243 "UID", uid, "ID", cameraId);
244 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
245 StatsWriteHiSysEvent(statsService,
246 HiSysEvent::Domain::CAMERA, StatsHiSysEvent::FLASHLIGHT_ON, HiSysEvent::EventType::STATISTIC);
247 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
248 StatsWriteHiSysEvent(statsService,
249 HiSysEvent::Domain::CAMERA, StatsHiSysEvent::FLASHLIGHT_OFF, HiSysEvent::EventType::STATISTIC);
250 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
251 StatsWriteHiSysEvent(statsService,
252 HiSysEvent::Domain::CAMERA, StatsHiSysEvent::CAMERA_DISCONNECT, HiSysEvent::EventType::STATISTIC,
253 "ID", cameraId);
254
255 double expectedPower = (3 * SERVICE_POWER_CONSUMPTION_DURATION_US * cameraOnAverageMa / US_PER_HOUR) +
256 (SERVICE_POWER_CONSUMPTION_DURATION_US * flashlightOnAverageMa / US_PER_HOUR);
257 int32_t tempError;
258 double actualPower;
259 g_statsServiceProxy->GetAppStatsMahIpc(uid, actualPower, tempError);
260 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
261 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
262 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
263 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
264 STATS_HILOGI(LABEL_TEST, "StatsServiceCameraTest_005 end");
265 }
266
267 /**
268 * @tc.name: StatsServiceCameraTest_006
269 * @tc.desc: test GetAppStatsPercent function(Camera with Flashlight)
270 * @tc.type: FUNC
271 * @tc.require: issueI663DX
272 */
273 HWTEST_F (StatsServiceCameraTest, StatsServiceCameraTest_006, TestSize.Level0)
274 {
275 STATS_HILOGI(LABEL_TEST, "StatsServiceCameraTest_006 start");
276 ASSERT_NE(g_statsServiceProxy, nullptr);
277 auto statsService = BatteryStatsService::GetInstance();
278 g_statsServiceProxy->ResetIpc();
279
280 int32_t uid = 10003;
281 int32_t pid = 3458;
282 std::string cameraId = "Camera0";
283 double fullPercent = 1;
284 double zeroPercent = 0;
285
286 StatsWriteHiSysEvent(statsService,
287 HiSysEvent::Domain::CAMERA, StatsHiSysEvent::CAMERA_CONNECT, HiSysEvent::EventType::STATISTIC, "PID", pid,
288 "UID", uid, "ID", cameraId);
289 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
290 StatsWriteHiSysEvent(statsService,
291 HiSysEvent::Domain::CAMERA, StatsHiSysEvent::FLASHLIGHT_ON, HiSysEvent::EventType::STATISTIC);
292 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
293 StatsWriteHiSysEvent(statsService,
294 HiSysEvent::Domain::CAMERA, StatsHiSysEvent::FLASHLIGHT_OFF, HiSysEvent::EventType::STATISTIC);
295 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
296 StatsWriteHiSysEvent(statsService,
297 HiSysEvent::Domain::CAMERA, StatsHiSysEvent::CAMERA_DISCONNECT, HiSysEvent::EventType::STATISTIC,
298 "ID", cameraId);
299
300 int32_t tempError;
301 double actualPercent;
302 g_statsServiceProxy->GetAppStatsPercentIpc(uid, actualPercent, tempError);
303 GTEST_LOG_(INFO) << __func__ << ": actual percent = " << actualPercent;
304 EXPECT_TRUE(actualPercent >= zeroPercent && actualPercent <= fullPercent);
305 STATS_HILOGI(LABEL_TEST, "StatsServiceCameraTest_006 end");
306 }
307
308 /**
309 * @tc.name: StatsServiceCameraTest_007
310 * @tc.desc: test Reset function, The same Uid triggers the camera(different id) continuously
311 * @tc.type: FUNC
312 * @tc.require: issueI663DX
313 */
314 HWTEST_F (StatsServiceCameraTest, StatsServiceCameraTest_007, TestSize.Level0)
315 {
316 STATS_HILOGI(LABEL_TEST, "StatsServiceCameraTest_007 start");
317 ASSERT_NE(g_statsServiceProxy, nullptr);
318 auto statsService = BatteryStatsService::GetInstance();
319 g_statsServiceProxy->ResetIpc();
320
321 int32_t uid = 10003;
322 int32_t pid = 3458;
323 std::string cameraId0 = "Camera0";
324 std::string cameraId1 = "Camera1";
325
326 StatsWriteHiSysEvent(statsService,
327 HiSysEvent::Domain::CAMERA, StatsHiSysEvent::CAMERA_CONNECT, HiSysEvent::EventType::STATISTIC, "PID", pid,
328 "UID", uid, "ID", cameraId0);
329 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
330 StatsWriteHiSysEvent(statsService,
331 HiSysEvent::Domain::CAMERA, StatsHiSysEvent::CAMERA_DISCONNECT, HiSysEvent::EventType::STATISTIC,
332 "ID", cameraId0);
333 StatsWriteHiSysEvent(statsService,
334 HiSysEvent::Domain::CAMERA, StatsHiSysEvent::CAMERA_CONNECT, HiSysEvent::EventType::STATISTIC, "PID", pid,
335 "UID", uid, "ID", cameraId1);
336 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
337 StatsWriteHiSysEvent(statsService,
338 HiSysEvent::Domain::CAMERA, StatsHiSysEvent::CAMERA_DISCONNECT, HiSysEvent::EventType::STATISTIC,
339 "ID", cameraId1);
340 int32_t tempError;
341 double powerMahBefore;
342 g_statsServiceProxy->GetAppStatsMahIpc(uid, powerMahBefore, tempError);
343 g_statsServiceProxy->ResetIpc();
344 double powerMahAfter;
345 g_statsServiceProxy->GetAppStatsMahIpc(uid, powerMahAfter, tempError);
346 GTEST_LOG_(INFO) << __func__ << ": before consumption = " << powerMahBefore << " mAh";
347 GTEST_LOG_(INFO) << __func__ << ": after consumption = " << powerMahAfter << " mAh";
348 EXPECT_TRUE(powerMahBefore >= StatsUtils::DEFAULT_VALUE && powerMahAfter == StatsUtils::DEFAULT_VALUE);
349 STATS_HILOGI(LABEL_TEST, "StatsServiceCameraTest_007 end");
350 }
351
352 /**
353 * @tc.name: StatsServiceCameraTest_008
354 * @tc.desc: test GetAppStatsMah function, The same Uid triggers the camera(different id) continuously
355 * @tc.type: FUNC
356 * @tc.require: issueI663DX
357 */
358 HWTEST_F (StatsServiceCameraTest, StatsServiceCameraTest_008, TestSize.Level0)
359 {
360 STATS_HILOGI(LABEL_TEST, "StatsServiceCameraTest_008 start");
361 ASSERT_NE(g_statsServiceProxy, nullptr);
362 auto statsService = BatteryStatsService::GetInstance();
363 g_statsServiceProxy->ResetIpc();
364
365 double cameraOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_CAMERA_ON);
366 int32_t uid = 10003;
367 int32_t pid = 3458;
368 std::string cameraId0 = "Camera0";
369 std::string cameraId1 = "Camera1";
370
371 StatsWriteHiSysEvent(statsService,
372 HiSysEvent::Domain::CAMERA, StatsHiSysEvent::CAMERA_CONNECT, HiSysEvent::EventType::STATISTIC, "PID", pid,
373 "UID", uid, "ID", cameraId0);
374 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
375 StatsWriteHiSysEvent(statsService,
376 HiSysEvent::Domain::CAMERA, StatsHiSysEvent::CAMERA_DISCONNECT, HiSysEvent::EventType::STATISTIC,
377 "ID", cameraId0);
378 StatsWriteHiSysEvent(statsService,
379 HiSysEvent::Domain::CAMERA, StatsHiSysEvent::CAMERA_CONNECT, HiSysEvent::EventType::STATISTIC, "PID", pid,
380 "UID", uid, "ID", cameraId1);
381 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
382 StatsWriteHiSysEvent(statsService,
383 HiSysEvent::Domain::CAMERA, StatsHiSysEvent::CAMERA_DISCONNECT, HiSysEvent::EventType::STATISTIC,
384 "ID", cameraId1);
385
386 double expectedPower = 2 * SERVICE_POWER_CONSUMPTION_DURATION_US * cameraOnAverageMa / US_PER_HOUR;
387 int32_t tempError;
388 double actualPower;
389 g_statsServiceProxy->GetAppStatsMahIpc(uid, actualPower, tempError);
390 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
391 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
392 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
393 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
394 STATS_HILOGI(LABEL_TEST, "StatsServiceCameraTest_008 end");
395 }
396
397 /**
398 * @tc.name: StatsServiceCameraTest_009
399 * @tc.desc: test GetAppStatsPercent function, The same Uid triggers the camera(different id) continuously
400 * @tc.type: FUNC
401 * @tc.require: issueI663DX
402 */
403 HWTEST_F (StatsServiceCameraTest, StatsServiceCameraTest_009, TestSize.Level0)
404 {
405 STATS_HILOGI(LABEL_TEST, "StatsServiceCameraTest_009 start");
406 ASSERT_NE(g_statsServiceProxy, nullptr);
407 auto statsService = BatteryStatsService::GetInstance();
408 g_statsServiceProxy->ResetIpc();
409
410 int32_t uid = 10003;
411 int32_t pid = 3458;
412 std::string cameraId0 = "Camera0";
413 std::string cameraId1 = "Camera1";
414 double fullPercent = 1;
415 double zeroPercent = 0;
416
417 StatsWriteHiSysEvent(statsService,
418 HiSysEvent::Domain::CAMERA, StatsHiSysEvent::CAMERA_CONNECT, HiSysEvent::EventType::STATISTIC, "PID", pid,
419 "UID", uid, "ID", cameraId0);
420 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
421 StatsWriteHiSysEvent(statsService,
422 HiSysEvent::Domain::CAMERA, StatsHiSysEvent::CAMERA_DISCONNECT, HiSysEvent::EventType::STATISTIC,
423 "ID", cameraId0);
424 StatsWriteHiSysEvent(statsService,
425 HiSysEvent::Domain::CAMERA, StatsHiSysEvent::CAMERA_CONNECT, HiSysEvent::EventType::STATISTIC, "PID", pid,
426 "UID", uid, "ID", cameraId1);
427 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
428 StatsWriteHiSysEvent(statsService,
429 HiSysEvent::Domain::CAMERA, StatsHiSysEvent::CAMERA_DISCONNECT, HiSysEvent::EventType::STATISTIC,
430 "ID", cameraId1);
431
432 int32_t tempError;
433 double actualPercent;
434 g_statsServiceProxy->GetAppStatsPercentIpc(uid, actualPercent, tempError);
435 GTEST_LOG_(INFO) << __func__ << ": actual percent = " << actualPercent;
436 EXPECT_TRUE(actualPercent >= zeroPercent && actualPercent <= fullPercent);
437 STATS_HILOGI(LABEL_TEST, "StatsServiceCameraTest_009 end");
438 }
439
440 /**
441 * @tc.name: StatsServiceCameraTest_010
442 * @tc.desc: test GetAppStatsMah function
443 * @tc.type: FUNC
444 * @tc.require: issueI663DX
445 */
446 HWTEST_F (StatsServiceCameraTest, StatsServiceCameraTest_010, TestSize.Level0)
447 {
448 STATS_HILOGI(LABEL_TEST, "StatsServiceCameraTest_010 start");
449 ASSERT_NE(g_statsServiceProxy, nullptr);
450 auto statsService = BatteryStatsService::GetInstance();
451 g_statsServiceProxy->ResetIpc();
452
453 double cameraOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_CAMERA_ON);
454 int32_t uid = 10003;
455 int32_t pid = 3458;
456 std::string cameraId0 = "Camera0";
457 std::string cameraId1 = "Camera1";
458
459 StatsWriteHiSysEvent(statsService,
460 HiSysEvent::Domain::CAMERA, StatsHiSysEvent::CAMERA_CONNECT, HiSysEvent::EventType::STATISTIC, "PID", pid,
461 "UID", uid, "ID", cameraId0);
462 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
463 StatsWriteHiSysEvent(statsService,
464 HiSysEvent::Domain::CAMERA, StatsHiSysEvent::CAMERA_CONNECT, HiSysEvent::EventType::STATISTIC, "PID", pid,
465 "UID", uid, "ID", cameraId1);
466 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
467 StatsWriteHiSysEvent(statsService,
468 HiSysEvent::Domain::CAMERA, StatsHiSysEvent::CAMERA_DISCONNECT, HiSysEvent::EventType::STATISTIC,
469 "ID", cameraId1);
470 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
471 StatsWriteHiSysEvent(statsService,
472 HiSysEvent::Domain::CAMERA, StatsHiSysEvent::CAMERA_DISCONNECT, HiSysEvent::EventType::STATISTIC,
473 "ID", cameraId0);
474
475 double expectedPower = 3 * SERVICE_POWER_CONSUMPTION_DURATION_US * cameraOnAverageMa / US_PER_HOUR;
476 int32_t tempError;
477 double actualPower;
478 g_statsServiceProxy->GetAppStatsMahIpc(uid, actualPower, tempError);
479 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
480 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
481 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
482 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
483 STATS_HILOGI(LABEL_TEST, "StatsServiceCameraTest_010 end");
484 }
485
486 /**
487 * @tc.name: StatsServiceCameraTest_011
488 * @tc.desc: test GetAppStatsMah function
489 * @tc.type: FUNC
490 * @tc.require: issueI663DX
491 */
492 HWTEST_F (StatsServiceCameraTest, StatsServiceCameraTest_011, TestSize.Level0)
493 {
494 STATS_HILOGI(LABEL_TEST, "StatsServiceCameraTest_011 start");
495 ASSERT_NE(g_statsServiceProxy, nullptr);
496 auto statsService = BatteryStatsService::GetInstance();
497 g_statsServiceProxy->ResetIpc();
498
499 double cameraOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_CAMERA_ON);
500 int32_t uid1 = 10003;
501 int32_t pid1 = 3458;
502 int32_t uid2 = 10004;
503 int32_t pid2 = 3459;
504 std::string cameraId = "Camera0";
505
506 StatsWriteHiSysEvent(statsService,
507 HiSysEvent::Domain::CAMERA, StatsHiSysEvent::CAMERA_CONNECT, HiSysEvent::EventType::STATISTIC, "PID", pid1,
508 "UID", uid1, "ID", cameraId);
509 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
510 StatsWriteHiSysEvent(statsService,
511 HiSysEvent::Domain::CAMERA, StatsHiSysEvent::CAMERA_CONNECT, HiSysEvent::EventType::STATISTIC, "PID", pid2,
512 "UID", uid2, "ID", cameraId);
513 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
514 StatsWriteHiSysEvent(statsService,
515 HiSysEvent::Domain::CAMERA, StatsHiSysEvent::CAMERA_DISCONNECT, HiSysEvent::EventType::STATISTIC,
516 "ID", cameraId);
517 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
518 StatsWriteHiSysEvent(statsService,
519 HiSysEvent::Domain::CAMERA, StatsHiSysEvent::CAMERA_DISCONNECT, HiSysEvent::EventType::STATISTIC,
520 "ID", cameraId);
521
522 double expectedPower = 2 * SERVICE_POWER_CONSUMPTION_DURATION_US * cameraOnAverageMa / US_PER_HOUR;
523 int32_t tempError;
524 double actualPower;
525 g_statsServiceProxy->GetAppStatsMahIpc(uid1, actualPower, tempError);
526 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
527 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
528 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
529 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
530 STATS_HILOGI(LABEL_TEST, "StatsServiceCameraTest_011 end");
531 }
532
533 /**
534 * @tc.name: StatsServiceCameraTest_012
535 * @tc.desc: test GetAppStatsMah function, Camera-Flashlight is opened when camera closed
536 * @tc.type: FUNC
537 * @tc.require: issueI663DX
538 */
539 HWTEST_F (StatsServiceCameraTest, StatsServiceCameraTest_012, TestSize.Level0)
540 {
541 STATS_HILOGI(LABEL_TEST, "StatsServiceCameraTest_012 start");
542 ASSERT_NE(g_statsServiceProxy, nullptr);
543 auto statsService = BatteryStatsService::GetInstance();
544 g_statsServiceProxy->ResetIpc();
545
546 int32_t uid = 10003;
547
548 StatsWriteHiSysEvent(statsService,
549 HiSysEvent::Domain::CAMERA, StatsHiSysEvent::FLASHLIGHT_ON, HiSysEvent::EventType::STATISTIC);
550 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
551 StatsWriteHiSysEvent(statsService,
552 HiSysEvent::Domain::CAMERA, StatsHiSysEvent::FLASHLIGHT_OFF, HiSysEvent::EventType::STATISTIC);
553
554 int32_t tempError;
555 double actualPower;
556 g_statsServiceProxy->GetAppStatsMahIpc(uid, actualPower, tempError);
557 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
558 EXPECT_TRUE(actualPower >= StatsUtils::DEFAULT_VALUE);
559 STATS_HILOGI(LABEL_TEST, "StatsServiceCameraTest_012 end");
560 }
561
562 /**
563 * @tc.name: StatsServiceCameraTest_013
564 * @tc.desc: test GetAppStatsMah function
565 * @tc.type: FUNC
566 * @tc.require: issueI663DX
567 */
568 HWTEST_F (StatsServiceCameraTest, StatsServiceCameraTest_013, TestSize.Level0)
569 {
570 STATS_HILOGI(LABEL_TEST, "StatsServiceCameraTest_013 start");
571 ASSERT_NE(g_statsServiceProxy, nullptr);
572 auto statsService = BatteryStatsService::GetInstance();
573 g_statsServiceProxy->ResetIpc();
574
575 double cameraOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_CAMERA_ON);
576 double flashlightOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_FLASHLIGHT_ON);
577 int32_t uid = 10003;
578 int32_t pid = 3458;
579 std::string cameraId = "Camera0";
580
581 StatsWriteHiSysEvent(statsService,
582 HiSysEvent::Domain::CAMERA, StatsHiSysEvent::CAMERA_CONNECT, HiSysEvent::EventType::STATISTIC, "PID", pid,
583 "UID", uid, "ID", cameraId);
584 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
585 StatsWriteHiSysEvent(statsService,
586 HiSysEvent::Domain::CAMERA, StatsHiSysEvent::FLASHLIGHT_ON, HiSysEvent::EventType::STATISTIC);
587 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
588 StatsWriteHiSysEvent(statsService,
589 HiSysEvent::Domain::CAMERA, StatsHiSysEvent::CAMERA_DISCONNECT,
590 HiSysEvent::EventType::STATISTIC, "ID", cameraId);
591 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
592
593 double expectedPower = (2 * SERVICE_POWER_CONSUMPTION_DURATION_US * cameraOnAverageMa / US_PER_HOUR) +
594 (SERVICE_POWER_CONSUMPTION_DURATION_US * flashlightOnAverageMa / US_PER_HOUR);
595 int32_t tempError;
596 double actualPower;
597 g_statsServiceProxy->GetAppStatsMahIpc(uid, actualPower, tempError);
598 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
599 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
600 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
601 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
602 STATS_HILOGI(LABEL_TEST, "StatsServiceCameraTest_013 end");
603 }
604
605 /**
606 * @tc.name: StatsServiceCameraTest_014
607 * @tc.desc: test Reset function(Torch)
608 * @tc.type: FUNC
609 * @tc.require: issueI663DX
610 */
611 HWTEST_F (StatsServiceCameraTest, StatsServiceCameraTest_014, TestSize.Level0)
612 {
613 STATS_HILOGI(LABEL_TEST, "StatsServiceCameraTest_014 start");
614 ASSERT_NE(g_statsServiceProxy, nullptr);
615 auto statsService = BatteryStatsService::GetInstance();
616 g_statsServiceProxy->ResetIpc();
617
618 int32_t uid = 10003;
619 int32_t pid = 3458;
620 int32_t stateOn = 1;
621 int32_t stateOff = 0;
622
623 StatsWriteHiSysEvent(statsService,
624 HiSysEvent::Domain::CAMERA, StatsHiSysEvent::TORCH_STATE, HiSysEvent::EventType::STATISTIC, "PID", pid,
625 "UID", uid, "STATE", stateOn);
626 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
627 StatsWriteHiSysEvent(statsService,
628 HiSysEvent::Domain::CAMERA, StatsHiSysEvent::TORCH_STATE, HiSysEvent::EventType::STATISTIC, "PID", pid,
629 "UID", uid, "STATE", stateOff);
630 int32_t tempError;
631 double powerMahBefore;
632 g_statsServiceProxy->GetAppStatsMahIpc(uid, powerMahBefore, tempError);
633 g_statsServiceProxy->ResetIpc();
634 double powerMahAfter;
635 g_statsServiceProxy->GetAppStatsMahIpc(uid, powerMahAfter, tempError);
636 GTEST_LOG_(INFO) << __func__ << ": before consumption = " << powerMahBefore << " mAh";
637 GTEST_LOG_(INFO) << __func__ << ": after consumption = " << powerMahAfter << " mAh";
638 EXPECT_TRUE(powerMahBefore >= StatsUtils::DEFAULT_VALUE && powerMahAfter == StatsUtils::DEFAULT_VALUE);
639 STATS_HILOGI(LABEL_TEST, "StatsServiceCameraTest_014 end");
640 }
641
642 /**
643 * @tc.name: StatsServiceCameraTest_015
644 * @tc.desc: test GetAppStatsMah function(Torch)
645 * @tc.type: FUNC
646 * @tc.require: issueI663DX
647 */
648 HWTEST_F (StatsServiceCameraTest, StatsServiceCameraTest_015, TestSize.Level0)
649 {
650 STATS_HILOGI(LABEL_TEST, "StatsServiceCameraTest_015 start");
651 ASSERT_NE(g_statsServiceProxy, nullptr);
652 auto statsService = BatteryStatsService::GetInstance();
653 g_statsServiceProxy->ResetIpc();
654
655 double flashlightOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_FLASHLIGHT_ON);
656 int32_t uid = 10003;
657 int32_t pid = 3458;
658 int32_t stateOn = 1;
659 int32_t stateOff = 0;
660
661 StatsWriteHiSysEvent(statsService,
662 HiSysEvent::Domain::CAMERA, StatsHiSysEvent::TORCH_STATE, HiSysEvent::EventType::STATISTIC, "PID", pid,
663 "UID", uid, "STATE", stateOn);
664 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
665 StatsWriteHiSysEvent(statsService,
666 HiSysEvent::Domain::CAMERA, StatsHiSysEvent::TORCH_STATE, HiSysEvent::EventType::STATISTIC, "PID", pid,
667 "UID", uid, "STATE", stateOff);
668
669 double expectedPower = SERVICE_POWER_CONSUMPTION_DURATION_US * flashlightOnAverageMa / US_PER_HOUR;
670 int32_t tempError;
671 double actualPower;
672 g_statsServiceProxy->GetAppStatsMahIpc(uid, actualPower, tempError);
673 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
674 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
675 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
676 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
677 STATS_HILOGI(LABEL_TEST, "StatsServiceCameraTest_015 end");
678 }
679
680 /**
681 * @tc.name: StatsServiceCameraTest_016
682 * @tc.desc: test GetAppStatsPercent function(Torch)
683 * @tc.type: FUNC
684 * @tc.require: issueI663DX
685 */
686 HWTEST_F (StatsServiceCameraTest, StatsServiceCameraTest_016, TestSize.Level0)
687 {
688 STATS_HILOGI(LABEL_TEST, "StatsServiceCameraTest_016 start");
689 ASSERT_NE(g_statsServiceProxy, nullptr);
690 auto statsService = BatteryStatsService::GetInstance();
691 g_statsServiceProxy->ResetIpc();
692
693 int32_t uid = 10003;
694 int32_t pid = 3458;
695 int32_t stateOn = 1;
696 int32_t stateOff = 0;
697 double fullPercent = 1;
698 double zeroPercent = 0;
699
700 StatsWriteHiSysEvent(statsService,
701 HiSysEvent::Domain::CAMERA, StatsHiSysEvent::TORCH_STATE, HiSysEvent::EventType::STATISTIC, "PID", pid,
702 "UID", uid, "STATE", stateOn);
703 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
704 StatsWriteHiSysEvent(statsService,
705 HiSysEvent::Domain::CAMERA, StatsHiSysEvent::TORCH_STATE, HiSysEvent::EventType::STATISTIC, "PID", pid,
706 "UID", uid, "STATE", stateOff);
707 int32_t tempError;
708 double actualPercent;
709 g_statsServiceProxy->GetAppStatsPercentIpc(uid, actualPercent, tempError);
710 GTEST_LOG_(INFO) << __func__ << ": actual percent = " << actualPercent;
711 EXPECT_TRUE(actualPercent >= zeroPercent && actualPercent <= fullPercent);
712 STATS_HILOGI(LABEL_TEST, "StatsServiceCameraTest_016 end");
713 }
714
715 /**
716 * @tc.name: StatsServiceCameraTest_017
717 * @tc.desc: test GetAppStatsMah(Torch) and GetAppStatsPercent(Camera) function
718 * @tc.type: FUNC
719 * @tc.require: issueI663DX
720 */
721 HWTEST_F (StatsServiceCameraTest, StatsServiceCameraTest_017, TestSize.Level0)
722 {
723 STATS_HILOGI(LABEL_TEST, "StatsServiceCameraTest_017 start");
724 ASSERT_NE(g_statsServiceProxy, nullptr);
725 auto statsService = BatteryStatsService::GetInstance();
726 g_statsServiceProxy->ResetIpc();
727
728 double flashlightOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_FLASHLIGHT_ON);
729 int32_t uid = 10003;
730 int32_t pid = 3458;
731 int32_t stateOn = 1;
732 int32_t stateOff = 0;
733
734 StatsWriteHiSysEvent(statsService,
735 HiSysEvent::Domain::CAMERA, StatsHiSysEvent::TORCH_STATE, HiSysEvent::EventType::STATISTIC, "PID", pid,
736 "UID", uid, "STATE", stateOn);
737 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
738 StatsWriteHiSysEvent(statsService,
739 HiSysEvent::Domain::CAMERA, StatsHiSysEvent::TORCH_STATE, HiSysEvent::EventType::STATISTIC, "PID", pid,
740 "UID", uid, "STATE", stateOff);
741
742 double expectedPower = SERVICE_POWER_CONSUMPTION_DURATION_US * flashlightOnAverageMa / US_PER_HOUR;
743 int32_t tempError;
744 double actualPower;
745 g_statsServiceProxy->GetAppStatsMahIpc(uid, actualPower, tempError);
746 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
747 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
748 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
749 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
750
751 uid = 10004;
752 pid = 3459;
753 std::string deviceId = "Camera0";
754 double fullPercent = 1;
755 double zeroPercent = 0;
756
757 StatsWriteHiSysEvent(statsService,
758 HiSysEvent::Domain::CAMERA, StatsHiSysEvent::CAMERA_CONNECT, HiSysEvent::EventType::STATISTIC, "PID", pid,
759 "UID", uid, "ID", deviceId);
760 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
761 StatsWriteHiSysEvent(statsService,
762 HiSysEvent::Domain::CAMERA, StatsHiSysEvent::CAMERA_DISCONNECT, HiSysEvent::EventType::STATISTIC,
763 "ID", deviceId);
764 double actualPercent;
765 g_statsServiceProxy->GetAppStatsPercentIpc(uid, actualPercent, tempError);
766 GTEST_LOG_(INFO) << __func__ << ": actual percent = " << actualPercent;
767 EXPECT_TRUE(actualPercent >= zeroPercent && actualPercent <= fullPercent);
768 STATS_HILOGI(LABEL_TEST, "StatsServiceCameraTest_017 end");
769 }
770
771 /**
772 * @tc.name: StatsServiceCameraTest_018
773 * @tc.desc: test GetAppStatsMah(Camera) and GetAppStatsPercent(Audio) function
774 * @tc.type: FUNC
775 * @tc.require: issueI663DX
776 */
777 HWTEST_F (StatsServiceCameraTest, StatsServiceCameraTest_018, TestSize.Level0)
778 {
779 STATS_HILOGI(LABEL_TEST, "StatsServiceCameraTest_018 start");
780 ASSERT_NE(g_statsServiceProxy, nullptr);
781 auto statsService = BatteryStatsService::GetInstance();
782 g_statsServiceProxy->ResetIpc();
783
784 double cameraOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_CAMERA_ON);
785 int32_t uid = 10003;
786 int32_t pid = 3458;
787 std::string deviceId = "Camera0";
788
789 StatsWriteHiSysEvent(statsService,
790 HiSysEvent::Domain::CAMERA, StatsHiSysEvent::CAMERA_CONNECT, HiSysEvent::EventType::STATISTIC, "PID", pid,
791 "UID", uid, "ID", deviceId);
792 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
793 StatsWriteHiSysEvent(statsService,
794 HiSysEvent::Domain::CAMERA, StatsHiSysEvent::CAMERA_DISCONNECT, HiSysEvent::EventType::STATISTIC,
795 "ID", deviceId);
796
797 double expectedPower = SERVICE_POWER_CONSUMPTION_DURATION_US * cameraOnAverageMa / US_PER_HOUR;
798 int32_t tempError;
799 double actualPower;
800 g_statsServiceProxy->GetAppStatsMahIpc(uid, actualPower, tempError);
801 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
802 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
803 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
804 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
805
806 uid = 10004;
807 pid = 3459;
808 int32_t stateRunning = 2;
809 int32_t stateStopped = 3;
810 double fullPercent = 1;
811 double zeroPercent = 0;
812
813 StatsWriteHiSysEvent(statsService,
814 HiSysEvent::Domain::AUDIO, StatsHiSysEvent::STREAM_CHANGE, HiSysEvent::EventType::BEHAVIOR, "PID", pid,
815 "UID", uid, "STATE", stateRunning);
816 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
817 StatsWriteHiSysEvent(statsService,
818 HiSysEvent::Domain::AUDIO, StatsHiSysEvent::STREAM_CHANGE, HiSysEvent::EventType::BEHAVIOR, "PID", pid,
819 "UID", uid, "STATE", stateStopped);
820 double actualPercent;
821 g_statsServiceProxy->GetAppStatsPercentIpc(uid, actualPercent, tempError);
822 GTEST_LOG_(INFO) << __func__ << ": actual percent = " << actualPercent;
823 EXPECT_TRUE(actualPercent >= zeroPercent && actualPercent <= fullPercent);
824 STATS_HILOGI(LABEL_TEST, "StatsServiceCameraTest_018 end");
825 }
826
827 /**
828 * @tc.name: StatsServiceCameraTest_019
829 * @tc.desc: test camera entity GetPartStatsMah function(Camera)
830 * @tc.type: FUNC
831 * @tc.require: issueI663DX
832 */
833 HWTEST_F (StatsServiceCameraTest, StatsServiceCameraTest_019, TestSize.Level0)
834 {
835 STATS_HILOGI(LABEL_TEST, "StatsServiceCameraTest_019 start");
836 ASSERT_NE(g_statsServiceProxy, nullptr);
837 auto statsService = BatteryStatsService::GetInstance();
838 g_statsServiceProxy->ResetIpc();
839
840 double cameraOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_CAMERA_ON);
841 int32_t uid = 10003;
842 int32_t pid = 3458;
843 std::string cameraId = "Camera0";
844
845 StatsWriteHiSysEvent(statsService,
846 HiSysEvent::Domain::CAMERA, StatsHiSysEvent::CAMERA_CONNECT, HiSysEvent::EventType::STATISTIC, "PID", pid,
847 "UID", uid, "ID", cameraId);
848 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
849 StatsWriteHiSysEvent(statsService,
850 HiSysEvent::Domain::CAMERA, StatsHiSysEvent::CAMERA_DISCONNECT, HiSysEvent::EventType::STATISTIC,
851 "ID", cameraId);
852
853 auto statsCore = statsService->GetBatteryStatsCore();
854 auto cameraEntity = statsCore->GetEntity(BatteryStatsInfo::CONSUMPTION_TYPE_CAMERA);
855 statsCore->ComputePower();
856
857 double expectedPower = SERVICE_POWER_CONSUMPTION_DURATION_US * cameraOnAverageMa / US_PER_HOUR;
858 double actualPower = cameraEntity->GetStatsPowerMah(StatsUtils::STATS_TYPE_CAMERA_ON, uid);
859 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
860 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
861 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
862 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
863
864 EXPECT_EQ(StatsUtils::DEFAULT_VALUE, cameraEntity->GetStatsPowerMah(StatsUtils::STATS_TYPE_CAMERA_ON));
865 EXPECT_EQ(StatsUtils::DEFAULT_VALUE, cameraEntity->GetStatsPowerMah(StatsUtils::STATS_TYPE_INVALID, uid));
866 STATS_HILOGI(LABEL_TEST, "StatsServiceCameraTest_019 end");
867 }
868
869 /**
870 * @tc.name: StatsServiceCameraTest_020
871 * @tc.desc: test flashlight entity GetPartStatsMah function(Torch)
872 * @tc.type: FUNC
873 * @tc.require: issueI663DX
874 */
875 HWTEST_F (StatsServiceCameraTest, StatsServiceCameraTest_020, TestSize.Level0)
876 {
877 STATS_HILOGI(LABEL_TEST, "StatsServiceCameraTest_020 start");
878 ASSERT_NE(g_statsServiceProxy, nullptr);
879 auto statsService = BatteryStatsService::GetInstance();
880 g_statsServiceProxy->ResetIpc();
881
882 double flashlightOnAverageMa = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_FLASHLIGHT_ON);
883 int32_t uid = 10003;
884 int32_t pid = 3458;
885 int32_t stateOn = 1;
886 int32_t stateOff = 0;
887
888 StatsWriteHiSysEvent(statsService,
889 HiSysEvent::Domain::CAMERA, StatsHiSysEvent::TORCH_STATE, HiSysEvent::EventType::STATISTIC, "PID", pid,
890 "UID", uid, "STATE", stateOn);
891 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
892 StatsWriteHiSysEvent(statsService,
893 HiSysEvent::Domain::CAMERA, StatsHiSysEvent::TORCH_STATE, HiSysEvent::EventType::STATISTIC, "PID", pid,
894 "UID", uid, "STATE", stateOff);
895
896 auto statsCore = statsService->GetBatteryStatsCore();
897 auto flashlightEntity = statsCore->GetEntity(BatteryStatsInfo::CONSUMPTION_TYPE_FLASHLIGHT);
898 statsCore->ComputePower();
899
900 double expectedPower = SERVICE_POWER_CONSUMPTION_DURATION_US * flashlightOnAverageMa / US_PER_HOUR;
901 double actualPower = flashlightEntity->GetStatsPowerMah(StatsUtils::STATS_TYPE_FLASHLIGHT_ON, uid);
902 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
903 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
904 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
905 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
906
907 EXPECT_EQ(StatsUtils::DEFAULT_VALUE, flashlightEntity->GetStatsPowerMah(StatsUtils::STATS_TYPE_FLASHLIGHT_ON));
908 EXPECT_EQ(StatsUtils::DEFAULT_VALUE, flashlightEntity->GetStatsPowerMah(StatsUtils::STATS_TYPE_INVALID, uid));
909 STATS_HILOGI(LABEL_TEST, "StatsServiceCameraTest_020 end");
910 }
911
912 /**
913 * @tc.name: StatsServiceCameraTest_021
914 * @tc.desc: test send hisysevent with missing information(Camera & Flashlight)
915 * @tc.type: FUNC
916 * @tc.require: issueI663DX
917 */
918 HWTEST_F (StatsServiceCameraTest, StatsServiceCameraTest_021, TestSize.Level0)
919 {
920 STATS_HILOGI(LABEL_TEST, "StatsServiceCameraTest_021 start");
921 ASSERT_NE(g_statsServiceProxy, nullptr);
922 auto statsService = BatteryStatsService::GetInstance();
923 g_statsServiceProxy->ResetIpc();
924
925 int32_t uid = 10003;
926 StatsWriteHiSysEvent(statsService, HiSysEvent::Domain::CAMERA, StatsHiSysEvent::CAMERA_CONNECT,
927 HiSysEvent::EventType::STATISTIC);
928 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
929 StatsWriteHiSysEvent(statsService,
930 HiSysEvent::Domain::CAMERA, StatsHiSysEvent::CAMERA_DISCONNECT, HiSysEvent::EventType::STATISTIC);
931
932 StatsWriteHiSysEvent(statsService, HiSysEvent::Domain::CAMERA, StatsHiSysEvent::TORCH_STATE,
933 HiSysEvent::EventType::STATISTIC);
934 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
935 StatsWriteHiSysEvent(statsService, HiSysEvent::Domain::CAMERA, StatsHiSysEvent::TORCH_STATE,
936 HiSysEvent::EventType::STATISTIC);
937
938 double expectedPower = StatsUtils::DEFAULT_VALUE;
939 int32_t tempError;
940 double actualPower;
941 g_statsServiceProxy->GetAppStatsMahIpc(uid, actualPower, tempError);
942 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
943 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
944 EXPECT_EQ(expectedPower, actualPower);
945 STATS_HILOGI(LABEL_TEST, "StatsServiceCameraTest_021 end");
946 }
947 }