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