1 /*
2 * Copyright (c) 2022-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
18 #include "platform/common/rs_innovation.h"
19
20 #include "common/rs_occlusion_region.h"
21
22 using namespace testing;
23 using namespace testing::ext;
24
25 namespace OHOS::Rosen::Occlusion {
26 class RSOcclusionRegionTest : public testing::Test {
27 public:
28 static void SetUpTestCase();
29 static void TearDownTestCase();
30 void SetUp() override;
31 void TearDown() override;
32 static inline std::shared_ptr<Node> testnode;
33 };
34
SetUpTestCase()35 void RSOcclusionRegionTest::SetUpTestCase() {}
TearDownTestCase()36 void RSOcclusionRegionTest::TearDownTestCase() {}
SetUp()37 void RSOcclusionRegionTest::SetUp()
38 {
39 constexpr int s = 0, e = 2;
40 testnode = std::make_shared<Node>(s, e);
41 }
TearDown()42 void RSOcclusionRegionTest::TearDown() {}
43
44 /**
45 * @tc.name: OstreamOperator001
46 * @tc.desc: test results of operator<<
47 * @tc.type:FUNC
48 * @tc.require:
49 */
50 HWTEST_F(RSOcclusionRegionTest, OstreamOperator001, Function | MediumTest | Level2)
51 {
52 /**
53 * @tc.steps: step1. operator<<
54 */
55 Rect rect;
56 ASSERT_TRUE(rect.IsEmpty());
57 std::cout << rect;
58 }
59
60 /**
61 * @tc.name: OstreamOperator002
62 * @tc.desc: test results of operator<<
63 * @tc.type:FUNC
64 * @tc.require:
65 */
66 HWTEST_F(RSOcclusionRegionTest, OstreamOperator002, Function | MediumTest | Level2)
67 {
68 /**
69 * @tc.steps: step1. operator<<
70 */
71 Rect rect;
72 ASSERT_TRUE(rect.IsEmpty());
73 Region region(rect);
74 std::cout << region;
75 }
76
77 /**
78 * @tc.name: EventSortBy001
79 * @tc.desc: test results of EventSortBy
80 * @tc.type:FUNC
81 * @tc.require: issueI5HRIF
82 */
83 HWTEST_F(RSOcclusionRegionTest, EventSortBy001, Function | MediumTest | Level2)
84 {
85 /**
86 * @tc.steps: step1. EventSortBy
87 */
88 Event e1 = Event(0, Event::Type::OPEN, 0, 100);
89 Event e2 = Event(1, Event::Type::CLOSE, 0, 100);
90 ASSERT_TRUE(EventSortByY(e1, e2));
91
92 Event e3 = Event(0, Event::Type::CLOSE, 0, 100);
93 ASSERT_FALSE(EventSortByY(e1, e3));
94 }
95
96 /**
97 * @tc.name: GetAndRange001
98 * @tc.desc: test results of GetAndRange001
99 * @tc.type:FUNC
100 * @tc.require: issueI5HRIF
101 */
102 HWTEST_F(RSOcclusionRegionTest, GetAndRange001, Function | MediumTest | Level2)
103 {
104 /**
105 * @tc.steps: step1. GetAndRange
106 */
107 std::vector<Range> res;
108 testnode->GetAndRange(res, true, true);
109 ASSERT_EQ(res.size(), 1);
110 ASSERT_TRUE(res[0] == Range(0, 2));
111
112 testnode->GetAndRange(res, true, false);
113 ASSERT_EQ(res.size(), 1);
114
115 //left_ and right_ will be delated when deleting testnode
116 testnode->left_ = new Node(0, 1);
117 testnode->right_ = new Node(0, 1);
118 testnode->GetAndRange(res, true, false);
119 ASSERT_EQ(res.size(), 1);
120 ASSERT_TRUE(res[0] == Range(0, 2));
121 }
122
123 /**
124 * @tc.name: GetOrRange001
125 * @tc.desc: test results of GetOrRange001
126 * @tc.type:FUNC
127 * @tc.require: issueI5HRIF
128 */
129 HWTEST_F(RSOcclusionRegionTest, GetOrRange001, Function | MediumTest | Level2)
130 {
131 /**
132 * @tc.steps: step1. GetOrRange
133 */
134 std::vector<Range> res;
135 testnode->GetOrRange(res, false, false);
136 ASSERT_EQ(res.size(), 0);
137
138 testnode->GetOrRange(res, true, false);
139 ASSERT_EQ(res.size(), 1);
140 ASSERT_TRUE(res[0] == Range(0, 2));
141
142 //left_ and right_ will be delated when deleting testnode
143 testnode->left_ = new Node(0, 1);
144 testnode->right_ = new Node(0, 1);
145 testnode->GetOrRange(res, false, false);
146 ASSERT_EQ(res.size(), 1);
147 ASSERT_TRUE(res[0] == Range(0, 2));
148 }
149
150 /**
151 * @tc.name: GetXOrRange001
152 * @tc.desc: test results of GetXOrRange001
153 * @tc.type:FUNC
154 * @tc.require: issueI5HRIF
155 */
156 HWTEST_F(RSOcclusionRegionTest, GetXOrRange001, Function | MediumTest | Level2)
157 {
158 /**
159 * @tc.steps: step1. GetXOrRange
160 */
161 std::vector<Range> res;
162 testnode->GetXOrRange(res, true, false);
163 ASSERT_EQ(res.size(), 1);
164 ASSERT_TRUE(res[0] == Range(0, 2));
165
166 testnode->GetXOrRange(res, true, true);
167 ASSERT_EQ(res.size(), 1);
168 ASSERT_TRUE(res[0] == Range(0, 2));
169
170 //left_ and right_ will be delated when deleting testnode
171 testnode->left_ = new Node(0, 1);
172 testnode->right_ = new Node(0, 1);
173 testnode->GetXOrRange(res, true, false);
174 ASSERT_EQ(res.size(), 3);
175 ASSERT_TRUE(res[2] == Range(0, 1));
176
177 testnode->GetXOrRange(res, false, false);
178 ASSERT_EQ(res.size(), 3);
179 ASSERT_TRUE(res[2] == Range(0, 1));
180 }
181
182 /**
183 * @tc.name: GetSubRange001
184 * @tc.desc: test results of GetSubRange001
185 * @tc.type:FUNC
186 * @tc.require: issueI5HRIF
187 */
188 HWTEST_F(RSOcclusionRegionTest, GetSubRange001, Function | MediumTest | Level2)
189 {
190 /**
191 * @tc.steps: step1. GetSubRange
192 */
193 std::vector<Range> res;
194 testnode->GetSubRange(res, true, false);
195 ASSERT_EQ(res.size(), 1);
196 ASSERT_TRUE(res[0] == Range(0, 2));
197
198 testnode->GetSubRange(res, false, true);
199 ASSERT_EQ(res.size(), 1);
200 ASSERT_TRUE(res[0] == Range(0, 2));
201
202 //left_ and right_ will be delated when deleting testnode
203 testnode->left_ = new Node(0, 1);
204 testnode->right_ = new Node(0, 1);
205 testnode->GetSubRange(res, true, false);
206 ASSERT_EQ(res.size(), 3);
207 ASSERT_TRUE(res[2] == Range(0, 1));
208 }
209
210 /**
211 * @tc.name: RegionOp001
212 * @tc.desc: test results of RegionOp
213 * @tc.type:FUNC
214 * @tc.require:
215 */
216 HWTEST_F(RSOcclusionRegionTest, RegionOp001, Function | MediumTest | Level2)
217 {
218 /**
219 * @tc.steps: step1. RegionOp
220 */
221 Region region;
222 Region region1;
223 Region region2;
224 Region res;
225 ASSERT_TRUE(region.IsEmpty());
226 Region::OP op = Region::OP::SUB;
227 region.RegionOp(region1, region2, res, op);
228 }
229
230 /**
231 * @tc.name: RegionOpLocal001
232 * @tc.desc: test results of RegionOpLocal
233 * @tc.type:FUNC
234 * @tc.require:
235 */
236 HWTEST_F(RSOcclusionRegionTest, RegionOpLocal001, Function | MediumTest | Level2)
237 {
238 /**
239 * @tc.steps: step1. RegionOpLocal
240 */
241 Region region;
242 Region region1;
243 Region region2;
244 Region res;
245 ASSERT_TRUE(region.IsEmpty());
246 Region::OP op = Region::OP::AND;
247 region.RegionOpLocal(region1, region2, res, op);
248 }
249
250 /**
251 * @tc.name: RegionOpLocal002
252 * @tc.desc: test results of RegionOpLocal
253 * @tc.type:FUNC
254 * @tc.require:
255 */
256 HWTEST_F(RSOcclusionRegionTest, RegionOpLocal002, Function | MediumTest | Level2)
257 {
258 /**
259 * @tc.steps: step1. RegionOpLocal
260 */
261 Rect rect;
262 Region region;
263 Region region1(rect);
264 Region region2(rect);
265 Region res;
266 ASSERT_TRUE(region.IsEmpty());
267 Region::OP op = static_cast<Region::OP>(0);
268 region.RegionOpLocal(region1, region2, res, op);
269 }
270
271 /**
272 * @tc.name: XOrSelf001
273 * @tc.desc: test results of XOrSelf
274 * @tc.type:FUNC
275 * @tc.require:
276 */
277 HWTEST_F(RSOcclusionRegionTest, XOrSelf001, Function | MediumTest | Level2)
278 {
279 /**
280 * @tc.steps: step1. XOrSelf
281 */
282 Rect rect;
283 ASSERT_TRUE(rect.IsEmpty());
284 Region region1(rect);
285 Region region2(rect);
286 region1.XOrSelf(region2);
287 }
288
289 /**
290 * @tc.name: Area
291 * @tc.desc: test results of Area
292 * @tc.type:FUNC
293 * @tc.require: I80I2D
294 */
295 HWTEST_F(RSOcclusionRegionTest, Area, Function | MediumTest | Level2)
296 {
297 /**
298 * @tc.steps: step1. Area
299 */
300 Rect rect1{0, 0, 100, 100};
301 Rect rect2{50, 50, 150, 150};
302 Rect rect3{0, 0, 0, 0};
303 Region region1(rect1);
304 Region region2(rect2);
305 Region region3 = region1.Or(region2);
306 Region region4 = region1.And(region2);
307 Region region5(rect3);
308 ASSERT_TRUE(rect1.Area() == 10000);
309 ASSERT_TRUE(rect2.Area() == 10000);
310 ASSERT_TRUE(rect3.Area() == 0);
311 ASSERT_TRUE(region1.Area() == 10000);
312 ASSERT_TRUE(region2.Area() == 10000);
313 ASSERT_TRUE(region3.Area() == 17500);
314 ASSERT_TRUE(region4.Area() == 2500);
315 ASSERT_TRUE(region5.Area() == 0);
316 }
317
318 /**
319 * @tc.name: IntersectArea
320 * @tc.desc: test results of IntersectArea
321 * @tc.type:FUNC
322 * @tc.require: I80I2D
323 */
324 HWTEST_F(RSOcclusionRegionTest, IntersectArea, Function | MediumTest | Level2)
325 {
326 /**
327 * @tc.steps: step. IntersectArea
328 */
329 Rect rect1{0, 0, 100, 100};
330 Rect rect2{50, 50, 150, 150};
331 Rect rect3{60, 60, 70, 80};
332 Region region1(rect1);
333 Region region2(rect2);
334 Region region3(rect3);
335
336 Rect testRect{65, 64, 82, 95};
337 Region testRegion(testRect);
338
339 Region region4 = region1.Or(region2);
340 Region region5 = region4.Sub(region3);
341 Region region6 = region5.And(testRegion);
342 ASSERT_TRUE(region5.IntersectArea(testRect) == region6.Area());
343 }
344
345 /**
346 * @tc.name: ResetSurfaceOpaqueRegionTest1
347 * @tc.desc: test abnormal value of RectI input
348 * @tc.type:FUNC
349 * @tc.require: I8K5SW
350 */
351 HWTEST_F(RSOcclusionRegionTest, ResetSurfaceOpaqueRegionTest1, Function | MediumTest | Level2)
352 {
353 Rect trans{};
354 ASSERT_TRUE(trans.IsEmpty());
355 Rect opaque{353284384, 2147483647, 1184, 2147483647};
356 Rect screen{0, 0, 1260, 2720};
357 Region transparentRegion{trans};
358 Region opaqueRegion{opaque};
359 Region screenRegion{screen};
360 std::cout << "transparentRegion " << transparentRegion.GetRegionInfo() << std::endl;
361 std::cout << "opaqueRegion " << opaqueRegion.GetRegionInfo() << std::endl;
362 std::cout << "screenRegion " << screenRegion.GetRegionInfo() << std::endl;
363 transparentRegion.AndSelf(screenRegion);
364 opaqueRegion.AndSelf(screenRegion);
365 std::cout << "transparentRegion " << transparentRegion.GetRegionInfo() << std::endl;
366 std::cout << "opaqueRegion " << opaqueRegion.GetRegionInfo() << std::endl;
367 }
368
369 /**
370 * @tc.name: ResetSurfaceOpaqueRegionTest2
371 * @tc.desc: test abnormal value of RectI input
372 * @tc.type:FUNC
373 * @tc.require: I8K5SW
374 */
375 HWTEST_F(RSOcclusionRegionTest, ResetSurfaceOpaqueRegionTest2, Function | MediumTest | Level2)
376 {
377 Rect trans{};
378 ASSERT_TRUE(trans.IsEmpty());
379 Rect opaque{1021068672, 2147483647, 1024, 2147483647};
380 Rect screen{0, 0, 1260, 2720};
381 Region transparentRegion{trans};
382 Region opaqueRegion{opaque};
383 Region screenRegion{screen};
384 std::cout << "transparentRegion " << transparentRegion.GetRegionInfo() << std::endl;
385 std::cout << "opaqueRegion " << opaqueRegion.GetRegionInfo() << std::endl;
386 std::cout << "screenRegion " << screenRegion.GetRegionInfo() << std::endl;
387 transparentRegion.AndSelf(screenRegion);
388 opaqueRegion.AndSelf(screenRegion);
389 std::cout << "transparentRegion " << transparentRegion.GetRegionInfo() << std::endl;
390 std::cout << "opaqueRegion " << opaqueRegion.GetRegionInfo() << std::endl;
391 }
392
393 /**
394 * @tc.name: ResetSurfaceOpaqueRegionTest3
395 * @tc.desc: test abnormal value of RectI input
396 * @tc.type:FUNC
397 * @tc.require: I8K5SW
398 */
399 HWTEST_F(RSOcclusionRegionTest, ResetSurfaceOpaqueRegionTest3, Function | MediumTest | Level2)
400 {
401 Rect trans{};
402 ASSERT_TRUE(trans.IsEmpty());
403 Rect opaque{2147483647, 2147483647, 24964864, 2147483647};
404 Rect screen{0, 0, 1260, 2720};
405 Region transparentRegion{trans};
406 Region opaqueRegion{opaque};
407 Region screenRegion{screen};
408 std::cout << "transparentRegion " << transparentRegion.GetRegionInfo() << std::endl;
409 std::cout << "opaqueRegion " << opaqueRegion.GetRegionInfo() << std::endl;
410 std::cout << "screenRegion " << screenRegion.GetRegionInfo() << std::endl;
411 transparentRegion.AndSelf(screenRegion);
412 opaqueRegion.AndSelf(screenRegion);
413 std::cout << "transparentRegion " << transparentRegion.GetRegionInfo() << std::endl;
414 std::cout << "opaqueRegion " << opaqueRegion.GetRegionInfo() << std::endl;
415 }
416
417 /**
418 * @tc.name: UpdateTest
419 * @tc.desc: Verify function Update
420 * @tc.type: FUNC
421 * @tc.require: issuesI9OX7J
422 */
423 HWTEST_F(RSOcclusionRegionTest, UpdateTest, Function | MediumTest | Level2)
424 {
425 // for test
426 Node node(0, 10);
427 node.Update(10, 10, Event::Type::OPEN);
428 node.Update(0, 10, Event::Type::OPEN);
429 EXPECT_EQ(node.positive_count_, 1);
430 node.Update(0, 10, Event::Type::CLOSE);
431 EXPECT_EQ(node.positive_count_, 0);
432 node.Update(0, 10, Event::Type::VOID_CLOSE);
433 EXPECT_EQ(node.negative_count_, Event::Type::VOID_CLOSE);
434 node.Update(0, 5, Event::Type::OPEN);
435 EXPECT_EQ(node.left_ != nullptr, true);
436 EXPECT_EQ(node.right_ != nullptr, true);
437 }
438
439 /**
440 * @tc.name: getRangeTest
441 * @tc.desc: Verify function getRange
442 * @tc.type: FUNC
443 * @tc.require: issuesI9OX7J
444 */
445 HWTEST_F(RSOcclusionRegionTest, getRangeTest, Function | MediumTest | Level2)
446 {
447 // for test
448 Node node(0, 10);
449 std::vector<Range> ranges;
450 Region region;
451 region.getRange(ranges, node, Region::OP::AND);
452 region.getRange(ranges, node, Region::OP::OR);
453 region.getRange(ranges, node, Region::OP::XOR);
454 region.getRange(ranges, node, Region::OP::SUB);
455 EXPECT_EQ(node.right_ != nullptr, false);
456 }
457
458 /**
459 * @tc.name: UpdateRectsTest
460 * @tc.desc: Verify function UpdateRects
461 * @tc.type: FUNC
462 * @tc.require: issuesI9OX7J
463 */
464 HWTEST_F(RSOcclusionRegionTest, UpdateRectsTest, Function | MediumTest | Level2)
465 {
466 Region::Rects rects;
467 std::vector<Range> ranges;
468 std::vector<int> indexAt;
469 Region region;
470 Region resultRegion;
471 // for test
472 rects.preRects.push_back(Rect { 0, 0, 100, 50 });
473 rects.preRects.push_back(Rect { 150, 0, 100, 50 });
474 rects.preRects.push_back(Rect { 150, 0, 250, 50 });
475 rects.curY = 100;
476 rects.preY = 50;
477
478 ranges.emplace_back(Range { 0, 1 });
479 ranges.emplace_back(Range { 1, 2 });
480 ranges.emplace_back(Range { 1, 2 });
481 indexAt.push_back(0);
482 indexAt.push_back(100);
483 indexAt.push_back(250);
484 region.UpdateRects(rects, ranges, indexAt, resultRegion);
485 EXPECT_EQ(rects.preRects[0], (Rect { 0, 0, 100, 100 }));
486 }
487
488 /**
489 * @tc.name: RegionOpTest
490 * @tc.desc: Verify function RegionOp
491 * @tc.type: FUNC
492 * @tc.require: issuesI9OX7J
493 */
494 HWTEST_F(RSOcclusionRegionTest, RegionOpTest, Function | MediumTest | Level2)
495 {
496 Region emptyRegion(Rect { 0, 0, 0, 0 });
497 ASSERT_TRUE(emptyRegion.IsEmpty());
498 Region baseRegion;
499 Region resultRegion;
500 Region::OP operationType = Region::OP::AND;
501 Region regionOperator;
502 regionOperator.RegionOp(emptyRegion, baseRegion, resultRegion, operationType);
503 }
504
505 /**
506 * @tc.name: CheckAndCorrectValue001
507 * @tc.desc: test function CheckAndCorrectValue
508 * @tc.type: FUNC
509 * @tc.require: issuesIAEG1C
510 */
511 HWTEST_F(RSOcclusionRegionTest, CheckAndCorrectValue001, Function | MediumTest | Level2)
512 {
513 const Rect maxRect { MIN_REGION_VALUE, MIN_REGION_VALUE, MAX_REGION_VALUE, MAX_REGION_VALUE };
514 constexpr int invalidLeft = MIN_REGION_VALUE - 1;
515 constexpr int invalidTop = MIN_REGION_VALUE - 1;
516 constexpr int invalidRight = MAX_REGION_VALUE + 1;
517 constexpr int invalidBottom = MAX_REGION_VALUE + 1;
518 Rect rect{ invalidLeft, invalidTop, invalidRight, invalidBottom, false };
519 EXPECT_NE(rect, maxRect);
520 rect.CheckAndCorrectValue();
521 EXPECT_EQ(rect, maxRect);
522 }
523 } // namespace OHOS::Rosen::Occlusion