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->ResetIpc();
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 */
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->ResetIpc();
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 int32_t tempError;
128 double powerMahBefore;
129 g_statsServiceProxy->GetPartStatsMahIpc(BatteryStatsInfo::CONSUMPTION_TYPE_SCREEN, powerMahBefore, tempError);
130 g_statsServiceProxy->ResetIpc();
131 double powerMahAfter;
132 g_statsServiceProxy->GetPartStatsMahIpc(BatteryStatsInfo::CONSUMPTION_TYPE_SCREEN, powerMahAfter, tempError);
133 GTEST_LOG_(INFO) << __func__ << ": before consumption = " << powerMahBefore << " mAh";
134 GTEST_LOG_(INFO) << __func__ << ": after consumption = " << powerMahAfter << " mAh";
135 EXPECT_TRUE(powerMahBefore >= StatsUtils::DEFAULT_VALUE && powerMahAfter == StatsUtils::DEFAULT_VALUE);
136 STATS_HILOGI(LABEL_TEST, "StatsServiceDisplayTest_001 end");
137 }
138
139 /**
140 * @tc.name: StatsServiceDisplayTest_002
141 * @tc.desc: test SetOnBattery function(Screen)
142 * @tc.type: FUNC
143 * @tc.require: issueI663DX
144 */
145 HWTEST_F (StatsServiceDisplayTest, StatsServiceDisplayTest_002, TestSize.Level0)
146 {
147 STATS_HILOGI(LABEL_TEST, "StatsServiceDisplayTest_002 start");
148 ASSERT_NE(g_statsServiceProxy, nullptr);
149 auto statsService = BatteryStatsService::GetInstance();
150 g_statsServiceProxy->ResetIpc();
151 g_statsServiceProxy->SetOnBatteryIpc(false);
152
153 int32_t stateOn = static_cast<int32_t>(OHOS::DisplayPowerMgr::DisplayState::DISPLAY_ON);
154 int32_t stateOff = static_cast<int32_t>(OHOS::DisplayPowerMgr::DisplayState::DISPLAY_OFF);
155 int32_t brightness = 120;
156
157 StatsWriteHiSysEvent(statsService,
158 HiSysEvent::Domain::DISPLAY, StatsHiSysEvent::SCREEN_STATE,
159 HiSysEvent::EventType::STATISTIC, "STATE", stateOn);
160 StatsWriteHiSysEvent(statsService,
161 HiSysEvent::Domain::DISPLAY, StatsHiSysEvent::BRIGHTNESS_NIT,
162 HiSysEvent::EventType::STATISTIC, "BRIGHTNESS", brightness);
163 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
164 StatsWriteHiSysEvent(statsService,
165 HiSysEvent::Domain::DISPLAY, StatsHiSysEvent::SCREEN_STATE,
166 HiSysEvent::EventType::STATISTIC, "STATE", stateOff);
167
168 double expectedPower = StatsUtils::DEFAULT_VALUE;
169 int32_t tempError;
170 double actualPower;
171 g_statsServiceProxy->GetPartStatsMahIpc(BatteryStatsInfo::CONSUMPTION_TYPE_SCREEN, actualPower, tempError);
172 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
173 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
174 EXPECT_EQ(expectedPower, actualPower);
175 g_statsServiceProxy->SetOnBatteryIpc(true);
176 STATS_HILOGI(LABEL_TEST, "StatsServiceDisplayTest_002 end");
177 }
178
179 /**
180 * @tc.name: StatsServiceDisplayTest_003
181 * @tc.desc: test GetPartStatsMah function(Screen)
182 * @tc.type: FUNC
183 * @tc.require: issueI663DX
184 */
185 HWTEST_F (StatsServiceDisplayTest, StatsServiceDisplayTest_003, TestSize.Level0)
186 {
187 STATS_HILOGI(LABEL_TEST, "StatsServiceDisplayTest_003 start");
188 ASSERT_NE(g_statsServiceProxy, nullptr);
189 auto statsService = BatteryStatsService::GetInstance();
190 g_statsServiceProxy->ResetIpc();
191
192 int32_t stateOn = static_cast<int32_t>(OHOS::DisplayPowerMgr::DisplayState::DISPLAY_ON);
193 int32_t stateOff = static_cast<int32_t>(OHOS::DisplayPowerMgr::DisplayState::DISPLAY_OFF);
194 int32_t brightness = 100;
195 double screenOnAverage = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_SCREEN_ON);
196 double screenBrightnessAverage = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_SCREEN_BRIGHTNESS);
197
198 StatsWriteHiSysEvent(statsService,
199 HiSysEvent::Domain::DISPLAY, StatsHiSysEvent::SCREEN_STATE,
200 HiSysEvent::EventType::STATISTIC, "STATE", stateOn);
201 StatsWriteHiSysEvent(statsService,
202 HiSysEvent::Domain::DISPLAY, StatsHiSysEvent::BRIGHTNESS_NIT,
203 HiSysEvent::EventType::STATISTIC, "BRIGHTNESS", brightness);
204 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
205 StatsWriteHiSysEvent(statsService,
206 HiSysEvent::Domain::DISPLAY, StatsHiSysEvent::SCREEN_STATE,
207 HiSysEvent::EventType::STATISTIC, "STATE", stateOff);
208
209 double average = screenBrightnessAverage * brightness + screenOnAverage;
210
211 double expectedPower = average * SERVICE_POWER_CONSUMPTION_DURATION_US / US_PER_HOUR;
212 int32_t tempError;
213 double actualPower;
214 g_statsServiceProxy->GetPartStatsMahIpc(BatteryStatsInfo::CONSUMPTION_TYPE_SCREEN, actualPower, tempError);
215 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
216 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
217 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
218 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
219 STATS_HILOGI(LABEL_TEST, "StatsServiceDisplayTest_003 end");
220 }
221
222 /**
223 * @tc.name: StatsServiceDisplayTest_004
224 * @tc.desc: test GetPartStatsPercent function(Screen)
225 * @tc.type: FUNC
226 * @tc.require: issueI663DX
227 */
228 HWTEST_F (StatsServiceDisplayTest, StatsServiceDisplayTest_004, TestSize.Level0)
229 {
230 STATS_HILOGI(LABEL_TEST, "StatsServiceDisplayTest_004 start");
231 ASSERT_NE(g_statsServiceProxy, nullptr);
232 auto statsService = BatteryStatsService::GetInstance();
233 g_statsServiceProxy->ResetIpc();
234
235 int32_t stateOn = static_cast<int32_t>(OHOS::DisplayPowerMgr::DisplayState::DISPLAY_ON);
236 int32_t stateOff = static_cast<int32_t>(OHOS::DisplayPowerMgr::DisplayState::DISPLAY_OFF);
237 int32_t brightness = 100;
238 double fullPercent = 1;
239 double zeroPercent = 0;
240
241 StatsWriteHiSysEvent(statsService,
242 HiSysEvent::Domain::DISPLAY, StatsHiSysEvent::SCREEN_STATE,
243 HiSysEvent::EventType::STATISTIC, "STATE", stateOn);
244 StatsWriteHiSysEvent(statsService,
245 HiSysEvent::Domain::DISPLAY, StatsHiSysEvent::BRIGHTNESS_NIT,
246 HiSysEvent::EventType::STATISTIC, "BRIGHTNESS", brightness);
247 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
248 StatsWriteHiSysEvent(statsService,
249 HiSysEvent::Domain::DISPLAY, StatsHiSysEvent::SCREEN_STATE,
250 HiSysEvent::EventType::STATISTIC, "STATE", stateOff);
251 int32_t tempError;
252 double actualPercent;
253 g_statsServiceProxy->GetPartStatsPercentIpc(BatteryStatsInfo::CONSUMPTION_TYPE_SCREEN, actualPercent, tempError);
254 GTEST_LOG_(INFO) << __func__ << ": actual percent = " << actualPercent;
255 EXPECT_TRUE(actualPercent >= zeroPercent && actualPercent <= fullPercent);
256 STATS_HILOGI(LABEL_TEST, "StatsServiceDisplayTest_004 end");
257 }
258
259 /**
260 * @tc.name: StatsServiceDisplayTest_005
261 * @tc.desc: test GetBatteryStats function(Screen)
262 * @tc.type: FUNC
263 * @tc.require: issueI663DX
264 */
265 HWTEST_F (StatsServiceDisplayTest, StatsServiceDisplayTest_005, TestSize.Level0)
266 {
267 STATS_HILOGI(LABEL_TEST, "StatsServiceDisplayTest_005 start");
268 ASSERT_NE(g_statsServiceProxy, nullptr);
269 auto statsService = BatteryStatsService::GetInstance();
270 g_statsServiceProxy->ResetIpc();
271
272 int32_t stateOn = static_cast<int32_t>(OHOS::DisplayPowerMgr::DisplayState::DISPLAY_ON);
273 int32_t stateOff = static_cast<int32_t>(OHOS::DisplayPowerMgr::DisplayState::DISPLAY_OFF);
274 int32_t brightness = 100;
275 double screenOnAverage = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_SCREEN_ON);
276 double screenBrightnessAverage = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_SCREEN_BRIGHTNESS);
277
278 StatsWriteHiSysEvent(statsService,
279 HiSysEvent::Domain::DISPLAY, StatsHiSysEvent::SCREEN_STATE,
280 HiSysEvent::EventType::STATISTIC, "STATE", stateOn);
281 StatsWriteHiSysEvent(statsService,
282 HiSysEvent::Domain::DISPLAY, StatsHiSysEvent::BRIGHTNESS_NIT,
283 HiSysEvent::EventType::STATISTIC, "BRIGHTNESS", brightness);
284 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
285 StatsWriteHiSysEvent(statsService,
286 HiSysEvent::Domain::DISPLAY, StatsHiSysEvent::SCREEN_STATE,
287 HiSysEvent::EventType::STATISTIC, "STATE", stateOff);
288
289 double average = screenBrightnessAverage * brightness + screenOnAverage;
290
291 double expectedPower = average * SERVICE_POWER_CONSUMPTION_DURATION_US / US_PER_HOUR;
292 double actualPower = StatsUtils::DEFAULT_VALUE;
293 ParcelableBatteryStatsList parcelableEntityList;
294 int32_t tempError;
295 g_statsServiceProxy->GetBatteryStatsIpc(parcelableEntityList, tempError);
296 auto list = parcelableEntityList.statsList_;
297 for (auto it : list) {
298 if ((*it).GetConsumptionType() == BatteryStatsInfo::CONSUMPTION_TYPE_SCREEN) {
299 actualPower = (*it).GetPower();
300 }
301 }
302 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
303 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
304 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
305 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
306 STATS_HILOGI(LABEL_TEST, "StatsServiceDisplayTest_005 end");
307 }
308
309 /**
310 * @tc.name: StatsServiceDisplayTest_006
311 * @tc.desc: test Last brightness value exists, but no BRIGHTNESS_NIT event notification, screen power consumption
312 * @tc.type: FUNC
313 * @tc.require: issueI663DX
314 */
315 HWTEST_F (StatsServiceDisplayTest, StatsServiceDisplayTest_006, TestSize.Level0)
316 {
317 STATS_HILOGI(LABEL_TEST, "StatsServiceDisplayTest_006 start");
318 ASSERT_NE(g_statsServiceProxy, nullptr);
319 auto statsService = BatteryStatsService::GetInstance();
320 g_statsServiceProxy->ResetIpc();
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 double screenOnAverage = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_SCREEN_ON);
326 double screenBrightnessAverage = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_SCREEN_BRIGHTNESS);
327
328 SetLastBrightness(lastBrightness);
329
330 StatsWriteHiSysEvent(statsService,
331 HiSysEvent::Domain::DISPLAY, StatsHiSysEvent::SCREEN_STATE,
332 HiSysEvent::EventType::STATISTIC, "STATE", stateOn);
333 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
334 StatsWriteHiSysEvent(statsService,
335 HiSysEvent::Domain::DISPLAY, StatsHiSysEvent::SCREEN_STATE,
336 HiSysEvent::EventType::STATISTIC, "STATE", stateOff);
337
338 double average = screenBrightnessAverage * lastBrightness + screenOnAverage;
339
340 double expectedPower = average * SERVICE_POWER_CONSUMPTION_DURATION_US / US_PER_HOUR;
341 int32_t tempError;
342 double actualPower;
343 g_statsServiceProxy->GetPartStatsMahIpc(BatteryStatsInfo::CONSUMPTION_TYPE_SCREEN, actualPower, tempError);
344 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
345 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
346 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
347 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
348 STATS_HILOGI(LABEL_TEST, "StatsServiceDisplayTest_006 end");
349 }
350
351 /**
352 * @tc.name: StatsServiceDisplayTest_007
353 * @tc.desc: test SCREEN_STATE event are sent repeatedly, screen power consumption
354 * @tc.type: FUNC
355 * @tc.require: issueI663DX
356 */
357 HWTEST_F (StatsServiceDisplayTest, StatsServiceDisplayTest_007, TestSize.Level0)
358 {
359 STATS_HILOGI(LABEL_TEST, "StatsServiceDisplayTest_007 start");
360 ASSERT_NE(g_statsServiceProxy, nullptr);
361 auto statsService = BatteryStatsService::GetInstance();
362 g_statsServiceProxy->ResetIpc();
363
364 int32_t stateOn = static_cast<int32_t>(OHOS::DisplayPowerMgr::DisplayState::DISPLAY_ON);
365 int32_t stateOff = static_cast<int32_t>(OHOS::DisplayPowerMgr::DisplayState::DISPLAY_OFF);
366 int32_t lastBrightness = 100;
367 double screenOnAverage = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_SCREEN_ON);
368 double screenBrightnessAverage = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_SCREEN_BRIGHTNESS);
369
370 SetLastBrightness(lastBrightness);
371
372 StatsWriteHiSysEvent(statsService,
373 HiSysEvent::Domain::DISPLAY, StatsHiSysEvent::SCREEN_STATE,
374 HiSysEvent::EventType::STATISTIC, "STATE", stateOn);
375 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
376 StatsWriteHiSysEvent(statsService,
377 HiSysEvent::Domain::DISPLAY, StatsHiSysEvent::SCREEN_STATE,
378 HiSysEvent::EventType::STATISTIC, "STATE", stateOn);
379 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
380 StatsWriteHiSysEvent(statsService,
381 HiSysEvent::Domain::DISPLAY, StatsHiSysEvent::SCREEN_STATE,
382 HiSysEvent::EventType::STATISTIC, "STATE", stateOff);
383 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
384 StatsWriteHiSysEvent(statsService,
385 HiSysEvent::Domain::DISPLAY, StatsHiSysEvent::SCREEN_STATE,
386 HiSysEvent::EventType::STATISTIC, "STATE", stateOff);
387
388 double average = screenBrightnessAverage * lastBrightness + screenOnAverage;
389
390 double expectedPower = average * 2 * SERVICE_POWER_CONSUMPTION_DURATION_US / US_PER_HOUR;
391 int32_t tempError;
392 double actualPower;
393 g_statsServiceProxy->GetPartStatsMahIpc(BatteryStatsInfo::CONSUMPTION_TYPE_SCREEN, actualPower, tempError);
394 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
395 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
396 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
397 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
398 STATS_HILOGI(LABEL_TEST, "StatsServiceDisplayTest_007 end");
399 }
400
401 /**
402 * @tc.name: StatsServiceDisplayTest_008
403 * @tc.desc: test Screen is off, BRIGHTNESS_NIT event is invalid
404 * @tc.type: FUNC
405 * @tc.require: issueI663DX
406 */
407 HWTEST_F (StatsServiceDisplayTest, StatsServiceDisplayTest_008, TestSize.Level0)
408 {
409 STATS_HILOGI(LABEL_TEST, "StatsServiceDisplayTest_008 start");
410 ASSERT_NE(g_statsServiceProxy, nullptr);
411 auto statsService = BatteryStatsService::GetInstance();
412 g_statsServiceProxy->ResetIpc();
413
414 int32_t brightness = 100;
415
416 StatsWriteHiSysEvent(statsService,
417 HiSysEvent::Domain::DISPLAY, StatsHiSysEvent::BRIGHTNESS_NIT,
418 HiSysEvent::EventType::STATISTIC, "BRIGHTNESS", brightness);
419 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
420
421 double expectedPower = StatsUtils::DEFAULT_VALUE;
422 int32_t tempError;
423 double actualPower;
424 g_statsServiceProxy->GetPartStatsMahIpc(BatteryStatsInfo::CONSUMPTION_TYPE_SCREEN, actualPower, tempError);
425 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
426 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
427 EXPECT_EQ(expectedPower, actualPower);
428 STATS_HILOGI(LABEL_TEST, "StatsServiceDisplayTest_008 end");
429 }
430
431 /**
432 * @tc.name: StatsServiceDisplayTest_009
433 * @tc.desc: test Screen is off, BRIGHTNESS_NIT event is invalid
434 * @tc.type: FUNC
435 * @tc.require: issueI663DX
436 */
437 HWTEST_F (StatsServiceDisplayTest, StatsServiceDisplayTest_009, TestSize.Level0)
438 {
439 STATS_HILOGI(LABEL_TEST, "StatsServiceDisplayTest_009 start");
440 ASSERT_NE(g_statsServiceProxy, nullptr);
441 auto statsService = BatteryStatsService::GetInstance();
442 g_statsServiceProxy->ResetIpc();
443
444 int32_t stateOn = static_cast<int32_t>(OHOS::DisplayPowerMgr::DisplayState::DISPLAY_ON);
445 int32_t stateOff = static_cast<int32_t>(OHOS::DisplayPowerMgr::DisplayState::DISPLAY_OFF);
446 int32_t lastBrightness = 100;
447 int32_t currentBrightness = 200;
448 double screenOnAverage = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_SCREEN_ON);
449 double screenBrightnessAverage = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_SCREEN_BRIGHTNESS);
450
451 SetLastBrightness(lastBrightness);
452
453 StatsWriteHiSysEvent(statsService, HiSysEvent::Domain::DISPLAY, StatsHiSysEvent::BRIGHTNESS_NIT,
454 HiSysEvent::EventType::STATISTIC, "BRIGHTNESS", currentBrightness);
455 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
456
457 StatsWriteHiSysEvent(statsService,
458 HiSysEvent::Domain::DISPLAY, StatsHiSysEvent::SCREEN_STATE,
459 HiSysEvent::EventType::STATISTIC, "STATE", stateOn);
460 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
461 StatsWriteHiSysEvent(statsService,
462 HiSysEvent::Domain::DISPLAY, StatsHiSysEvent::SCREEN_STATE,
463 HiSysEvent::EventType::STATISTIC, "STATE", stateOff);
464
465 double average = screenBrightnessAverage * lastBrightness + screenOnAverage;
466
467 double expectedPower = average * SERVICE_POWER_CONSUMPTION_DURATION_US / US_PER_HOUR;
468 int32_t tempError;
469 double actualPower;
470 g_statsServiceProxy->GetPartStatsMahIpc(BatteryStatsInfo::CONSUMPTION_TYPE_SCREEN, actualPower, tempError);
471 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
472 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
473 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
474 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
475 STATS_HILOGI(LABEL_TEST, "StatsServiceDisplayTest_009 end");
476 }
477
478 /**
479 * @tc.name: StatsServiceDisplayTest_010
480 * @tc.desc: test Screen is on, BRIGHTNESS_NIT event are sent delay
481 * @tc.type: FUNC
482 * @tc.require: issueI663DX
483 */
484 HWTEST_F (StatsServiceDisplayTest, StatsServiceDisplayTest_010, TestSize.Level0)
485 {
486 STATS_HILOGI(LABEL_TEST, "StatsServiceDisplayTest_010 start");
487 ASSERT_NE(g_statsServiceProxy, nullptr);
488 auto statsService = BatteryStatsService::GetInstance();
489 g_statsServiceProxy->ResetIpc();
490
491 int32_t stateOn = static_cast<int32_t>(OHOS::DisplayPowerMgr::DisplayState::DISPLAY_ON);
492 int32_t stateOff = static_cast<int32_t>(OHOS::DisplayPowerMgr::DisplayState::DISPLAY_OFF);
493 int32_t lastBrightness = 100;
494 int32_t currentBrightness = 200;
495 double screenOnAverage = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_SCREEN_ON);
496 double screenBrightnessAverage = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_SCREEN_BRIGHTNESS);
497
498 SetLastBrightness(lastBrightness);
499
500 StatsWriteHiSysEvent(statsService,
501 HiSysEvent::Domain::DISPLAY, StatsHiSysEvent::SCREEN_STATE,
502 HiSysEvent::EventType::STATISTIC, "STATE", stateOn);
503 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
504 StatsWriteHiSysEvent(statsService,
505 HiSysEvent::Domain::DISPLAY, StatsHiSysEvent::BRIGHTNESS_NIT,
506 HiSysEvent::EventType::STATISTIC, "BRIGHTNESS", currentBrightness);
507 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
508 StatsWriteHiSysEvent(statsService,
509 HiSysEvent::Domain::DISPLAY, StatsHiSysEvent::SCREEN_STATE,
510 HiSysEvent::EventType::STATISTIC, "STATE", stateOff);
511
512 double screenOnPower = screenOnAverage * 2 * SERVICE_POWER_CONSUMPTION_DURATION_US;
513 double lastBrightnessPower = screenBrightnessAverage * lastBrightness * SERVICE_POWER_CONSUMPTION_DURATION_US;
514 double curBrightnessPower = screenBrightnessAverage * currentBrightness * SERVICE_POWER_CONSUMPTION_DURATION_US;
515
516 double expectedPower = (screenOnPower + lastBrightnessPower + curBrightnessPower) / US_PER_HOUR;
517 int32_t tempError;
518 double actualPower;
519 g_statsServiceProxy->GetPartStatsMahIpc(BatteryStatsInfo::CONSUMPTION_TYPE_SCREEN, actualPower, tempError);
520 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
521 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
522 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
523 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
524 STATS_HILOGI(LABEL_TEST, "StatsServiceDisplayTest_010 end");
525 }
526
527 /**
528 * @tc.name: StatsServiceDisplayTest_011
529 * @tc.desc: test Screen is on, BRIGHTNESS_NIT event are sent with invalid value
530 * @tc.type: FUNC
531 * @tc.require: issueI663DX
532 */
533 HWTEST_F (StatsServiceDisplayTest, StatsServiceDisplayTest_011, TestSize.Level0)
534 {
535 STATS_HILOGI(LABEL_TEST, "StatsServiceDisplayTest_011 start");
536 ASSERT_NE(g_statsServiceProxy, nullptr);
537 auto statsService = BatteryStatsService::GetInstance();
538 g_statsServiceProxy->ResetIpc();
539
540 int32_t stateOn = static_cast<int32_t>(OHOS::DisplayPowerMgr::DisplayState::DISPLAY_ON);
541 int32_t stateOff = static_cast<int32_t>(OHOS::DisplayPowerMgr::DisplayState::DISPLAY_OFF);
542 int32_t lastBrightness = 100;
543 int32_t invalidBrightness1 = -1;
544 int32_t invalidBrightness2 = 300;
545 double screenOnAverage = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_SCREEN_ON);
546 double screenBrightnessAverage = g_statsParser->GetAveragePowerMa(StatsUtils::CURRENT_SCREEN_BRIGHTNESS);
547
548 SetLastBrightness(lastBrightness);
549
550 StatsWriteHiSysEvent(statsService,
551 HiSysEvent::Domain::DISPLAY, StatsHiSysEvent::SCREEN_STATE,
552 HiSysEvent::EventType::STATISTIC, "STATE", stateOn);
553 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
554 StatsWriteHiSysEvent(statsService, HiSysEvent::Domain::DISPLAY, StatsHiSysEvent::BRIGHTNESS_NIT,
555 HiSysEvent::EventType::STATISTIC, "BRIGHTNESS", invalidBrightness1);
556 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
557 StatsWriteHiSysEvent(statsService, HiSysEvent::Domain::DISPLAY, StatsHiSysEvent::BRIGHTNESS_NIT,
558 HiSysEvent::EventType::STATISTIC, "BRIGHTNESS", invalidBrightness2);
559 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
560 StatsWriteHiSysEvent(statsService,
561 HiSysEvent::Domain::DISPLAY, StatsHiSysEvent::SCREEN_STATE,
562 HiSysEvent::EventType::STATISTIC, "STATE", stateOff);
563
564 double average = screenBrightnessAverage * lastBrightness + screenOnAverage;
565
566 double expectedPower = average * 3 * SERVICE_POWER_CONSUMPTION_DURATION_US / US_PER_HOUR;
567 int32_t tempError;
568 double actualPower;
569 g_statsServiceProxy->GetPartStatsMahIpc(BatteryStatsInfo::CONSUMPTION_TYPE_SCREEN, actualPower, tempError);
570 double devPrecent = abs(expectedPower - actualPower) / expectedPower;
571 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
572 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
573 EXPECT_LE(devPrecent, DEVIATION_PERCENT_THRESHOLD);
574 STATS_HILOGI(LABEL_TEST, "StatsServiceDisplayTest_011 end");
575 }
576
577 /**
578 * @tc.name: StatsServiceDisplayTest_012
579 * @tc.desc: test send hisysevent with missing information(Screen)
580 * @tc.type: FUNC
581 * @tc.require: issueI663DX
582 */
583 HWTEST_F (StatsServiceDisplayTest, StatsServiceDisplayTest_012, TestSize.Level0)
584 {
585 STATS_HILOGI(LABEL_TEST, "StatsServiceDisplayTest_012 start");
586 ASSERT_NE(g_statsServiceProxy, nullptr);
587 auto statsService = BatteryStatsService::GetInstance();
588 g_statsServiceProxy->ResetIpc();
589
590 StatsWriteHiSysEvent(statsService, HiSysEvent::Domain::DISPLAY,
591 StatsHiSysEvent::SCREEN_STATE, HiSysEvent::EventType::STATISTIC);
592 StatsWriteHiSysEvent(statsService, HiSysEvent::Domain::DISPLAY,
593 StatsHiSysEvent::BRIGHTNESS_NIT, HiSysEvent::EventType::STATISTIC);
594 usleep(SERVICE_POWER_CONSUMPTION_DURATION_US);
595 StatsWriteHiSysEvent(statsService, HiSysEvent::Domain::DISPLAY,
596 StatsHiSysEvent::SCREEN_STATE, HiSysEvent::EventType::STATISTIC);
597
598 double expectedPower = StatsUtils::DEFAULT_VALUE;
599 int32_t tempError;
600 double actualPower;
601 g_statsServiceProxy->GetPartStatsMahIpc(BatteryStatsInfo::CONSUMPTION_TYPE_SCREEN, actualPower, tempError);
602 GTEST_LOG_(INFO) << __func__ << ": expected consumption = " << expectedPower << " mAh";
603 GTEST_LOG_(INFO) << __func__ << ": actual consumption = " << actualPower << " mAh";
604 EXPECT_EQ(expectedPower, actualPower);
605 STATS_HILOGI(LABEL_TEST, "StatsServiceDisplayTest_012 end");
606 }
607 }