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