1 /*
2 * Copyright (c) 2020-2021 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 "components/ui_view_group.h"
17
18 #include <climits>
19 #include <gtest/gtest.h>
20
21 using namespace testing::ext;
22 namespace OHOS {
23 namespace {
24 const int16_t POS_X = 10;
25 const int16_t POS_Y = 20;
26 const int16_t DEFAULE_WIDTH = 100;
27 const int16_t DEFAULE_HEIGHT = 100;
28 const int16_t BUTTON_WIDTH = 20;
29 const int16_t BUTTON_HEIGHT = 20;
30 const int16_t MARGIN_LEFT = 50;
31 const int16_t MARGIN_TOP = 30;
32 const int16_t PADDING_LEFT = 10;
33 const int16_t PADDING_TOP = 20;
34 const int16_t PADDING_RIGHT = 30;
35 const int16_t PADDING_BOTTOM = 40;
36 const int16_t BORDER_WIDTH = 10;
37 const float POS_X_PERCENT = 0.1;
38 const float POS_Y_PERCENT = 0.2;
39 const float DEFAULT_WIDTH_PERCENT = 0.3;
40 const float DEFAULT_HEIGHT_PERCENT = 0.4;
41 const float INVALID_PERCENT_ZERO = 0.0f;
42 const float INVALID_PERCENT_ONE = 1.0f;
43 const int16_t DEFAULE_ANGLE = 45;
44 const Vector2<float> VIEW_CENTER = {50, 50};
45 const Vector2<float> SCALE_VALUE = {0.5f, 0.5f};
46 const Vector2<int16_t> POLYGON1 = {0, 0};
47 const Vector2<int16_t> POLYGON2 = {70, 70};
48 const Vector2<int16_t> POLYGON3 = {0, 140};
49 const Vector2<int16_t> POLYGON4 = {-70, 70};
50 }
51
52 class UIViewTest : public testing::Test {
53 public:
UIViewTest()54 UIViewTest() : view_(nullptr) {}
~UIViewTest()55 virtual ~UIViewTest() {}
SetUpTestCase()56 static void SetUpTestCase() {}
TearDownTestCase()57 static void TearDownTestCase() {}
58 void SetUp();
59 void TearDown();
60 UIView* view_;
61 };
62
SetUp()63 void UIViewTest::SetUp()
64 {
65 if (view_ == nullptr) {
66 view_ = new UIView();
67 }
68 }
69
TearDown()70 void UIViewTest::TearDown()
71 {
72 if (view_ != nullptr) {
73 delete view_;
74 view_ = nullptr;
75 }
76 }
77
78 /**
79 * @tc.name: UIViewSetOnDragListener_001
80 * @tc.desc: Verify SetOnDragListener function, equal.
81 * @tc.type: FUNC
82 * @tc.require: AR000EEMQF
83 */
84 HWTEST_F(UIViewTest, UIViewSetOnDragListener_001, TestSize.Level1)
85 {
86 if (view_ == nullptr) {
87 EXPECT_NE(0, 0);
88 return;
89 }
90 UIView::OnDragListener* listener = new UIView::OnDragListener();
91 view_->SetOnDragListener(listener);
92 EXPECT_EQ(view_->GetOnDragListener(), listener);
93 delete listener;
94 }
95
96 /**
97 * @tc.name: UIViewSetOnClickListener_001
98 * @tc.desc: Verify SetOnClickListener function, equal.
99 * @tc.type: FUNC
100 * @tc.require: AR000EEMQF
101 */
102 HWTEST_F(UIViewTest, UIViewSetOnClickListener_001, TestSize.Level1)
103 {
104 if (view_ == nullptr) {
105 EXPECT_NE(0, 0);
106 return;
107 }
108 UIView::OnClickListener* listener = new UIView::OnClickListener();
109 view_->SetOnClickListener(listener);
110 EXPECT_EQ(view_->GetOnClickListener(), listener);
111 delete listener;
112 }
113
114 /**
115 * @tc.name: UIViewSetOnLongPressListener_001
116 * @tc.desc: Verify SetOnLongPressListener function, equal.
117 * @tc.type: FUNC
118 * @tc.require: AR000EEMQF
119 */
120 HWTEST_F(UIViewTest, UIViewSetOnLongPressListener_001, TestSize.Level1)
121 {
122 if (view_ == nullptr) {
123 EXPECT_NE(0, 0);
124 return;
125 }
126 UIView::OnLongPressListener* listener = new UIView::OnLongPressListener();
127 view_->SetOnLongPressListener(listener);
128 EXPECT_EQ(view_->GetOnLongPressListener(), listener);
129 delete listener;
130 }
131
132 /**
133 * @tc.name: UIViewSetOnTouchListener_001
134 * @tc.desc: Verify SetOnTouchListener function, equal.
135 * @tc.type: FUNC
136 * @tc.require: AR000EEMQF
137 */
138 HWTEST_F(UIViewTest, UIViewSetOnTouchListener_001, TestSize.Level1)
139 {
140 if (view_ == nullptr) {
141 EXPECT_NE(0, 0);
142 return;
143 }
144 UIView::OnTouchListener* listener = new UIView::OnTouchListener();
145 view_->SetOnTouchListener(listener);
146 EXPECT_EQ(view_->GetTouchListener(), listener);
147 delete listener;
148 }
149
150 /**
151 * @tc.name: UIViewSetParent_001
152 * @tc.desc: Verify SetParent function, equal.
153 * @tc.type: FUNC
154 * @tc.require: AR000EEMQF
155 */
156 HWTEST_F(UIViewTest, UIViewSetParent_001, TestSize.Level1)
157 {
158 if (view_ == nullptr) {
159 EXPECT_NE(0, 0);
160 return;
161 }
162 UIViewGroup* viewGroup = new UIViewGroup();
163 if (viewGroup == nullptr) {
164 EXPECT_NE(0, 0);
165 return;
166 }
167 view_->SetParent(viewGroup);
168 EXPECT_EQ(view_->GetParent(), viewGroup);
169
170 delete viewGroup;
171 }
172
173 /**
174 * @tc.name: UIViewSetNextSibling_001
175 * @tc.desc: Verify SetNextSibling function, equal.
176 * @tc.type: FUNC
177 * @tc.require: AR000EEMQF
178 */
179 HWTEST_F(UIViewTest, UIViewSetNextSibling_001, TestSize.Level1)
180 {
181 if (view_ == nullptr) {
182 EXPECT_NE(0, 0);
183 return;
184 }
185 UIView* tempView = new UIView();
186 if (tempView == nullptr) {
187 EXPECT_NE(0, 0);
188 return;
189 }
190 view_->SetNextSibling(tempView);
191 EXPECT_EQ(view_->GetNextSibling(), tempView);
192
193 delete tempView;
194 }
195
196 /**
197 * @tc.name: UIViewSetVisible_001
198 * @tc.desc: Verify SetVisible function, equal.
199 * @tc.type: FUNC
200 * @tc.require: AR000EEMQF
201 */
202 HWTEST_F(UIViewTest, UIViewSetVisible_001, TestSize.Level1)
203 {
204 if (view_ == nullptr) {
205 EXPECT_NE(0, 0);
206 return;
207 }
208 view_->SetVisible(true);
209 EXPECT_EQ(view_->IsVisible(), true);
210 }
211
212 /**
213 * @tc.name: UIViewSetTouchable_001
214 * @tc.desc: Verify SetTouchable function, equal.
215 * @tc.type: FUNC
216 * @tc.require: AR000EEMQF
217 */
218 HWTEST_F(UIViewTest, UIViewSetTouchable_001, TestSize.Level1)
219 {
220 if (view_ == nullptr) {
221 EXPECT_NE(0, 0);
222 return;
223 }
224 view_->SetTouchable(true);
225 EXPECT_EQ(view_->IsTouchable(), true);
226 }
227
228 /**
229 * @tc.name: UIViewSetDraggable_001
230 * @tc.desc: Verify SetDraggable function, equal.
231 * @tc.type: FUNC
232 * @tc.require: AR000EEMQF
233 */
234 HWTEST_F(UIViewTest, UIViewSetDraggable_001, TestSize.Level1)
235 {
236 if (view_ == nullptr) {
237 EXPECT_NE(0, 0);
238 return;
239 }
240 view_->SetDraggable(true);
241 EXPECT_EQ(view_->IsDraggable(), true);
242 }
243
244 /**
245 * @tc.name: UIViewSetDragParentInstead_001
246 * @tc.desc: Verify SetDragParentInstead function, equal.
247 * @tc.type: FUNC
248 * @tc.require: AR000EEMQF
249 */
250 HWTEST_F(UIViewTest, UIViewSetDragParentInstead_001, TestSize.Level1)
251 {
252 if (view_ == nullptr) {
253 EXPECT_NE(0, 0);
254 return;
255 }
256 view_->SetDragParentInstead(true);
257 EXPECT_EQ(view_->IsDragParentInstead(), true);
258 }
259
260 /**
261 * @tc.name: UIViewResizeVisibleArea_001
262 * @tc.desc: Verify ResizeVisibleArea function, equal.
263 * @tc.type: FUNC
264 * @tc.require: AR000EEMQF
265 */
266 HWTEST_F(UIViewTest, UIViewResizeVisibleArea_001, TestSize.Level1)
267 {
268 if (view_ == nullptr) {
269 EXPECT_NE(0, 0);
270 return;
271 }
272 view_->ResizeVisibleArea(POS_X, POS_Y, DEFAULE_WIDTH, DEFAULE_HEIGHT);
273
274 EXPECT_EQ(view_->GetVisibleRect().GetWidth(), DEFAULE_WIDTH);
275 EXPECT_EQ(view_->GetVisibleRect().GetHeight(), DEFAULE_HEIGHT);
276 }
277
278 /**
279 * @tc.name: UIViewSetWidth_001
280 * @tc.desc: Verify SetWidth function, equal.
281 * @tc.type: FUNC
282 * @tc.require: AR000EEMQF
283 */
284 HWTEST_F(UIViewTest, UIViewSetWidth_001, TestSize.Level1)
285 {
286 if (view_ == nullptr) {
287 EXPECT_NE(0, 0);
288 return;
289 }
290 view_->SetWidth(0);
291 EXPECT_EQ(view_->GetWidth(), 0);
292 view_->SetWidth(DEFAULE_WIDTH);
293 EXPECT_EQ(view_->GetWidth(), DEFAULE_WIDTH);
294 }
295
296 /**
297 * @tc.name: UIViewSetHeight_001
298 * @tc.desc: Verify SetHeight function, equal.
299 * @tc.type: FUNC
300 * @tc.require: AR000EEMQF
301 */
302 HWTEST_F(UIViewTest, UIViewSetHeight_001, TestSize.Level1)
303 {
304 if (view_ == nullptr) {
305 EXPECT_NE(0, 0);
306 return;
307 }
308 view_->SetHeight(0);
309 EXPECT_EQ(view_->GetHeight(), 0);
310 view_->SetHeight(DEFAULE_HEIGHT);
311 EXPECT_EQ(view_->GetHeight(), DEFAULE_HEIGHT);
312 }
313
314 /**
315 * @tc.name: UIViewResize_001
316 * @tc.desc: Verify Resize function, equal.
317 * @tc.type: FUNC
318 * @tc.require: AR000EEMQF
319 */
320 HWTEST_F(UIViewTest, UIViewResize_001, TestSize.Level1)
321 {
322 if (view_ == nullptr) {
323 EXPECT_NE(0, 0);
324 return;
325 }
326 view_->Resize(0, 0);
327 EXPECT_EQ(view_->GetHeight(), 0);
328 EXPECT_EQ(view_->GetWidth(), 0);
329 view_->Resize(DEFAULE_WIDTH, DEFAULE_HEIGHT);
330 EXPECT_EQ(view_->GetHeight(), DEFAULE_HEIGHT);
331 EXPECT_EQ(view_->GetWidth(), DEFAULE_WIDTH);
332 }
333
334 /**
335 * @tc.name: UIViewSetX_001
336 * @tc.desc: Verify SetX function, equal.
337 * @tc.type: FUNC
338 * @tc.require: AR000EEMQF
339 */
340 HWTEST_F(UIViewTest, UIViewSetX_001, TestSize.Level1)
341 {
342 if (view_ == nullptr) {
343 EXPECT_NE(0, 0);
344 return;
345 }
346 view_->SetX(0);
347 EXPECT_EQ(view_->GetX(), 0);
348 view_->SetX(POS_X);
349 EXPECT_EQ(view_->GetX(), POS_X);
350 }
351
352 /**
353 * @tc.name: UIViewSetY_001
354 * @tc.desc: Verify SetY function, equal.
355 * @tc.type: FUNC
356 * @tc.require: AR000EEMQF
357 */
358 HWTEST_F(UIViewTest, UIViewSetY_001, TestSize.Level1)
359 {
360 if (view_ == nullptr) {
361 EXPECT_NE(0, 0);
362 return;
363 }
364 view_->SetY(0);
365 EXPECT_EQ(view_->GetY(), 0);
366 view_->SetY(POS_Y);
367 EXPECT_EQ(view_->GetY(), POS_Y);
368 }
369
370 /**
371 * @tc.name: UIViewSetPosition_001
372 * @tc.desc: Verify SetPosition function, equal.
373 * @tc.type: FUNC
374 * @tc.require: AR000EEMQF
375 */
376 HWTEST_F(UIViewTest, UIViewSetPosition_001, TestSize.Level1)
377 {
378 if (view_ == nullptr) {
379 EXPECT_NE(0, 0);
380 return;
381 }
382 view_->SetPosition(0, 0);
383 EXPECT_EQ(view_->GetX(), 0);
384 EXPECT_EQ(view_->GetY(), 0);
385 view_->SetPosition(POS_X, POS_Y);
386 EXPECT_EQ(view_->GetX(), POS_X);
387 EXPECT_EQ(view_->GetY(), POS_Y);
388 }
389
390 /**
391 * @tc.name: UIViewSetPosition_002
392 * @tc.desc: Verify SetPosition function, equal.
393 * @tc.type: FUNC
394 * @tc.require: AR000EEMQF
395 */
396 HWTEST_F(UIViewTest, UIViewSetPosition_002, TestSize.Level1)
397 {
398 if (view_ == nullptr) {
399 EXPECT_NE(0, 0);
400 return;
401 }
402 view_->SetPosition(0, 0, 0, 0);
403 EXPECT_EQ(view_->GetHeight(), 0);
404 EXPECT_EQ(view_->GetWidth(), 0);
405 EXPECT_EQ(view_->GetX(), 0);
406 EXPECT_EQ(view_->GetY(), 0);
407 view_->SetPosition(POS_X, POS_Y, DEFAULE_WIDTH, DEFAULE_HEIGHT);
408 EXPECT_EQ(view_->GetHeight(), DEFAULE_HEIGHT);
409 EXPECT_EQ(view_->GetWidth(), DEFAULE_WIDTH);
410 EXPECT_EQ(view_->GetX(), POS_X);
411 EXPECT_EQ(view_->GetY(), POS_Y);
412 }
413
414 /**
415 * @tc.name: UIViewSetWidthPercent_001
416 * @tc.desc: Verify SetWidthPercent function, equal.
417 * @tc.type: FUNC
418 * @tc.require: SR000F3PE8
419 */
420 HWTEST_F(UIViewTest, UIViewSetWidthPercent_001, TestSize.Level0)
421 {
422 if (view_ == nullptr) {
423 EXPECT_NE(0, 0);
424 return;
425 }
426 view_->SetPosition(POS_X, POS_Y, DEFAULE_WIDTH, DEFAULE_HEIGHT);
427 EXPECT_EQ(view_->GetHeight(), DEFAULE_HEIGHT);
428 EXPECT_EQ(view_->GetWidth(), DEFAULE_WIDTH);
429 EXPECT_EQ(view_->GetX(), POS_X);
430 EXPECT_EQ(view_->GetY(), POS_Y);
431
432 // Not has parent, SetWidthPercent failed
433 view_->SetWidthPercent(POS_X_PERCENT);
434 EXPECT_EQ(view_->GetWidth(), DEFAULE_WIDTH);
435
436 // Parent does not SetWidth, view SetWidthPercent failed
437 UIViewGroup* viewGroup = new UIViewGroup();
438 viewGroup->Add(view_);
439 view_->SetWidthPercent(POS_X_PERCENT);
440 EXPECT_EQ(view_->GetWidth(), DEFAULE_WIDTH);
441
442 viewGroup->SetWidth(DEFAULE_WIDTH);
443 viewGroup->SetHeight(DEFAULE_HEIGHT);
444
445 // Input invalid percent, SetWidthPercent failed
446 view_->SetWidthPercent(INVALID_PERCENT_ZERO);
447 EXPECT_EQ(view_->GetWidth(), DEFAULE_WIDTH);
448 view_->SetWidthPercent(INVALID_PERCENT_ONE);
449 EXPECT_EQ(view_->GetWidth(), DEFAULE_WIDTH);
450
451 view_->SetWidthPercent(POS_X_PERCENT);
452 EXPECT_EQ(view_->GetWidth(), (int16_t)(DEFAULE_WIDTH * POS_X_PERCENT));
453
454 delete viewGroup;
455 }
456
457 /**
458 * @tc.name: UIViewSetHeightPercent_001
459 * @tc.desc: Verify SetHeightPercent function, equal.
460 * @tc.type: FUNC
461 * @tc.require: AR000F4770
462 */
463 HWTEST_F(UIViewTest, UIViewSetHeightPercent_001, TestSize.Level0)
464 {
465 if (view_ == nullptr) {
466 EXPECT_NE(0, 0);
467 return;
468 }
469 view_->SetPosition(POS_X, POS_Y, DEFAULE_WIDTH, DEFAULE_HEIGHT);
470 EXPECT_EQ(view_->GetHeight(), DEFAULE_HEIGHT);
471 EXPECT_EQ(view_->GetWidth(), DEFAULE_WIDTH);
472 EXPECT_EQ(view_->GetX(), POS_X);
473 EXPECT_EQ(view_->GetY(), POS_Y);
474
475 // Not has parent, SetHeightPercent failed
476 view_->SetHeightPercent(POS_Y_PERCENT);
477 EXPECT_EQ(view_->GetHeight(), DEFAULE_HEIGHT);
478
479 // Parent does not SetHeight, view SetHeightPercent failed
480 UIViewGroup* viewGroup = new UIViewGroup();
481 viewGroup->Add(view_);
482 view_->SetHeightPercent(POS_Y_PERCENT);
483 EXPECT_EQ(view_->GetHeight(), DEFAULE_HEIGHT);
484
485 viewGroup->SetWidth(DEFAULE_WIDTH);
486 viewGroup->SetHeight(DEFAULE_HEIGHT);
487
488 // Input invalid percent, SetHeightPercent failed
489 view_->SetHeightPercent(INVALID_PERCENT_ZERO);
490 EXPECT_EQ(view_->GetHeight(), DEFAULE_HEIGHT);
491 view_->SetHeightPercent(INVALID_PERCENT_ONE);
492 EXPECT_EQ(view_->GetHeight(), DEFAULE_HEIGHT);
493
494 view_->SetHeightPercent(POS_Y_PERCENT);
495 EXPECT_EQ(view_->GetHeight(), (int16_t)(DEFAULE_HEIGHT * POS_Y_PERCENT));
496
497 delete viewGroup;
498 }
499
500 /**
501 * @tc.name: UIViewResizePercent_001
502 * @tc.desc: Verify ResizePercent function, equal.
503 * @tc.type: FUNC
504 * @tc.require: AR000F4770
505 */
506 HWTEST_F(UIViewTest, UIViewResizePercent_001, TestSize.Level0)
507 {
508 if (view_ == nullptr) {
509 EXPECT_NE(0, 0);
510 return;
511 }
512 view_->SetPosition(POS_X, POS_Y, DEFAULE_WIDTH, DEFAULE_HEIGHT);
513 EXPECT_EQ(view_->GetHeight(), DEFAULE_HEIGHT);
514 EXPECT_EQ(view_->GetWidth(), DEFAULE_WIDTH);
515 EXPECT_EQ(view_->GetX(), POS_X);
516 EXPECT_EQ(view_->GetY(), POS_Y);
517
518 // Not has parent, ResizePercent failed
519 view_->ResizePercent(POS_X_PERCENT, POS_Y_PERCENT);
520 EXPECT_EQ(view_->GetHeight(), DEFAULE_HEIGHT);
521 EXPECT_EQ(view_->GetWidth(), DEFAULE_WIDTH);
522
523 // Parent does not SetWidth and SetHeight, view ResizePercent failed
524 UIViewGroup* viewGroup = new UIViewGroup();
525 viewGroup->Add(view_);
526 view_->ResizePercent(POS_X_PERCENT, POS_Y_PERCENT);
527 EXPECT_EQ(view_->GetHeight(), DEFAULE_HEIGHT);
528 EXPECT_EQ(view_->GetWidth(), DEFAULE_WIDTH);
529
530 viewGroup->SetWidth(DEFAULE_WIDTH);
531 viewGroup->SetHeight(DEFAULE_HEIGHT);
532
533 // Input invalid percent, ResizePercent failed
534 view_->ResizePercent(INVALID_PERCENT_ZERO, POS_Y_PERCENT);
535 EXPECT_EQ(view_->GetHeight(), DEFAULE_HEIGHT);
536 EXPECT_EQ(view_->GetWidth(), DEFAULE_WIDTH);
537 view_->ResizePercent(POS_X_PERCENT, INVALID_PERCENT_ONE);
538 EXPECT_EQ(view_->GetHeight(), DEFAULE_HEIGHT);
539 EXPECT_EQ(view_->GetWidth(), DEFAULE_WIDTH);
540
541 view_->ResizePercent(POS_X_PERCENT, POS_Y_PERCENT);
542 EXPECT_EQ(view_->GetHeight(), (int16_t)(DEFAULE_HEIGHT * POS_Y_PERCENT));
543 EXPECT_EQ(view_->GetWidth(), (int16_t)(DEFAULE_WIDTH * POS_X_PERCENT));
544
545 delete viewGroup;
546 }
547
548 /**
549 * @tc.name: UIViewSetXPercent_001
550 * @tc.desc: Verify SetXPercent function, equal.
551 * @tc.type: FUNC
552 * @tc.require: AR000F4770
553 */
554 HWTEST_F(UIViewTest, UIViewSetXPercent_001, TestSize.Level0)
555 {
556 if (view_ == nullptr) {
557 EXPECT_NE(0, 0);
558 return;
559 }
560 view_->SetPosition(POS_X, POS_Y, DEFAULE_WIDTH, DEFAULE_HEIGHT);
561 EXPECT_EQ(view_->GetHeight(), DEFAULE_HEIGHT);
562 EXPECT_EQ(view_->GetWidth(), DEFAULE_WIDTH);
563 EXPECT_EQ(view_->GetX(), POS_X);
564 EXPECT_EQ(view_->GetY(), POS_Y);
565
566 // Not has parent, SetXPercent failed
567 view_->SetXPercent(POS_X_PERCENT);
568 EXPECT_EQ(view_->GetX(), POS_X);
569
570 // Parent does not SetWidth, view SetXPercent failed
571 UIViewGroup* viewGroup = new UIViewGroup();
572 viewGroup->Add(view_);
573 view_->SetXPercent(POS_X_PERCENT);
574 EXPECT_EQ(view_->GetX(), POS_X);
575
576 viewGroup->SetWidth(DEFAULE_WIDTH);
577 viewGroup->SetHeight(DEFAULE_HEIGHT);
578
579 // Input invalid percent, SetXPercent failed
580 view_->SetXPercent(INVALID_PERCENT_ZERO);
581 EXPECT_EQ(view_->GetX(), POS_X);
582 view_->SetXPercent(INVALID_PERCENT_ONE);
583 EXPECT_EQ(view_->GetX(), POS_X);
584
585 view_->SetXPercent(POS_X_PERCENT);
586 EXPECT_EQ(view_->GetX(), (int16_t)(POS_X_PERCENT * DEFAULE_WIDTH));
587
588 delete viewGroup;
589 }
590
591 /**
592 * @tc.name: UIViewSetYPercent_001
593 * @tc.desc: Verify SetYPercent function, equal.
594 * @tc.type: FUNC
595 * @tc.require: AR000F4770
596 */
597 HWTEST_F(UIViewTest, UIViewSetYPercent_001, TestSize.Level0)
598 {
599 if (view_ == nullptr) {
600 EXPECT_NE(0, 0);
601 return;
602 }
603 view_->SetPosition(POS_X, POS_Y, DEFAULE_WIDTH, DEFAULE_HEIGHT);
604 EXPECT_EQ(view_->GetHeight(), DEFAULE_HEIGHT);
605 EXPECT_EQ(view_->GetWidth(), DEFAULE_WIDTH);
606 EXPECT_EQ(view_->GetX(), POS_X);
607 EXPECT_EQ(view_->GetY(), POS_Y);
608
609 // Not has parent, SetYPercent failed
610 view_->SetYPercent(POS_Y_PERCENT);
611 EXPECT_EQ(view_->GetY(), POS_Y);
612
613 // Parent does not SetHeight, view SetYPercent failed
614 UIViewGroup* viewGroup = new UIViewGroup();
615 viewGroup->Add(view_);
616 view_->SetYPercent(POS_Y_PERCENT);
617 EXPECT_EQ(view_->GetY(), POS_Y);
618
619 viewGroup->SetWidth(DEFAULE_WIDTH);
620 viewGroup->SetHeight(DEFAULE_HEIGHT);
621
622 // Input invalid percent, SetYPercent failed
623 view_->SetYPercent(INVALID_PERCENT_ZERO);
624 EXPECT_EQ(view_->GetY(), POS_Y);
625 view_->SetYPercent(INVALID_PERCENT_ONE);
626 EXPECT_EQ(view_->GetY(), POS_Y);
627
628 view_->SetYPercent(POS_Y_PERCENT);
629 EXPECT_EQ(view_->GetY(), (int16_t)(POS_Y_PERCENT * DEFAULE_HEIGHT));
630
631 delete viewGroup;
632 }
633
634 /**
635 * @tc.name: UIViewSetPositionPercent_001
636 * @tc.desc: Verify SetPositionPercent function, equal.
637 * @tc.type: FUNC
638 * @tc.require: AR000F4770
639 */
640 HWTEST_F(UIViewTest, UIViewSetPositionPercent_001, TestSize.Level0)
641 {
642 if (view_ == nullptr) {
643 EXPECT_NE(0, 0);
644 return;
645 }
646 view_->SetPosition(POS_X, POS_Y, DEFAULE_WIDTH, DEFAULE_HEIGHT);
647 EXPECT_EQ(view_->GetHeight(), DEFAULE_HEIGHT);
648 EXPECT_EQ(view_->GetWidth(), DEFAULE_WIDTH);
649 EXPECT_EQ(view_->GetX(), POS_X);
650 EXPECT_EQ(view_->GetY(), POS_Y);
651
652 // Not has parent, SetPositionPercent failed
653 view_->SetPositionPercent(POS_X_PERCENT, POS_Y_PERCENT);
654 EXPECT_EQ(view_->GetX(), POS_X);
655 EXPECT_EQ(view_->GetY(), POS_Y);
656
657 // Parent does not SetWidth, view SetPositionPercent failed
658 UIViewGroup* viewGroup = new UIViewGroup();
659 viewGroup->Add(view_);
660 view_->SetPositionPercent(POS_X_PERCENT, POS_Y_PERCENT);
661 EXPECT_EQ(view_->GetX(), POS_X);
662 EXPECT_EQ(view_->GetY(), POS_Y);
663
664 viewGroup->SetWidth(DEFAULE_WIDTH);
665 viewGroup->SetHeight(DEFAULE_HEIGHT);
666
667 // Input invalid percent, SetPositionPercent failed
668 view_->SetPositionPercent(INVALID_PERCENT_ZERO, INVALID_PERCENT_ONE);
669 EXPECT_EQ(view_->GetX(), POS_X);
670 EXPECT_EQ(view_->GetY(), POS_Y);
671
672 view_->SetPositionPercent(POS_X_PERCENT, POS_Y_PERCENT);
673 EXPECT_EQ(view_->GetX(), (int16_t)(POS_X_PERCENT * DEFAULE_WIDTH));
674 EXPECT_EQ(view_->GetY(), (int16_t)(POS_Y_PERCENT * DEFAULE_HEIGHT));
675
676 delete viewGroup;
677 }
678
679 /**
680 * @tc.name: Graphic_UIView_Test_SetPositionPercent_002
681 * @tc.desc: Verify SetPositionPercent function, equal.
682 * @tc.type: FUNC
683 * @tc.require: AR000F4770
684 */
685 HWTEST_F(UIViewTest, UIViewSetPositionPercent_002, TestSize.Level0)
686 {
687 if (view_ == nullptr) {
688 EXPECT_NE(0, 0);
689 return;
690 }
691 view_->SetPosition(POS_X, POS_Y, DEFAULE_WIDTH, DEFAULE_HEIGHT);
692 EXPECT_EQ(view_->GetHeight(), DEFAULE_HEIGHT);
693 EXPECT_EQ(view_->GetWidth(), DEFAULE_WIDTH);
694 EXPECT_EQ(view_->GetX(), POS_X);
695 EXPECT_EQ(view_->GetY(), POS_Y);
696
697 // Not has parent, SetPositionPercent failed
698 view_->SetPositionPercent(POS_X_PERCENT, POS_Y_PERCENT, DEFAULT_WIDTH_PERCENT, DEFAULT_HEIGHT_PERCENT);
699 EXPECT_EQ(view_->GetHeight(), DEFAULE_HEIGHT);
700 EXPECT_EQ(view_->GetWidth(), DEFAULE_WIDTH);
701 EXPECT_EQ(view_->GetX(), POS_X);
702 EXPECT_EQ(view_->GetY(), POS_Y);
703
704 // Parent does not SetWidth, view SetPositionPercent failed
705 UIViewGroup* viewGroup = new UIViewGroup();
706 viewGroup->Add(view_);
707 view_->SetPositionPercent(POS_X_PERCENT, POS_Y_PERCENT, DEFAULT_WIDTH_PERCENT, DEFAULT_HEIGHT_PERCENT);
708 EXPECT_EQ(view_->GetHeight(), DEFAULE_HEIGHT);
709 EXPECT_EQ(view_->GetWidth(), DEFAULE_WIDTH);
710 EXPECT_EQ(view_->GetX(), POS_X);
711 EXPECT_EQ(view_->GetY(), POS_Y);
712
713 viewGroup->SetWidth(DEFAULE_WIDTH);
714 viewGroup->SetHeight(DEFAULE_HEIGHT);
715
716 // Input invalid percent, SetPositionPercent failed
717 view_->SetPositionPercent(INVALID_PERCENT_ZERO, INVALID_PERCENT_ONE, DEFAULT_WIDTH_PERCENT, DEFAULT_HEIGHT_PERCENT);
718 EXPECT_EQ(view_->GetHeight(), DEFAULE_HEIGHT);
719 EXPECT_EQ(view_->GetWidth(), DEFAULE_WIDTH);
720 EXPECT_EQ(view_->GetX(), POS_X);
721 EXPECT_EQ(view_->GetY(), POS_Y);
722
723
724 view_->SetPositionPercent(POS_X_PERCENT, POS_Y_PERCENT, DEFAULT_WIDTH_PERCENT, DEFAULT_HEIGHT_PERCENT);
725 EXPECT_EQ(view_->GetHeight(), (int16_t)(DEFAULE_HEIGHT * DEFAULT_HEIGHT_PERCENT));
726 EXPECT_EQ(view_->GetWidth(), (int16_t)(DEFAULE_WIDTH * DEFAULT_WIDTH_PERCENT));
727 EXPECT_EQ(view_->GetX(), (int16_t)(POS_X_PERCENT * DEFAULE_WIDTH));
728 EXPECT_EQ(view_->GetY(), (int16_t)(POS_Y_PERCENT * DEFAULE_HEIGHT));
729
730 delete viewGroup;
731 }
732
733 /**
734 * @tc.name: UIViewSetViewId_001
735 * @tc.desc: Verify SetViewId function, equal.
736 * @tc.type: FUNC
737 * @tc.require: AR000EEMQF
738 */
739 HWTEST_F(UIViewTest, UIViewSetViewId_001, TestSize.Level1)
740 {
741 if (view_ == nullptr) {
742 EXPECT_NE(0, 0);
743 return;
744 }
745 const char* id = "graphic_unittest_view";
746
747 view_->SetViewId(id);
748 EXPECT_EQ(memcmp(view_->GetViewId(), id, strlen(id)), 0);
749 }
750
751 /**
752 * @tc.name: UIViewSetViewIndex_001
753 * @tc.desc: Verify SetViewIndex function, equal.
754 * @tc.type: FUNC
755 * @tc.require: AR000EEMQF
756 */
757 HWTEST_F(UIViewTest, UIViewSetViewIndex_001, TestSize.Level1)
758 {
759 if (view_ == nullptr) {
760 EXPECT_NE(0, 0);
761 return;
762 }
763 int16_t index = 1;
764
765 view_->SetViewIndex(index);
766 EXPECT_EQ(view_->GetViewIndex(), index);
767 }
768
769 /**
770 * @tc.name: UIViewGetViewType_001
771 * @tc.desc: Verify GetViewType function, equal.
772 * @tc.type: FUNC
773 * @tc.require: AR000EEMQF
774 */
775 HWTEST_F(UIViewTest, UIViewGetViewType_001, TestSize.Level1)
776 {
777 if (view_ == nullptr) {
778 EXPECT_NE(0, 0);
779 return;
780 }
781 EXPECT_EQ(view_->GetViewType(), UI_NUMBER_MAX);
782 }
783
784 /**
785 * @tc.name: UIViewSetOpaScale_001
786 * @tc.desc: Verify SetOpaScale function, equal.
787 * @tc.type: FUNC
788 * @tc.require: AR000F4E5D
789 */
790 HWTEST_F(UIViewTest, UIViewSetOpaScale_001, TestSize.Level1)
791 {
792 if (view_ == nullptr) {
793 EXPECT_NE(0, 0);
794 return;
795 }
796
797 view_->SetOpaScale(OPA_OPAQUE);
798 EXPECT_EQ(view_->GetOpaScale(), OPA_OPAQUE);
799 }
800
801 /**
802 * @tc.name: UIViewSetOpaScale_002
803 * @tc.desc: Verify SetOpaScale function, equal.
804 * @tc.type: FUNC
805 * @tc.require: SR000F3PEB
806 */
807 HWTEST_F(UIViewTest, UIViewSetOpaScale_002, TestSize.Level1)
808 {
809 if (view_ == nullptr) {
810 EXPECT_NE(0, 0);
811 return;
812 }
813 uint8_t opaScale = OPA_OPAQUE;
814
815 view_->SetOpaScale(OPA_OPAQUE);
816 view_->SetStyle(STYLE_BACKGROUND_OPA, opaScale >> 1);
817 view_->SetStyle(STYLE_BORDER_OPA, opaScale >> 1);
818 EXPECT_EQ(view_->GetOpaScale(), OPA_OPAQUE);
819 }
820
821 /**
822 * @tc.name: UIViewSetStyle_001
823 * @tc.desc: Verify SetStyle function, equal.
824 * @tc.type: FUNC
825 * @tc.require: AR000EEMQF
826 */
827 HWTEST_F(UIViewTest, UIViewSetStyle_001, TestSize.Level1)
828 {
829 if (view_ == nullptr) {
830 EXPECT_NE(0, 0);
831 return;
832 }
833 Style style;
834 style.borderOpa_ = OPA_OPAQUE;
835 view_->SetStyle(style);
836 EXPECT_EQ(view_->GetStyleConst().borderOpa_, OPA_OPAQUE);
837 view_->SetStyle(STYLE_LINE_OPA, OPA_OPAQUE);
838 EXPECT_EQ(view_->GetStyle(STYLE_LINE_OPA), OPA_OPAQUE);
839 }
840
841 /**
842 * @tc.name: UIViewLayoutOfParent_001
843 * @tc.desc: Verify LayoutOfParent function, equal.
844 * @tc.type: FUNC
845 * @tc.require: AR000EEMQF
846 */
847 HWTEST_F(UIViewTest, UIViewLayoutOfParent_001, TestSize.Level0)
848 {
849 if (view_ == nullptr) {
850 EXPECT_NE(0, 0);
851 return;
852 }
853 UIViewGroup* viewGroup = new UIViewGroup();
854 viewGroup->SetPosition(0, 0, DEFAULE_WIDTH, DEFAULE_HEIGHT);
855 view_->SetPosition(POS_X, POS_Y, BUTTON_WIDTH, BUTTON_HEIGHT);
856 viewGroup->Add(view_);
857 int16_t centerX = (DEFAULE_WIDTH- BUTTON_WIDTH) / 2; // 2: center of x;
858 int16_t centerY = (DEFAULE_HEIGHT- BUTTON_HEIGHT) / 2; // 2: center of y;
859 EXPECT_EQ(view_->GetX(), POS_X);
860 EXPECT_EQ(view_->GetY(), POS_Y);
861 view_->LayoutCenterOfParent();
862 EXPECT_EQ(view_->GetX(), centerX);
863 EXPECT_EQ(view_->GetY(), centerY);
864 view_->LayoutLeftOfParent();
865 EXPECT_EQ(view_->GetX(), 0);
866 EXPECT_EQ(view_->GetY(), centerY);
867 view_->LayoutRightOfParent();
868 EXPECT_EQ(view_->GetX(), DEFAULE_WIDTH- BUTTON_WIDTH);
869 EXPECT_EQ(view_->GetY(), centerY);
870 view_->LayoutTopOfParent();
871 EXPECT_EQ(view_->GetX(), DEFAULE_WIDTH- BUTTON_WIDTH);
872 EXPECT_EQ(view_->GetY(), 0);
873 view_->LayoutBottomOfParent();
874 EXPECT_EQ(view_->GetX(), DEFAULE_WIDTH- BUTTON_WIDTH);
875 EXPECT_EQ(view_->GetY(), DEFAULE_HEIGHT- BUTTON_HEIGHT);
876
877 delete viewGroup;
878 }
879
880 /**
881 * @tc.name: UIViewAlignToSibling_001
882 * @tc.desc: Verify AlignToSibling function, equal.
883 * @tc.type: FUNC
884 * @tc.require: AR000EEMQF
885 */
886 HWTEST_F(UIViewTest, UIViewAlignToSibling_001, TestSize.Level0)
887 {
888 if (view_ == nullptr) {
889 EXPECT_NE(0, 0);
890 return;
891 }
892 UIViewGroup* viewGroup = new UIViewGroup();
893 viewGroup->SetPosition(0, 0, DEFAULE_WIDTH, DEFAULE_HEIGHT);
894 view_->SetPosition(POS_X, POS_Y, BUTTON_WIDTH, BUTTON_HEIGHT);
895 viewGroup->Add(view_);
896 int16_t centerX = (DEFAULE_WIDTH- BUTTON_WIDTH) / 2; // 2: center of x;
897 int16_t centerY = (DEFAULE_HEIGHT- BUTTON_HEIGHT) / 2; // 2: center of y;
898 UIView* view2 = new UIView();
899 view2->SetPosition(centerX, centerY, BUTTON_WIDTH, BUTTON_HEIGHT);
900 view2->SetViewId("refView");
901 viewGroup->Add(view2);
902 EXPECT_EQ(view_->GetX(), POS_X);
903 EXPECT_EQ(view_->GetY(), POS_Y);
904 view_->AlignLeftToSibling("refView");
905 EXPECT_EQ(view_->GetX(), centerX);
906 EXPECT_EQ(view_->GetY(), POS_Y);
907 view_->AlignRightToSibling("refView");
908 EXPECT_EQ(view_->GetX(), centerX);
909 EXPECT_EQ(view_->GetY(), POS_Y);
910 view_->AlignTopToSibling("refView");
911 EXPECT_EQ(view_->GetX(), centerX);
912 EXPECT_EQ(view_->GetY(), centerY);
913 view_->AlignBottomToSibling("refView");
914 EXPECT_EQ(view_->GetX(), centerX);
915 EXPECT_EQ(view_->GetY(), centerY);
916 view_->AlignHorCenterToSibling("refView");
917 EXPECT_EQ(view_->GetX(), centerX);
918 EXPECT_EQ(view_->GetY(), centerY);
919 view_->AlignVerCenterToSibling("refView");
920 EXPECT_EQ(view_->GetX(), centerX);
921 EXPECT_EQ(view_->GetY(), centerY);
922
923 delete view2;
924 delete viewGroup;
925 }
926
927 /**
928 * @tc.name: UIViewLayoutToSibling_001
929 * @tc.desc: Verify LayoutToSibling function, equal.
930 * @tc.type: FUNC
931 * @tc.require: AR000EEMQF
932 */
933 HWTEST_F(UIViewTest, UIViewLayoutToSibling_001, TestSize.Level0)
934 {
935 if (view_ == nullptr) {
936 EXPECT_NE(0, 0);
937 return;
938 }
939 UIViewGroup* viewGroup = new UIViewGroup();
940 viewGroup->SetPosition(0, 0, DEFAULE_WIDTH, DEFAULE_HEIGHT);
941 view_->SetPosition(POS_X, POS_Y, BUTTON_WIDTH, BUTTON_HEIGHT);
942 viewGroup->Add(view_);
943 int16_t centerX = (DEFAULE_WIDTH- BUTTON_WIDTH) / 2; // 2: center of x;
944 int16_t centerY = (DEFAULE_HEIGHT- BUTTON_HEIGHT) / 2; // 2: center of y;
945 UIView* view2 = new UIView();
946 view2->SetPosition(centerX, centerY, BUTTON_WIDTH, BUTTON_HEIGHT);
947 view2->SetViewId("refView");
948 viewGroup->Add(view2);
949 EXPECT_EQ(view_->GetX(), POS_X);
950 EXPECT_EQ(view_->GetY(), POS_Y);
951 view_->LayoutLeftToSibling("refView");
952 EXPECT_EQ(view_->GetX(), BUTTON_WIDTH);
953 EXPECT_EQ(view_->GetY(), POS_Y);
954 view_->LayoutRightToSibling("refView");
955 EXPECT_EQ(view_->GetX(), centerX + BUTTON_WIDTH);
956 EXPECT_EQ(view_->GetY(), POS_Y);
957 view_->LayoutTopToSibling("refView");
958 EXPECT_EQ(view_->GetX(), centerX + BUTTON_WIDTH);
959 EXPECT_EQ(view_->GetY(), BUTTON_HEIGHT);
960 view_->LayoutBottomToSibling("refView");
961 EXPECT_EQ(view_->GetX(), centerX + BUTTON_WIDTH);
962 EXPECT_EQ(view_->GetY(), centerY + BUTTON_HEIGHT);
963
964 delete view2;
965 delete viewGroup;
966 }
967
968 /**
969 * @tc.name: Graphic_UIView_Test_Rotate_001
970 * @tc.desc: Verify Rotate function, equal.
971 * @tc.type: FUNC
972 * @tc.require: SR000F3PEC
973 */
974 HWTEST_F(UIViewTest, Graphic_UIView_Test_Rotate_001, TestSize.Level1)
975 {
976 if (view_ == nullptr) {
977 EXPECT_NE(0, 0);
978 return;
979 }
980 view_->SetPosition(0, 0, DEFAULE_WIDTH, DEFAULE_HEIGHT);
981 view_->Rotate(DEFAULE_ANGLE, {0, 0});
982 TransformMap& trans = view_->GetTransformMap();
983 EXPECT_EQ(view_->GetOrigRect(), trans.GetTransMapRect());
984 }
985
986 /**
987 * @tc.name: Graphic_UIView_Test_Rotate_002
988 * @tc.desc: Verify Rotate function, equal.
989 * @tc.type: FUNC
990 * @tc.require: AR000F4E5E
991 */
992 HWTEST_F(UIViewTest, Graphic_UIView_Test_Rotate_002, TestSize.Level1)
993 {
994 if (view_ == nullptr) {
995 EXPECT_NE(0, 0);
996 return;
997 }
998 view_->SetPosition(0, 0, DEFAULE_WIDTH, DEFAULE_HEIGHT);
999 view_->Rotate(DEFAULE_ANGLE, {0, 0});
1000 Polygon polygon = view_->GetTransformMap().GetPolygon();
1001
1002 EXPECT_EQ(POLYGON1, polygon[0]); // 0: polygon num
1003 EXPECT_EQ(POLYGON2, polygon[1]); // 1: polygon num
1004 EXPECT_EQ(POLYGON3, polygon[2]); // 2: polygon num
1005 EXPECT_EQ(POLYGON4, polygon[3]); // 3: polygon num
1006 }
1007
1008 /**
1009 * @tc.name: Graphic_UIView_Test_Scale_001
1010 * @tc.desc: Verify Scale function, equal.
1011 * @tc.type: FUNC
1012 * @tc.require: SR000ERCQH
1013 */
1014 HWTEST_F(UIViewTest, Graphic_UIView_Test_Scale_001, TestSize.Level0)
1015 {
1016 if (view_ == nullptr) {
1017 EXPECT_NE(0, 0);
1018 return;
1019 }
1020 view_->SetPosition(0, 0, DEFAULE_WIDTH, DEFAULE_HEIGHT);
1021 view_->Scale(SCALE_VALUE, VIEW_CENTER);
1022 TransformMap& trans = view_->GetTransformMap();
1023 EXPECT_EQ(view_->GetOrigRect(), trans.GetTransMapRect());
1024 }
1025
1026 /**
1027 * @tc.name: Graphic_UIView_Test_Scale_002
1028 * @tc.desc: Verify Scale function, equal.
1029 * @tc.type: FUNC
1030 * @tc.require: AR000EVI2T
1031 */
1032 HWTEST_F(UIViewTest, Graphic_UIView_Test_Scale_002, TestSize.Level1)
1033 {
1034 if (view_ == nullptr) {
1035 EXPECT_NE(0, 0);
1036 return;
1037 }
1038 view_->SetPosition(0, 0, DEFAULE_WIDTH, DEFAULE_HEIGHT);
1039 view_->Scale(SCALE_VALUE, {0, 0});
1040 Polygon polygon = view_->GetTransformMap().GetPolygon();
1041 EXPECT_EQ(0, polygon[0].x_);
1042 EXPECT_EQ(0, polygon[0].y_);
1043 EXPECT_EQ(DEFAULE_WIDTH >> 1, polygon[2].x_); // 2: polygon num
1044 EXPECT_EQ(DEFAULE_HEIGHT >> 1, polygon[2].y_); // 2: polygon num
1045 }
1046
1047 /**
1048 * @tc.name: Graphic_UIView_Test_Margin_001
1049 * @tc.desc: Test whether the Rect is normal in the margin scenario.
1050 * @tc.type: FUNC
1051 * @tc.require: AR000FQNFP
1052 */
1053 HWTEST_F(UIViewTest, Graphic_UIView_Test_Margin_001, TestSize.Level0)
1054 {
1055 if (view_ == nullptr) {
1056 EXPECT_NE(0, 0);
1057 return;
1058 }
1059 view_->SetStyle(STYLE_MARGIN_LEFT, MARGIN_LEFT);
1060 view_->SetStyle(STYLE_MARGIN_TOP, MARGIN_TOP);
1061 view_->SetPosition(0, 0, DEFAULE_WIDTH, DEFAULE_HEIGHT);
1062 EXPECT_EQ(DEFAULE_WIDTH, view_->GetWidth());
1063 EXPECT_EQ(DEFAULE_HEIGHT, view_->GetHeight());
1064 EXPECT_EQ(0, view_->GetX());
1065 EXPECT_EQ(0, view_->GetY());
1066 Rect rect = view_->GetRelativeRect();
1067 EXPECT_EQ(MARGIN_LEFT, rect.GetX());
1068 EXPECT_EQ(MARGIN_TOP, rect.GetY());
1069 }
1070
1071 /**
1072 * @tc.name: Graphic_UIView_Test_Padding_001
1073 * @tc.desc: Test whether the Rect is normal in the setting padding scene.
1074 * @tc.type: FUNC
1075 * @tc.require: AR000FQNFP
1076 */
1077 HWTEST_F(UIViewTest, Graphic_UIView_Test_Padding_001, TestSize.Level0)
1078 {
1079 if (view_ == nullptr) {
1080 EXPECT_NE(0, 0);
1081 return;
1082 }
1083 view_->SetStyle(STYLE_PADDING_LEFT, PADDING_LEFT);
1084 view_->SetStyle(STYLE_PADDING_TOP, PADDING_TOP);
1085 view_->SetStyle(STYLE_PADDING_RIGHT, PADDING_RIGHT);
1086 view_->SetStyle(STYLE_PADDING_BOTTOM, PADDING_BOTTOM);
1087 view_->SetPosition(0, 0, DEFAULE_WIDTH, DEFAULE_HEIGHT);
1088 Rect rect = view_->GetContentRect();
1089 EXPECT_EQ(PADDING_LEFT, rect.GetX());
1090 EXPECT_EQ(PADDING_TOP, rect.GetY());
1091 EXPECT_EQ(PADDING_LEFT + DEFAULE_WIDTH - 1, rect.GetRight());
1092 EXPECT_EQ(PADDING_TOP + DEFAULE_HEIGHT - 1, rect.GetBottom());
1093 rect = view_->GetRelativeRect();
1094 EXPECT_EQ(0, rect.GetX());
1095 EXPECT_EQ(0, rect.GetY());
1096 EXPECT_EQ(PADDING_LEFT + PADDING_RIGHT + DEFAULE_WIDTH - 1, rect.GetRight());
1097 EXPECT_EQ(PADDING_TOP + PADDING_BOTTOM + DEFAULE_HEIGHT - 1, rect.GetBottom());
1098 }
1099
1100 /**
1101 * @tc.name: Graphic_UIView_Test_Border_001
1102 * @tc.desc: Test whether the Rect is normal in the setting of the border scene.
1103 * @tc.type: FUNC
1104 * @tc.require: AR000FQNFP
1105 */
1106 HWTEST_F(UIViewTest, Graphic_UIView_Test_Border_001, TestSize.Level0)
1107 {
1108 if (view_ == nullptr) {
1109 EXPECT_NE(0, 0);
1110 return;
1111 }
1112 view_->SetStyle(STYLE_BORDER_WIDTH, BORDER_WIDTH);
1113 view_->SetPosition(0, 0, DEFAULE_WIDTH, DEFAULE_HEIGHT);
1114 Rect rect = view_->GetContentRect();
1115 EXPECT_EQ(BORDER_WIDTH, rect.GetX());
1116 EXPECT_EQ(BORDER_WIDTH, rect.GetY());
1117 EXPECT_EQ(BORDER_WIDTH + DEFAULE_WIDTH - 1, rect.GetRight());
1118 EXPECT_EQ(BORDER_WIDTH + DEFAULE_HEIGHT - 1, rect.GetBottom());
1119 rect = view_->GetRelativeRect();
1120 EXPECT_EQ(0, rect.GetX());
1121 EXPECT_EQ(0, rect.GetY());
1122 EXPECT_EQ(BORDER_WIDTH + BORDER_WIDTH + DEFAULE_WIDTH - 1, rect.GetRight());
1123 EXPECT_EQ(BORDER_WIDTH + BORDER_WIDTH + DEFAULE_HEIGHT - 1, rect.GetBottom());
1124 }
1125
1126 /**
1127 * @tc.name: Graphic_UIView_Test_SetZIndex_001
1128 * @tc.desc: Check zIndex equal
1129 * @tc.type: FUNC
1130 * @tc.require:issueI5AD8G
1131 */
1132 HWTEST_F(UIViewTest, Graphic_UIView_Test_SetZIndex_001, TestSize.Level0)
1133 {
1134 UIView* view = new UIView();
1135
1136 // check 0
1137 int16_t zIndex = 0;
1138 view->SetZIndex(zIndex);
1139 EXPECT_EQ(zIndex, view->GetZIndex());
1140
1141 // check negative
1142 zIndex = 20;
1143 view->SetZIndex(zIndex);
1144 EXPECT_EQ(zIndex, view->GetZIndex());
1145
1146 // check big num
1147 zIndex = 66666;
1148 view->SetZIndex(zIndex);
1149 EXPECT_EQ(zIndex, view->GetZIndex());
1150
1151 // check negative
1152 zIndex = -1;
1153 view->SetZIndex(zIndex);
1154 EXPECT_EQ(zIndex, view->GetZIndex());
1155
1156 zIndex = -66666;
1157 view->SetZIndex(zIndex);
1158 EXPECT_EQ(zIndex, view->GetZIndex());
1159
1160 // check set multi times
1161 zIndex = 20;
1162 view->SetZIndex(zIndex);
1163 view->SetZIndex(zIndex * 2);
1164 EXPECT_EQ(zIndex * 2, view->GetZIndex());
1165 }
1166
1167 /**
1168 * @tc.name: Graphic_UIView_Test_GetZIndex_001
1169 * @tc.desc: Check the default zIndex
1170 * @tc.type: FUNC
1171 * @tc.require:issueI5AD8G
1172 */
1173 HWTEST_F(UIViewTest, Graphic_UIView_Test_GetZIndex_001, TestSize.Level0)
1174 {
1175 UIView* view = new UIView();
1176 // check default zIndex value
1177 EXPECT_EQ(0, view->GetZIndex());
1178
1179 UIViewGroup* viewGroup = new UIViewGroup();
1180 // check default zIndex value
1181 EXPECT_EQ(0, viewGroup->GetZIndex());
1182 delete view;
1183 delete viewGroup;
1184 }
1185
1186 /**
1187 * @tc.name: Graphic_UIView_Test_GetNextRenderSibling_001
1188 * @tc.desc: Check the default zIndex
1189 * @tc.type: FUNC
1190 * @tc.require:issueI5AD8G
1191 */
1192 HWTEST_F(UIViewTest, Graphic_UIView_Test_GetNextRenderSibling_001, TestSize.Level0)
1193 {
1194 UIView* view = new UIView();
1195 UIView* sibling = view->GetNextRenderSibling();
1196 EXPECT_EQ(sibling, nullptr);
1197
1198 UIViewGroup* viewGroup = new UIViewGroup();
1199 sibling = viewGroup->GetNextRenderSibling();
1200 EXPECT_EQ(sibling, nullptr);
1201 delete view;
1202 delete viewGroup;
1203 }
1204
1205 /**
1206 * @tc.name: Graphic_UIView_Test_SetNextRenderSibling_001
1207 * @tc.desc: Check the default zIndex
1208 * @tc.type: FUNC
1209 * @tc.require:issueI5AD8G
1210 */
1211 HWTEST_F(UIViewTest, Graphic_UIView_Test_SetNextRenderSibling_001, TestSize.Level0)
1212 {
1213 UIView* view = new UIView();
1214 UIView* tempView = new UIView();
1215 view->SetNextRenderSibling(tempView);
1216 EXPECT_EQ(view->GetNextRenderSibling(), tempView);
1217
1218 UIViewGroup* viewGroup = new UIViewGroup();
1219 viewGroup->SetNextRenderSibling(tempView);
1220 EXPECT_EQ(viewGroup->GetNextRenderSibling(), tempView);
1221
1222 delete tempView;
1223 delete view;
1224 delete viewGroup;
1225 }
1226 } // namespace OHOS