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