1 /*
2 * Copyright (c) 2023 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_lite.h"
18 #include "mock_display_manager_adapter_lite.h"
19 #include "singleton_mocker.h"
20 #include "display_manager_lite.cpp"
21
22 using namespace testing;
23 using namespace testing::ext;
24
25 namespace OHOS {
26 namespace Rosen {
27 using Mocker = SingletonMocker<DisplayManagerAdapterLite, MockDisplayManagerAdapterLite>;
28 class DmMockDisplayListener : public DisplayManagerLite::IDisplayListener {
29 public:
OnCreate(DisplayId)30 void OnCreate(DisplayId) override {}
OnDestroy(DisplayId)31 void OnDestroy(DisplayId) override {}
OnChange(DisplayId)32 void OnChange(DisplayId) override {}
33 };
34 class DmMockFoldStatusListener : public DisplayManagerLite::IFoldStatusListener {
35 public:
36 virtual void OnFoldStatusChanged([[maybe_unused]]FoldStatus foldStatus) {}
37 };
38 class DisplayManagerTest : public testing::Test {
39 public:
40 static void SetUpTestCase();
41 static void TearDownTestCase();
42 void SetUp() override;
43 void TearDown() override;
44 };
45
SetUpTestCase()46 void DisplayManagerTest::SetUpTestCase()
47 {
48 }
49
TearDownTestCase()50 void DisplayManagerTest::TearDownTestCase()
51 {
52 }
53
SetUp()54 void DisplayManagerTest::SetUp()
55 {
56 }
57
TearDown()58 void DisplayManagerTest::TearDown()
59 {
60 }
61
62 namespace {
63 /**
64 * @tc.name: OnDisplayCreate01
65 * @tc.desc: OnDisplayCreate
66 * @tc.type: FUNC
67 */
68 HWTEST_F(DisplayManagerTest, OnDisplayCreate01, Function | SmallTest | Level1)
69 {
70 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
71 EXPECT_CALL(m->Mock(), RegisterDisplayManagerAgent(_, _)).Times(1).WillOnce(Return(DMError::DM_OK));
72 sptr<DisplayManagerLite::IDisplayListener> listener = new DmMockDisplayListener();
73 DisplayManagerLite::GetInstance().RegisterDisplayListener(listener);
74 auto displayManagerListener = DisplayManagerLite::GetInstance().pImpl_->displayManagerListener_;
75 ASSERT_NE(displayManagerListener, nullptr);
76 displayManagerListener->OnDisplayCreate(nullptr);
77 sptr<DisplayInfo> displayInfo = new DisplayInfo();
78 displayInfo->SetDisplayId(DISPLAY_ID_INVALID);
79 displayManagerListener->OnDisplayCreate(displayInfo);
80 displayInfo->SetDisplayId(0);
81 displayManagerListener->OnDisplayCreate(displayInfo);
82 ASSERT_NE(displayManagerListener->pImpl_, nullptr);
83 displayManagerListener->pImpl_ = nullptr;
84 displayManagerListener->OnDisplayCreate(displayInfo);
85 DisplayManagerLite::GetInstance().pImpl_->displayManagerListener_ = nullptr;
86 }
87
88 /**
89 * @tc.name: OnDisplayDestroy
90 * @tc.desc: OnDisplayDestroy
91 * @tc.type: FUNC
92 */
93 HWTEST_F(DisplayManagerTest, OnDisplayDestroy, Function | SmallTest | Level1)
94 {
95 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
96 EXPECT_CALL(m->Mock(), RegisterDisplayManagerAgent(_, _)).Times(1).WillOnce(Return(DMError::DM_OK));
97 sptr<DisplayManagerLite::IDisplayListener> listener = new DmMockDisplayListener();
98 DisplayManagerLite::GetInstance().RegisterDisplayListener(listener);
99 auto displayManagerListener = DisplayManagerLite::GetInstance().pImpl_->displayManagerListener_;
100 ASSERT_NE(displayManagerListener, nullptr);
101 displayManagerListener->OnDisplayDestroy(DISPLAY_ID_INVALID);
102 displayManagerListener->OnDisplayDestroy(0);
103 displayManagerListener->pImpl_ = nullptr;
104 displayManagerListener->OnDisplayDestroy(1);
105 DisplayManagerLite::GetInstance().pImpl_->displayManagerListener_ = nullptr;
106 }
107
108 /**
109 * @tc.name: OnDisplayChange
110 * @tc.desc: OnDisplayChange
111 * @tc.type: FUNC
112 */
113 HWTEST_F(DisplayManagerTest, OnDisplayChange, Function | SmallTest | Level1)
114 {
115 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
116 EXPECT_CALL(m->Mock(), RegisterDisplayManagerAgent(_, _)).Times(1).WillOnce(Return(DMError::DM_OK));
117 sptr<DisplayManagerLite::IDisplayListener> listener = new DmMockDisplayListener();
118 DisplayManagerLite::GetInstance().RegisterDisplayListener(listener);
119 auto displayManagerListener = DisplayManagerLite::GetInstance().pImpl_->displayManagerListener_;
120 ASSERT_NE(displayManagerListener, nullptr);
121 DisplayChangeEvent event = DisplayChangeEvent::DISPLAY_SIZE_CHANGED;
122 displayManagerListener->OnDisplayChange(nullptr, event);
123 sptr<DisplayInfo> displayInfo = new DisplayInfo();
124 displayInfo->SetDisplayId(DISPLAY_ID_INVALID);
125 displayManagerListener->OnDisplayChange(displayInfo, event);
126 displayInfo->SetDisplayId(0);
127 displayManagerListener->OnDisplayChange(displayInfo, event);
128 ASSERT_NE(displayManagerListener->pImpl_, nullptr);
129 displayManagerListener->pImpl_ = nullptr;
130 displayManagerListener->OnDisplayChange(displayInfo, event);
131 DisplayManagerLite::GetInstance().pImpl_->displayManagerListener_ = nullptr;
132 }
133
134 /**
135 * @tc.name: ImplUpdateDisplayInfoLocked
136 * @tc.desc: ImplUpdateDisplayInfoLocked fun
137 * @tc.type: FUNC
138 */
139 HWTEST_F(DisplayManagerTest, ImplUpdateDisplayInfoLocked, Function | SmallTest | Level1)
140 {
141 sptr<DisplayInfo> displayInfo = new DisplayInfo();
142 displayInfo->SetDisplayId(DISPLAY_ID_INVALID);
143 auto ret = DisplayManagerLite::GetInstance().pImpl_->UpdateDisplayInfoLocked(displayInfo);
144 ASSERT_EQ(ret, false);
145 displayInfo.clear();
146 }
147
148 /**
149 * @tc.name: ImplUpdateDisplayInfoLocked
150 * @tc.desc: ImplUpdateDisplayInfoLocked fun
151 * @tc.type: FUNC
152 */
153 HWTEST_F(DisplayManagerTest, ImplUpdateDisplayInfoLocked01, Function | SmallTest | Level1)
154 {
155 sptr<DisplayInfo> displayInfo = nullptr;
156 auto ret = DisplayManagerLite::GetInstance().pImpl_->UpdateDisplayInfoLocked(displayInfo);
157 ASSERT_EQ(ret, false);
158 displayInfo.clear();
159 }
160
161 /**
162 * @tc.name: RegisterDisplayListener
163 * @tc.desc: displayManagerListener_ == nullptr, ret == DMError::DM_OK
164 * @tc.type: FUNC
165 */
166 HWTEST_F(DisplayManagerTest, RegisterDisplayListener01, Function | SmallTest | Level1)
167 {
168 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
169 EXPECT_CALL(m->Mock(), RegisterDisplayManagerAgent(_, _)).Times(1).WillOnce(Return(DMError::DM_OK));
170 sptr<DisplayManagerLite::IDisplayListener> listener = new DmMockDisplayListener();
171 DisplayManagerLite::GetInstance().pImpl_->displayManagerListener_ = nullptr;
172 DisplayManagerLite::GetInstance().RegisterDisplayListener(listener);
173 auto displayManagerListener = DisplayManagerLite::GetInstance().pImpl_->displayManagerListener_;
174 ASSERT_NE(displayManagerListener, nullptr);
175 }
176
177 /**
178 * @tc.name: RegisterDisplayListener
179 * @tc.desc: ret ! = DMError::DM_OK
180 * @tc.type: FUNC
181 */
182 HWTEST_F(DisplayManagerTest, RegisterDisplayListener02, Function | SmallTest | Level1)
183 {
184 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
185 EXPECT_CALL(m->Mock(), RegisterDisplayManagerAgent(_, _)).Times(1).WillOnce(Return(DMError::DM_ERROR_IPC_FAILED));
186 sptr<DisplayManagerLite::IDisplayListener> listener = new DmMockDisplayListener();
187 DisplayManagerLite::GetInstance().pImpl_->displayManagerListener_ = nullptr;
188 DisplayManagerLite::GetInstance().RegisterDisplayListener(listener);
189 auto displayManagerListener = DisplayManagerLite::GetInstance().pImpl_->displayManagerListener_;
190 ASSERT_EQ(displayManagerListener, nullptr);
191 }
192
193 /**
194 * @tc.name: RegisterDisplayListener
195 * @tc.desc: listener == nullptr
196 * @tc.type: FUNC
197 */
198 HWTEST_F(DisplayManagerTest, RegisterDisplayListener03, Function | SmallTest | Level1)
199 {
200 sptr<DisplayManagerLite::IDisplayListener> listener = nullptr;
201 auto ret = DisplayManagerLite::GetInstance().RegisterDisplayListener(listener);
202 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
203 }
204
205 /**
206 * @tc.name: RegisterDisplayListener
207 * @tc.desc: displayManagerListener_ != nullptr
208 * @tc.type: FUNC
209 */
210 HWTEST_F(DisplayManagerTest, RegisterDisplayListener04, Function | SmallTest | Level1)
211 {
212 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
213 EXPECT_CALL(m->Mock(), RegisterDisplayManagerAgent(_, _)).Times(1).WillOnce(Return(DMError::DM_OK));
214 sptr<DisplayManagerLite::IDisplayListener> listener = new DmMockDisplayListener();
215 sptr<DisplayManagerLite::IDisplayListener> listener1 = new DmMockDisplayListener();
216 DisplayManagerLite::GetInstance().RegisterDisplayListener(listener);
217 auto ret = DisplayManagerLite::GetInstance().RegisterDisplayListener(listener1);
218 ASSERT_EQ(ret, DMError::DM_OK);
219 }
220
221 /**
222 * @tc.name: UnregisterDisplayListener
223 * @tc.desc: listener == nullptr
224 * @tc.type: FUNC
225 */
226 HWTEST_F(DisplayManagerTest, UnregisterDisplayListener01, Function | SmallTest | Level1)
227 {
228 sptr<DisplayManagerLite::IDisplayListener> listener = nullptr;
229 auto ret = DisplayManagerLite::GetInstance().UnregisterDisplayListener(listener);
230 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
231 }
232
233 /**
234 * @tc.name: UnregisterDisplayListener
235 * @tc.desc: iter == displayListeners_.end()
236 * @tc.type: FUNC
237 */
238 HWTEST_F(DisplayManagerTest, UnregisterDisplayListener02, Function | SmallTest | Level1)
239 {
240 sptr<DisplayManagerLite::IDisplayListener> listener = new DmMockDisplayListener();
241 auto ret = DisplayManagerLite::GetInstance().UnregisterDisplayListener(listener);
242 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
243 }
244
245 /**
246 * @tc.name: UnregisterDisplayListener
247 * @tc.desc: iter == displayListeners_.end()
248 * @tc.type: FUNC
249 */
250 HWTEST_F(DisplayManagerTest, UnregisterDisplayListener03, Function | SmallTest | Level1)
251 {
252 sptr<DisplayManagerLite::IDisplayListener> listener = new DmMockDisplayListener();
253 DisplayManagerLite::GetInstance().pImpl_->displayListeners_.insert(listener);
254 auto ret = DisplayManagerLite::GetInstance().UnregisterDisplayListener(listener);
255 ASSERT_EQ(ret, DMError::DM_OK);
256 }
257
258 /**
259 * @tc.name: RegisterFoldStatusListener
260 * @tc.desc: listener == nullptr
261 * @tc.type: FUNC
262 */
263 HWTEST_F(DisplayManagerTest, RegisterFoldStatusListener01, Function | SmallTest | Level1)
264 {
265 sptr<DisplayManagerLite::IFoldStatusListener> listener = nullptr;
266 auto ret = DisplayManagerLite::GetInstance().RegisterFoldStatusListener(listener);
267 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
268 }
269
270 /**
271 * @tc.name: RegisterFoldStatusListener
272 * @tc.desc: listener == nullptr
273 * @tc.type: FUNC
274 */
275 HWTEST_F(DisplayManagerTest, RegisterFoldStatusListener02, Function | SmallTest | Level1)
276 {
277 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
278 EXPECT_CALL(m->Mock(), RegisterDisplayManagerAgent(_, _)).Times(1).WillOnce(Return(DMError::DM_OK));
279 sptr<DisplayManagerLite::IFoldStatusListener> listener = new DmMockFoldStatusListener();
280 auto ret = DisplayManagerLite::GetInstance().RegisterFoldStatusListener(listener);
281 ASSERT_EQ(ret, DMError::DM_OK);
282 DisplayManagerLite::GetInstance().pImpl_->foldStatusListenerAgent_ = nullptr;
283 }
284
285 /**
286 * @tc.name: RegisterFoldStatusListener
287 * @tc.desc: foldStatusListenerAgent_ == nullptr, ret != DMError::DM_OK
288 * @tc.type: FUNC
289 */
290 HWTEST_F(DisplayManagerTest, RegisterFoldStatusListener03, Function | SmallTest | Level1)
291 {
292 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
293 EXPECT_CALL(m->Mock(), RegisterDisplayManagerAgent(_, _)).Times(1).WillOnce(Return(DMError::DM_ERROR_IPC_FAILED));
294 sptr<DisplayManagerLite::IFoldStatusListener> listener = new DmMockFoldStatusListener();
295 DisplayManagerLite::GetInstance().RegisterFoldStatusListener(listener);
296 ASSERT_EQ(DisplayManagerLite::GetInstance().pImpl_->foldStatusListenerAgent_, nullptr);
297 }
298
299 /**
300 * @tc.name: RegisterFoldStatusListener
301 * @tc.desc: foldStatusListenerAgent_ != nullptr, ret == DMError::DM_OK
302 * @tc.type: FUNC
303 */
304 HWTEST_F(DisplayManagerTest, RegisterFoldStatusListener04, Function | SmallTest | Level1)
305 {
306 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
307 EXPECT_CALL(m->Mock(), RegisterDisplayManagerAgent(_, _)).Times(1).WillOnce(Return(DMError::DM_OK));
308 sptr<DisplayManagerLite::IFoldStatusListener> listener = new DmMockFoldStatusListener();
309 sptr<DisplayManagerLite::IFoldStatusListener> listener1 = new DmMockFoldStatusListener();
310 DisplayManagerLite::GetInstance().RegisterFoldStatusListener(listener);
311 auto ret = DisplayManagerLite::GetInstance().RegisterFoldStatusListener(listener1);
312 ASSERT_EQ(ret, DMError::DM_OK);
313 }
314
315 /**
316 * @tc.name: UnregisterFoldStatusListener
317 * @tc.desc: foldStatusListenerAgent_ != nullptr, ret == DMError::DM_OK
318 * @tc.type: FUNC
319 */
320 HWTEST_F(DisplayManagerTest, UnregisterFoldStatusListener01, Function | SmallTest | Level1)
321 {
322 sptr<DisplayManagerLite::IFoldStatusListener> listener = nullptr;
323 auto ret = DisplayManagerLite::GetInstance().UnregisterFoldStatusListener(listener);
324 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
325 }
326
327 /**
328 * @tc.name: UnregisterFoldStatusListener
329 * @tc.desc: iter == foldStatusListeners_.end()
330 * @tc.type: FUNC
331 */
332 HWTEST_F(DisplayManagerTest, UnregisterFoldStatusListener02, Function | SmallTest | Level1)
333 {
334 sptr<DisplayManagerLite::IFoldStatusListener> listener = new DmMockFoldStatusListener();
335 auto ret = DisplayManagerLite::GetInstance().UnregisterFoldStatusListener(listener);
336 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
337 }
338
339 /**
340 * @tc.name: UnregisterFoldStatusListener
341 * @tc.desc: iter != foldStatusListeners_.end()
342 * @tc.type: FUNC
343 */
344 HWTEST_F(DisplayManagerTest, UnregisterFoldStatusListener03, Function | SmallTest | Level1)
345 {
346 sptr<DisplayManagerLite::IFoldStatusListener> listener = new DmMockFoldStatusListener();
347 DisplayManagerLite::GetInstance().pImpl_->foldStatusListeners_.insert(listener);
348 auto ret = DisplayManagerLite::GetInstance().UnregisterFoldStatusListener(listener);
349 ASSERT_EQ(ret, DMError::DM_OK);
350 }
351
352 /**
353 * @tc.name: GetDefaultDisplay
354 * @tc.desc: GetDefaultDisplay
355 * @tc.type: FUNC
356 */
357 HWTEST_F(DisplayManagerTest, GetDefaultDisplay, Function | SmallTest | Level1)
358 {
359 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
360 EXPECT_CALL(m->Mock(), GetDefaultDisplayInfo()).Times(1).WillOnce(Return(nullptr));
361 auto ret = DisplayManagerLite::GetInstance().GetDefaultDisplay();
362 ASSERT_EQ(ret, nullptr);
363 }
364
365 /**
366 * @tc.name: GetDisplayById
367 * @tc.desc: destroyed_ == false
368 * @tc.type: FUNC
369 */
370 HWTEST_F(DisplayManagerTest, GetDisplayById01, Function | SmallTest | Level1)
371 {
372 DisplayId displayId = 1000;
373 auto ret = DisplayManagerLite::GetInstance().GetDisplayById(displayId);
374 ASSERT_EQ(ret, nullptr);
375 }
376
377 /**
378 * @tc.name: GetDisplayById
379 * @tc.desc: UpdateDisplayInfoLocked
380 * @tc.type: FUNC
381 */
382 HWTEST_F(DisplayManagerTest, GetDisplayById02, Function | SmallTest | Level1)
383 {
384 DisplayManagerLite::GetInstance().destroyed_ = false;
385 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
386 EXPECT_CALL(m->Mock(), GetDisplayInfo(_)).Times(1).WillOnce(Return(nullptr));
387 DisplayId displayId = 1000;
388 auto ret = DisplayManagerLite::GetInstance().GetDisplayById(displayId);
389 ASSERT_EQ(ret, nullptr);
390 }
391
392 /**
393 * @tc.name: GetScreenBrightness
394 * @tc.desc: GetScreenBrightness
395 * @tc.type: FUNC
396 */
397 HWTEST_F(DisplayManagerTest, GetScreenBrightness, Function | SmallTest | Level1)
398 {
399 uint64_t screenId = 2;
400 auto ret = DisplayManagerLite::GetInstance().GetScreenBrightness(screenId);
401 ASSERT_FALSE(ret == 1);
402 }
403
404 }
405 } // namespace Rosen
406 } // namespace OHOS