1 /*
2 * Copyright (c) 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 #define private public
18 #include "display_manager_adapter_impl.h"
19 #include "screen_manager.h"
20 #include "screen_manager/rs_screen_mode_info.h"
21 #undef private
22
23 #include "syspara/parameters.h"
24 #include "display_info.h"
25
26 using namespace testing;
27 using namespace testing::ext;
28 using namespace OHOS;
29 using namespace OHOS::Rosen;
30 using namespace OHOS::NWeb;
31
32 namespace OHOS {
33 namespace {
34 DMError g_unregister = DMError::DM_ERROR_NULLPTR;
35 constexpr uint64_t DISPLAY_ID_INVALID = -1ULL;
36 }
37
38 namespace Rosen {
UnregisterDisplayListener(sptr<IDisplayListener> listener)39 DMError DisplayManager::UnregisterDisplayListener(sptr<IDisplayListener> listener)
40 {
41 return g_unregister;
42 }
43 }
44
45 std::string g_deviceType = "";
46 namespace system {
GetDeviceType()47 std::string GetDeviceType()
48 {
49 return g_deviceType;
50 }
51 }
52
53 namespace NWeb {
54 class DisplayListenerAdapterTest : public DisplayListenerAdapter {
55 public:
56 DisplayListenerAdapterTest() = default;
57
58 virtual ~DisplayListenerAdapterTest() = default;
59
OnCreate(DisplayId)60 void OnCreate(DisplayId) override {}
OnDestroy(DisplayId)61 void OnDestroy(DisplayId) override {}
OnChange(DisplayId)62 void OnChange(DisplayId) override {}
63 };
64
65 class FoldStatusListenerAdapterTest : public FoldStatusListenerAdapter {
66 public:
67 FoldStatusListenerAdapterTest() = default;
68
69 virtual ~FoldStatusListenerAdapterTest() = default;
70
OnFoldStatusChanged(FoldStatus foldstatus)71 void OnFoldStatusChanged(FoldStatus foldstatus) override {}
72 };
73
74 class DisplayManagerAdapterImplTest : public testing::Test {
75 public:
76 static void SetUpTestCase(void);
77 static void TearDownTestCase(void);
78 void SetUp();
79 void TearDown();
80 };
81
SetUpTestCase(void)82 void DisplayManagerAdapterImplTest::SetUpTestCase(void)
83 {}
84
TearDownTestCase(void)85 void DisplayManagerAdapterImplTest::TearDownTestCase(void)
86 {}
87
SetUp(void)88 void DisplayManagerAdapterImplTest::SetUp(void)
89 {}
90
TearDown(void)91 void DisplayManagerAdapterImplTest::TearDown(void)
92 {}
93
94 /**
95 * @tc.name: DisplayManagerAdapterImplTest_001.
96 * @tc.desc: test lock type.
97 * @tc.type: FUNC
98 * @tc.require:
99 */
100 HWTEST_F(DisplayManagerAdapterImplTest, DisplayManagerAdapterImplTest_001, TestSize.Level1)
101 {
102 std::unique_ptr<DisplayAdapterImpl> displayAdapterImpl = std::make_unique<DisplayAdapterImpl>(nullptr);
103 EXPECT_NE(displayAdapterImpl, nullptr);
104 EXPECT_EQ(displayAdapterImpl->GetId(), static_cast<DisplayId>(-1));
105 EXPECT_EQ(displayAdapterImpl->GetWidth(), -1);
106 EXPECT_EQ(displayAdapterImpl->GetHeight(), -1);
107 EXPECT_EQ(displayAdapterImpl->GetVirtualPixelRatio(), -1);
108 EXPECT_EQ(displayAdapterImpl->GetRotation(), RotationType::ROTATION_BUTT);
109 EXPECT_EQ(displayAdapterImpl->GetOrientation(), OrientationType::BUTT);
110 EXPECT_EQ(displayAdapterImpl->GetDisplayOrientation(), DisplayOrientation::UNKNOWN);
111 EXPECT_EQ(displayAdapterImpl->GetDpi(), -1);
112 EXPECT_EQ(displayAdapterImpl->GetFoldStatus(), FoldStatus::UNKNOWN);
113 EXPECT_EQ(displayAdapterImpl->IsFoldable(), false);
114 }
115
116 /**
117 * @tc.name: DisplayManagerAdapterImplTest_002.
118 * @tc.desc: test lock type.
119 * @tc.type: FUNC
120 * @tc.require:
121 */
122 HWTEST_F(DisplayManagerAdapterImplTest, DisplayManagerAdapterImplTest_002, TestSize.Level1)
123 {
124 std::shared_ptr<DisplayListenerAdapter> listener = std::make_shared<DisplayListenerAdapterTest>();
125 std::unique_ptr<DisplayListenerAdapterImpl> displayListenerAdapterImpl =
126 std::make_unique<DisplayListenerAdapterImpl>(listener);
127 displayListenerAdapterImpl->OnCreate(static_cast<DisplayId>(1));
128 displayListenerAdapterImpl->OnDestroy(static_cast<DisplayId>(1));
129 displayListenerAdapterImpl->OnChange(static_cast<DisplayId>(1));
130 EXPECT_NE(displayListenerAdapterImpl, nullptr);
131 std::unique_ptr<DisplayListenerAdapterImpl> displayListenerAdapterImpl1 =
132 std::make_unique<DisplayListenerAdapterImpl>(nullptr);
133 displayListenerAdapterImpl1->OnCreate(static_cast<DisplayId>(1));
134 displayListenerAdapterImpl1->OnDestroy(static_cast<DisplayId>(1));
135 displayListenerAdapterImpl1->OnChange(static_cast<DisplayId>(1));
136 }
137
138 /**
139 * @tc.name: DisplayManagerAdapterImplTest_003.
140 * @tc.desc: test ConvertRotationType.
141 * @tc.type: FUNC
142 * @tc.require:
143 */
144 HWTEST_F(DisplayManagerAdapterImplTest, DisplayManagerAdapterImplTest_003, TestSize.Level1)
145 {
146 std::unique_ptr<DisplayAdapterImpl> displayAdapterImpl = std::make_unique<DisplayAdapterImpl>(nullptr);
147 EXPECT_NE(displayAdapterImpl, nullptr);
148
149 OHOS::Rosen::Rotation type = OHOS::Rosen::Rotation::ROTATION_0;
150 OHOS::NWeb::RotationType retType;
151 retType = displayAdapterImpl->ConvertRotationType(type);
152 EXPECT_EQ(retType, OHOS::NWeb::RotationType::ROTATION_0);
153
154 type = OHOS::Rosen::Rotation::ROTATION_90;
155 retType = displayAdapterImpl->ConvertRotationType(type);
156 EXPECT_EQ(retType, OHOS::NWeb::RotationType::ROTATION_90);
157
158 type = OHOS::Rosen::Rotation::ROTATION_180;
159 retType = displayAdapterImpl->ConvertRotationType(type);
160 EXPECT_EQ(retType, OHOS::NWeb::RotationType::ROTATION_180);
161
162 type = OHOS::Rosen::Rotation::ROTATION_270;
163 retType = displayAdapterImpl->ConvertRotationType(type);
164 EXPECT_EQ(retType, OHOS::NWeb::RotationType::ROTATION_270);
165
166 const uint32_t ROTATION_butt = 4;
167 type = static_cast<OHOS::Rosen::Rotation>(ROTATION_butt);
168 retType = displayAdapterImpl->ConvertRotationType(type);
169 EXPECT_EQ(retType, OHOS::NWeb::RotationType::ROTATION_BUTT);
170 }
171
172 /**
173 * @tc.name: DisplayManagerAdapterImplTest_004.
174 * @tc.desc: test ConvertRotationType.
175 * @tc.type: FUNC
176 * @tc.require:
177 */
178 HWTEST_F(DisplayManagerAdapterImplTest, DisplayManagerAdapterImplTest_004, TestSize.Level1)
179 {
180 std::unique_ptr<DisplayAdapterImpl> displayAdapterImpl = std::make_unique<DisplayAdapterImpl>(nullptr);
181 EXPECT_NE(displayAdapterImpl, nullptr);
182
183 OHOS::Rosen::Orientation type = OHOS::Rosen::Orientation::UNSPECIFIED;
184 OHOS::NWeb::OrientationType retType;
185 retType = displayAdapterImpl->ConvertOrientationType(type);
186 EXPECT_EQ(retType, OHOS::NWeb::OrientationType::UNSPECIFIED);
187
188 type = OHOS::Rosen::Orientation::VERTICAL;
189 retType = displayAdapterImpl->ConvertOrientationType(type);
190 EXPECT_EQ(retType, OHOS::NWeb::OrientationType::VERTICAL);
191
192 type = OHOS::Rosen::Orientation::HORIZONTAL;
193 retType = displayAdapterImpl->ConvertOrientationType(type);
194 EXPECT_EQ(retType, OHOS::NWeb::OrientationType::HORIZONTAL);
195
196 type = OHOS::Rosen::Orientation::REVERSE_VERTICAL;
197 retType = displayAdapterImpl->ConvertOrientationType(type);
198 EXPECT_EQ(retType, OHOS::NWeb::OrientationType::REVERSE_VERTICAL);
199
200 type = OHOS::Rosen::Orientation::REVERSE_HORIZONTAL;
201 retType = displayAdapterImpl->ConvertOrientationType(type);
202 EXPECT_EQ(retType, OHOS::NWeb::OrientationType::REVERSE_HORIZONTAL);
203
204 type = OHOS::Rosen::Orientation::SENSOR;
205 retType = displayAdapterImpl->ConvertOrientationType(type);
206 EXPECT_EQ(retType, OHOS::NWeb::OrientationType::SENSOR);
207
208 type = OHOS::Rosen::Orientation::SENSOR_VERTICAL;
209 retType = displayAdapterImpl->ConvertOrientationType(type);
210 EXPECT_EQ(retType, OHOS::NWeb::OrientationType::SENSOR_VERTICAL);
211
212 type = OHOS::Rosen::Orientation::SENSOR_HORIZONTAL;
213 retType = displayAdapterImpl->ConvertOrientationType(type);
214 EXPECT_EQ(retType, OHOS::NWeb::OrientationType::SENSOR_HORIZONTAL);
215
216 type = OHOS::Rosen::Orientation::AUTO_ROTATION_RESTRICTED;
217 retType = displayAdapterImpl->ConvertOrientationType(type);
218 EXPECT_EQ(retType, OHOS::NWeb::OrientationType::BUTT);
219 }
220
221 /**
222 * @tc.name: DisplayManagerAdapterImplTest_005.
223 * @tc.desc: test lock type.
224 * @tc.type: FUNC
225 * @tc.require:
226 */
227 HWTEST_F(DisplayManagerAdapterImplTest, DisplayManagerAdapterImplTest_005, TestSize.Level1)
228 {
229 std::shared_ptr<DisplayManagerAdapterImpl> displayManagerAdapterImpl =
230 std::make_shared<DisplayManagerAdapterImpl>();
231 std::shared_ptr<DisplayListenerAdapter> listener = std::make_shared<DisplayListenerAdapterTest>();
232 EXPECT_NE(displayManagerAdapterImpl, nullptr);
233 EXPECT_NE(displayManagerAdapterImpl->GetDefaultDisplayId(), DISPLAY_ID_INVALID);
234 EXPECT_NE(displayManagerAdapterImpl->GetDefaultDisplay(), nullptr);
235 EXPECT_EQ(displayManagerAdapterImpl->RegisterDisplayListener(listener), 1);
236 EXPECT_FALSE(displayManagerAdapterImpl->UnregisterDisplayListener(1));
237 EXPECT_FALSE(displayManagerAdapterImpl->UnregisterDisplayListener(2));
238
239 std::shared_ptr<FoldStatusListenerAdapter> foldListener = std::make_shared<FoldStatusListenerAdapterTest>();
240 EXPECT_EQ(displayManagerAdapterImpl->RegisterFoldStatusListener(foldListener), 0);
241 EXPECT_EQ(displayManagerAdapterImpl->UnregisterFoldStatusListener(1), false);
242 EXPECT_EQ(displayManagerAdapterImpl->UnregisterFoldStatusListener(2), false);
243 g_unregister = DMError::DM_OK;
244 }
245
246 /**
247 * @tc.name: DisplayManagerAdapterImplTest_006.
248 * @tc.desc: test lock type.
249 * @tc.type: FUNC
250 * @tc.require:
251 */
252 HWTEST_F(DisplayManagerAdapterImplTest, DisplayManagerAdapterImplTest_006, TestSize.Level1)
253 {
254 sptr<Display> display = DisplayManager::GetInstance().GetDefaultDisplay();
255 ScreenId defaultScreenId = display->GetScreenId();
256 auto defaultScreen = ScreenManager::GetInstance().GetScreenById(defaultScreenId);
257 defaultScreen->SetOrientation(Orientation::REVERSE_HORIZONTAL);
258 std::unique_ptr<DisplayAdapterImpl> displayAdapterImpl = std::make_unique<DisplayAdapterImpl>(display);
259 EXPECT_NE(displayAdapterImpl, nullptr);
260 EXPECT_NE(displayAdapterImpl->GetId(), static_cast<DisplayId>(-1));
261 EXPECT_NE(displayAdapterImpl->GetWidth(), -1);
262 EXPECT_NE(displayAdapterImpl->GetHeight(), -1);
263 EXPECT_NE(displayAdapterImpl->GetVirtualPixelRatio(), -1);
264 EXPECT_NE(displayAdapterImpl->GetRotation(), RotationType::ROTATION_BUTT);
265 EXPECT_NE(displayAdapterImpl->GetOrientation(), OrientationType::BUTT);
266 EXPECT_NE(displayAdapterImpl->GetDisplayOrientation(), DisplayOrientation::UNKNOWN);
267 EXPECT_NE(displayAdapterImpl->GetDpi(), -1);
268 EXPECT_EQ(displayAdapterImpl->GetFoldStatus(), FoldStatus::UNKNOWN);
269 EXPECT_EQ(displayAdapterImpl->IsFoldable(), false);
270 }
271
272 /**
273 * @tc.name: DisplayManagerAdapterImplTest_007.
274 * @tc.desc: test IsDefaultPortrait.
275 * @tc.type: FUNC
276 * @tc.require:
277 */
278 HWTEST_F(DisplayManagerAdapterImplTest, DisplayManagerAdapterImplTest_007, TestSize.Level1)
279 {
280 std::shared_ptr<DisplayManagerAdapterImpl> displayManagerAdapterImpl =
281 std::make_shared<DisplayManagerAdapterImpl>();
282 EXPECT_NE(displayManagerAdapterImpl, nullptr);
283 bool result = displayManagerAdapterImpl->IsDefaultPortrait();
284 std::string deviceType = OHOS::system::GetDeviceType();
285 if (deviceType == "phone" || deviceType == "default") {
286 EXPECT_TRUE(result);
287 } else {
288 EXPECT_FALSE(result);
289 }
290 }
291
292 /**
293 * @tc.name: DisplayManagerAdapterImplTest_008.
294 * @tc.desc: test ConvertDisplayRotationType.
295 * @tc.type: FUNC
296 * @tc.require:
297 */
298 HWTEST_F(DisplayManagerAdapterImplTest, DisplayManagerAdapterImplTest_008, TestSize.Level1)
299 {
300 std::unique_ptr<DisplayAdapterImpl> displayAdapterImpl = std::make_unique<DisplayAdapterImpl>(nullptr);
301 EXPECT_NE(displayAdapterImpl, nullptr);
302
303 OHOS::Rosen::DisplayOrientation type = OHOS::Rosen::DisplayOrientation::UNKNOWN;
304 OHOS::NWeb::DisplayOrientation retType;
305 retType = displayAdapterImpl->ConvertDisplayOrientationType(type);
306 EXPECT_EQ(retType, OHOS::NWeb::DisplayOrientation::UNKNOWN);
307
308 type = OHOS::Rosen::DisplayOrientation::PORTRAIT;
309 retType = displayAdapterImpl->ConvertDisplayOrientationType(type);
310 EXPECT_EQ(retType, OHOS::NWeb::DisplayOrientation::PORTRAIT);
311
312 type = OHOS::Rosen::DisplayOrientation::LANDSCAPE;
313 retType = displayAdapterImpl->ConvertDisplayOrientationType(type);
314 EXPECT_EQ(retType, OHOS::NWeb::DisplayOrientation::LANDSCAPE);
315
316 type = OHOS::Rosen::DisplayOrientation::PORTRAIT_INVERTED;
317 retType = displayAdapterImpl->ConvertDisplayOrientationType(type);
318 EXPECT_EQ(retType, OHOS::NWeb::DisplayOrientation::PORTRAIT_INVERTED);
319
320 type = OHOS::Rosen::DisplayOrientation::LANDSCAPE_INVERTED;
321 retType = displayAdapterImpl->ConvertDisplayOrientationType(type);
322 EXPECT_EQ(retType, OHOS::NWeb::DisplayOrientation::LANDSCAPE_INVERTED);
323 }
324
325 /**
326 * @tc.name: DisplayManagerAdapterImplTest_009.
327 * @tc.desc: test fold change.
328 * @tc.type: FUNC
329 * @tc.require:
330 */
331 HWTEST_F(DisplayManagerAdapterImplTest, DisplayManagerAdapterImplTest_009, TestSize.Level1)
332 {
333 std::shared_ptr<FoldStatusListenerAdapter> listener = std::make_shared<FoldStatusListenerAdapterTest>();
334 std::unique_ptr<FoldStatusListenerAdapterImpl> foldStatusListenerAdapterImpl =
335 std::make_unique<FoldStatusListenerAdapterImpl>(listener);
336 foldStatusListenerAdapterImpl->OnFoldStatusChanged(
337 NativeDisplayManager_FoldDisplayMode::DISPLAY_MANAGER_FOLD_DISPLAY_MODE_FULL);
338 EXPECT_NE(foldStatusListenerAdapterImpl, nullptr);
339 std::unique_ptr<FoldStatusListenerAdapterImpl> foldStatusListenerAdapterImpl2 =
340 std::make_unique<FoldStatusListenerAdapterImpl>(nullptr);
341 foldStatusListenerAdapterImpl->OnFoldStatusChanged(
342 NativeDisplayManager_FoldDisplayMode::DISPLAY_MANAGER_FOLD_DISPLAY_MODE_FULL);
343 }
344
345 /**
346 * @tc.name: DisplayManagerAdapterImplTest_010.
347 * @tc.desc: test ConvertRotationType.
348 * @tc.type: FUNC
349 * @tc.require:
350 */
351 HWTEST_F(DisplayManagerAdapterImplTest, DisplayManagerAdapterImplTest_010, TestSize.Level1)
352 {
353 std::unique_ptr<DisplayAdapterImpl> displayAdapterImpl = std::make_unique<DisplayAdapterImpl>(nullptr);
354 EXPECT_NE(displayAdapterImpl, nullptr);
355
356 NativeDisplayManager_FoldDisplayMode type =
357 NativeDisplayManager_FoldDisplayMode::DISPLAY_MANAGER_FOLD_DISPLAY_MODE_FULL;
358 OHOS::NWeb::FoldStatus retType;
359 retType = displayAdapterImpl->ConvertFoldStatus(type);
360 EXPECT_EQ(retType, OHOS::NWeb::FoldStatus::FULL);
361
362 type = NativeDisplayManager_FoldDisplayMode::DISPLAY_MANAGER_FOLD_DISPLAY_MODE_MAIN;
363 retType = displayAdapterImpl->ConvertFoldStatus(type);
364 EXPECT_EQ(retType, OHOS::NWeb::FoldStatus::MAIN);
365
366 type = NativeDisplayManager_FoldDisplayMode::DISPLAY_MANAGER_FOLD_DISPLAY_MODE_SUB;
367 retType = displayAdapterImpl->ConvertFoldStatus(type);
368 EXPECT_EQ(retType, OHOS::NWeb::FoldStatus::SUB);
369
370 type = NativeDisplayManager_FoldDisplayMode::DISPLAY_MANAGER_FOLD_DISPLAY_MODE_COORDINATION;
371 retType = displayAdapterImpl->ConvertFoldStatus(type);
372 EXPECT_EQ(retType, OHOS::NWeb::FoldStatus::COORDINATION);
373 }
374
375 /**
376 * @tc.name: GetDpi_001.
377 * @tc.desc: test GetDpi.
378 * @tc.type: FUNC
379 * @tc.require:
380 */
381 HWTEST_F(DisplayManagerAdapterImplTest, GetDpi_001, TestSize.Level1)
382 {
383 std::unique_ptr<DisplayAdapterImpl> displayAdapterImpl = std::make_unique<DisplayAdapterImpl>(nullptr);
384 EXPECT_NE(displayAdapterImpl, nullptr);
385
386 displayAdapterImpl->display_ = nullptr;
387 EXPECT_EQ(displayAdapterImpl->GetDpi(), -1);
388 }
389
390 /**
391 * @tc.name: OnChange_001.
392 * @tc.desc: test OnChange.
393 * @tc.type: FUNC
394 * @tc.require:
395 */
396 HWTEST_F(DisplayManagerAdapterImplTest, OnChange_001, TestSize.Level1)
397 {
398 std::unique_ptr<DisplayListenerAdapterImpl> displayListenerAdapterImpl =
399 std::make_unique<DisplayListenerAdapterImpl>(nullptr);
400 EXPECT_FALSE(displayListenerAdapterImpl->CheckOnlyRefreshRateDecreased(static_cast<DisplayId>(1)));
401 DisplayId id = DisplayManager::GetInstance().GetDefaultDisplayId();
402 auto displayPtr = DisplayManager::GetInstance().GetDefaultDisplay();
403 ASSERT_NE(displayPtr, nullptr);
404 auto displayInfo = displayPtr->GetDisplayInfo();
405 ASSERT_NE(displayInfo, nullptr);
406 EXPECT_EQ(id, DisplayManager::GetInstance().GetDefaultDisplayId());
407 EXPECT_FALSE(displayListenerAdapterImpl->CheckOnlyRefreshRateDecreased(
408 DisplayManager::GetInstance().GetDefaultDisplayId()));
409 auto nwebDisplayInfo = displayListenerAdapterImpl->ConvertDisplayInfo(*displayInfo);
410 displayListenerAdapterImpl->cachedDisplayedInfo_ = nwebDisplayInfo;
411 displayListenerAdapterImpl->cachedDisplayedInfo_.refreshRate_ = 100;
412 EXPECT_TRUE(displayListenerAdapterImpl->CheckOnlyRefreshRateDecreased(
413 DisplayManager::GetInstance().GetDefaultDisplayId()));
414 }
415
416 /**
417 * @tc.name: DisplayManagerAdapterImplTest_011.
418 * @tc.desc: test newer get method.
419 * @tc.type: FUNC
420 * @tc.require:
421 */
422 HWTEST_F(DisplayManagerAdapterImplTest, DisplayManagerAdapterImplTest_011, TestSize.Level1)
423 {
424 std::unique_ptr<DisplayAdapterImpl> displayAdapterImpl = std::make_unique<DisplayAdapterImpl>(nullptr);
425 ASSERT_NE(displayAdapterImpl, nullptr);
426 EXPECT_EQ(displayAdapterImpl->GetName(), "");
427 EXPECT_EQ(displayAdapterImpl->GetAvailableWidth(), 0);
428 EXPECT_EQ(displayAdapterImpl->GetAvailableHeight(), 0);
429 EXPECT_EQ(displayAdapterImpl->GetAliveStatus(), true);
430 EXPECT_EQ(displayAdapterImpl->GetDisplayState(), DisplayState::UNKNOWN);
431 EXPECT_EQ(displayAdapterImpl->GetDensityDpi(), 0);
432 EXPECT_EQ(displayAdapterImpl->GetX(), 0);
433 EXPECT_EQ(displayAdapterImpl->GetY(), 0);
434 EXPECT_EQ(displayAdapterImpl->GetDisplaySourceMode(), DisplaySourceMode::NONE);
435 EXPECT_EQ(displayAdapterImpl->GetPhysicalWidth(), 0);
436 EXPECT_EQ(displayAdapterImpl->GetPhysicalHeight(), 0);
437 EXPECT_FLOAT_EQ(displayAdapterImpl->GetDefaultVirtualPixelRatio(), 0);
438 }
439
440 /**
441 * @tc.name: DisplayManagerAdapterImplTest_012.
442 * @tc.desc: test newer get method.
443 * @tc.type: FUNC
444 * @tc.require:
445 */
446 HWTEST_F(DisplayManagerAdapterImplTest, DisplayManagerAdapterImplTest_012, TestSize.Level1)
447 {
448 auto display = DisplayManager::GetInstance().GetDefaultDisplay();
449 ASSERT_NE(display, nullptr);
450 auto displayInfo = display->GetDisplayInfo();
451 ASSERT_NE(displayInfo, nullptr);
452 std::unique_ptr<DisplayAdapterImpl> displayAdapterImpl = std::make_unique<DisplayAdapterImpl>(display);
453
454 EXPECT_NE(displayAdapterImpl->GetName(), "");
455 EXPECT_GE(displayAdapterImpl->GetAvailableWidth(), 0);
456 EXPECT_GE(displayAdapterImpl->GetAvailableHeight(), 0);
457 EXPECT_EQ(displayAdapterImpl->GetAliveStatus(), true);
458 EXPECT_NE(displayAdapterImpl->GetDisplayState(), DisplayState::UNKNOWN);
459 EXPECT_GT(displayAdapterImpl->GetDensityDpi(), 0);
460 EXPECT_GE(displayAdapterImpl->GetX(), 0);
461 EXPECT_GE(displayAdapterImpl->GetY(), 0);
462 EXPECT_NE(displayAdapterImpl->GetDisplaySourceMode(), DisplaySourceMode::NONE);
463 EXPECT_GE(displayAdapterImpl->GetPhysicalWidth(), 0);
464 EXPECT_GE(displayAdapterImpl->GetPhysicalHeight(), 0);
465 EXPECT_GT(displayAdapterImpl->GetDefaultVirtualPixelRatio(), 0);
466 }
467
468 /**
469 * @tc.name: DisplayManagerAdapterImplTest_013.
470 * @tc.desc: test ConvertDisplayState.
471 * @tc.type: FUNC
472 * @tc.require:
473 */
474 HWTEST_F(DisplayManagerAdapterImplTest, DisplayManagerAdapterImplTest_013, TestSize.Level1)
475 {
476 std::unique_ptr<DisplayAdapterImpl> displayAdapterImpl = std::make_unique<DisplayAdapterImpl>(nullptr);
477 ASSERT_NE(displayAdapterImpl, nullptr);
478
479 OHOS::Rosen::DisplayState state = OHOS::Rosen::DisplayState::UNKNOWN;
480 OHOS::NWeb::DisplayState retType;
481 retType = displayAdapterImpl->ConvertDisplayState(state);
482 EXPECT_EQ(retType, OHOS::NWeb::DisplayState::UNKNOWN);
483
484 state = OHOS::Rosen::DisplayState::OFF;
485 retType = displayAdapterImpl->ConvertDisplayState(state);
486 EXPECT_EQ(retType, OHOS::NWeb::DisplayState::OFF);
487
488 state = OHOS::Rosen::DisplayState::ON;
489 retType = displayAdapterImpl->ConvertDisplayState(state);
490 EXPECT_EQ(retType, OHOS::NWeb::DisplayState::ON);
491
492 state = OHOS::Rosen::DisplayState::DOZE;
493 retType = displayAdapterImpl->ConvertDisplayState(state);
494 EXPECT_EQ(retType, OHOS::NWeb::DisplayState::DOZE);
495
496 state = OHOS::Rosen::DisplayState::DOZE_SUSPEND;
497 retType = displayAdapterImpl->ConvertDisplayState(state);
498 EXPECT_EQ(retType, OHOS::NWeb::DisplayState::DOZE_SUSPEND);
499
500 state = OHOS::Rosen::DisplayState::VR;
501 retType = displayAdapterImpl->ConvertDisplayState(state);
502 EXPECT_EQ(retType, OHOS::NWeb::DisplayState::VR);
503
504 state = OHOS::Rosen::DisplayState::ON_SUSPEND;
505 retType = displayAdapterImpl->ConvertDisplayState(state);
506 EXPECT_EQ(retType, OHOS::NWeb::DisplayState::ON_SUSPEND);
507 }
508
509 /**
510 * @tc.name: DisplayManagerAdapterImplTest_014.
511 * @tc.desc: test ConvertDisplaySourceMode.
512 * @tc.type: FUNC
513 * @tc.require:
514 */
515 HWTEST_F(DisplayManagerAdapterImplTest, DisplayManagerAdapterImplTest_014, TestSize.Level1)
516 {
517 std::unique_ptr<DisplayAdapterImpl> displayAdapterImpl = std::make_unique<DisplayAdapterImpl>(nullptr);
518 ASSERT_NE(displayAdapterImpl, nullptr);
519
520 OHOS::Rosen::DisplaySourceMode mode = OHOS::Rosen::DisplaySourceMode::NONE;
521 OHOS::NWeb::DisplaySourceMode retType;
522 retType = displayAdapterImpl->ConvertDisplaySourceMode(mode);
523 EXPECT_EQ(retType, OHOS::NWeb::DisplaySourceMode::NONE);
524
525 mode = OHOS::Rosen::DisplaySourceMode::MAIN;
526 retType = displayAdapterImpl->ConvertDisplaySourceMode(mode);
527 EXPECT_EQ(retType, OHOS::NWeb::DisplaySourceMode::MAIN);
528
529 mode = OHOS::Rosen::DisplaySourceMode::MIRROR;
530 retType = displayAdapterImpl->ConvertDisplaySourceMode(mode);
531 EXPECT_EQ(retType, OHOS::NWeb::DisplaySourceMode::MIRROR);
532
533 mode = OHOS::Rosen::DisplaySourceMode::EXTEND;
534 retType = displayAdapterImpl->ConvertDisplaySourceMode(mode);
535 EXPECT_EQ(retType, OHOS::NWeb::DisplaySourceMode::EXTEND);
536
537 mode = OHOS::Rosen::DisplaySourceMode::ALONE;
538 retType = displayAdapterImpl->ConvertDisplaySourceMode(mode);
539 EXPECT_EQ(retType, OHOS::NWeb::DisplaySourceMode::ALONE);
540 }
541
542 /**
543 * @tc.name: DisplayManagerAdapterImplTest_015.
544 * @tc.desc: test GetPrimaryDisplay.
545 * @tc.type: FUNC
546 * @tc.require:
547 */
548 HWTEST_F(DisplayManagerAdapterImplTest, DisplayManagerAdapterImplTest_015, TestSize.Level1)
549 {
550 std::shared_ptr<DisplayManagerAdapterImpl> displayManagerAdapterImpl =
551 std::make_shared<DisplayManagerAdapterImpl>();
552 ASSERT_NE(displayManagerAdapterImpl, nullptr);
553 auto primaryDisplayBase = DisplayManager::GetInstance().GetPrimaryDisplaySync();
554 ASSERT_NE(primaryDisplayBase, nullptr);
555 auto primaryDisplay = displayManagerAdapterImpl->GetPrimaryDisplay();
556 EXPECT_NE(primaryDisplay, nullptr);
557 EXPECT_EQ(primaryDisplay->GetId(), primaryDisplayBase->GetId());
558 }
559
560 /**
561 * @tc.name: DisplayManagerAdapterImplTest_016.
562 * @tc.desc: test GetAllDisplays.
563 * @tc.type: FUNC
564 * @tc.require:
565 */
566 HWTEST_F(DisplayManagerAdapterImplTest, DisplayManagerAdapterImplTest_016, TestSize.Level1)
567 {
568 std::shared_ptr<DisplayManagerAdapterImpl> displayManagerAdapterImpl =
569 std::make_shared<DisplayManagerAdapterImpl>();
570 ASSERT_NE(displayManagerAdapterImpl, nullptr);
571 auto allDisplaysBase = DisplayManager::GetInstance().GetAllDisplays();
572 EXPECT_FALSE(allDisplaysBase.empty());
573 auto allDisplays = displayManagerAdapterImpl->GetAllDisplays();
574 EXPECT_EQ(allDisplays.size(), allDisplaysBase.size());
575 }
576
577 /**
578 * @tc.name: DisplayManagerAdapterImplTest_017.
579 * @tc.desc: test lock type.
580 * @tc.type: FUNC
581 * @tc.require:
582 */
583 HWTEST_F(DisplayManagerAdapterImplTest, DisplayManagerAdapterImplTest_017, TestSize.Level1)
584 {
585 std::unique_ptr<FoldStatusListenerAdapterImpl> displayAdapterImpl =
586 std::make_unique<FoldStatusListenerAdapterImpl>(nullptr);
587 EXPECT_EQ(displayAdapterImpl->ConvertFoldStatus(DISPLAY_MANAGER_FOLD_DISPLAY_MODE_FULL),
588 OHOS::NWeb::FoldStatus::FULL);
589 EXPECT_EQ(displayAdapterImpl->ConvertFoldStatus(DISPLAY_MANAGER_FOLD_DISPLAY_MODE_MAIN),
590 OHOS::NWeb::FoldStatus::MAIN);
591 EXPECT_EQ(displayAdapterImpl->ConvertFoldStatus(DISPLAY_MANAGER_FOLD_DISPLAY_MODE_SUB),
592 OHOS::NWeb::FoldStatus::SUB);
593 EXPECT_EQ(displayAdapterImpl->ConvertFoldStatus(
594 DISPLAY_MANAGER_FOLD_DISPLAY_MODE_COORDINATION), OHOS::NWeb::FoldStatus::COORDINATION);
595 }
596
597 /**
598 * @tc.name: DisplayManagerAdapterImplTest_018.
599 * @tc.desc: test lock type.
600 * @tc.type: FUNC
601 * @tc.require:
602 */
603 HWTEST_F(DisplayManagerAdapterImplTest, DisplayManagerAdapterImplTest_018, TestSize.Level1)
604 {
605 std::unique_ptr<DisplayAdapterImpl> displayAdapterImpl =
606 std::make_unique<DisplayAdapterImpl>(nullptr);
607 EXPECT_EQ(displayAdapterImpl->ConvertFoldStatus(DISPLAY_MANAGER_FOLD_DISPLAY_MODE_FULL),
608 OHOS::NWeb::FoldStatus::FULL);
609 EXPECT_EQ(displayAdapterImpl->ConvertFoldStatus(DISPLAY_MANAGER_FOLD_DISPLAY_MODE_MAIN),
610 OHOS::NWeb::FoldStatus::MAIN);
611 EXPECT_EQ(displayAdapterImpl->ConvertFoldStatus(DISPLAY_MANAGER_FOLD_DISPLAY_MODE_SUB),
612 OHOS::NWeb::FoldStatus::SUB);
613 EXPECT_EQ(displayAdapterImpl->ConvertFoldStatus(DISPLAY_MANAGER_FOLD_DISPLAY_MODE_COORDINATION),
614 OHOS::NWeb::FoldStatus::COORDINATION);
615 }
616
617 /**
618 * @tc.name: DisplayManagerAdapterImplTest_019.
619 * @tc.desc: test lock type.
620 * @tc.type: FUNC
621 * @tc.require:
622 */
623 HWTEST_F(DisplayManagerAdapterImplTest, DisplayManagerAdapterImplTest_019, TestSize.Level1)
624 {
625 std::unique_ptr<DisplayAdapterImpl> displayAdapterImpl = std::make_unique<DisplayAdapterImpl>(nullptr);
626 EXPECT_FALSE(displayAdapterImpl->IsFoldable());
627 }
628
629 /**
630 * @tc.name: DisplayManagerAdapterImplTest_020.
631 * @tc.desc: test lock type.
632 * @tc.type: FUNC
633 * @tc.require:
634 */
635 HWTEST_F(DisplayManagerAdapterImplTest, DisplayManagerAdapterImplTest_020, TestSize.Level1)
636 {
637 std::unique_ptr<DisplayAdapterImpl> displayAdapterImpl = std::make_unique<DisplayAdapterImpl>(nullptr);
638 EXPECT_NE(displayAdapterImpl->GetFoldStatus(), OHOS::NWeb::FoldStatus::FULL);
639 }
640
641 /**
642 * @tc.name: DisplayManagerAdapterImplTest_021.
643 * @tc.desc: test lock type.
644 * @tc.type: FUNC
645 * @tc.require:
646 */
647 HWTEST_F(DisplayManagerAdapterImplTest, DisplayManagerAdapterImplTest_021, TestSize.Level1)
648 {
649 std::shared_ptr<DisplayManagerAdapterImpl> displayManagerAdapterImpl =
650 std::make_shared<DisplayManagerAdapterImpl>();
651 ASSERT_NE(displayManagerAdapterImpl, nullptr);
652 int32_t id = 0;
653 EXPECT_FALSE(displayManagerAdapterImpl->UnregisterFoldStatusListener(id));
654 }
655
656 /**
657 * @tc.name: DisplayManagerAdapterImplTest_022.
658 * @tc.desc: test lock type.
659 * @tc.type: FUNC
660 * @tc.require:
661 */
662 HWTEST_F(DisplayManagerAdapterImplTest, DisplayManagerAdapterImplTest_022, TestSize.Level1)
663 {
664 std::shared_ptr<DisplayManagerAdapterImpl> displayManagerAdapterImpl =
665 std::make_shared<DisplayManagerAdapterImpl>();
666 ASSERT_NE(displayManagerAdapterImpl, nullptr);
667 EXPECT_GE(displayManagerAdapterImpl->RegisterFoldStatusListener(nullptr), 0);
668 }
669 }
670 }
671