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 "display_manager.h"
18 #include "screen_manager.h"
19 #include "mock_display_manager_adapter.h"
20 #include "singleton_mocker.h"
21
22 using namespace testing;
23 using namespace testing::ext;
24
25 namespace OHOS {
26 namespace Rosen {
27 using Mocker = SingletonMocker<DisplayManagerAdapter, MockDisplayManagerAdapter>;
28
29 class DisplayPowerEventListener : public IDisplayPowerEventListener {
30 public:
OnDisplayPowerEvent(DisplayPowerEvent event,EventStatus status)31 virtual void OnDisplayPowerEvent(DisplayPowerEvent event, EventStatus status) {}
32 };
33
34 class DisplayPowerUnitTest : public testing::Test {
35 public:
36 static void SetUpTestCase();
37 static void TearDownTestCase();
38 virtual void SetUp() override;
39 virtual void TearDown() override;
40 static inline sptr<DisplayPowerEventListener> listener_ = new DisplayPowerEventListener();
41 static inline DisplayId defaultId_ = 0;
42 static inline uint32_t brightnessLevel_ = 80;
43 static inline uint32_t invalidBrightnessLevel_ = 1000000000;
44 static inline ScreenPowerState initialPowerState_;
45 static inline DisplayState initialState_;
46 };
47
SetUpTestCase()48 void DisplayPowerUnitTest::SetUpTestCase()
49 {
50 }
51
TearDownTestCase()52 void DisplayPowerUnitTest::TearDownTestCase()
53 {
54 }
55
SetUp()56 void DisplayPowerUnitTest::SetUp()
57 {
58 initialPowerState_ = ScreenManager::GetInstance().GetScreenPower(defaultId_);
59 initialState_ = DisplayManager::GetInstance().GetDisplayState(defaultId_);
60 }
61
TearDown()62 void DisplayPowerUnitTest::TearDown()
63 {
64 ScreenManager::GetInstance().SetScreenPowerForAll(initialPowerState_, PowerStateChangeReason::POWER_BUTTON);
65 DisplayStateCallback callback;
66 DisplayManager::GetInstance().SetDisplayState(initialState_, callback);
67 }
68
69 namespace {
70 /**
71 * @tc.name: register_display_power_event_listener_001
72 * @tc.desc: call Register/UnregisterDisplayPowerEventListener with a valid listener and check return value
73 * @tc.type: FUNC
74 */
75 HWTEST_F(DisplayPowerUnitTest, register_display_power_event_listener_001, Function | SmallTest | Level2)
76 {
77 Mocker m;
78
79 EXPECT_CALL(m.Mock(), RegisterDisplayManagerAgent(_, DisplayManagerAgentType::DISPLAY_POWER_EVENT_LISTENER))
80 .Times(1).WillOnce(Return(DMError::DM_OK));
81 DMError ret = DisplayManager::GetInstance().RegisterDisplayPowerEventListener(listener_);
82 ASSERT_EQ(DMError::DM_OK, ret);
83
84 EXPECT_CALL(m.Mock(), UnregisterDisplayManagerAgent(_, DisplayManagerAgentType::DISPLAY_POWER_EVENT_LISTENER))
85 .Times(1).WillOnce(Return(DMError::DM_OK));
86 ret = DisplayManager::GetInstance().UnregisterDisplayPowerEventListener(listener_);
87 ASSERT_EQ(DMError::DM_OK, ret);
88 }
89
90 /**
91 * @tc.name: register_display_power_event_listener_002
92 * @tc.desc: call Register/UnregisterDisplayPowerEventListener with nullptr and check return value
93 * @tc.type: FUNC
94 */
95 HWTEST_F(DisplayPowerUnitTest, register_display_power_event_listener_002, Function | SmallTest | Level2)
96 {
97 Mocker m;
98 EXPECT_CALL(m.Mock(), RegisterDisplayManagerAgent(_, DisplayManagerAgentType::DISPLAY_POWER_EVENT_LISTENER))
99 .Times(0);
100 DMError ret = DisplayManager::GetInstance().RegisterDisplayPowerEventListener(nullptr);
101 ASSERT_EQ(DMError::DM_ERROR_NULLPTR, ret);
102
103 EXPECT_CALL(m.Mock(), UnregisterDisplayManagerAgent(_, DisplayManagerAgentType::DISPLAY_POWER_EVENT_LISTENER))
104 .Times(0);
105 ret = DisplayManager::GetInstance().UnregisterDisplayPowerEventListener(nullptr);
106 ASSERT_EQ(DMError::DM_ERROR_NULLPTR, ret);
107 }
108
109 /**
110 * @tc.name: register_display_power_event_listener_003
111 * @tc.desc: call Register/UnregisterDisplayPowerEventListener with ipc failed and check return value
112 * @tc.type: FUNC
113 */
114 HWTEST_F(DisplayPowerUnitTest, register_display_power_event_listener_003, Function | SmallTest | Level2)
115 {
116 Mocker m;
117 EXPECT_CALL(m.Mock(), RegisterDisplayManagerAgent(_, DisplayManagerAgentType::DISPLAY_POWER_EVENT_LISTENER))
118 .Times(1).WillOnce(Return(DMError::DM_ERROR_NULLPTR));
119 DMError ret = DisplayManager::GetInstance().RegisterDisplayPowerEventListener(listener_);
120 ASSERT_EQ(DMError::DM_ERROR_NULLPTR, ret);
121
122 EXPECT_CALL(m.Mock(), UnregisterDisplayManagerAgent(_, DisplayManagerAgentType::DISPLAY_POWER_EVENT_LISTENER))
123 .Times(0);
124 ret = DisplayManager::GetInstance().UnregisterDisplayPowerEventListener(listener_);
125 ASSERT_EQ(DMError::DM_ERROR_NULLPTR, ret);
126 }
127
128 /**
129 * @tc.name: unregister_display_power_event_listener_001
130 * @tc.desc: call UnregisterDisplayPowerEventListener with a listener never registered and check return value
131 * @tc.type: FUNC
132 */
133 HWTEST_F(DisplayPowerUnitTest, unregister_display_power_event_listener_001, Function | SmallTest | Level2)
134 {
135 Mocker m;
136 EXPECT_CALL(m.Mock(), UnregisterDisplayManagerAgent(_, DisplayManagerAgentType::DISPLAY_POWER_EVENT_LISTENER))
137 .Times(0);
138 DMError ret = DisplayManager::GetInstance().UnregisterDisplayPowerEventListener(listener_);
139 ASSERT_EQ(DMError::DM_ERROR_NULLPTR, ret);
140 }
141
142 /**
143 * @tc.name: unregister_display_power_event_listener_002
144 * @tc.desc: call UnregisterDisplayPowerEventListener with nullptr and check return value
145 * @tc.type: FUNC
146 */
147 HWTEST_F(DisplayPowerUnitTest, unregister_display_power_event_listener_002, Function | SmallTest | Level2)
148 {
149 Mocker m;
150 EXPECT_CALL(m.Mock(), UnregisterDisplayManagerAgent(_, DisplayManagerAgentType::DISPLAY_POWER_EVENT_LISTENER))
151 .Times(0);
152 DMError ret = DisplayManager::GetInstance().UnregisterDisplayPowerEventListener(nullptr);
153 ASSERT_EQ(DMError::DM_ERROR_NULLPTR, ret);
154 }
155
156 /**
157 * @tc.name: wake_up_begin_001
158 * @tc.desc: call WakeUpBegin and check return value
159 * @tc.type: FUNC
160 */
161 HWTEST_F(DisplayPowerUnitTest, wake_up_begin_001, Function | SmallTest | Level2)
162 {
163 Mocker m;
164 EXPECT_CALL(m.Mock(), WakeUpBegin(PowerStateChangeReason::POWER_BUTTON)).Times(1).WillOnce(Return(true));;
165 bool ret = DisplayManager::GetInstance().WakeUpBegin(PowerStateChangeReason::POWER_BUTTON);
166 ASSERT_EQ(true, ret);
167
168 EXPECT_CALL(m.Mock(), WakeUpBegin(PowerStateChangeReason::POWER_BUTTON)).Times(1).WillOnce(Return(false));;
169 ret = DisplayManager::GetInstance().WakeUpBegin(PowerStateChangeReason::POWER_BUTTON);
170 ASSERT_EQ(false, ret);
171 }
172
173 /**
174 * @tc.name: wake_up_end_001
175 * @tc.desc: call WakeUpEnd and check return value
176 * @tc.type: FUNC
177 */
178 HWTEST_F(DisplayPowerUnitTest, wake_up_end_001, Function | SmallTest | Level2)
179 {
180 Mocker m;
181 EXPECT_CALL(m.Mock(), WakeUpEnd()).Times(1).WillOnce(Return(true));
182 bool ret = DisplayManager::GetInstance().WakeUpEnd();
183 ASSERT_EQ(true, ret);
184
185 EXPECT_CALL(m.Mock(), WakeUpEnd()).Times(1).WillOnce(Return(false));
186 ret = DisplayManager::GetInstance().WakeUpEnd();
187 ASSERT_EQ(false, ret);
188 }
189
190 /**
191 * @tc.name: suspend_begin_001
192 * @tc.desc: call SuspendBegin and check return value
193 * @tc.type: FUNC
194 */
195 HWTEST_F(DisplayPowerUnitTest, suspend_begin_001, Function | SmallTest | Level2)
196 {
197 Mocker m;
198 EXPECT_CALL(m.Mock(), SuspendBegin(PowerStateChangeReason::POWER_BUTTON)).Times(1).WillOnce(Return(true));;
199 bool ret = DisplayManager::GetInstance().SuspendBegin(PowerStateChangeReason::POWER_BUTTON);
200 ASSERT_EQ(true, ret);
201
202 EXPECT_CALL(m.Mock(), SuspendBegin(PowerStateChangeReason::POWER_BUTTON)).Times(1).WillOnce(Return(false));;
203 ret = DisplayManager::GetInstance().SuspendBegin(PowerStateChangeReason::POWER_BUTTON);
204 ASSERT_EQ(false, ret);
205 }
206
207 /**
208 * @tc.name: suspend_end_001
209 * @tc.desc: call SuspendEnd and check return value
210 * @tc.type: FUNC
211 */
212 HWTEST_F(DisplayPowerUnitTest, suspend_end_001, Function | SmallTest | Level2)
213 {
214 Mocker m;
215 EXPECT_CALL(m.Mock(), SuspendEnd()).Times(1).WillOnce(Return(true));
216 bool ret = DisplayManager::GetInstance().SuspendEnd();
217 ASSERT_EQ(true, ret);
218
219 EXPECT_CALL(m.Mock(), SuspendEnd()).Times(1).WillOnce(Return(false));
220 ret = DisplayManager::GetInstance().SuspendEnd();
221 ASSERT_EQ(false, ret);
222 }
223
224 /**
225 * @tc.name: set_screen_brightness_001
226 * @tc.desc: Call SetScreenBrightness with a valid value and check the GetScreenBrightness return value
227 * @tc.type: FUNC
228 */
229 HWTEST_F(DisplayPowerUnitTest, set_screen_brightness_001, Function | MediumTest | Level2)
230 {
231 bool ret = DisplayManager::GetInstance().SetScreenBrightness(defaultId_, brightnessLevel_);
232 ASSERT_EQ(true, ret);
233 }
234
235 /**
236 * @tc.name: set_screen_power_for_all_001
237 * @tc.desc: Call SetScreenPowerForAll with valid value and check the GetScreenPower return value
238 * @tc.type: FUNC
239 */
240 HWTEST_F(DisplayPowerUnitTest, set_screen_power_for_all_001, Function | MediumTest | Level2)
241 {
242 SingletonMocker<ScreenManagerAdapter, MockScreenManagerAdapter> m;
243 EXPECT_CALL(m.Mock(), GetScreenPower(_)).Times(1).WillOnce(Return(ScreenPowerState::POWER_OFF));
244 EXPECT_CALL(m.Mock(), SetScreenPowerForAll(_, PowerStateChangeReason::POWER_BUTTON))
245 .Times(1).WillOnce(Return(true));
246
247 bool ret = ScreenManager::GetInstance().SetScreenPowerForAll(ScreenPowerState::POWER_OFF,
248 PowerStateChangeReason::POWER_BUTTON);
249 ASSERT_EQ(true, ret);
250
251 ScreenPowerState state = ScreenManager::GetInstance().GetScreenPower(defaultId_);
252 ASSERT_EQ(state, ScreenPowerState::POWER_OFF);
253 }
254
255 /**
256 * @tc.name: set_display_state_001
257 * @tc.desc: Call SetDisplayState with valid value and check the GetDisplayState return value
258 * @tc.type: FUNC
259 */
260 HWTEST_F(DisplayPowerUnitTest, set_display_state_001, Function | MediumTest | Level2)
261 {
262 DisplayState stateToSet = (initialState_ == DisplayState::OFF ? DisplayState::ON : DisplayState::OFF);
263 Mocker m;
264 EXPECT_CALL(m.Mock(), RegisterDisplayManagerAgent(_, DisplayManagerAgentType::DISPLAY_STATE_LISTENER))
265 .Times(1).WillOnce(Return(DMError::DM_OK));
266 EXPECT_CALL(m.Mock(), SetDisplayState(stateToSet)).Times(1).WillOnce(Return(true));
__anon8640d15e0202(DisplayState state) 267 DisplayStateCallback callback = [](DisplayState state) {};
268 bool ret = DisplayManager::GetInstance().SetDisplayState(stateToSet, callback);
269 ASSERT_EQ(true, ret);
270
271 EXPECT_CALL(m.Mock(), GetDisplayState(defaultId_)).Times(1).WillOnce(Return(stateToSet));
272 DisplayState state = DisplayManager::GetInstance().GetDisplayState(defaultId_);
273 ASSERT_EQ(state, stateToSet);
274 }
275
276 /**
277 * @tc.name: set_display_state_002
278 * @tc.desc: Call SetDisplayState with invalid callback and check the GetDisplayState return value
279 * @tc.type: FUNC
280 */
281 HWTEST_F(DisplayPowerUnitTest, set_display_state_002, Function | MediumTest | Level2)
282 {
283 Mocker m;
284 EXPECT_CALL(m.Mock(), SetDisplayState(_)).Times(0);
285 DisplayState stateToSet = (initialState_ == DisplayState::OFF ? DisplayState::ON : DisplayState::OFF);
286 bool ret = DisplayManager::GetInstance().SetDisplayState(stateToSet, nullptr);
287 ASSERT_EQ(false, ret);
288 }
289 }
290 }
291 }