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 using namespace testing;
24 using namespace testing::ext;
25 using namespace OHOS;
26 using namespace OHOS::Rosen;
27 using namespace OHOS::NWeb;
28
29 namespace OHOS {
30 namespace {
31 bool g_unregister = false;
32 constexpr uint64_t DISPLAY_ID_INVALID = -1ULL;
33 }
34
35 namespace Rosen {
UnregisterDisplayListener(sptr<IDisplayListener> listener)36 bool DisplayManager::UnregisterDisplayListener(sptr<IDisplayListener> listener)
37 {
38 return g_unregister;
39 }
40 }
41
42 std::string g_deviceType = "";
43 namespace system {
GetDeviceType()44 std::string GetDeviceType()
45 {
46 return g_deviceType;
47 }
48 }
49
50 namespace NWeb {
51 class DisplayListenerAdapterTest : public DisplayListenerAdapter {
52 public:
53 DisplayListenerAdapterTest() = default;
54
55 virtual ~DisplayListenerAdapterTest() = default;
56
OnCreate(DisplayId)57 void OnCreate(DisplayId) override {}
OnDestroy(DisplayId)58 void OnDestroy(DisplayId) override {}
OnChange(DisplayId)59 void OnChange(DisplayId) override {}
60 };
61
62 class DisplayManagerAdapterImplTest : public testing::Test {
63 public:
64 static void SetUpTestCase(void);
65 static void TearDownTestCase(void);
66 void SetUp();
67 void TearDown();
68 };
69
SetUpTestCase(void)70 void DisplayManagerAdapterImplTest::SetUpTestCase(void)
71 {}
72
TearDownTestCase(void)73 void DisplayManagerAdapterImplTest::TearDownTestCase(void)
74 {}
75
SetUp(void)76 void DisplayManagerAdapterImplTest::SetUp(void)
77 {}
78
TearDown(void)79 void DisplayManagerAdapterImplTest::TearDown(void)
80 {}
81
82 /**
83 * @tc.name: DisplayManagerAdapterImplTest_001.
84 * @tc.desc: test lock type.
85 * @tc.type: FUNC
86 * @tc.require:
87 */
88 HWTEST_F(DisplayManagerAdapterImplTest, DisplayManagerAdapterImplTest_001, TestSize.Level1)
89 {
90 std::unique_ptr<DisplayAdapterImpl> displayAdapterImpl = std::make_unique<DisplayAdapterImpl>(nullptr);
91 EXPECT_NE(displayAdapterImpl, nullptr);
92 EXPECT_EQ(displayAdapterImpl->GetId(), static_cast<DisplayId>(-1));
93 EXPECT_EQ(displayAdapterImpl->GetWidth(), -1);
94 EXPECT_EQ(displayAdapterImpl->GetHeight(), -1);
95 EXPECT_EQ(displayAdapterImpl->GetVirtualPixelRatio(), -1);
96 EXPECT_EQ(displayAdapterImpl->GetRotation(), RotationType::ROTATION_BUTT);
97 EXPECT_EQ(displayAdapterImpl->GetOrientation(), OrientationType::BUTT);
98 }
99
100 /**
101 * @tc.name: DisplayManagerAdapterImplTest_002.
102 * @tc.desc: test lock type.
103 * @tc.type: FUNC
104 * @tc.require:
105 */
106 HWTEST_F(DisplayManagerAdapterImplTest, DisplayManagerAdapterImplTest_002, TestSize.Level1)
107 {
108 std::shared_ptr<DisplayListenerAdapter> listener = std::make_shared<DisplayListenerAdapterTest>();
109 std::unique_ptr<DisplayListenerAdapterImpl> displayListenerAdapterImpl =
110 std::make_unique<DisplayListenerAdapterImpl>(listener);
111 displayListenerAdapterImpl->OnCreate(static_cast<DisplayId>(1));
112 displayListenerAdapterImpl->OnDestroy(static_cast<DisplayId>(1));
113 displayListenerAdapterImpl->OnChange(static_cast<DisplayId>(1));
114 EXPECT_NE(displayListenerAdapterImpl, nullptr);
115 std::unique_ptr<DisplayListenerAdapterImpl> displayListenerAdapterImpl1 =
116 std::make_unique<DisplayListenerAdapterImpl>(nullptr);
117 displayListenerAdapterImpl1->OnCreate(static_cast<DisplayId>(1));
118 displayListenerAdapterImpl1->OnDestroy(static_cast<DisplayId>(1));
119 displayListenerAdapterImpl1->OnChange(static_cast<DisplayId>(1));
120 }
121
122 /**
123 * @tc.name: DisplayManagerAdapterImplTest_003.
124 * @tc.desc: test ConvertRotationType.
125 * @tc.type: FUNC
126 * @tc.require:
127 */
128 HWTEST_F(DisplayManagerAdapterImplTest, DisplayManagerAdapterImplTest_003, TestSize.Level1)
129 {
130 std::unique_ptr<DisplayAdapterImpl> displayAdapterImpl = std::make_unique<DisplayAdapterImpl>(nullptr);
131 EXPECT_NE(displayAdapterImpl, nullptr);
132
133 OHOS::Rosen::Rotation type = OHOS::Rosen::Rotation::ROTATION_0;
134 OHOS::NWeb::RotationType retType;
135 retType = displayAdapterImpl->ConvertRotationType(type);
136 EXPECT_EQ(retType, OHOS::NWeb::RotationType::ROTATION_0);
137
138 type = OHOS::Rosen::Rotation::ROTATION_90;
139 retType = displayAdapterImpl->ConvertRotationType(type);
140 EXPECT_EQ(retType, OHOS::NWeb::RotationType::ROTATION_90);
141
142 type = OHOS::Rosen::Rotation::ROTATION_180;
143 retType = displayAdapterImpl->ConvertRotationType(type);
144 EXPECT_EQ(retType, OHOS::NWeb::RotationType::ROTATION_180);
145
146 type = OHOS::Rosen::Rotation::ROTATION_270;
147 retType = displayAdapterImpl->ConvertRotationType(type);
148 EXPECT_EQ(retType, OHOS::NWeb::RotationType::ROTATION_270);
149
150 const uint32_t ROTATION_butt = 4;
151 type = static_cast<OHOS::Rosen::Rotation>(ROTATION_butt);
152 retType = displayAdapterImpl->ConvertRotationType(type);
153 EXPECT_EQ(retType, OHOS::NWeb::RotationType::ROTATION_BUTT);
154 }
155
156 /**
157 * @tc.name: DisplayManagerAdapterImplTest_004.
158 * @tc.desc: test ConvertRotationType.
159 * @tc.type: FUNC
160 * @tc.require:
161 */
162 HWTEST_F(DisplayManagerAdapterImplTest, DisplayManagerAdapterImplTest_004, TestSize.Level1)
163 {
164 std::unique_ptr<DisplayAdapterImpl> displayAdapterImpl = std::make_unique<DisplayAdapterImpl>(nullptr);
165 EXPECT_NE(displayAdapterImpl, nullptr);
166
167 OHOS::Rosen::Orientation type = OHOS::Rosen::Orientation::UNSPECIFIED;
168 OHOS::NWeb::OrientationType retType;
169 retType = displayAdapterImpl->ConvertOrientationType(type);
170 EXPECT_EQ(retType, OHOS::NWeb::OrientationType::UNSPECIFIED);
171
172 type = OHOS::Rosen::Orientation::VERTICAL;
173 retType = displayAdapterImpl->ConvertOrientationType(type);
174 EXPECT_EQ(retType, OHOS::NWeb::OrientationType::VERTICAL);
175
176 type = OHOS::Rosen::Orientation::HORIZONTAL;
177 retType = displayAdapterImpl->ConvertOrientationType(type);
178 EXPECT_EQ(retType, OHOS::NWeb::OrientationType::HORIZONTAL);
179
180 type = OHOS::Rosen::Orientation::REVERSE_VERTICAL;
181 retType = displayAdapterImpl->ConvertOrientationType(type);
182 EXPECT_EQ(retType, OHOS::NWeb::OrientationType::REVERSE_VERTICAL);
183
184 type = OHOS::Rosen::Orientation::REVERSE_HORIZONTAL;
185 retType = displayAdapterImpl->ConvertOrientationType(type);
186 EXPECT_EQ(retType, OHOS::NWeb::OrientationType::REVERSE_HORIZONTAL);
187
188 type = OHOS::Rosen::Orientation::SENSOR;
189 retType = displayAdapterImpl->ConvertOrientationType(type);
190 EXPECT_EQ(retType, OHOS::NWeb::OrientationType::SENSOR);
191
192 type = OHOS::Rosen::Orientation::SENSOR_VERTICAL;
193 retType = displayAdapterImpl->ConvertOrientationType(type);
194 EXPECT_EQ(retType, OHOS::NWeb::OrientationType::SENSOR_VERTICAL);
195
196 type = OHOS::Rosen::Orientation::SENSOR_HORIZONTAL;
197 retType = displayAdapterImpl->ConvertOrientationType(type);
198 EXPECT_EQ(retType, OHOS::NWeb::OrientationType::SENSOR_HORIZONTAL);
199
200 type = OHOS::Rosen::Orientation::AUTO_ROTATION_RESTRICTED;
201 retType = displayAdapterImpl->ConvertOrientationType(type);
202 EXPECT_EQ(retType, OHOS::NWeb::OrientationType::BUTT);
203 }
204
205 /**
206 * @tc.name: DisplayManagerAdapterImplTest_005.
207 * @tc.desc: test lock type.
208 * @tc.type: FUNC
209 * @tc.require:
210 */
211 HWTEST_F(DisplayManagerAdapterImplTest, DisplayManagerAdapterImplTest_005, TestSize.Level1)
212 {
213 std::shared_ptr<DisplayManagerAdapterImpl> displayManagerAdapterImpl =
214 std::make_shared<DisplayManagerAdapterImpl>();
215 std::shared_ptr<DisplayListenerAdapter> listener = std::make_shared<DisplayListenerAdapterTest>();
216 EXPECT_NE(displayManagerAdapterImpl, nullptr);
217 EXPECT_NE(displayManagerAdapterImpl->GetDefaultDisplayId(), DISPLAY_ID_INVALID);
218 EXPECT_NE(displayManagerAdapterImpl->GetDefaultDisplay(), nullptr);
219 EXPECT_EQ(displayManagerAdapterImpl->RegisterDisplayListener(listener), true);
220 EXPECT_FALSE(displayManagerAdapterImpl->UnregisterDisplayListener(listener));
221 std::shared_ptr<DisplayListenerAdapter> listener1 = std::make_shared<DisplayListenerAdapterTest>();
222 EXPECT_FALSE(displayManagerAdapterImpl->UnregisterDisplayListener(listener1));
223 g_unregister = true;
224 }
225
226 /**
227 * @tc.name: DisplayManagerAdapterImplTest_006.
228 * @tc.desc: test lock type.
229 * @tc.type: FUNC
230 * @tc.require:
231 */
232 HWTEST_F(DisplayManagerAdapterImplTest, DisplayManagerAdapterImplTest_006, TestSize.Level1)
233 {
234 sptr<Display> display = DisplayManager::GetInstance().GetDefaultDisplay();
235 ScreenId defaultScreenId = display->GetScreenId();
236 auto defaultScreen = ScreenManager::GetInstance().GetScreenById(defaultScreenId);
237 defaultScreen->SetOrientation(Orientation::REVERSE_HORIZONTAL);
238 std::unique_ptr<DisplayAdapterImpl> displayAdapterImpl = std::make_unique<DisplayAdapterImpl>(display);
239 EXPECT_NE(displayAdapterImpl, nullptr);
240 EXPECT_NE(displayAdapterImpl->GetId(), static_cast<DisplayId>(-1));
241 EXPECT_NE(displayAdapterImpl->GetWidth(), -1);
242 EXPECT_NE(displayAdapterImpl->GetHeight(), -1);
243 EXPECT_NE(displayAdapterImpl->GetVirtualPixelRatio(), -1);
244 EXPECT_NE(displayAdapterImpl->GetRotation(), RotationType::ROTATION_BUTT);
245 EXPECT_NE(displayAdapterImpl->GetOrientation(), OrientationType::BUTT);
246 }
247
248 /**
249 * @tc.name: DisplayManagerAdapterImplTest_007.
250 * @tc.desc: test IsDefaultPortrait.
251 * @tc.type: FUNC
252 * @tc.require:
253 */
254 HWTEST_F(DisplayManagerAdapterImplTest, DisplayManagerAdapterImplTest_007, TestSize.Level1)
255 {
256 std::shared_ptr<DisplayManagerAdapterImpl> displayManagerAdapterImpl =
257 std::make_shared<DisplayManagerAdapterImpl>();
258 EXPECT_NE(displayManagerAdapterImpl, nullptr);
259 g_deviceType = "phone";
260 EXPECT_EQ(displayManagerAdapterImpl->IsDefaultPortrait(), true);
261 g_deviceType = "default";
262 EXPECT_EQ(displayManagerAdapterImpl->IsDefaultPortrait(), true);
263 g_deviceType = "tablet";
264 EXPECT_EQ(displayManagerAdapterImpl->IsDefaultPortrait(), false);
265 }
266 }
267 }
268