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
18 #include "wm_occlusion_region.h"
19
20 using namespace testing;
21 using namespace testing::ext;
22
23 namespace OHOS {
24 namespace Rosen {
25 namespace WmOcclusion {
26 class WmOcclusionRegionTest : public testing::Test {
27 public:
28 static void SetUpTestCase();
29 static void TearDownTestCase();
30 void SetUp() override;
31 void TearDown() override;
32 };
33
SetUpTestCase()34 void WmOcclusionRegionTest::SetUpTestCase()
35 {
36 }
37
TearDownTestCase()38 void WmOcclusionRegionTest::TearDownTestCase()
39 {
40 }
41
SetUp()42 void WmOcclusionRegionTest::SetUp()
43 {
44 }
45
TearDown()46 void WmOcclusionRegionTest::TearDown()
47 {
48 }
49
50 namespace {
51 /**
52 * @tc.name: EventSortByY01
53 * @tc.desc: test WmOcclusion::EventSortByY
54 * @tc.type: FUNC
55 */
56 HWTEST_F(WmOcclusionRegionTest, EventSortByY, Function | SmallTest | Level2)
57 {
58 Event event1{ 0, Event::Type::OPEN, 0, 0 };
59 Event event2{ 0, Event::Type::OPEN, 0, 0 };
60 bool result = true;
61
62 event1.y_ = 1;
63 event1.type_ = Event::Type::CLOSE;
64 event2.y_ = 1;
65 event2.type_ = Event::Type::OPEN;
66 result = EventSortByY(event1, event2);
67 ASSERT_EQ(true, result);
68
69 event1.y_ = 1;
70 event1.type_ = Event::Type::OPEN;
71 event2.y_ = 1;
72 event2.type_ = Event::Type::CLOSE;
73 result = EventSortByY(event1, event2);
74 ASSERT_EQ(false, result);
75
76 event1.y_ = 1;
77 event2.y_ = 2;
78 result = EventSortByY(event1, event2);
79 ASSERT_EQ(true, result);
80
81 event1.y_ = 2;
82 event2.y_ = 1;
83 result = EventSortByY(event1, event2);
84 ASSERT_EQ(false, result);
85 }
86
87 /**
88 * @tc.name: Node::Update01
89 * @tc.desc: test WmOcclusion::Node::Update
90 * @tc.type: FUNC
91 */
92 HWTEST_F(WmOcclusionRegionTest, Update01, Function | SmallTest | Level2)
93 {
94 Node* rootNode = new Node(0, 2);
95 ASSERT_NE(rootNode, nullptr);
96 rootNode->positive_count_ = Event::Type::CLOSE;
97 rootNode->Update(0, 0, Event::Type::OPEN);
98 ASSERT_EQ(Event::Type::CLOSE, rootNode->positive_count_);
99
100 rootNode->positive_count_ = Event::Type::CLOSE;
101 rootNode->Update(0, 2, Event::Type::OPEN);
102 ASSERT_EQ(0, rootNode->positive_count_);
103
104 rootNode->positive_count_ = Event::Type::CLOSE;
105 rootNode->Update(0, 2, Event::Type::CLOSE);
106 ASSERT_EQ(-2, rootNode->positive_count_);
107
108 rootNode->negative_count_ = Event::Type::VOID_CLOSE;
109 rootNode->Update(0, 2, Event::Type::VOID_OPEN);
110 ASSERT_EQ(0, rootNode->negative_count_);
111
112 rootNode->negative_count_ = Event::Type::VOID_CLOSE;
113 rootNode->Update(0, 2, Event::Type::VOID_CLOSE);
114 ASSERT_EQ(-4, rootNode->negative_count_);
115
116 rootNode->positive_count_ = Event::Type::CLOSE;
117 rootNode->Update(0, 1, Event::Type::OPEN);
118
119 ASSERT_NE(nullptr, rootNode->left_);
120 ASSERT_NE(nullptr, rootNode->right_);
121 ASSERT_EQ(1, rootNode->left_->positive_count_);
122 ASSERT_EQ(0, rootNode->right_->positive_count_);
123
124 rootNode->Update(1, 2, Event::Type::CLOSE);
125 ASSERT_EQ(1, rootNode->left_->positive_count_);
126 ASSERT_EQ(-1, rootNode->right_->positive_count_);
127
128 delete rootNode;
129 }
130
131 /**
132 * @tc.name: Node::GetAndRange01
133 * @tc.desc: test WmOcclusionRegion WmOcclusion::Node::GetAndRange
134 * @tc.type: FUNC
135 */
136 HWTEST_F(WmOcclusionRegionTest, GetAndRange01, Function | SmallTest | Level2)
137 {
138 Node* rootNode = new Node(0, 2);
139 ASSERT_NE(rootNode, nullptr);
140 rootNode->positive_count_ = 0;
141 rootNode->negative_count_ = 0;
142 std::vector<Range> res;
143 rootNode->GetAndRange(res, false, false);
144 ASSERT_EQ(0, res.size());
145 rootNode->GetAndRange(res, true, true);
146 ASSERT_EQ(1, res.size());
147 ASSERT_EQ(0, res.at(0).start_);
148 ASSERT_EQ(2, res.at(0).end_);
149
150 rootNode->left_ = new Node { 0, 1 };
151 rootNode->left_->positive_count_ = 1;
152 rootNode->GetAndRange(res, false, true);
153 ASSERT_EQ(2, res.size());
154 ASSERT_EQ(0, res[1].start_);
155 ASSERT_EQ(1, res[1].end_);
156
157 rootNode->right_ = new Node { 1, 3 };
158 rootNode->right_->negative_count_ = 1;
159 rootNode->GetAndRange(res, true, false);
160 ASSERT_EQ(2, res.size());
161 ASSERT_EQ(0, res[1].start_);
162 ASSERT_EQ(3, res[1].end_);
163
164 delete rootNode->right_;
165 rootNode->right_ = new Node { 1, 4 };
166 rootNode->right_->positive_count_ = 1;
167 rootNode->right_->negative_count_ = 1;
168 rootNode->GetAndRange(res, false, false);
169 ASSERT_EQ(3, res.size());
170 ASSERT_EQ(1, res[2].start_);
171 ASSERT_EQ(4, res[2].end_);
172
173 delete rootNode;
174 }
175
176 /**
177 * @tc.name: Node::GetOrRange01
178 * @tc.desc: test WmOcclusionRegion WmOcclusion::Node::GetOrRange
179 * @tc.type: FUNC
180 */
181 HWTEST_F(WmOcclusionRegionTest, GetOrRange01, Function | SmallTest | Level2)
182 {
183 std::vector<Range> res;
184 Node* rootNode = new Node(0, 2);
185 ASSERT_NE(rootNode, nullptr);
186 rootNode->positive_count_ = 0;
187 rootNode->negative_count_ = 0;
188 rootNode->GetOrRange(res, true, true);
189 ASSERT_EQ(1, res.size());
190 ASSERT_EQ(0, res.at(0).start_);
191 ASSERT_EQ(2, res.at(0).end_);
192
193 res.clear();
194 rootNode->GetOrRange(res, true, false);
195 ASSERT_EQ(1, res.size());
196 ASSERT_EQ(0, res.at(0).start_);
197 ASSERT_EQ(2, res.at(0).end_);
198
199 res.clear();
200 rootNode->GetOrRange(res, false, true);
201 ASSERT_EQ(1, res.size());
202 ASSERT_EQ(0, res.at(0).start_);
203 ASSERT_EQ(2, res.at(0).end_);
204
205 res.clear();
206 rootNode->GetOrRange(res, false, false);
207 ASSERT_EQ(0, res.size());
208
209 rootNode->left_ = new Node { 0, 1 };
210 rootNode->left_->positive_count_ = 0;
211 rootNode->left_->negative_count_ = 1;
212 rootNode->GetOrRange(res, false, false);
213 ASSERT_EQ(1, res.size());
214 ASSERT_EQ(0, res[0].start_);
215 ASSERT_EQ(1, res[0].end_);
216 delete rootNode->left_;
217 rootNode->left_ = nullptr;
218
219 res.clear();
220 rootNode->right_ = new Node { 1, 3 };
221 rootNode->right_->positive_count_ = 0;
222 rootNode->right_->negative_count_ = 1;
223 rootNode->GetOrRange(res, false, false);
224 ASSERT_EQ(1, res.size());
225 ASSERT_EQ(1, res[0].start_);
226 ASSERT_EQ(3, res[0].end_);
227
228 delete rootNode;
229 }
230
231 /**
232 * @tc.name: Node::GetXOrRange01
233 * @tc.desc: test WmOcclusionRegion WmOcclusion::Node::GetXOrRange
234 * @tc.type: FUNC
235 */
236 HWTEST_F(WmOcclusionRegionTest, GetXOrRange01, Function | SmallTest | Level2)
237 {
238 std::vector<Range> res;
239 Node* rootNode = new Node(0, 2);
240 ASSERT_NE(rootNode, nullptr);
241 rootNode->positive_count_ = 0;
242 rootNode->negative_count_ = 0;
243 rootNode->GetXOrRange(res, true, true);
244 ASSERT_EQ(0, res.size());
245
246 rootNode->GetXOrRange(res, true, false);
247 ASSERT_EQ(1, res.size());
248 ASSERT_EQ(0, res.at(0).start_);
249 ASSERT_EQ(2, res.at(0).end_);
250
251 res.clear();
252 rootNode->GetXOrRange(res, false, true);
253 ASSERT_EQ(1, res.size());
254 ASSERT_EQ(0, res.at(0).start_);
255 ASSERT_EQ(2, res.at(0).end_);
256
257 res.clear();
258 rootNode->GetXOrRange(res, false, false);
259 ASSERT_EQ(0, res.size());
260
261 rootNode->left_ = new Node { 0, 1 };
262 rootNode->left_->positive_count_ = 0;
263 rootNode->left_->negative_count_ = 1;
264 rootNode->GetXOrRange(res, false, false);
265 ASSERT_EQ(1, res.size());
266 ASSERT_EQ(0, res[0].start_);
267 ASSERT_EQ(1, res[0].end_);
268
269 delete rootNode->left_;
270 rootNode->left_ = nullptr;
271
272 res.clear();
273 rootNode->right_ = new Node { 1, 3 };
274 rootNode->right_->positive_count_ = 0;
275 rootNode->right_->negative_count_ = 1;
276 rootNode->GetXOrRange(res, false, false);
277 ASSERT_EQ(1, res.size());
278 ASSERT_EQ(1, res[0].start_);
279 ASSERT_EQ(3, res[0].end_);
280
281 delete rootNode;
282 }
283
284 /**
285 * @tc.name: Node::GetSubRange01
286 * @tc.desc: test WmOcclusionRegion WmOcclusion::Node::GetSubRange
287 * @tc.type: FUNC
288 */
289 HWTEST_F(WmOcclusionRegionTest, GetSubRange01, Function | SmallTest | Level2)
290 {
291 std::vector<Range> res;
292 Node* rootNode = new Node(0, 2);
293 ASSERT_NE(rootNode, nullptr);
294 rootNode->positive_count_ = 0;
295 rootNode->negative_count_ = 0;
296 rootNode->GetSubRange(res, true, true);
297 ASSERT_EQ(0, res.size());
298
299 rootNode->GetSubRange(res, true, false);
300 ASSERT_EQ(1, res.size());
301 ASSERT_EQ(0, res.at(0).start_);
302 ASSERT_EQ(2, res.at(0).end_);
303
304 res.clear();
305 rootNode->GetSubRange(res, false, true);
306 ASSERT_EQ(0, res.size());
307
308 rootNode->GetSubRange(res, false, false);
309 ASSERT_EQ(0, res.size());
310
311 rootNode->left_ = new Node { 0, 1 };
312 rootNode->left_->positive_count_ = 1;
313 rootNode->left_->negative_count_ = 0;
314 rootNode->GetSubRange(res, false, false);
315 ASSERT_EQ(1, res.size());
316 ASSERT_EQ(0, res[0].start_);
317 ASSERT_EQ(1, res[0].end_);
318
319 delete rootNode->left_;
320 rootNode->left_ = nullptr;
321
322 res.clear();
323 rootNode->right_ = new Node { 1, 3 };
324 rootNode->right_->positive_count_ = 1;
325 rootNode->right_->negative_count_ = 0;
326 rootNode->GetSubRange(res, false, false);
327 ASSERT_EQ(1, res.size());
328 ASSERT_EQ(1, res[0].start_);
329 ASSERT_EQ(3, res[0].end_);
330
331 delete rootNode;
332 }
333
334 /**
335 * @tc.name: Region::UpdateRects01
336 * @tc.desc: test WmOcclusionRegion WmOcclusion::Region::UpdateRects
337 * @tc.type: FUNC
338 */
339 HWTEST_F(WmOcclusionRegionTest, UpdateRects01, Function | SmallTest | Level2)
340 {
341 Region* region = new Region();
342 ASSERT_NE(region, nullptr);
343 Region::Rects rects;
344 rects.preRects = {
345 Rect{0, 10, 1, 10},
346 Rect{3, 10, 1, 10},
347 Rect{1, 10, 3, 10},
348 };
349 std::vector<Range> ranges = {
350 Range{0, 1},
351 Range{1, 2},
352 Range{3, 4},
353 };
354 std::vector<int> indexAt = {
355 0, 1, 2, 2, 3
356 };
357 Region regionRes;
358 region->UpdateRects(rects, ranges, indexAt, regionRes);
359
360 std::vector<int> resultPreRectsLeft = { 0, 1, 2, 10 };
361 ASSERT_EQ(3, rects.preRects.size());
362 for (uint32_t i = 0; i < rects.preRects.size(); ++i) {
363 ASSERT_EQ(resultPreRectsLeft[i], rects.preRects[i].left_);
364 }
365 ASSERT_EQ(2, regionRes.GetRegionRects().size());
366 auto regionRects = regionRes.GetRegionRects();
367 std::vector<int> resultRegionRectsLeft = { 3, 1, 10, };
368 for (uint32_t i = 0; i < regionRects.size(); ++i) {
369 ASSERT_EQ(resultRegionRectsLeft[i], regionRects[i].left_);
370 }
371 delete region;
372 }
373
374 /**
375 * @tc.name: Region::MakeBound01
376 * @tc.desc: test WmOcclusionRegion WmOcclusion::Region::MakeBound
377 * @tc.type: FUNC
378 */
379 HWTEST_F(WmOcclusionRegionTest, MakeBound01, Function | SmallTest | Level2)
380 {
381 Region* region = new Region();
382 ASSERT_NE(region, nullptr);
383 region->bound_ = { 10, 10, 10, 10 };
384 region->rects_.clear();
385 region->MakeBound();
386 ASSERT_EQ(10, region->bound_.left_);
387 ASSERT_EQ(10, region->bound_.top_);
388 ASSERT_EQ(10, region->bound_.right_);
389 ASSERT_EQ(10, region->bound_.bottom_);
390
391 region->rects_ = {
392 Rect{5, 5, 5, 5},
393 Rect{6, 4, 6, 6},
394 Rect{7, 6, 2, 8},
395 Rect{8, 7, 7, 3},
396 };
397 region->MakeBound();
398 ASSERT_EQ(5, region->bound_.left_);
399 ASSERT_EQ(4, region->bound_.top_);
400 ASSERT_EQ(7, region->bound_.right_);
401 ASSERT_EQ(8, region->bound_.bottom_);
402
403 delete region;
404 }
405
406 /**
407 * @tc.name: Region::RegionOpLocal01
408 * @tc.desc: test WmOcclusionRegion WmOcclusion::Region::RegionOpLocal
409 * @tc.type: FUNC
410 */
411 HWTEST_F(WmOcclusionRegionTest, RegionOpLocal01, Function | SmallTest | Level2)
412 {
413 Region regionBase;
414 Region region1;
415 Region region2;
416 Region regionRes;
417 Region::OP op = Region::OP::SUB;
418 regionRes.rects_.emplace_back(Rect{ 10, 10, 10, 10 });
419 regionBase.RegionOpLocal(region1, region2, regionRes, op);
420 ASSERT_EQ(0, regionRes.GetRegionRects().size());
421
422 region1.rects_.emplace_back(Rect{ 6, 7, 8, 9, });
423 region1.rects_.emplace_back(Rect{ 10, 9, 8, 7, });
424 region1.rects_.emplace_back(Rect{ 5, 6, 7, 8, });
425 region1.rects_.emplace_back(Rect{ 11, 10, 9, 8, });
426 regionBase.RegionOpLocal(region1, region2, regionRes, op);
427 ASSERT_EQ(3, regionRes.GetRegionRects().size());
428 }
429 }
430 }
431 } // namespace Rosen
432 } // namespace OHOS