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