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