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 #include "modifier_render_thread/rs_modifiers_draw_thread.h"
18 #include "display_cutout_controller.h"
19 #include "display_manager_service_inner.h"
20 #include "display_manager_service.h"
21 #include "dm_common.h"
22
23 using namespace testing;
24 using namespace testing::ext;
25
26 namespace OHOS {
27 namespace Rosen {
28 class DisplayCutoutControllerTest : public testing::Test {
29 public:
30 static void SetUpTestCase();
31 static void TearDownTestCase();
32 void SetUp() override;
33 void TearDown() override;
34 };
35
SetUpTestCase()36 void DisplayCutoutControllerTest::SetUpTestCase()
37 {
38 }
39
TearDownTestCase()40 void DisplayCutoutControllerTest::TearDownTestCase()
41 {
42 #ifdef RS_ENABLE_VK
43 RSModifiersDrawThread::Destroy();
44 #endif
45 }
46
SetUp()47 void DisplayCutoutControllerTest::SetUp()
48 {
49 }
50
TearDown()51 void DisplayCutoutControllerTest::TearDown()
52 {
53 }
54
55 namespace {
56 /**
57 * @tc.name: SetCurvedScreenBoundary
58 * @tc.desc: SetCurvedScreenBoundary size < 4
59 * @tc.type: FUNC
60 */
61 HWTEST_F(DisplayCutoutControllerTest, SetCurvedScreenBoundary, TestSize.Level1)
62 {
63 sptr<DisplayCutoutController> controller = new DisplayCutoutController();
64 std::vector<int> curvedScreenBoundary;
65 curvedScreenBoundary.emplace_back(2);
66 controller->SetCurvedScreenBoundary(curvedScreenBoundary);
67 ASSERT_EQ(controller->curvedScreenBoundary_.size(), 4);
68 }
69
70 /**
71 * @tc.name: SetCutoutSvgPath
72 * @tc.desc: SetCutoutSvgPath
73 * @tc.type: FUNC
74 */
75 HWTEST_F(DisplayCutoutControllerTest, SetCutoutSvgPath, TestSize.Level1)
76 {
77 sptr<DisplayCutoutController> controller = new DisplayCutoutController();
78 DisplayId displayId = 1;
79 std::string svgPath = "m10";
80 controller->SetCutoutSvgPath(displayId, svgPath);
81 controller->SetCutoutSvgPath(displayId, svgPath);
82 ASSERT_EQ(controller->svgPaths_.size(), 1);
83 ASSERT_EQ(controller->svgPaths_[displayId].size(), 2);
84 }
85
86 /**
87 * @tc.name: GetCutoutInfo
88 * @tc.desc: GetCutoutInfo
89 * @tc.type: FUNC
90 */
91 HWTEST_F(DisplayCutoutControllerTest, GetCutoutInfo, TestSize.Level1)
92 {
93 sptr<DisplayCutoutController> controller = new DisplayCutoutController();
94 DisplayId displayId = DisplayManagerServiceInner::GetInstance().GetDefaultDisplayId();
95 std::string svgPath = "m10";
96 controller->SetCutoutSvgPath(displayId, svgPath);
97 controller->SetIsWaterfallDisplay(true);
98 sptr<CutoutInfo> cutoutInfo = controller->GetCutoutInfo(displayId);
99 ASSERT_NE(cutoutInfo, nullptr);
100 }
101
102 /**
103 * @tc.name: CalcBuiltInDisplayWaterfallRects
104 * @tc.desc: CalcBuiltInDisplayWaterfallRects
105 * @tc.type: FUNC
106 */
107 HWTEST_F(DisplayCutoutControllerTest, CalcBuiltInDisplayWaterfallRects, TestSize.Level1)
108 {
109 sptr<DisplayCutoutController> controller = new DisplayCutoutController();
110 controller->SetIsWaterfallDisplay(true);
111 std::vector<int> curvedScreenBoundary;
112 controller->SetCurvedScreenBoundary(curvedScreenBoundary);
113 controller->CalcBuiltInDisplayWaterfallRects();
114 ASSERT_TRUE(controller->waterfallDisplayAreaRects_.isUninitialized());
115 curvedScreenBoundary.emplace_back(1);
116 curvedScreenBoundary.emplace_back(2);
117 curvedScreenBoundary.emplace_back(3);
118 curvedScreenBoundary.emplace_back(4);
119 controller->SetCurvedScreenBoundary(curvedScreenBoundary);
120 controller->CalcBuiltInDisplayWaterfallRects();
121 ASSERT_TRUE(controller->waterfallDisplayAreaRects_.isUninitialized());
122 }
123
124 /**
125 * @tc.name: CalcBuiltInDisplayWaterfallRectsByRotation
126 * @tc.desc: CalcBuiltInDisplayWaterfallRectsByRotation
127 * @tc.type: FUNC
128 */
129 HWTEST_F(DisplayCutoutControllerTest, CalcBuiltInDisplayWaterfallRectsByRotation, TestSize.Level1)
130 {
131 sptr<DisplayCutoutController> controller = new DisplayCutoutController();
132 uint32_t displayHeight = 300;
133 uint32_t displayWidth = 300;
134 std::vector<int> curvedScreenBoundary;
135 curvedScreenBoundary.emplace_back(0);
136 curvedScreenBoundary.emplace_back(0);
137 curvedScreenBoundary.emplace_back(500);
138 curvedScreenBoundary.emplace_back(500);
139 controller->SetCurvedScreenBoundary(curvedScreenBoundary);
140 controller->CalcBuiltInDisplayWaterfallRectsByRotation(Rotation::ROTATION_270, displayHeight, displayWidth);
141 controller->CalcBuiltInDisplayWaterfallRectsByRotation(Rotation::ROTATION_180, displayHeight, displayWidth);
142 controller->CalcBuiltInDisplayWaterfallRectsByRotation(Rotation::ROTATION_90, displayHeight, displayWidth);
143 controller->CalcBuiltInDisplayWaterfallRectsByRotation(Rotation::ROTATION_0, displayHeight, displayWidth);
144 controller->CalcBuiltInDisplayWaterfallRectsByRotation(static_cast<Rotation>(10), displayHeight, displayWidth);
145 ASSERT_FALSE(controller->waterfallDisplayAreaRects_.isUninitialized());
146 }
147
148 /**
149 * @tc.name: CheckBoundingRectsBoundary01
150 * @tc.desc: CheckBoundingRectsBoundary
151 * @tc.type: FUNC
152 */
153 HWTEST_F(DisplayCutoutControllerTest, CheckBoundingRectsBoundary01, TestSize.Level1)
154 {
155 sptr<DisplayCutoutController> controller = new DisplayCutoutController();
156 DisplayId displayId = DisplayManagerServiceInner::GetInstance().GetDefaultDisplayId();
157 std::vector<DMRect> boundingRects;
158 controller->CheckBoundingRectsBoundary(displayId, boundingRects);
159 ASSERT_TRUE(boundingRects.empty());
160 }
161
162 /**
163 * @tc.name: CheckBoundingRectsBoundary02
164 * @tc.desc: CheckBoundingRectsBoundary
165 * @tc.type: FUNC
166 */
167 HWTEST_F(DisplayCutoutControllerTest, CheckBoundingRectsBoundary02, TestSize.Level1)
168 {
169 sptr<DisplayCutoutController> controller = new DisplayCutoutController();
170 DisplayId displayId = DisplayManagerServiceInner::GetInstance().GetDefaultDisplayId();
171 std::vector<DMRect> boundingRects;
172 DMRect rect1 = {0, 0, 100, 100};
173 DMRect rect2 = {50, 50, 50, 50};
174 boundingRects.push_back(rect1);
175 boundingRects.push_back(rect2);
176 controller->CheckBoundingRectsBoundary(displayId, boundingRects);
177 ASSERT_FALSE(boundingRects.empty());
178 }
179
180 /**
181 * @tc.name: CheckBoundingRectsBoundary03
182 * @tc.desc: CheckBoundingRectsBoundary
183 * @tc.type: FUNC
184 */
185 HWTEST_F(DisplayCutoutControllerTest, CheckBoundingRectsBoundary03, TestSize.Level1)
186 {
187 sptr<DisplayCutoutController> controller = new DisplayCutoutController();
188 DisplayId displayId = 0;
189 std::vector<DMRect> boundingRects;
190 DMRect rect = {-1, -1, 100, 100};
191 boundingRects.push_back(rect);
192 controller->CheckBoundingRectsBoundary(displayId, boundingRects);
193 ASSERT_FALSE(boundingRects.empty());
194 }
195
196 /**
197 * @tc.name: CheckBoundingRectsBoundary04
198 * @tc.desc: CheckBoundingRectsBoundary
199 * @tc.type: FUNC
200 */
201 HWTEST_F(DisplayCutoutControllerTest, CheckBoundingRectsBoundary04, TestSize.Level1)
202 {
203 sptr<DisplayCutoutController> controller = new DisplayCutoutController();
204 DisplayId displayId = DisplayManagerServiceInner::GetInstance().GetDefaultDisplayId();
205 std::vector<DMRect> boundingRects;
206 DMRect rect1 = {-1, -1, 100, 100};
207 DMRect rect2 = {50, 50, 50, 50};
208 boundingRects.push_back(rect1);
209 boundingRects.push_back(rect2);
210 controller->CheckBoundingRectsBoundary(displayId, boundingRects);
211 ASSERT_FALSE(boundingRects.empty());
212 }
213
214 /**
215 * @tc.name: CalcCutoutBoundingRect
216 * @tc.desc: CalcCutoutBoundingRect success
217 * @tc.type: FUNC
218 */
219 HWTEST_F(DisplayCutoutControllerTest, CalcCutoutBoundingRect, TestSize.Level1)
220 {
221 sptr<DisplayCutoutController> controller = new DisplayCutoutController();
222 std::string svgPath = "M 100,100 m -75,0 a 75,75 0 1,0 150,0 a 75,75 0 1,0 -150,0 z";
223 DMRect rect = controller->CalcCutoutBoundingRect(svgPath);
224 DMRect emptyRect = {0, 0, 0, 0};
225 ASSERT_NE(rect, emptyRect);
226 }
227
228 /**
229 * @tc.name: TransferBoundingRectsByRotation01
230 * @tc.desc: TransferBoundingRectsByRotation empty
231 * @tc.type: FUNC
232 */
233 HWTEST_F(DisplayCutoutControllerTest, TransferBoundingRectsByRotation01, TestSize.Level1)
234 {
235 sptr<DisplayCutoutController> controller = new DisplayCutoutController();
236 DisplayId id = 10;
237 std::vector<DMRect> boundingRects;
238 controller->TransferBoundingRectsByRotation(id, boundingRects);
239 ASSERT_TRUE(boundingRects.empty());
240 }
241
242 /**
243 * @tc.name: TransferBoundingRectsByRotation02
244 * @tc.desc: TransferBoundingRectsByRotation empty
245 * @tc.type: FUNC
246 */
247 HWTEST_F(DisplayCutoutControllerTest, TransferBoundingRectsByRotation02, TestSize.Level1)
248 {
249 sptr<DisplayCutoutController> controller = new DisplayCutoutController();
250 DisplayId id = 10;
251 std::vector<DMRect> emptyRects;
252 controller->boundingRects_[id] = emptyRects;
253 std::vector<DMRect> boundingRects;
254 controller->TransferBoundingRectsByRotation(id, boundingRects);
255 ASSERT_TRUE(boundingRects.empty());
256 }
257
258 /**
259 * @tc.name: TransferBoundingRectsByRotation03
260 * @tc.desc: TransferBoundingRectsByRotation success
261 * @tc.type: FUNC
262 */
263 HWTEST_F(DisplayCutoutControllerTest, TransferBoundingRectsByRotation03, TestSize.Level1)
264 {
265 DisplayId id = 11;
266 ScreenId sid = 12;
267 std::string name = "abstract_display_test";
268 SupportedScreenModes modesInfo;
269 modesInfo.width_ = 2160;
270 modesInfo.height_ = 1600;
271 modesInfo.refreshRate_ = 60;
272 sptr<SupportedScreenModes> info = new SupportedScreenModes(modesInfo);
273 sptr<AbstractScreenController> absScreenController;
274 sptr<AbstractScreen> absScreen;
275 absScreenController = nullptr;
276 absScreen = new AbstractScreen(absScreenController, name, sid, 1);
277 auto displayController = DisplayManagerService::GetInstance().abstractDisplayController_;
278 ASSERT_NE(displayController, nullptr);
279
280 sptr<AbstractDisplay> absDisplay = new AbstractDisplay(id, info, absScreen);
281 absDisplay->RequestRotation(Rotation::ROTATION_0);
282 displayController->abstractDisplayMap_.insert((std::make_pair(id, absDisplay)));
283
284 sptr<DisplayCutoutController> controller = new DisplayCutoutController();
285 std::vector<DMRect> dmRects;
286 DMRect rect = {1, 1, 100, 100};
287 dmRects.emplace_back(rect);
288 controller->boundingRects_[id] = dmRects;
289 ASSERT_FALSE(controller->boundingRects_.count(id) == 0);
290 ASSERT_FALSE(controller->boundingRects_[id].empty());
291 ASSERT_NE(DisplayManagerServiceInner::GetInstance().GetDisplayById(id), nullptr);
292 std::vector<DMRect> boundingRects;
293 controller->TransferBoundingRectsByRotation(id, boundingRects);
294
295 absScreenController = DisplayManagerService::GetInstance().abstractScreenController_;
296 ASSERT_NE(absScreenController, nullptr);
297 absScreenController->dmsScreenMap_.insert(std::make_pair(sid, absScreen));
298 absScreen->modes_.emplace_back(info);
299 absDisplay->RequestRotation(Rotation::ROTATION_180);
300 controller->TransferBoundingRectsByRotation(id, boundingRects);
301
302 absDisplay->RequestRotation(Rotation::ROTATION_90);
303 controller->TransferBoundingRectsByRotation(id, boundingRects);
304
305 absDisplay->RequestRotation(Rotation::ROTATION_270);
306 controller->TransferBoundingRectsByRotation(id, boundingRects);
307 ASSERT_FALSE(boundingRects.empty());
308 displayController->abstractDisplayMap_.clear();
309 absScreenController->dmsScreenMap_.clear();
310 }
311 }
312 } // Rosen
313 } // OHOS
314