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