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_display_test.h"
17 
18 #include <display_power_info.h>
19 #include <hisysevent.h>
20 
21 #include "battery_stats_listener.h"
22 #include "battery_stats_service.h"
23 #include "hisysevent_operation.h"
24 #include "power_mgr_client.h"
25 #include "stats_hisysevent.h"
26 #include "stats_service_test_proxy.h"
27 #include "stats_service_write_event.h"
28 
29 using namespace OHOS;
30 using namespace testing::ext;
31 using namespace OHOS::HiviewDFX;
32 using namespace OHOS::PowerMgr;
33 using namespace std;
34 
35 namespace {
36 static sptr<BatteryStatsService> g_statsService = nullptr;
37 static std::shared_ptr<StatsServiceTestProxy> g_statsServiceProxy = nullptr;
38 } // namespace
39 
SetLastBrightness(int32_t lastBrightness)40 static void SetLastBrightness(int32_t lastBrightness)
41 {
42     auto statsService = BatteryStatsService::GetInstance();
43     int32_t stateOn = static_cast<int32_t>(OHOS::DisplayPowerMgr::DisplayState::DISPLAY_ON);
44     int32_t stateOff = static_cast<int32_t>(OHOS::DisplayPowerMgr::DisplayState::DISPLAY_OFF);
45 
46     GTEST_LOG_(INFO) << __func__ << ": Set last screen brightness value = " << lastBrightness;
47     StatsWriteHiSysEvent(statsService,
48         HiSysEvent::Domain::DISPLAY, StatsHiSysEvent::SCREEN_STATE,
49         HiSysEvent::EventType::STATISTIC, "STATE", stateOn);
50     StatsWriteHiSysEvent(statsService,
51         HiSysEvent::Domain::DISPLAY, StatsHiSysEvent::BRIGHTNESS_NIT,
52         HiSysEvent::EventType::STATISTIC, "BRIGHTNESS", lastBrightness);
53     usleep(StatsTest::SERVICE_POWER_CONSUMPTION_DURATION_US);
54     StatsWriteHiSysEvent(statsService,
55         HiSysEvent::Domain::DISPLAY, StatsHiSysEvent::SCREEN_STATE,
56         HiSysEvent::EventType::STATISTIC, "STATE", stateOff);
57 
58     GTEST_LOG_(INFO) << __func__ << ": Battery stats client reset";
59     g_statsServiceProxy->Reset();
60 }
61 
SetUpTestCase()62 void StatsServiceDisplayTest::SetUpTestCase()
63 {
64     ParserAveragePowerFile();
65     g_statsService = BatteryStatsService::GetInstance();
66     g_statsService->OnStart();
67 
68     if (g_statsService->listenerPtr_ == nullptr) {
69         g_statsService->listenerPtr_ = std::make_shared<BatteryStatsListener>();
70     }
71 
72     if (g_statsServiceProxy == nullptr) {
73         g_statsServiceProxy = std::make_shared<StatsServiceTestProxy>(g_statsService);
74     }
75 
76     auto& pms = PowerMgrClient::GetInstance();
77     pms.SuspendDevice();
78 }
79 
TearDownTestCase()80 void StatsServiceDisplayTest::TearDownTestCase()
81 {
82     g_statsService->listenerPtr_ = nullptr;
83     g_statsService->OnStop();
84 }
85 
SetUp()86 void StatsServiceDisplayTest::SetUp()
87 {
88     auto statsService = BatteryStatsService::GetInstance();
89     statsService->SetOnBattery(true);
90 }
91 
TearDown()92 void StatsServiceDisplayTest::TearDown()
93 {
94     auto statsService = BatteryStatsService::GetInstance();
95     statsService->SetOnBattery(false);
96 }
97 
98 namespace {
99 /**
100  * @tc.name: StatsServiceDisplayTest_001
101  * @tc.desc: test Reset function(Screen)
102  * @tc.type: FUNC
103  * @tc.require: issueI663DX
104  */
105 HWTEST_F (StatsServiceDisplayTest, StatsServiceDisplayTest_001, TestSize.Level0)
106 {
107     ASSERT_NE(g_statsServiceProxy, nullptr);
108     auto statsService = BatteryStatsService::GetInstance();
109     g_statsServiceProxy->Reset();
110 
111     int32_t stateOn = static_cast<int32_t>(OHOS::DisplayPowerMgr::DisplayState::DISPLAY_ON);
112     int32_t stateOff = static_cast<int32_t>(OHOS::DisplayPowerMgr::DisplayState::DISPLAY_OFF);
113     int32_t brightness = 100;
114 
115     StatsWriteHiSysEvent(statsService,
116         HiSysEvent::Domain::DISPLAY, StatsHiSysEvent::SCREEN_STATE,
117         HiSysEvent::EventType::STATISTIC, "STATE", stateOn);
118     StatsWriteHiSysEvent(statsService,
119         HiSysEvent::Domain::DISPLAY, StatsHiSysEvent::BRIGHTNESS_NIT,
120         HiSysEvent::EventType::STATISTIC, "BRIGHTNESS", brightness);
121     usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
122     StatsWriteHiSysEvent(statsService,
123         HiSysEvent::Domain::DISPLAY, StatsHiSysEvent::SCREEN_STATE,
124         HiSysEvent::EventType::STATISTIC, "STATE", stateOff);
125 
126     double powerMahBefore = g_statsServiceProxy->GetPartStatsMah(BatteryStatsInfo::CONSUMPTION_TYPE_SCREEN);
127     g_statsServiceProxy->Reset();
128     double powerMahAfter = g_statsServiceProxy->GetPartStatsMah(BatteryStatsInfo::CONSUMPTION_TYPE_SCREEN);
129     GTEST_LOG_(INFO) << __func__ << ": before consumption = " << powerMahBefore << " mAh";
130     GTEST_LOG_(INFO) << __func__ << ": after consumption = " << powerMahAfter << " mAh";
131     EXPECT_TRUE(powerMahBefore >= StatsUtils::DEFAULT_VALUE && powerMahAfter == StatsUtils::DEFAULT_VALUE);
132 }
133 
134 /**
135  * @tc.name: StatsServiceDisplayTest_002
136  * @tc.desc: test SetOnBattery function(Screen)
137  * @tc.type: FUNC
138  * @tc.require: issueI663DX
139  */
140 HWTEST_F (StatsServiceDisplayTest, StatsServiceDisplayTest_002, TestSize.Level0)
141 {
142     ASSERT_NE(g_statsServiceProxy, nullptr);
143     auto statsService = BatteryStatsService::GetInstance();
144     g_statsServiceProxy->Reset();
145     g_statsServiceProxy->SetOnBattery(false);
146 
147     int32_t stateOn = static_cast<int32_t>(OHOS::DisplayPowerMgr::DisplayState::DISPLAY_ON);
148     int32_t stateOff = static_cast<int32_t>(OHOS::DisplayPowerMgr::DisplayState::DISPLAY_OFF);
149     int32_t brightness = 120;
150 
151     StatsWriteHiSysEvent(statsService,
152         HiSysEvent::Domain::DISPLAY, StatsHiSysEvent::SCREEN_STATE,
153         HiSysEvent::EventType::STATISTIC, "STATE", stateOn);
154     StatsWriteHiSysEvent(statsService,
155         HiSysEvent::Domain::DISPLAY, StatsHiSysEvent::BRIGHTNESS_NIT,
156         HiSysEvent::EventType::STATISTIC, "BRIGHTNESS", brightness);
157     usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
158     StatsWriteHiSysEvent(statsService,
159         HiSysEvent::Domain::DISPLAY, StatsHiSysEvent::SCREEN_STATE,
160         HiSysEvent::EventType::STATISTIC, "STATE", stateOff);
161 
162     double expectedPower = StatsUtils::DEFAULT_VALUE;
163     double actualPower = g_statsServiceProxy->GetPartStatsMah(BatteryStatsInfo::CONSUMPTION_TYPE_SCREEN);
164     GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
165     GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
166     EXPECT_EQ(expectedPower, actualPower);
167     g_statsServiceProxy->SetOnBattery(true);
168 }
169 
170 /**
171  * @tc.name: StatsServiceDisplayTest_003
172  * @tc.desc: test GetPartStatsMah function(Screen)
173  * @tc.type: FUNC
174  * @tc.require: issueI663DX
175  */
176 HWTEST_F (StatsServiceDisplayTest, StatsServiceDisplayTest_003, TestSize.Level0)
177 {
178     ASSERT_NE(g_statsServiceProxy, nullptr);
179     auto statsService = BatteryStatsService::GetInstance();
180     g_statsServiceProxy->Reset();
181 
182     int32_t stateOn = static_cast<int32_t>(OHOS::DisplayPowerMgr::DisplayState::DISPLAY_ON);
183     int32_t stateOff = static_cast<int32_t>(OHOS::DisplayPowerMgr::DisplayState::DISPLAY_OFF);
184     int32_t brightness = 100;
185     double screenOnAverage = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_SCREEN_ON);
186     double screenBrightnessAverage = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_SCREEN_BRIGHTNESS);
187 
188     StatsWriteHiSysEvent(statsService,
189         HiSysEvent::Domain::DISPLAY, StatsHiSysEvent::SCREEN_STATE,
190         HiSysEvent::EventType::STATISTIC, "STATE", stateOn);
191     StatsWriteHiSysEvent(statsService,
192         HiSysEvent::Domain::DISPLAY, StatsHiSysEvent::BRIGHTNESS_NIT,
193         HiSysEvent::EventType::STATISTIC, "BRIGHTNESS", brightness);
194     usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
195     StatsWriteHiSysEvent(statsService,
196         HiSysEvent::Domain::DISPLAY, StatsHiSysEvent::SCREEN_STATE,
197         HiSysEvent::EventType::STATISTIC, "STATE", stateOff);
198 
199     double average = screenBrightnessAverage * brightness + screenOnAverage;
200 
201     double expectedPower = average * SERVICE_POWER_CONSUMPTION_DURATION_US / US_PER_HOUR;
202     double actualPower = g_statsServiceProxy->GetPartStatsMah(BatteryStatsInfo::CONSUMPTION_TYPE_SCREEN);
203     double devPrecent = abs(expectedPower - actualPower) / expectedPower;
204     GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
205     GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
206     EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
207 }
208 
209 /**
210  * @tc.name: StatsServiceDisplayTest_004
211  * @tc.desc: test GetPartStatsPercent function(Screen)
212  * @tc.type: FUNC
213  * @tc.require: issueI663DX
214  */
215 HWTEST_F (StatsServiceDisplayTest, StatsServiceDisplayTest_004, TestSize.Level0)
216 {
217     ASSERT_NE(g_statsServiceProxy, nullptr);
218     auto statsService = BatteryStatsService::GetInstance();
219     g_statsServiceProxy->Reset();
220 
221     int32_t stateOn = static_cast<int32_t>(OHOS::DisplayPowerMgr::DisplayState::DISPLAY_ON);
222     int32_t stateOff = static_cast<int32_t>(OHOS::DisplayPowerMgr::DisplayState::DISPLAY_OFF);
223     int32_t brightness = 100;
224     double fullPercent = 1;
225     double zeroPercent = 0;
226 
227     StatsWriteHiSysEvent(statsService,
228         HiSysEvent::Domain::DISPLAY, StatsHiSysEvent::SCREEN_STATE,
229         HiSysEvent::EventType::STATISTIC, "STATE", stateOn);
230     StatsWriteHiSysEvent(statsService,
231         HiSysEvent::Domain::DISPLAY, StatsHiSysEvent::BRIGHTNESS_NIT,
232         HiSysEvent::EventType::STATISTIC, "BRIGHTNESS", brightness);
233     usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
234     StatsWriteHiSysEvent(statsService,
235         HiSysEvent::Domain::DISPLAY, StatsHiSysEvent::SCREEN_STATE,
236         HiSysEvent::EventType::STATISTIC, "STATE", stateOff);
237 
238     double actualPercent = g_statsServiceProxy->GetPartStatsPercent(BatteryStatsInfo::CONSUMPTION_TYPE_SCREEN);
239     GTEST_LOG_(INFO) << __func__ << ": actual percent = " << actualPercent;
240     EXPECT_TRUE(actualPercent >= zeroPercent && actualPercent <= fullPercent);
241 }
242 
243 /**
244  * @tc.name: StatsServiceDisplayTest_005
245  * @tc.desc: test GetBatteryStats function(Screen)
246  * @tc.type: FUNC
247  * @tc.require: issueI663DX
248  */
249 HWTEST_F (StatsServiceDisplayTest, StatsServiceDisplayTest_005, TestSize.Level0)
250 {
251     ASSERT_NE(g_statsServiceProxy, nullptr);
252     auto statsService = BatteryStatsService::GetInstance();
253     g_statsServiceProxy->Reset();
254 
255     int32_t stateOn = static_cast<int32_t>(OHOS::DisplayPowerMgr::DisplayState::DISPLAY_ON);
256     int32_t stateOff = static_cast<int32_t>(OHOS::DisplayPowerMgr::DisplayState::DISPLAY_OFF);
257     int32_t brightness = 100;
258     double screenOnAverage = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_SCREEN_ON);
259     double screenBrightnessAverage = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_SCREEN_BRIGHTNESS);
260 
261     StatsWriteHiSysEvent(statsService,
262         HiSysEvent::Domain::DISPLAY, StatsHiSysEvent::SCREEN_STATE,
263         HiSysEvent::EventType::STATISTIC, "STATE", stateOn);
264     StatsWriteHiSysEvent(statsService,
265         HiSysEvent::Domain::DISPLAY, StatsHiSysEvent::BRIGHTNESS_NIT,
266         HiSysEvent::EventType::STATISTIC, "BRIGHTNESS", brightness);
267     usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
268     StatsWriteHiSysEvent(statsService,
269         HiSysEvent::Domain::DISPLAY, StatsHiSysEvent::SCREEN_STATE,
270         HiSysEvent::EventType::STATISTIC, "STATE", stateOff);
271 
272     double average = screenBrightnessAverage * brightness + screenOnAverage;
273 
274     double expectedPower = average * SERVICE_POWER_CONSUMPTION_DURATION_US / US_PER_HOUR;
275     double actualPower = StatsUtils::DEFAULT_VALUE;
276     auto list = g_statsServiceProxy->GetBatteryStats();
277     for (auto it : list) {
278         if ((*it).GetConsumptionType() == BatteryStatsInfo::CONSUMPTION_TYPE_SCREEN) {
279             actualPower = (*it).GetPower();
280         }
281     }
282     double devPrecent = abs(expectedPower - actualPower) / expectedPower;
283     GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
284     GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
285     EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
286 }
287 
288 /**
289  * @tc.name: StatsServiceDisplayTest_006
290  * @tc.desc: test Last brightness value exists, but no BRIGHTNESS_NIT event notification, screen power consumption
291  * @tc.type: FUNC
292  * @tc.require: issueI663DX
293  */
294 HWTEST_F (StatsServiceDisplayTest, StatsServiceDisplayTest_006, TestSize.Level0)
295 {
296     ASSERT_NE(g_statsServiceProxy, nullptr);
297     auto statsService = BatteryStatsService::GetInstance();
298     g_statsServiceProxy->Reset();
299 
300     int32_t stateOn = static_cast<int32_t>(OHOS::DisplayPowerMgr::DisplayState::DISPLAY_ON);
301     int32_t stateOff = static_cast<int32_t>(OHOS::DisplayPowerMgr::DisplayState::DISPLAY_OFF);
302     int32_t lastBrightness = 100;
303     double screenOnAverage = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_SCREEN_ON);
304     double screenBrightnessAverage = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_SCREEN_BRIGHTNESS);
305 
306     SetLastBrightness(lastBrightness);
307 
308     StatsWriteHiSysEvent(statsService,
309         HiSysEvent::Domain::DISPLAY, StatsHiSysEvent::SCREEN_STATE,
310         HiSysEvent::EventType::STATISTIC, "STATE", stateOn);
311     usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
312     StatsWriteHiSysEvent(statsService,
313         HiSysEvent::Domain::DISPLAY, StatsHiSysEvent::SCREEN_STATE,
314         HiSysEvent::EventType::STATISTIC, "STATE", stateOff);
315 
316     double average = screenBrightnessAverage * lastBrightness + screenOnAverage;
317 
318     double expectedPower = average * SERVICE_POWER_CONSUMPTION_DURATION_US / US_PER_HOUR;
319     double actualPower = g_statsServiceProxy->GetPartStatsMah(BatteryStatsInfo::CONSUMPTION_TYPE_SCREEN);
320     double devPrecent = abs(expectedPower - actualPower) / expectedPower;
321     GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
322     GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
323     EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
324 }
325 
326 /**
327  * @tc.name: StatsServiceDisplayTest_007
328  * @tc.desc: test SCREEN_STATE event are sent repeatedly, screen power consumption
329  * @tc.type: FUNC
330  * @tc.require: issueI663DX
331  */
332 HWTEST_F (StatsServiceDisplayTest, StatsServiceDisplayTest_007, TestSize.Level0)
333 {
334     ASSERT_NE(g_statsServiceProxy, nullptr);
335     auto statsService = BatteryStatsService::GetInstance();
336     g_statsServiceProxy->Reset();
337 
338     int32_t stateOn = static_cast<int32_t>(OHOS::DisplayPowerMgr::DisplayState::DISPLAY_ON);
339     int32_t stateOff = static_cast<int32_t>(OHOS::DisplayPowerMgr::DisplayState::DISPLAY_OFF);
340     int32_t lastBrightness = 100;
341     double screenOnAverage = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_SCREEN_ON);
342     double screenBrightnessAverage = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_SCREEN_BRIGHTNESS);
343 
344     SetLastBrightness(lastBrightness);
345 
346     StatsWriteHiSysEvent(statsService,
347         HiSysEvent::Domain::DISPLAY, StatsHiSysEvent::SCREEN_STATE,
348         HiSysEvent::EventType::STATISTIC, "STATE", stateOn);
349     usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
350     StatsWriteHiSysEvent(statsService,
351         HiSysEvent::Domain::DISPLAY, StatsHiSysEvent::SCREEN_STATE,
352         HiSysEvent::EventType::STATISTIC, "STATE", stateOn);
353     usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
354     StatsWriteHiSysEvent(statsService,
355         HiSysEvent::Domain::DISPLAY, StatsHiSysEvent::SCREEN_STATE,
356         HiSysEvent::EventType::STATISTIC, "STATE", stateOff);
357     usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
358     StatsWriteHiSysEvent(statsService,
359         HiSysEvent::Domain::DISPLAY, StatsHiSysEvent::SCREEN_STATE,
360         HiSysEvent::EventType::STATISTIC, "STATE", stateOff);
361 
362     double average = screenBrightnessAverage * lastBrightness + screenOnAverage;
363 
364     double expectedPower = average * 2 * SERVICE_POWER_CONSUMPTION_DURATION_US / US_PER_HOUR;
365     double actualPower = g_statsServiceProxy->GetPartStatsMah(BatteryStatsInfo::CONSUMPTION_TYPE_SCREEN);
366     double devPrecent = abs(expectedPower - actualPower) / expectedPower;
367     GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
368     GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
369     EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
370 }
371 
372 /**
373  * @tc.name: StatsServiceDisplayTest_008
374  * @tc.desc: test Screen is off, BRIGHTNESS_NIT event is invalid
375  * @tc.type: FUNC
376  * @tc.require: issueI663DX
377  */
378 HWTEST_F (StatsServiceDisplayTest, StatsServiceDisplayTest_008, TestSize.Level0)
379 {
380     ASSERT_NE(g_statsServiceProxy, nullptr);
381     auto statsService = BatteryStatsService::GetInstance();
382     g_statsServiceProxy->Reset();
383 
384     int32_t brightness = 100;
385 
386     StatsWriteHiSysEvent(statsService,
387         HiSysEvent::Domain::DISPLAY, StatsHiSysEvent::BRIGHTNESS_NIT,
388         HiSysEvent::EventType::STATISTIC, "BRIGHTNESS", brightness);
389     usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
390 
391     double expectedPower = StatsUtils::DEFAULT_VALUE;
392     double actualPower = g_statsServiceProxy->GetPartStatsMah(BatteryStatsInfo::CONSUMPTION_TYPE_SCREEN);
393     GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
394     GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
395     EXPECT_EQ(expectedPower, actualPower);
396 }
397 
398 /**
399  * @tc.name: StatsServiceDisplayTest_009
400  * @tc.desc: test Screen is off, BRIGHTNESS_NIT event is invalid
401  * @tc.type: FUNC
402  * @tc.require: issueI663DX
403  */
404 HWTEST_F (StatsServiceDisplayTest, StatsServiceDisplayTest_009, TestSize.Level0)
405 {
406     ASSERT_NE(g_statsServiceProxy, nullptr);
407     auto statsService = BatteryStatsService::GetInstance();
408     g_statsServiceProxy->Reset();
409 
410     int32_t stateOn = static_cast<int32_t>(OHOS::DisplayPowerMgr::DisplayState::DISPLAY_ON);
411     int32_t stateOff = static_cast<int32_t>(OHOS::DisplayPowerMgr::DisplayState::DISPLAY_OFF);
412     int32_t lastBrightness = 100;
413     int32_t currentBrightness = 200;
414     double screenOnAverage = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_SCREEN_ON);
415     double screenBrightnessAverage = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_SCREEN_BRIGHTNESS);
416 
417     SetLastBrightness(lastBrightness);
418 
419     StatsWriteHiSysEvent(statsService, HiSysEvent::Domain::DISPLAY, StatsHiSysEvent::BRIGHTNESS_NIT,
420         HiSysEvent::EventType::STATISTIC, "BRIGHTNESS", currentBrightness);
421     usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
422 
423     StatsWriteHiSysEvent(statsService,
424         HiSysEvent::Domain::DISPLAY, StatsHiSysEvent::SCREEN_STATE,
425         HiSysEvent::EventType::STATISTIC, "STATE", stateOn);
426     usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
427     StatsWriteHiSysEvent(statsService,
428         HiSysEvent::Domain::DISPLAY, StatsHiSysEvent::SCREEN_STATE,
429         HiSysEvent::EventType::STATISTIC, "STATE", stateOff);
430 
431     double average = screenBrightnessAverage * lastBrightness + screenOnAverage;
432 
433     double expectedPower = average * SERVICE_POWER_CONSUMPTION_DURATION_US / US_PER_HOUR;
434     double actualPower = g_statsServiceProxy->GetPartStatsMah(BatteryStatsInfo::CONSUMPTION_TYPE_SCREEN);
435     double devPrecent = abs(expectedPower - actualPower) / expectedPower;
436     GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
437     GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
438     EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
439 }
440 
441 /**
442  * @tc.name: StatsServiceDisplayTest_010
443  * @tc.desc: test Screen is on, BRIGHTNESS_NIT event are sent delay
444  * @tc.type: FUNC
445  * @tc.require: issueI663DX
446  */
447 HWTEST_F (StatsServiceDisplayTest, StatsServiceDisplayTest_010, TestSize.Level0)
448 {
449     ASSERT_NE(g_statsServiceProxy, nullptr);
450     auto statsService = BatteryStatsService::GetInstance();
451     g_statsServiceProxy->Reset();
452 
453     int32_t stateOn = static_cast<int32_t>(OHOS::DisplayPowerMgr::DisplayState::DISPLAY_ON);
454     int32_t stateOff = static_cast<int32_t>(OHOS::DisplayPowerMgr::DisplayState::DISPLAY_OFF);
455     int32_t lastBrightness = 100;
456     int32_t currentBrightness = 200;
457     double screenOnAverage = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_SCREEN_ON);
458     double screenBrightnessAverage = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_SCREEN_BRIGHTNESS);
459 
460     SetLastBrightness(lastBrightness);
461 
462     StatsWriteHiSysEvent(statsService,
463         HiSysEvent::Domain::DISPLAY, StatsHiSysEvent::SCREEN_STATE,
464         HiSysEvent::EventType::STATISTIC, "STATE", stateOn);
465     usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
466     StatsWriteHiSysEvent(statsService,
467         HiSysEvent::Domain::DISPLAY, StatsHiSysEvent::BRIGHTNESS_NIT,
468         HiSysEvent::EventType::STATISTIC, "BRIGHTNESS", currentBrightness);
469     usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
470     StatsWriteHiSysEvent(statsService,
471         HiSysEvent::Domain::DISPLAY, StatsHiSysEvent::SCREEN_STATE,
472         HiSysEvent::EventType::STATISTIC, "STATE", stateOff);
473 
474     double screenOnPower = screenOnAverage * 2 * SERVICE_POWER_CONSUMPTION_DURATION_US;
475     double lastBrightnessPower = screenBrightnessAverage * lastBrightness * SERVICE_POWER_CONSUMPTION_DURATION_US;
476     double curBrightnessPower = screenBrightnessAverage * currentBrightness * SERVICE_POWER_CONSUMPTION_DURATION_US;
477 
478     double expectedPower = (screenOnPower + lastBrightnessPower + curBrightnessPower) / US_PER_HOUR;
479     double actualPower = g_statsServiceProxy->GetPartStatsMah(BatteryStatsInfo::CONSUMPTION_TYPE_SCREEN);
480     double devPrecent = abs(expectedPower - actualPower) / expectedPower;
481     GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
482     GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
483     EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
484 }
485 
486 /**
487  * @tc.name: StatsServiceDisplayTest_011
488  * @tc.desc: test Screen is on, BRIGHTNESS_NIT event are sent with invalid value
489  * @tc.type: FUNC
490  * @tc.require: issueI663DX
491  */
492 HWTEST_F (StatsServiceDisplayTest, StatsServiceDisplayTest_011, TestSize.Level0)
493 {
494     ASSERT_NE(g_statsServiceProxy, nullptr);
495     auto statsService = BatteryStatsService::GetInstance();
496     g_statsServiceProxy->Reset();
497 
498     int32_t stateOn = static_cast<int32_t>(OHOS::DisplayPowerMgr::DisplayState::DISPLAY_ON);
499     int32_t stateOff = static_cast<int32_t>(OHOS::DisplayPowerMgr::DisplayState::DISPLAY_OFF);
500     int32_t lastBrightness = 100;
501     int32_t invalidBrightness1 = -1;
502     int32_t invalidBrightness2 = 300;
503     double screenOnAverage = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_SCREEN_ON);
504     double screenBrightnessAverage = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_SCREEN_BRIGHTNESS);
505 
506     SetLastBrightness(lastBrightness);
507 
508     StatsWriteHiSysEvent(statsService,
509         HiSysEvent::Domain::DISPLAY, StatsHiSysEvent::SCREEN_STATE,
510         HiSysEvent::EventType::STATISTIC, "STATE", stateOn);
511     usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
512     StatsWriteHiSysEvent(statsService, HiSysEvent::Domain::DISPLAY, StatsHiSysEvent::BRIGHTNESS_NIT,
513         HiSysEvent::EventType::STATISTIC, "BRIGHTNESS", invalidBrightness1);
514     usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
515     StatsWriteHiSysEvent(statsService, HiSysEvent::Domain::DISPLAY, StatsHiSysEvent::BRIGHTNESS_NIT,
516         HiSysEvent::EventType::STATISTIC, "BRIGHTNESS", invalidBrightness2);
517     usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
518     StatsWriteHiSysEvent(statsService,
519         HiSysEvent::Domain::DISPLAY, StatsHiSysEvent::SCREEN_STATE,
520         HiSysEvent::EventType::STATISTIC, "STATE", stateOff);
521 
522     double average = screenBrightnessAverage * lastBrightness + screenOnAverage;
523 
524     double expectedPower = average * 3 * SERVICE_POWER_CONSUMPTION_DURATION_US / US_PER_HOUR;
525     double actualPower = g_statsServiceProxy->GetPartStatsMah(BatteryStatsInfo::CONSUMPTION_TYPE_SCREEN);
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 }
531 
532 /**
533  * @tc.name: StatsServiceDisplayTest_012
534  * @tc.desc: test send hisysevent with missing information(Screen)
535  * @tc.type: FUNC
536  * @tc.require: issueI663DX
537  */
538 HWTEST_F (StatsServiceDisplayTest, StatsServiceDisplayTest_012, TestSize.Level0)
539 {
540     ASSERT_NE(g_statsServiceProxy, nullptr);
541     auto statsService = BatteryStatsService::GetInstance();
542     g_statsServiceProxy->Reset();
543 
544     StatsWriteHiSysEvent(statsService, HiSysEvent::Domain::DISPLAY,
545     StatsHiSysEvent::SCREEN_STATE, HiSysEvent::EventType::STATISTIC);
546     StatsWriteHiSysEvent(statsService, HiSysEvent::Domain::DISPLAY,
547     StatsHiSysEvent::BRIGHTNESS_NIT, HiSysEvent::EventType::STATISTIC);
548     usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
549     StatsWriteHiSysEvent(statsService, HiSysEvent::Domain::DISPLAY,
550     StatsHiSysEvent::SCREEN_STATE, HiSysEvent::EventType::STATISTIC);
551 
552     double expectedPower = StatsUtils::DEFAULT_VALUE;
553     double actualPower = g_statsServiceProxy->GetPartStatsMah(BatteryStatsInfo::CONSUMPTION_TYPE_SCREEN);
554     GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
555     GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
556     EXPECT_EQ(expectedPower, actualPower);
557 }
558 }