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  * @tc.name: Node::GetAndRange01
132  * @tc.desc: test WmOcclusionRegion WmOcclusion::Node::GetAndRange
133  * @tc.type: FUNC
134  */
135 HWTEST_F(WmOcclusionRegionTest, GetAndRange01, Function | SmallTest | Level2)
136 {
137     Node* rootNode = new Node(0, 2);
138     ASSERT_NE(rootNode, nullptr);
139     rootNode->positive_count_ = 0;
140     rootNode->negative_count_ = 0;
141     std::vector<Range> res;
142     rootNode->GetAndRange(res, false, false);
143     ASSERT_EQ(0, res.size());
144     rootNode->GetAndRange(res, true, true);
145     ASSERT_EQ(1, res.size());
146     ASSERT_EQ(0, res.at(0).start_);
147     ASSERT_EQ(2, res.at(0).end_);
148 
149     rootNode->left_ = new Node { 0, 1 };
150     rootNode->left_->positive_count_ = 1;
151     rootNode->GetAndRange(res, false, true);
152     ASSERT_EQ(2, res.size());
153     ASSERT_EQ(0, res[1].start_);
154     ASSERT_EQ(1, res[1].end_);
155 
156     rootNode->right_ = new Node { 1, 3 };
157     rootNode->right_->negative_count_ = 1;
158     rootNode->GetAndRange(res, true, false);
159     ASSERT_EQ(2, res.size());
160     ASSERT_EQ(0, res[1].start_);
161     ASSERT_EQ(3, res[1].end_);
162 
163     delete rootNode->right_;
164     rootNode->right_ = new Node { 1, 4 };
165     rootNode->right_->positive_count_ = 1;
166     rootNode->right_->negative_count_ = 1;
167     rootNode->GetAndRange(res, false, false);
168     ASSERT_EQ(3, res.size());
169     ASSERT_EQ(1, res[2].start_);
170     ASSERT_EQ(4, res[2].end_);
171 
172     delete rootNode;
173 }
174 /**
175  * @tc.name: Node::GetOrRange01
176  * @tc.desc: test WmOcclusionRegion WmOcclusion::Node::GetOrRange
177  * @tc.type: FUNC
178  */
179 HWTEST_F(WmOcclusionRegionTest, GetOrRange01, Function | SmallTest | Level2)
180 {
181     std::vector<Range> res;
182     Node* rootNode = new Node(0, 2);
183     ASSERT_NE(rootNode, nullptr);
184     rootNode->positive_count_ = 0;
185     rootNode->negative_count_ = 0;
186     rootNode->GetOrRange(res, true, true);
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, true, false);
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, true);
199     ASSERT_EQ(1, res.size());
200     ASSERT_EQ(0, res.at(0).start_);
201     ASSERT_EQ(2, res.at(0).end_);
202 
203     res.clear();
204     rootNode->GetOrRange(res, false, false);
205     ASSERT_EQ(0, res.size());
206 
207     rootNode->left_ = new Node { 0, 1 };
208     rootNode->left_->positive_count_ = 0;
209     rootNode->left_->negative_count_ = 1;
210     rootNode->GetOrRange(res, false, false);
211     ASSERT_EQ(1, res.size());
212     ASSERT_EQ(0, res[0].start_);
213     ASSERT_EQ(1, res[0].end_);
214     delete rootNode->left_;
215     rootNode->left_ = nullptr;
216 
217     res.clear();
218     rootNode->right_ = new Node { 1, 3 };
219     rootNode->right_->positive_count_ = 0;
220     rootNode->right_->negative_count_ = 1;
221     rootNode->GetOrRange(res, false, false);
222     ASSERT_EQ(1, res.size());
223     ASSERT_EQ(1, res[0].start_);
224     ASSERT_EQ(3, res[0].end_);
225 
226     delete rootNode;
227 }
228 /**
229  * @tc.name: Node::GetXOrRange01
230  * @tc.desc: test WmOcclusionRegion WmOcclusion::Node::GetXOrRange
231  * @tc.type: FUNC
232  */
233 HWTEST_F(WmOcclusionRegionTest, GetXOrRange01, Function | SmallTest | Level2)
234 {
235     std::vector<Range> res;
236     Node* rootNode = new Node(0, 2);
237     ASSERT_NE(rootNode, nullptr);
238     rootNode->positive_count_ = 0;
239     rootNode->negative_count_ = 0;
240     rootNode->GetXOrRange(res, true, true);
241     ASSERT_EQ(0, res.size());
242 
243     rootNode->GetXOrRange(res, true, false);
244     ASSERT_EQ(1, res.size());
245     ASSERT_EQ(0, res.at(0).start_);
246     ASSERT_EQ(2, res.at(0).end_);
247 
248     res.clear();
249     rootNode->GetXOrRange(res, false, true);
250     ASSERT_EQ(1, res.size());
251     ASSERT_EQ(0, res.at(0).start_);
252     ASSERT_EQ(2, res.at(0).end_);
253 
254     res.clear();
255     rootNode->GetXOrRange(res, false, false);
256     ASSERT_EQ(0, res.size());
257 
258     rootNode->left_ = new Node { 0, 1 };
259     rootNode->left_->positive_count_ = 0;
260     rootNode->left_->negative_count_ = 1;
261     rootNode->GetXOrRange(res, false, false);
262     ASSERT_EQ(1, res.size());
263     ASSERT_EQ(0, res[0].start_);
264     ASSERT_EQ(1, res[0].end_);
265 
266     delete rootNode->left_;
267     rootNode->left_ = nullptr;
268 
269     res.clear();
270     rootNode->right_ = new Node { 1, 3 };
271     rootNode->right_->positive_count_ = 0;
272     rootNode->right_->negative_count_ = 1;
273     rootNode->GetXOrRange(res, false, false);
274     ASSERT_EQ(1, res.size());
275     ASSERT_EQ(1, res[0].start_);
276     ASSERT_EQ(3, res[0].end_);
277 
278     delete rootNode;
279 }
280 /**
281  * @tc.name: Node::GetSubRange01
282  * @tc.desc: test WmOcclusionRegion WmOcclusion::Node::GetSubRange
283  * @tc.type: FUNC
284  */
285 HWTEST_F(WmOcclusionRegionTest, GetSubRange01, Function | SmallTest | Level2)
286 {
287     std::vector<Range> res;
288     Node* rootNode = new Node(0, 2);
289     ASSERT_NE(rootNode, nullptr);
290     rootNode->positive_count_ = 0;
291     rootNode->negative_count_ = 0;
292     rootNode->GetSubRange(res, true, true);
293     ASSERT_EQ(0, res.size());
294 
295     rootNode->GetSubRange(res, true, false);
296     ASSERT_EQ(1, res.size());
297     ASSERT_EQ(0, res.at(0).start_);
298     ASSERT_EQ(2, res.at(0).end_);
299 
300     res.clear();
301     rootNode->GetSubRange(res, false, true);
302     ASSERT_EQ(0, res.size());
303 
304     rootNode->GetSubRange(res, false, false);
305     ASSERT_EQ(0, res.size());
306 
307     rootNode->left_ = new Node { 0, 1 };
308     rootNode->left_->positive_count_ = 1;
309     rootNode->left_->negative_count_ = 0;
310     rootNode->GetSubRange(res, false, false);
311     ASSERT_EQ(1, res.size());
312     ASSERT_EQ(0, res[0].start_);
313     ASSERT_EQ(1, res[0].end_);
314 
315     delete rootNode->left_;
316     rootNode->left_ = nullptr;
317 
318     res.clear();
319     rootNode->right_ = new Node { 1, 3 };
320     rootNode->right_->positive_count_ = 1;
321     rootNode->right_->negative_count_ = 0;
322     rootNode->GetSubRange(res, false, false);
323     ASSERT_EQ(1, res.size());
324     ASSERT_EQ(1, res[0].start_);
325     ASSERT_EQ(3, res[0].end_);
326 
327     delete rootNode;
328 }
329 /**
330  * @tc.name: Region::UpdateRects01
331  * @tc.desc: test WmOcclusionRegion WmOcclusion::Region::UpdateRects
332  * @tc.type: FUNC
333  */
334 HWTEST_F(WmOcclusionRegionTest, UpdateRects01, Function | SmallTest | Level2)
335 {
336     Region* region = new Region();
337     ASSERT_NE(region, nullptr);
338     Region::Rects rects;
339     rects.preRects = {
340         Rect{0, 10, 1, 10},
341         Rect{3, 10, 1, 10},
342         Rect{1, 10, 3, 10},
343     };
344     std::vector<Range> ranges = {
345         Range{0, 1},
346         Range{1, 2},
347         Range{3, 4},
348     };
349     std::vector<int> indexAt = {
350         0, 1, 2, 2, 3
351     };
352     Region regionRes;
353     region->UpdateRects(rects, ranges, indexAt, regionRes);
354 
355     std::vector<int> resultPreRectsLeft = { 0, 1, 2, 10 };
356     ASSERT_EQ(3, rects.preRects.size());
357     for (uint32_t i = 0; i < rects.preRects.size(); ++i) {
358         ASSERT_EQ(resultPreRectsLeft[i], rects.preRects[i].left_);
359     }
360     ASSERT_EQ(2, regionRes.GetRegionRects().size());
361     auto regionRects = regionRes.GetRegionRects();
362     std::vector<int> resultRegionRectsLeft = { 3, 1, 10, };
363     for (uint32_t i = 0; i < regionRects.size(); ++i) {
364         ASSERT_EQ(resultRegionRectsLeft[i], regionRects[i].left_);
365     }
366     delete region;
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, Function | SmallTest | Level2)
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  * @tc.name: Region::RegionOpLocal01
401  * @tc.desc: test WmOcclusionRegion WmOcclusion::Region::RegionOpLocal
402  * @tc.type: FUNC
403  */
404 HWTEST_F(WmOcclusionRegionTest, RegionOpLocal01, Function | SmallTest | Level2)
405 {
406     Region regionBase;
407     Region region1;
408     Region region2;
409     Region regionRes;
410     Region::OP op = Region::OP::SUB;
411     regionRes.rects_.emplace_back(Rect{ 10, 10, 10, 10 });
412     regionBase.RegionOpLocal(region1, region2, regionRes, op);
413     ASSERT_EQ(0, regionRes.GetRegionRects().size());
414 
415     region1.rects_.emplace_back(Rect{ 6, 7, 8, 9, });
416     region1.rects_.emplace_back(Rect{ 10, 9, 8, 7, });
417     region1.rects_.emplace_back(Rect{ 5, 6, 7, 8, });
418     region1.rects_.emplace_back(Rect{ 11, 10, 9, 8, });
419     regionBase.RegionOpLocal(region1, region2, regionRes, op);
420     ASSERT_EQ(3, regionRes.GetRegionRects().size());
421 }
422 }
423 }
424 } // namespace Rosen
425 } // namespace OHOS