1 /*
2 * Copyright (c) 2021-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 <gtest/gtest.h>
17 #include "common_test_utils.h"
18 #include "display_manager.h"
19 #include "screen_manager.h"
20 #include "window.h"
21 #include "window_manager_hilog.h"
22
23 using namespace testing;
24 using namespace testing::ext;
25
26 namespace OHOS {
27 namespace Rosen {
28 namespace {
29 constexpr HiviewDFX::HiLogLabel LABEL = {LOG_CORE, HILOG_DOMAIN_DISPLAY, "DisplayPowerTest"};
30 constexpr uint32_t MAX_TIME_WAITING_FOR_CALLBACK = 40;
31 constexpr uint32_t SLEEP_TIME_IN_US = 50000;
32 }
33
34 class DisplayPowerEventListener : public IDisplayPowerEventListener {
35 public:
OnDisplayPowerEvent(DisplayPowerEvent event,EventStatus status)36 virtual void OnDisplayPowerEvent(DisplayPowerEvent event, EventStatus status)
37 {
38 isCallbackCalled_ = true;
39 event_ = event;
40 status_ = status;
41 }
42 DisplayPowerEvent event_;
43 EventStatus status_;
44 bool isCallbackCalled_ { false };
45 };
46
47 class DisplayPowerTest : public testing::Test {
48 public:
49 static void SetUpTestCase();
50 static void TearDownTestCase();
51 virtual void SetUp() override;
52 virtual void TearDown() override;
53
54 static void CheckDisplayStateCallback(bool valueExpected);
55 static void CheckDisplayPowerEventCallback(bool valueExpected);
56
57 static inline DisplayId defaultId_;
58 static inline uint32_t brightnessLevel_ = 80;
59 static inline uint32_t invalidBrightnessLevel_ = 1000000000;
60 static inline uint32_t times_ = 0;
61 static inline bool isDisplayStateCallbackCalled_ = false;
62 static sptr<DisplayPowerEventListener> listener_;
63
64 DisplayState state_ { DisplayState::ON };
__anon29a3f2400202(DisplayState state) 65 DisplayStateCallback callback_ = [this](DisplayState state) {
66 isDisplayStateCallbackCalled_ = true;
67 state_ = state;
68 };
69 };
70
71 sptr<DisplayPowerEventListener> DisplayPowerTest::listener_ = new DisplayPowerEventListener();
72
SetUpTestCase()73 void DisplayPowerTest::SetUpTestCase()
74 {
75 CommonTestUtils::SetAceessTokenPermission("SetDisplayState");
76 defaultId_ = DisplayManager::GetInstance().GetDefaultDisplayId();
77 if (defaultId_ == DISPLAY_ID_INVALID) {
78 WLOGFE("GetDefaultDisplayId failed!");
79 }
80 DisplayManager::GetInstance().RegisterDisplayPowerEventListener(listener_);
81 }
82
TearDownTestCase()83 void DisplayPowerTest::TearDownTestCase()
84 {
85 DisplayManager::GetInstance().UnregisterDisplayPowerEventListener(listener_);
86 }
87
SetUp()88 void DisplayPowerTest::SetUp()
89 {
90 times_ = 0;
91
92 isDisplayStateCallbackCalled_ = false;
93 state_ = DisplayState::UNKNOWN;
94
95 listener_->isCallbackCalled_ = false;
96 listener_->event_ = static_cast<DisplayPowerEvent>(-1);
97 listener_->status_ = static_cast<EventStatus>(-1);
98 }
99
TearDown()100 void DisplayPowerTest::TearDown()
101 {
102 }
103
CheckDisplayStateCallback(bool valueExpected)104 void DisplayPowerTest::CheckDisplayStateCallback(bool valueExpected)
105 {
106 do {
107 if (isDisplayStateCallbackCalled_ == valueExpected) {
108 return;
109 }
110 usleep(SLEEP_TIME_IN_US);
111 ++times_;
112 } while (times_ <= MAX_TIME_WAITING_FOR_CALLBACK);
113 }
114
CheckDisplayPowerEventCallback(bool valueExpected)115 void DisplayPowerTest::CheckDisplayPowerEventCallback(bool valueExpected)
116 {
117 do {
118 if (listener_->isCallbackCalled_ == valueExpected) {
119 return;
120 }
121 usleep(SLEEP_TIME_IN_US);
122 ++times_;
123 } while (times_ <= MAX_TIME_WAITING_FOR_CALLBACK);
124 }
125
126 namespace {
127 /**
128 * @tc.name: register_display_power_event_listener_001
129 * @tc.desc: call RegisterDisplayPowerEventListener with a valid listener and check return value
130 * @tc.type: FUNC
131 */
132 HWTEST_F(DisplayPowerTest, register_display_power_event_listener_001, Function | SmallTest | Level2)
133 {
134 sptr<IDisplayPowerEventListener> listener = new DisplayPowerEventListener();
135 bool ret = DisplayManager::GetInstance().RegisterDisplayPowerEventListener(listener);
136 ASSERT_EQ(true, ret);
137 DisplayManager::GetInstance().UnregisterDisplayPowerEventListener(listener);
138 }
139
140 /**
141 * @tc.name: register_display_power_event_listener_002
142 * @tc.desc: call RegisterDisplayPowerEventListener with an invalid listener and check return value
143 * @tc.type: FUNC
144 */
145 HWTEST_F(DisplayPowerTest, register_display_power_event_listener_002, Function | SmallTest | Level2)
146 {
147 bool ret = DisplayManager::GetInstance().RegisterDisplayPowerEventListener(nullptr);
148 ASSERT_EQ(false, ret);
149 }
150
151 /**
152 * @tc.name: unregister_display_power_event_listener_001
153 * @tc.desc: call UnregisterDisplayPowerEventListener with a valid listener and check return value
154 * @tc.type: FUNC
155 */
156 HWTEST_F(DisplayPowerTest, unregister_display_power_event_listener_001, Function | SmallTest | Level2)
157 {
158 sptr<IDisplayPowerEventListener> listener = new DisplayPowerEventListener();
159 DisplayManager::GetInstance().RegisterDisplayPowerEventListener(listener);
160 bool ret = DisplayManager::GetInstance().UnregisterDisplayPowerEventListener(listener);
161 ASSERT_EQ(true, ret);
162 }
163
164 /**
165 * @tc.name: unregister_display_power_event_listener_002
166 * @tc.desc: call UnregisterDisplayPowerEventListener with nullptr and check return value
167 * @tc.type: FUNC
168 */
169 HWTEST_F(DisplayPowerTest, unregister_display_power_event_listener_002, Function | SmallTest | Level2)
170 {
171 bool ret = DisplayManager::GetInstance().UnregisterDisplayPowerEventListener(nullptr);
172 ASSERT_EQ(false, ret);
173 }
174
175 /**
176 * @tc.name: unregister_display_power_event_listener_003
177 * @tc.desc: call UnregisterDisplayPowerEventListener with an invalid listener and check return value
178 * @tc.type: FUNC
179 */
180 HWTEST_F(DisplayPowerTest, unregister_display_power_event_listener_003, Function | SmallTest | Level2)
181 {
182 sptr<IDisplayPowerEventListener> listener = new DisplayPowerEventListener();
183 bool ret = DisplayManager::GetInstance().UnregisterDisplayPowerEventListener(listener);
184 ASSERT_EQ(false, ret);
185 }
186
187 /**
188 * @tc.name: set_display_state_001
189 * @tc.desc: Call SetDisplayState and check if it the state set is the same as calling GetDisplayState
190 * @tc.type: FUNC
191 */
192 HWTEST_F(DisplayPowerTest, set_display_state_001, Function | MediumTest | Level2)
193 {
194 DisplayState initialState = DisplayManager::GetInstance().GetDisplayState(defaultId_);
195 DisplayState stateToSet = (initialState == DisplayState::OFF ? DisplayState::ON : DisplayState::OFF);
196 bool ret = DisplayManager::GetInstance().SetDisplayState(stateToSet, callback_);
197 ASSERT_EQ(true, ret);
198 DisplayState stateGet = DisplayManager::GetInstance().GetDisplayState(defaultId_);
199 ASSERT_EQ(stateGet, stateToSet);
200 CheckDisplayStateCallback(true);
201 }
202
203 /**
204 * @tc.name: set_display_state_002
205 * @tc.desc: Call SetDisplayState to set a value already set and check the return value
206 * @tc.type: FUNC
207 */
208 HWTEST_F(DisplayPowerTest, set_display_state_002, Function | MediumTest | Level2)
209 {
210 DisplayState initialState = DisplayManager::GetInstance().GetDisplayState(defaultId_);
211 bool ret = DisplayManager::GetInstance().SetDisplayState(initialState, callback_);
212 ASSERT_EQ(false, ret);
213 DisplayState stateGet = DisplayManager::GetInstance().GetDisplayState(defaultId_);
214 ASSERT_EQ(stateGet, initialState);
215 CheckDisplayStateCallback(false);
216 ASSERT_EQ(false, isDisplayStateCallbackCalled_);
217 }
218
219 /**
220 * @tc.name: set_display_state_003
221 * @tc.desc: Call SetDisplayState with an invalid value and check the return value
222 * @tc.type: FUNC
223 */
224 HWTEST_F(DisplayPowerTest, set_display_state_003, Function | MediumTest | Level2)
225 {
226 bool ret = DisplayManager::GetInstance().SetDisplayState(DisplayState::UNKNOWN, callback_);
227 ASSERT_EQ(false, ret);
228 CheckDisplayStateCallback(false);
229 ASSERT_EQ(false, isDisplayStateCallbackCalled_);
230 CheckDisplayPowerEventCallback(false);
231 ASSERT_EQ(false, listener_->isCallbackCalled_);
232 }
233
234 /**
235 * @tc.name: set_display_state_callback_001
236 * @tc.desc: Call SetDisplayState and check if callback state is correct
237 * @tc.type: FUNC
238 */
239 HWTEST_F(DisplayPowerTest, set_display_state_callback_001, Function | MediumTest | Level2)
240 {
241 DisplayState initialState = DisplayManager::GetInstance().GetDisplayState(defaultId_);
242 DisplayState stateToSet = (initialState == DisplayState::OFF ? DisplayState::ON : DisplayState::OFF);
243 DisplayManager::GetInstance().SetDisplayState(stateToSet, callback_);
244 CheckDisplayStateCallback(true);
245 ASSERT_EQ(true, isDisplayStateCallbackCalled_);
246 ASSERT_EQ(state_, stateToSet);
247 }
248
249 /**
250 * @tc.name: set_display_state_callback_002
251 * @tc.desc: Call SetDisplayState to set a value already set and check the DisplayStateCallback
252 * @tc.type: FUNC
253 */
254 HWTEST_F(DisplayPowerTest, set_display_state_callback_002, Function | MediumTest | Level2)
255 {
256 DisplayState initialState = DisplayManager::GetInstance().GetDisplayState(defaultId_);
257 DisplayManager::GetInstance().SetDisplayState(initialState, callback_);
258 CheckDisplayStateCallback(false);
259 ASSERT_EQ(false, isDisplayStateCallbackCalled_);
260 }
261
262 /**
263 * @tc.name: wake_up_begin_callback_001
264 * @tc.desc: Call WakeUpBegin and check the OnDisplayPowerEvent callback is called
265 * @tc.type: FUNC
266 */
267 HWTEST_F(DisplayPowerTest, wake_up_begin_callback_001, Function | MediumTest | Level2)
268 {
269 bool ret = DisplayManager::GetInstance().WakeUpBegin(PowerStateChangeReason::POWER_BUTTON);
270 ASSERT_EQ(true, ret);
271 CheckDisplayPowerEventCallback(true);
272 ASSERT_EQ(true, listener_->isCallbackCalled_);
273 ASSERT_EQ(DisplayPowerEvent::WAKE_UP, listener_->event_);
274 ASSERT_EQ(EventStatus::BEGIN, listener_->status_);
275 }
276
277 /**
278 * @tc.name: wake_up_end_callback_001
279 * @tc.desc: Call WakeUpEnd and check the OnDisplayPowerEvent callback is called
280 * @tc.type: FUNC
281 */
282 HWTEST_F(DisplayPowerTest, wake_up_end_callback_001, Function | MediumTest | Level2)
283 {
284 bool ret = DisplayManager::GetInstance().WakeUpEnd();
285 ASSERT_EQ(true, ret);
286 CheckDisplayPowerEventCallback(true);
287 ASSERT_EQ(true, listener_->isCallbackCalled_);
288 ASSERT_EQ(DisplayPowerEvent::WAKE_UP, listener_->event_);
289 ASSERT_EQ(EventStatus::END, listener_->status_);
290 }
291
292 /**
293 * @tc.name: suspend_begin_callback_001
294 * @tc.desc: Call SuspendBegin and check the OnDisplayPowerEvent callback is called
295 * @tc.type: FUNC
296 */
297 HWTEST_F(DisplayPowerTest, suspend_begin_callback_001, Function | MediumTest | Level2)
298 {
299 bool ret = DisplayManager::GetInstance().SuspendBegin(PowerStateChangeReason::POWER_BUTTON);
300 ASSERT_EQ(true, ret);
301 CheckDisplayPowerEventCallback(true);
302 ASSERT_EQ(true, listener_->isCallbackCalled_);
303 ASSERT_EQ(DisplayPowerEvent::SLEEP, listener_->event_);
304 ASSERT_EQ(EventStatus::BEGIN, listener_->status_);
305 }
306
307 /**
308 * @tc.name: suspend_end_callback_001
309 * @tc.desc: Call SuspendEnd and check the OnDisplayPowerEvent callback is called
310 * @tc.type: FUNC
311 */
312 HWTEST_F(DisplayPowerTest, suspend_end_callback_001, Function | MediumTest | Level2)
313 {
314 bool ret = DisplayManager::GetInstance().SuspendEnd();
315 ASSERT_EQ(true, ret);
316 CheckDisplayPowerEventCallback(true);
317 ASSERT_EQ(true, listener_->isCallbackCalled_);
318 ASSERT_EQ(DisplayPowerEvent::SLEEP, listener_->event_);
319 ASSERT_EQ(EventStatus::END, listener_->status_);
320 }
321
322 /**
323 * @tc.name: set_screen_power_for_all_001
324 * @tc.desc: Call SetScreenPowerForAll OFF and check the OnDisplayPowerEvent callback is called
325 * @tc.type: FUNC
326 */
327 HWTEST_F(DisplayPowerTest, set_screen_power_for_all_001, Function | MediumTest | Level2)
328 {
329 bool ret = ScreenManager::GetInstance().SetScreenPowerForAll(ScreenPowerState::POWER_OFF,
330 PowerStateChangeReason::POWER_BUTTON);
331 ASSERT_EQ(true, ret);
332 CheckDisplayPowerEventCallback(true);
333 ASSERT_EQ(true, listener_->isCallbackCalled_);
334 ASSERT_EQ(DisplayPowerEvent::DISPLAY_OFF, listener_->event_);
335 ASSERT_EQ(EventStatus::END, listener_->status_);
336 }
337
338 /**
339 * @tc.name: set_screen_power_for_all_002
340 * @tc.desc: Call SetScreenPowerForAll ON and check the OnDisplayPowerEvent callback is called
341 * @tc.type: FUNC
342 */
343 HWTEST_F(DisplayPowerTest, set_screen_power_for_all_002, Function | MediumTest | Level2)
344 {
345 bool ret = ScreenManager::GetInstance().SetScreenPowerForAll(ScreenPowerState::POWER_ON,
346 PowerStateChangeReason::POWER_BUTTON);
347 ASSERT_EQ(true, ret);
348 CheckDisplayPowerEventCallback(true);
349 ASSERT_EQ(true, listener_->isCallbackCalled_);
350 ASSERT_EQ(DisplayPowerEvent::DISPLAY_ON, listener_->event_);
351 ASSERT_EQ(EventStatus::END, listener_->status_);
352 }
353
354 /**
355 * @tc.name: set_screen_power_for_all_003
356 * @tc.desc: Call SetScreenPowerForAll with an invalid value and check the return value
357 * @tc.type: FUNC
358 */
359 HWTEST_F(DisplayPowerTest, set_screen_power_for_all_003, Function | MediumTest | Level2)
360 {
361 bool ret = ScreenManager::GetInstance().SetScreenPowerForAll(ScreenPowerState::INVALID_STATE,
362 PowerStateChangeReason::POWER_BUTTON);
363 ASSERT_EQ(false, ret);
364 CheckDisplayPowerEventCallback(true);
365 ASSERT_EQ(false, listener_->isCallbackCalled_);
366 }
367
368 /**
369 * @tc.name: set_display_state_power_event_callback_001
370 * @tc.desc: Call SetDisplayState with a valid value and check the OnDisplayPowerEvent callback is called
371 * @tc.type: FUNC
372 */
373 HWTEST_F(DisplayPowerTest, set_display_state_power_event_callback_001, Function | MediumTest | Level2)
374 {
375 DisplayState initialState = DisplayManager::GetInstance().GetDisplayState(defaultId_);
376 DisplayState stateToSet = (initialState == DisplayState::OFF ? DisplayState::ON : DisplayState::OFF);
377 bool ret = DisplayManager::GetInstance().SetDisplayState(stateToSet, callback_);
378 ASSERT_EQ(true, ret);
379 CheckDisplayPowerEventCallback(true);
380 ASSERT_EQ(true, listener_->isCallbackCalled_);
381 DisplayPowerEvent expectedEvent = (stateToSet == DisplayState::OFF ? DisplayPowerEvent::DISPLAY_OFF :
382 DisplayPowerEvent::DISPLAY_ON);
383 ASSERT_EQ(expectedEvent, listener_->event_);
384 ASSERT_EQ(EventStatus::BEGIN, listener_->status_);
385 }
386
387 /**
388 * @tc.name: get_display_power_002
389 * @tc.desc: Call SetScreenPowerForAll ON and check the GetScreenPower return value
390 * @tc.type: FUNC
391 */
392 HWTEST_F(DisplayPowerTest, get_display_power_002, Function | MediumTest | Level2)
393 {
394 ScreenPowerState stateToSet = ScreenPowerState::POWER_ON;
395 bool ret = ScreenManager::GetInstance().SetScreenPowerForAll(stateToSet, PowerStateChangeReason::POWER_BUTTON);
396 ASSERT_EQ(true, ret);
397 ScreenPowerState stateGet = ScreenManager::GetInstance().GetScreenPower(defaultId_);
398 ASSERT_EQ(stateGet, stateToSet);
399 }
400
401 /**
402 * @tc.name: set_screen_brightness_001
403 * @tc.desc: Call SetScreenBrightness with a valid value and check the GetScreenBrightness return value
404 * @tc.type: FUNC
405 */
406 HWTEST_F(DisplayPowerTest, set_screen_brightness_001, Function | MediumTest | Level2)
407 {
408 bool ret = DisplayManager::GetInstance().SetScreenBrightness(defaultId_, brightnessLevel_);
409 ASSERT_EQ(true, ret);
410 uint32_t level = DisplayManager::GetInstance().GetScreenBrightness(defaultId_);
411 ASSERT_EQ(level, brightnessLevel_);
412 }
413
414 /**
415 * @tc.name: window_life_cycle_001
416 * @tc.desc: Add a window and then call SuspendEnd and check window state; Notify unlock and check window state
417 * @tc.type: FUNC
418 */
419 HWTEST_F(DisplayPowerTest, window_life_cycle_001, Function | MediumTest | Level2)
420 {
421 sptr<WindowOption> option = new WindowOption();
422 sptr<Window> window = Window::Create("window1", option, nullptr);
423 EXPECT_EQ(WMError::WM_OK, window->Show());
424
425 DisplayManager::GetInstance().SuspendBegin(PowerStateChangeReason::POWER_BUTTON);
426 usleep(SLEEP_TIME_IN_US);
427 ASSERT_EQ(false, window->GetWindowState() == WindowState::STATE_SHOWN);
428
429 DisplayManager::GetInstance().NotifyDisplayEvent(DisplayEvent::UNLOCK);
430 usleep(SLEEP_TIME_IN_US);
431 ASSERT_EQ(true, window->GetWindowState() == WindowState::STATE_SHOWN);
432
433 window->Destroy();
434 }
435 } // namespace
436 } // namespace Rosen
437 } // namespace OHOS