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