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