1 /*
2  * Copyright (c) 2022-2024 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 #include "include/render/rs_border.h"
18 
19 #include "property/rs_properties.h"
20 #include "property/rs_properties_painter.h"
21 
22 using namespace testing;
23 using namespace testing::ext;
24 
25 namespace OHOS::Rosen {
26 class RSBorderTest : 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 RSBorderTest::SetUpTestCase() {}
TearDownTestCase()35 void RSBorderTest::TearDownTestCase() {}
SetUp()36 void RSBorderTest::SetUp() {}
TearDown()37 void RSBorderTest::TearDown() {}
38 
39 /**
40  * @tc.name: LifeCycle001
41  * @tc.desc:
42  * @tc.type:FUNC
43  */
44 HWTEST_F(RSBorderTest, LifeCycle001, TestSize.Level1)
45 {
46     /**
47      * @tc.steps: step1. create RSMask by Gradient
48      */
49     RSColor color(1, 1, 1);
50     std::shared_ptr<RSBorder> border = std::make_shared<RSBorder>();
51     ASSERT_TRUE(border->GetColor(0) == RgbPalette::Transparent());
52     ASSERT_TRUE(border->GetStyle(0) == BorderStyle::NONE);
53     border->SetColor(color);
54     border->GetColor(0);
55     RSColor color2(1, 1, 1);
56     border->SetColor(color2);
57     border->GetColor(1);
58     border->SetWidth(1.f);
59     border->SetWidth(2.f);
60     ASSERT_TRUE(border->GetWidth(1) == 2.f);
61     border->SetStyle(BorderStyle::DOTTED);
62     border->SetStyle(BorderStyle::DOTTED);
63     ASSERT_TRUE(border->GetStyle(1) == BorderStyle::DOTTED);
64 }
65 
66 /**
67  * @tc.name: LifeCycle002
68  * @tc.desc:
69  * @tc.type:FUNC
70  */
71 HWTEST_F(RSBorderTest, LifeCycle002, TestSize.Level1)
72 {
73     /**
74      * @tc.steps: step1. create RSMask by Gradient
75      */
76     Color color1(1, 1, 1);
77     Color color2(2, 2, 2);
78     Color color3(3, 3, 3);
79     Color color4(4, 4, 4);
80     Vector4<Color> vectorColor(color1, color2, color3, color4);
81     std::shared_ptr<RSBorder> border = std::make_shared<RSBorder>();
82     ASSERT_NE(border, nullptr);
83     border->GetColorFour();
84     border->SetColorFour(vectorColor);
85     border->GetColorFour();
86     Vector4f width(1, 1, 1, 1);
87     border->SetWidthFour(width);
88     Vector4f width2(1, 2, 3, 4);
89     border->SetWidthFour(width2);
90     border->GetWidthFour();
91     Vector4<uint32_t> vectorStyle(1, 2, 3, 4);
92     border->GetStyleFour();
93     border->SetStyleFour(vectorStyle);
94     border->GetStyleFour();
95     border->SetStyle(BorderStyle::DOTTED);
96     border->ToString();
97 }
98 
99 /**
100  * @tc.name: LifeCycle003
101  * @tc.desc:
102  * @tc.type:FUNC
103  */
104 HWTEST_F(RSBorderTest, LifeCycle003, TestSize.Level1)
105 {
106     /**
107      * @tc.steps: step1. create RSMask by Gradient
108      */
109     Color color1(1, 1, 1);
110     Color color2(1, 1, 1);
111     Color color3(1, 1, 1);
112     Color color4(1, 1, 1);
113     Vector4<Color> vectorColor(color1, color2, color3, color4);
114     RSProperties properties;
115     Drawing::Pen pen;
116     pen.SetAntiAlias(true);
117     properties.SetBorderColor(vectorColor);
118     Vector4<uint32_t> style(0, 0, 0, 0);
119     properties.SetBorderStyle(style);
120     Vector4f cornerRadius(0.f, 0.f, 0.f, 0.f);
121     properties.SetCornerRadius(cornerRadius);
122     Vector4f width(1.f, 1.f, 1.f, 1.f);
123     properties.SetBorderWidth(width);
124     properties.SetBorderDashWidth(width);
125     properties.SetBorderDashGap(width);
126     properties.SetOutlineDashWidth(width);
127     properties.SetOutlineDashGap(width);
128     ASSERT_TRUE(properties.GetCornerRadius().IsZero());
129     Drawing::Canvas canvas;
130     RSPropertiesPainter::DrawBorder(properties, canvas);
131     Vector4f cornerRadius2(1.f, 2.f, 0.f, 0.f);
132     properties.SetCornerRadius(cornerRadius2);
133     RSPropertiesPainter::DrawBorder(properties, canvas);
134     Vector4<uint32_t> style2(1, 1, 1, 1);
135     properties.SetBorderStyle(style2);
136     RSPropertiesPainter::DrawBorder(properties, canvas);
137     Color color5(2, 1, 1);
138     Vector4<Color> Color(color1, color2, color3, color5);
139     properties.SetBorderColor(Color);
140     RSPropertiesPainter::DrawBorder(properties, canvas);
141 }
142 
143 /**
144  * @tc.name: HasBorderTest
145  * @tc.desc:
146  * @tc.type:FUNC
147  */
148 HWTEST_F(RSBorderTest, HasBorderTest, TestSize.Level1)
149 {
150     Color blackColor(0, 0, 0);
151     std::shared_ptr<RSBorder> border = std::make_shared<RSBorder>();
152     border->SetColor(blackColor);
153     border->GetColor(1);
154     border->SetStyle(BorderStyle::DOTTED);
155     border->SetWidth(2.f);
156     bool hasBorder = border->HasBorder();
157     ASSERT_TRUE(hasBorder);
158 }
159 
160 /**
161  * @tc.name: SetColorTest
162  * @tc.desc: Verify function SetColor
163  * @tc.type:FUNC
164  * @tc.require: issueI9I98H
165  */
166 HWTEST_F(RSBorderTest, SetColorTest, TestSize.Level1)
167 {
168     auto border = std::make_shared<RSBorder>();
169     border->SetColor(Color(0, 0, 0));
170     EXPECT_EQ(border->GetColor(0), Color(0, 0, 0));
171 }
172 
173 /**
174  * @tc.name: SetWidthTest
175  * @tc.desc: Verify function SetWidth
176  * @tc.type:FUNC
177  * @tc.require: issueI9I98H
178  */
179 HWTEST_F(RSBorderTest, SetWidthTest, TestSize.Level1)
180 {
181     auto border = std::make_shared<RSBorder>();
182     border->SetWidth(1.0f);
183     EXPECT_EQ(border->GetWidth(0), 1.0f);
184 }
185 
186 /**
187  * @tc.name: SetStyleTest
188  * @tc.desc: Verify function SetStyle
189  * @tc.type:FUNC
190  * @tc.require: issueI9I98H
191  */
192 HWTEST_F(RSBorderTest, SetStyleTest, TestSize.Level1)
193 {
194     auto border = std::make_shared<RSBorder>();
195     border->SetStyle(BorderStyle::SOLID);
196     EXPECT_TRUE(border->GetStyle(0) == BorderStyle::SOLID);
197 }
198 
199 /**
200  * @tc.name: GetColorTest
201  * @tc.desc: Verify function GetColor
202  * @tc.type:FUNC
203  * @tc.require: issueI9I98H
204  */
205 HWTEST_F(RSBorderTest, GetColorTest, TestSize.Level1)
206 {
207     // for test
208     Color redColor(255, 0, 0);
209     Color blackColor(0, 0, 0);
210     Color whiteColor(255, 255, 255);
211     Color greenColor(0, 255, 0);
212     auto border = std::make_shared<RSBorder>();
213     RSColor val { 0, 0, 0, 0 };
214     EXPECT_TRUE(border->GetColor(0) == val);
215 
216     border->SetColor(redColor);
217     EXPECT_TRUE(border->GetColor(0) == redColor);
218 
219     Vector4<Color> vectorColor(redColor, blackColor, whiteColor, greenColor);
220     border->SetColorFour(vectorColor);
221     EXPECT_TRUE(border->GetColor(1) == blackColor);
222 }
223 
224 /**
225  * @tc.name: GetWidthTest
226  * @tc.desc: Verify function GetWidth
227  * @tc.type:FUNC
228  * @tc.require: issueI9I98H
229  */
230 HWTEST_F(RSBorderTest, GetWidthTest, TestSize.Level1)
231 {
232     auto border = std::make_shared<RSBorder>();
233     EXPECT_EQ(border->GetWidth(0), 0.f);
234 
235     border->SetWidth(1.f);
236     EXPECT_EQ(border->GetWidth(0), 1.f);
237     // for test
238     Vector4f widths(5.0f, 10.0f, 5.0f, 10.0f);
239     border->SetWidthFour(widths);
240     EXPECT_EQ(border->GetWidth(1), 10.0f);
241 }
242 
243 /**
244  * @tc.name: GetStyleTest
245  * @tc.desc: Verify function GetStyle
246  * @tc.type:FUNC
247  * @tc.require: issueI9I98H
248  */
249 HWTEST_F(RSBorderTest, GetStyleTest, TestSize.Level1)
250 {
251     auto border = std::make_shared<RSBorder>();
252     EXPECT_TRUE(border->GetStyle(0) == BorderStyle::NONE);
253 
254     border->SetStyle(BorderStyle::SOLID);
255     EXPECT_TRUE(border->GetStyle(0) == BorderStyle::SOLID);
256     // for test
257     Vector4<uint32_t> vectorStyle(0, 1, 2, 3);
258     border->SetStyleFour(vectorStyle);
259     EXPECT_TRUE(border->GetStyle(0) == BorderStyle::SOLID);
260 }
261 
262 /**
263  * @tc.name: SetColorFourTest
264  * @tc.desc: Verify function SetColorFour
265  * @tc.type:FUNC
266  * @tc.require: issueI9I98H
267  */
268 HWTEST_F(RSBorderTest, SetColorFourTest, TestSize.Level1)
269 {
270     auto border = std::make_shared<RSBorder>();
271     // for test
272     Color redColor(255, 0, 0);
273     Color blackColor(0, 0, 0);
274     Color whiteColor(255, 255, 255);
275     Color greenColor(0, 255, 0);
276     Vector4<Color> vectorColor1(redColor, blackColor, whiteColor, greenColor);
277     border->SetColorFour(vectorColor1);
278     EXPECT_TRUE(border->GetColorFour() == vectorColor1);
279     Vector4<Color> vectorColor2(redColor, redColor, redColor, redColor);
280     border->SetColorFour(vectorColor2);
281     EXPECT_TRUE(border->GetColor() == redColor);
282 }
283 
284 /**
285  * @tc.name: SetWidthFourTest
286  * @tc.desc: Verify function SetWidthFour
287  * @tc.type:FUNC
288  * @tc.require: issueI9I98H
289  */
290 HWTEST_F(RSBorderTest, SetWidthFourTest, TestSize.Level1)
291 {
292     auto border = std::make_shared<RSBorder>();
293     // for test
294     Vector4f initialBorderWidths(5.0f, 10.0f, 5.0f, 10.0f);
295     border->SetWidthFour(initialBorderWidths);
296     EXPECT_EQ(border->GetWidthFour(), initialBorderWidths);
297     // for test
298     Vector4f uniformBorderWidth(8.0f, 8.0f, 8.0f, 8.0f);
299     border->SetWidthFour(uniformBorderWidth);
300     EXPECT_EQ(border->GetWidthFour(), 8.0f);
301 }
302 
303 /**
304  * @tc.name: SetStyleFourTest
305  * @tc.desc: Verify function SetStyleFour
306  * @tc.type:FUNC
307  * @tc.require: issueI9I98H
308  */
309 HWTEST_F(RSBorderTest, SetStyleFourTest, TestSize.Level1)
310 {
311     auto border = std::make_shared<RSBorder>();
312     // for test
313     Vector4<uint32_t> vectorStyle(0, 1, 2, 3);
314     border->SetStyleFour(vectorStyle);
315     EXPECT_TRUE(border->GetStyleFour() == vectorStyle);
316 
317     Vector4<uint32_t> vectorStyle1(0, 0, 0, 0);
318     border->SetStyleFour(vectorStyle1);
319     EXPECT_TRUE(border->GetStyle() == BorderStyle::SOLID);
320 }
321 
322 /**
323  * @tc.name: SetRadiusFourTest
324  * @tc.desc: Verify function SetRadiusFour
325  * @tc.type:FUNC
326  * @tc.require: issueI9I98H
327  */
328 HWTEST_F(RSBorderTest, SetRadiusFourTest, TestSize.Level1)
329 {
330     // for test
331     Vector4f radius(5.0f, 10.0f, 5.0f, 10.0f);
332     auto border = std::make_shared<RSBorder>();
333     border->SetRadiusFour(radius);
334     EXPECT_TRUE(border->GetRadiusFour() == radius);
335 }
336 
337 /**
338  * @tc.name: GetColorFourTest
339  * @tc.desc: Verify function GetColorFour
340  * @tc.type:FUNC
341  * @tc.require: issueI9I98H
342  */
343 HWTEST_F(RSBorderTest, GetColorFourTest, TestSize.Level1)
344 {
345     auto border = std::make_shared<RSBorder>();
346     // for test
347     Color redColor(255, 0, 0);
348     Color blackColor(0, 0, 0);
349     Color whiteColor(255, 255, 255);
350     Color greenColor(0, 255, 0);
351     Vector4<Color> vectorColor1(redColor, blackColor, whiteColor, greenColor);
352     border->SetColorFour(vectorColor1);
353     EXPECT_TRUE(border->GetColorFour() == vectorColor1);
354 
355     Vector4<Color> vectorColor2(redColor, redColor, redColor, redColor);
356     border->SetColorFour(vectorColor2);
357     EXPECT_TRUE(border->GetColor() == redColor);
358 }
359 
360 /**
361  * @tc.name: GetWidthFourTest
362  * @tc.desc: Verify function GetWidthFour
363  * @tc.type:FUNC
364  * @tc.require: issueI9I98H
365  */
366 HWTEST_F(RSBorderTest, GetWidthFourTest, TestSize.Level1)
367 {
368     auto border = std::make_shared<RSBorder>();
369     // for test
370     Vector4f initialBorderWidths(5.0f, 10.0f, 5.0f, 10.0f);
371     border->SetWidthFour(initialBorderWidths);
372     EXPECT_EQ(border->GetWidthFour(), initialBorderWidths);
373     // for test
374     Vector4f uniformBorderWidth(8.0f, 8.0f, 8.0f, 8.0f);
375     border->SetWidthFour(uniformBorderWidth);
376     EXPECT_EQ(border->GetWidthFour(), 8.0f);
377 }
378 
379 /**
380  * @tc.name: GetStyleFourTest
381  * @tc.desc: Verify function GetStyleFour
382  * @tc.type:FUNC
383  * @tc.require: issueI9I98H
384  */
385 HWTEST_F(RSBorderTest, GetStyleFourTest, TestSize.Level1)
386 {
387     auto border = std::make_shared<RSBorder>();
388     // for test
389     Vector4<uint32_t> vectorStyle(0, 1, 2, 3);
390     border->SetStyleFour(vectorStyle);
391     EXPECT_TRUE(border->GetStyleFour() == vectorStyle);
392 
393     Vector4<uint32_t> vectorStyle1(0, 0, 0, 0);
394     border->SetStyleFour(vectorStyle1);
395     EXPECT_TRUE(border->GetStyleFour() == 0);
396 }
397 
398 /**
399  * @tc.name: GetRadiusFourTest
400  * @tc.desc: Verify function GetRadiusFour
401  * @tc.type:FUNC
402  * @tc.require: issueI9I98H
403  */
404 HWTEST_F(RSBorderTest, GetRadiusFourTest, TestSize.Level1)
405 {
406     auto border = std::make_shared<RSBorder>();
407     auto radius = border->GetRadiusFour();
408     EXPECT_TRUE(radius[0] == 0.0f);
409 }
410 
411 /**
412  * @tc.name: ApplyFillStyleTest
413  * @tc.desc: Verify function ApplyFillStyle
414  * @tc.type:FUNC
415  * @tc.require: issueI9I98H
416  */
417 HWTEST_F(RSBorderTest, ApplyFillStyleTest, TestSize.Level1)
418 {
419     auto border = std::make_shared<RSBorder>();
420     Drawing::Brush brush;
421     EXPECT_FALSE(border->ApplyFillStyle(brush));
422     border->SetColor(Color(0, 0, 0));
423     border->SetStyle(BorderStyle::NONE);
424     EXPECT_FALSE(border->ApplyFillStyle(brush));
425     // for test
426     Vector4<uint32_t> vectorStyle(0, 1, 2, 3);
427     border->SetStyleFour(vectorStyle);
428     EXPECT_FALSE(border->ApplyFillStyle(brush));
429     border->SetColor(Color(0, 0, 0));
430     border->SetStyle(BorderStyle::SOLID);
431     border->SetWidth(0.f);
432     EXPECT_FALSE(border->ApplyFillStyle(brush));
433     border->SetWidth(1.f);
434     EXPECT_TRUE(border->ApplyFillStyle(brush));
435 }
436 
437 /**
438  * @tc.name: ApplyPathStyleTest
439  * @tc.desc: Verify function ApplyPathStyle
440  * @tc.type:FUNC
441  * @tc.require: issueIA61E9
442  */
443 HWTEST_F(RSBorderTest, ApplyPathStyleTest, TestSize.Level1)
444 {
445     auto border = std::make_shared<RSBorder>();
446     Drawing::Pen pen;
447     EXPECT_FALSE(border->ApplyPathStyle(pen));
448     border->SetColor(Color(0, 0, 0));
449     EXPECT_FALSE(border->ApplyPathStyle(pen));
450     border->SetWidth(0.f);
451     EXPECT_FALSE(border->ApplyPathStyle(pen));
452     border->SetStyle(BorderStyle::SOLID);
453     EXPECT_FALSE(border->ApplyPathStyle(pen));
454     border->SetStyle(BorderStyle::DOTTED);
455     EXPECT_FALSE(border->ApplyPathStyle(pen));
456 }
457 
458 /**
459  * @tc.name: ApplyFourLineTest
460  * @tc.desc: Verify function ApplyFourLine
461  * @tc.type:FUNC
462  * @tc.require: issueI9I98H
463  */
464 HWTEST_F(RSBorderTest, ApplyFourLineTest, TestSize.Level1)
465 {
466     auto border = std::make_shared<RSBorder>();
467     Drawing::Pen pen;
468     EXPECT_FALSE(border->ApplyFourLine(pen));
469     border->SetColor(Color(0, 0, 0));
470     EXPECT_FALSE(border->ApplyFourLine(pen));
471     border->SetStyle(BorderStyle::SOLID);
472     EXPECT_TRUE(border->ApplyFourLine(pen));
473 }
474 
475 /**
476  * @tc.name: ApplyLineStyleTest
477  * @tc.desc: Verify function ApplyLineStyle
478  * @tc.type:FUNC
479  * @tc.require: issueI9I98H
480  */
481 HWTEST_F(RSBorderTest, ApplyLineStyleTest, TestSize.Level1)
482 {
483     auto border = std::make_shared<RSBorder>();
484     Drawing::Pen pen;
485     EXPECT_FALSE(border->ApplyLineStyle(pen, 0, 1.f));
486     border->SetWidth(1.f);
487     border->SetStyle(BorderStyle::DOTTED);
488     EXPECT_FALSE(border->ApplyLineStyle(pen, 0, 1.f));
489     border->SetStyle(BorderStyle::SOLID);
490     border->SetWidth(1.0f);
491     EXPECT_TRUE(border->ApplyLineStyle(pen, 0, 1.f));
492 }
493 
494 /**
495  * @tc.name: ApplySimpleBorderTest
496  * @tc.desc: Verify function ApplySimpleBorder
497  * @tc.type:FUNC
498  * @tc.require:
499  */
500 HWTEST_F(RSBorderTest, ApplySimpleBorderTest, TestSize.Level1)
501 {
502     auto border = std::make_shared<RSBorder>();
503     border->colors_.clear();
504     border->widths_.clear();
505     border->styles_.clear();
506     RRect rect;
507     EXPECT_FALSE(border->ApplySimpleBorder(rect));
508     {
509         Color color = { 0, 0, 0, 0 };
510         border->colors_.push_back(color);
511         EXPECT_FALSE(border->ApplySimpleBorder(rect));
512         border->widths_.push_back(1);
513         EXPECT_FALSE(border->ApplySimpleBorder(rect));
514         border->styles_.push_back(BorderStyle::SOLID);
515         EXPECT_TRUE(border->ApplySimpleBorder(rect));
516     }
517 
518     {
519         border->styles_.push_back(BorderStyle::DASHED);
520         EXPECT_FALSE(border->ApplySimpleBorder(rect));
521         Color color = { 0, 0, 0, 0 };
522         border->colors_.push_back(color);
523         EXPECT_FALSE(border->ApplySimpleBorder(rect));
524     }
525 
526     {
527         border->widths_.push_back(1);
528         EXPECT_FALSE(border->ApplySimpleBorder(rect));
529         border->styles_.push_back(BorderStyle::SOLID);
530         EXPECT_FALSE(border->ApplySimpleBorder(rect));
531     }
532 }
533 
534 /**
535  * @tc.name: PaintFourLineTest
536  * @tc.desc: Verify function PaintFourLine
537  * @tc.type:FUNC
538  * @tc.require: issueI9I98H
539  */
540 HWTEST_F(RSBorderTest, PaintFourLineTest, TestSize.Level1)
541 {
542     auto border = std::make_shared<RSBorder>();
543     Drawing::Canvas canvas;
544     Drawing::Pen pen;
545     RectF rect(1, 1, 1, 1);
546     Vector4<uint32_t> style = { 1, 1, 1, 1 };
547     border->SetStyleFour(style);
548     border->SetWidth(1);
549     border->PaintFourLine(canvas, pen, rect);
550     EXPECT_TRUE(border->colors_.empty());
551 }
552 
553 /**
554  * @tc.name: ToStringTest
555  * @tc.desc: Verify function ToString
556  * @tc.type:FUNC
557  * @tc.require: issueI9I98H
558  */
559 HWTEST_F(RSBorderTest, ToStringTest, TestSize.Level1)
560 {
561     auto border = std::make_shared<RSBorder>();
562     EXPECT_TRUE(border->ToString().empty());
563     border->SetColor(Color(1, 1, 1));
564     border->SetWidth(1.f);
565     border->SetStyle(BorderStyle::NONE);
566     EXPECT_FALSE(border->ToString().empty());
567 }
568 
569 /**
570  * @tc.name: GetIPTest
571  * @tc.desc: Verify function GetTRIP and GetTLIP and GetBLIP and GetBRIP
572  * @tc.type:FUNC
573  * @tc.require: issueI9TOXM
574  */
575 HWTEST_F(RSBorderTest, GetIPTest, TestSize.Level1)
576 {
577     auto border = std::make_shared<RSBorder>();
578     Drawing::RoundRect rrect;
579     Drawing::Point innerRectCenter;
580     innerRectCenter.SetX(1.f);
581     innerRectCenter.SetY(1.f);
582     rrect.rect_.SetRight(10.f);
583     rrect.rect_.SetBottom(10.f);
584     rrect.rect_.SetLeft(1.f);
585     rrect.rect_.SetTop(1.f);
586     EXPECT_EQ(border->GetTRIP(rrect, innerRectCenter).GetX(), 10);
587     EXPECT_EQ(border->GetTLIP(rrect, innerRectCenter).GetX(), 1);
588     EXPECT_EQ(border->GetBLIP(rrect, innerRectCenter).GetX(), 1);
589     EXPECT_EQ(border->GetBRIP(rrect, innerRectCenter).GetX(), 10);
590 }
591 
592 /**
593  * @tc.name: GetDashWidthTest
594  * @tc.desc: Verify function GetDashWidth
595  * @tc.type:FUNC
596  */
597 HWTEST_F(RSBorderTest, GetDashWidthTest, TestSize.Level1)
598 {
599     auto border = std::make_shared<RSBorder>(false);
600     border->SetDashWidth(0.1f);
601     border->dashWidth_.push_back(0.2f);
602     EXPECT_EQ(border->GetDashWidth(1), 0.2f);
603 }
604 
605 /**
606  * @tc.name: GetDashGapTest
607  * @tc.desc: Verify function GetDashGap
608  * @tc.type:FUNC
609  */
610 HWTEST_F(RSBorderTest, GetDashGapTest, TestSize.Level1)
611 {
612     auto border = std::make_shared<RSBorder>(false);
613     border->SetDashGap(0.1f);
614     border->dashGap_.push_back(0.2f);
615     EXPECT_EQ(border->GetDashGap(1), 0.2f);
616 }
617 
618 /**
619  * @tc.name: DrawBordersTest001
620  * @tc.desc:
621  * @tc.type:FUNC
622  */
623 HWTEST_F(RSBorderTest, DrawBordersTest001, TestSize.Level1)
624 {
625     auto border = std::make_shared<RSBorder>(false);
626     ASSERT_NE(border, nullptr);
627     // set test para
628     RectF rect(-65.0f, -97.5f, 821.0f, 747.5f);
629     Vector4f width(60.0f, 61.0f, 62.0f, 63.0f);
630     Vector4f radius(65.0f, 65.0f, 65.0f, 65.0f);
631     border->SetStyle(BorderStyle::DOTTED);
632     Color color1(255, 0, 0); // red
633     Color color2(0, 0, 0);   // black
634     Color color3(0, 0, 255); // blue
635     Color color4(0, 255, 0); // green
636 
637     // init border object
638     border->SetDashWidth(1.0f);
639     border->SetDashGap(1.0f);
640     border->SetWidthFour(width);
641     border->SetRadiusFour(radius);
642 
643     // init borderGeo
644     RSBorderGeo borderGeo;
645     borderGeo.rrect.rect_.SetLeft(rect.GetLeft());
646     borderGeo.rrect.rect_.SetTop(rect.GetTop());
647     borderGeo.rrect.rect_.SetRight(rect.GetRight());
648     borderGeo.rrect.rect_.SetBottom(rect.GetBottom());
649     borderGeo.innerRRect.rect_.SetLeft(rect.GetLeft() + width[RSBorder::LEFT]);
650     borderGeo.innerRRect.rect_.SetTop(rect.GetTop() + width[RSBorder::TOP]);
651     borderGeo.innerRRect.rect_.SetRight(rect.GetRight() + width[RSBorder::RIGHT]);
652     borderGeo.innerRRect.rect_.SetBottom(rect.GetBottom() + width[RSBorder::BOTTOM]);
653     borderGeo.center = { (borderGeo.innerRRect.rect_.GetLeft() + borderGeo.innerRRect.rect_.GetRight()) * 0.5,
654         (borderGeo.innerRRect.rect_.GetTop() + borderGeo.innerRRect.rect_.GetBottom()) * 0.5 };
655 
656     Drawing::Canvas canvas;
657     Drawing::Pen pen;
658     pen.SetAntiAlias(true);
659     Vector4<Color> vectorColor1(color1, color2, color3, color4);
660     border->SetColorFour(vectorColor1);
661     border->DrawBorders(canvas, pen, borderGeo);
662 
663     Vector4<Color> vectorColor2(color1, color1, color3, color4);
664     border->SetColorFour(vectorColor2);
665     border->DrawBorders(canvas, pen, borderGeo);
666 
667     Vector4<Color> vectorColor3(color1, color1, color1, color4);
668     border->SetColorFour(vectorColor3);
669     border->DrawBorders(canvas, pen, borderGeo);
670 
671     Vector4<Color> vectorColor4(color4, color2, color3, color4);
672     border->SetColorFour(vectorColor4);
673     border->DrawBorders(canvas, pen, borderGeo);
674 
675     Vector4<Color> vectorColor5(color1, color1, color1, color1);
676     border->SetColorFour(vectorColor5);
677     border->DrawBorders(canvas, pen, borderGeo);
678 }
679 
680 /**
681  * @tc.name: DrawBordersTest002
682  * @tc.desc: Verify function
683  * @tc.type:FUNC
684  * @tc.require: issueI9I98H
685  */
686 HWTEST_F(RSBorderTest, DrawBordersTest002, TestSize.Level1)
687 {
688     auto border = std::make_shared<RSBorder>(false);
689     ASSERT_NE(border, nullptr);
690     // set test para
691     RectF rect(-65.0f, -97.5f, 821.0f, 747.5f);
692     Vector4f width(60.0f, 61.0f, 62.0f, 63.0f);
693     Vector4f radius(65.0f, 65.0f, 65.0f, 65.0f);
694     border->SetStyle(BorderStyle::SOLID);
695     Color color1(255, 0, 0); // red
696     Color color2(0, 0, 0);   // black
697     Color color3(0, 0, 255); // blue
698     Color color4(0, 255, 0); // green
699 
700     // init border object
701     border->SetDashWidth(1.0f);
702     border->SetDashGap(1.0f);
703     border->SetWidthFour(width);
704     border->SetRadiusFour(radius);
705 
706     // init borderGeo
707     RSBorderGeo borderGeo;
708     borderGeo.rrect.rect_.SetLeft(rect.GetLeft());
709     borderGeo.rrect.rect_.SetTop(rect.GetTop());
710     borderGeo.rrect.rect_.SetRight(rect.GetRight());
711     borderGeo.rrect.rect_.SetBottom(rect.GetBottom());
712     borderGeo.innerRRect.rect_.SetLeft(rect.GetLeft() + width[RSBorder::LEFT]);
713     borderGeo.innerRRect.rect_.SetTop(rect.GetTop() + width[RSBorder::TOP]);
714     borderGeo.innerRRect.rect_.SetRight(rect.GetRight() + width[RSBorder::RIGHT]);
715     borderGeo.innerRRect.rect_.SetBottom(rect.GetBottom() + width[RSBorder::BOTTOM]);
716     borderGeo.center = { (borderGeo.innerRRect.rect_.GetLeft() + borderGeo.innerRRect.rect_.GetRight()) * 0.5,
717         (borderGeo.innerRRect.rect_.GetTop() + borderGeo.innerRRect.rect_.GetBottom()) * 0.5 };
718 
719     Drawing::Canvas canvas;
720     Drawing::Pen pen;
721     pen.SetAntiAlias(true);
722     Vector4<Color> vectorColor1(color1, color2, color3, color4);
723     border->SetColorFour(vectorColor1);
724     border->DrawBorders(canvas, pen, borderGeo);
725 
726     Vector4<Color> vectorColor2(color1, color1, color3, color4);
727     border->SetColorFour(vectorColor2);
728     border->DrawBorders(canvas, pen, borderGeo);
729 
730     Vector4<Color> vectorColor3(color1, color1, color1, color4);
731     border->SetColorFour(vectorColor3);
732     border->DrawBorders(canvas, pen, borderGeo);
733 
734     Vector4<Color> vectorColor4(color4, color2, color3, color4);
735     border->SetColorFour(vectorColor4);
736     border->DrawBorders(canvas, pen, borderGeo);
737 
738     Vector4<Color> vectorColor5(color1, color1, color1, color1);
739     border->SetColorFour(vectorColor5);
740     border->DrawBorders(canvas, pen, borderGeo);
741 }
742 
743 /**
744  * @tc.name: DrawBordersTest003
745  * @tc.desc: Verify function
746  * @tc.type:FUNC
747  * @tc.require: issueI9I98H
748  */
749 HWTEST_F(RSBorderTest, DrawBordersTest003, TestSize.Level1)
750 {
751     auto border = std::make_shared<RSBorder>(false);
752 
753     // set test para
754     RectF rect(-65.0f, -97.5f, 821.0f, 747.5f);
755     Vector4f width(60.0f, 61.0f, 62.0f, 63.0f);
756     Vector4f radius(65.0f, 65.0f, 65.0f, 65.0f);
757     border->SetStyle(BorderStyle::DASHED);
758     Color color1(255, 0, 0); // red
759     Color color2(0, 0, 0);   // black
760     Color color3(0, 0, 255); // blue
761     Color color4(0, 255, 0); // green
762 
763     // init border object
764     border->SetDashWidth(1.0f);
765     border->SetDashGap(1.0f);
766     border->SetWidthFour(width);
767     border->SetRadiusFour(radius);
768 
769     // init borderGeo
770     RSBorderGeo borderGeo;
771     borderGeo.rrect.rect_.SetLeft(rect.GetLeft());
772     borderGeo.rrect.rect_.SetTop(rect.GetTop());
773     borderGeo.rrect.rect_.SetRight(rect.GetRight());
774     borderGeo.rrect.rect_.SetBottom(rect.GetBottom());
775     borderGeo.innerRRect.rect_.SetLeft(rect.GetLeft() + width[RSBorder::LEFT]);
776     borderGeo.innerRRect.rect_.SetTop(rect.GetTop() + width[RSBorder::TOP]);
777     borderGeo.innerRRect.rect_.SetRight(rect.GetRight() + width[RSBorder::RIGHT]);
778     borderGeo.innerRRect.rect_.SetBottom(rect.GetBottom() + width[RSBorder::BOTTOM]);
779     borderGeo.center = { (borderGeo.innerRRect.rect_.GetLeft() + borderGeo.innerRRect.rect_.GetRight()) * 0.5,
780         (borderGeo.innerRRect.rect_.GetTop() + borderGeo.innerRRect.rect_.GetBottom()) * 0.5 };
781 
782     Drawing::Canvas canvas;
783     Drawing::Pen pen;
784     pen.SetAntiAlias(true);
785     Vector4<Color> vectorColor1(color1, color2, color3, color4);
786     border->SetColorFour(vectorColor1);
787     border->DrawBorders(canvas, pen, borderGeo);
788 
789     Vector4<Color> vectorColor2(color1, color1, color3, color4);
790     border->SetColorFour(vectorColor2);
791     border->DrawBorders(canvas, pen, borderGeo);
792 
793     Vector4<Color> vectorColor3(color1, color1, color1, color4);
794     border->SetColorFour(vectorColor3);
795     border->DrawBorders(canvas, pen, borderGeo);
796 
797     Vector4<Color> vectorColor4(color4, color2, color3, color4);
798     border->SetColorFour(vectorColor4);
799     border->DrawBorders(canvas, pen, borderGeo);
800 
801     Vector4<Color> vectorColor5(color1, color1, color1, color1);
802     border->SetColorFour(vectorColor5);
803     border->DrawBorders(canvas, pen, borderGeo);
804 
805     EXPECT_FALSE(border->styles_.empty());
806 }
807 
808 /**
809  * @tc.name: DrawBorderImplTest001
810  * @tc.desc: Verify function
811  * @tc.type:FUNC
812  * @tc.require: issueI9I98H
813  */
814 HWTEST_F(RSBorderTest, DrawBorderImplTest001, TestSize.Level1)
815 {
816     auto border = std::make_shared<RSBorder>(false);
817 
818     // set test para
819     RectF rect(-65.0f, -97.5f, 821.0f, 747.5f);
820     Vector4f width(60.0f, 61.0f, 62.0f, 63.0f);
821     Vector4f radius(65.0f, 65.0f, 65.0f, 65.0f);
822     border->SetStyle(BorderStyle::DASHED);
823     Color color1(255, 0, 0); // red
824     Color color2(0, 0, 0);   // black
825     Color color3(0, 0, 255); // blue
826     Color color4(0, 255, 0); // green
827 
828     // init border object
829     border->SetDashWidth(1.0f);
830     border->SetDashGap(1.0f);
831     border->SetWidthFour(width);
832     border->SetRadiusFour(radius);
833     Vector4<Color> vectorColor(color1, color2, color3, color4);
834     border->SetColorFour(vectorColor);
835 
836     // init borderGeo
837     RSBorderGeo borderGeo;
838     borderGeo.rrect.rect_.SetLeft(rect.GetLeft());
839     borderGeo.rrect.rect_.SetTop(rect.GetTop());
840     borderGeo.rrect.rect_.SetRight(rect.GetRight());
841     borderGeo.rrect.rect_.SetBottom(rect.GetBottom());
842     borderGeo.innerRRect.rect_.SetLeft(rect.GetLeft() + width[RSBorder::LEFT]);
843     borderGeo.innerRRect.rect_.SetTop(rect.GetTop() + width[RSBorder::TOP]);
844     borderGeo.innerRRect.rect_.SetRight(rect.GetRight() + width[RSBorder::RIGHT]);
845     borderGeo.innerRRect.rect_.SetBottom(rect.GetBottom() + width[RSBorder::BOTTOM]);
846     borderGeo.center = { (borderGeo.innerRRect.rect_.GetLeft() + borderGeo.innerRRect.rect_.GetRight()) * 0.5,
847         (borderGeo.innerRRect.rect_.GetTop() + borderGeo.innerRRect.rect_.GetBottom()) * 0.5 };
848 
849     Drawing::Canvas canvas;
850     Drawing::Pen pen;
851     pen.SetAntiAlias(true);
852 
853     border->CalcBorderPath(borderGeo);
854     border->DrawBorderImpl(canvas, pen, borderGeo, RSBorder::LEFT);
855     border->DrawBorderImpl(canvas, pen, borderGeo, RSBorder::TOP);
856     border->DrawBorderImpl(canvas, pen, borderGeo, RSBorder::RIGHT);
857     border->DrawBorderImpl(canvas, pen, borderGeo, RSBorder::BOTTOM);
858     EXPECT_FALSE(border->styles_.empty());
859 }
860 
861 /**
862  * @tc.name: DrawBorderImplTest002
863  * @tc.desc: Verify function
864  * @tc.type:FUNC
865  * @tc.require: issueI9I98H
866  */
867 HWTEST_F(RSBorderTest, DrawBorderImplTest002, TestSize.Level1)
868 {
869     auto border = std::make_shared<RSBorder>(false);
870 
871     // set test para
872     RectF rect(-65.0f, -97.5f, 821.0f, 747.5f);
873     Vector4f width(60.0f, 61.0f, 62.0f, 63.0f);
874     Vector4f radius(65.0f, 65.0f, 65.0f, 65.0f);
875     border->SetStyle(BorderStyle::SOLID);
876     Color color1(255, 0, 0); // red
877     Color color2(0, 0, 0);   // black
878     Color color3(0, 0, 255); // blue
879     Color color4(0, 255, 0); // green
880 
881     // init border object
882     border->SetDashWidth(1.0f);
883     border->SetDashGap(1.0f);
884     border->SetWidthFour(width);
885     border->SetRadiusFour(radius);
886 
887     // init borderGeo
888     RSBorderGeo borderGeo;
889     borderGeo.rrect.rect_.SetLeft(rect.GetLeft());
890     borderGeo.rrect.rect_.SetTop(rect.GetTop());
891     borderGeo.rrect.rect_.SetRight(rect.GetRight());
892     borderGeo.rrect.rect_.SetBottom(rect.GetBottom());
893     borderGeo.innerRRect.rect_.SetLeft(rect.GetLeft() + width[RSBorder::LEFT]);
894     borderGeo.innerRRect.rect_.SetTop(rect.GetTop() + width[RSBorder::TOP]);
895     borderGeo.innerRRect.rect_.SetRight(rect.GetRight() + width[RSBorder::RIGHT]);
896     borderGeo.innerRRect.rect_.SetBottom(rect.GetBottom() + width[RSBorder::BOTTOM]);
897     borderGeo.center = { (borderGeo.innerRRect.rect_.GetLeft() + borderGeo.innerRRect.rect_.GetRight()) * 0.5,
898         (borderGeo.innerRRect.rect_.GetTop() + borderGeo.innerRRect.rect_.GetBottom()) * 0.5 };
899 
900     Drawing::Canvas canvas;
901     Drawing::Pen pen;
902     pen.SetAntiAlias(true);
903 
904     border->CalcBorderPath(borderGeo);
905 
906     Vector4<Color> vectorColor1(color1, color1, color3, color3);
907     border->SetColorFour(vectorColor1);
908     border->DrawBorderImpl(canvas, pen, borderGeo, RSBorder::LEFT, RSBorder::TOP);
909     border->DrawBorderImpl(canvas, pen, borderGeo, RSBorder::RIGHT, RSBorder::BOTTOM);
910 
911     Vector4<Color> vectorColor2(color4, color2, color2, color4);
912     border->SetColorFour(vectorColor2);
913     border->DrawBorderImpl(canvas, pen, borderGeo, RSBorder::TOP, RSBorder::RIGHT);
914     border->DrawBorderImpl(canvas, pen, borderGeo, RSBorder::BOTTOM, RSBorder::LEFT);
915     EXPECT_FALSE(border->styles_.empty());
916 }
917 
918 /**
919  * @tc.name: DrawBorderImplTest003
920  * @tc.desc: Verify function
921  * @tc.type:FUNC
922  * @tc.require: issueI9I98H
923  */
924 HWTEST_F(RSBorderTest, DrawBorderImplTest003, TestSize.Level1)
925 {
926     auto border = std::make_shared<RSBorder>(false);
927 
928     // set test para
929     RectF rect(-65.0f, -97.5f, 821.0f, 747.5f);
930     Vector4f width(60.0f, 61.0f, 62.0f, 63.0f);
931     Vector4f radius(65.0f, 65.0f, 65.0f, 65.0f);
932     border->SetStyle(BorderStyle::SOLID);
933     Color color1(255, 0, 0); // red
934     Color color2(0, 0, 0);   // black
935     Color color3(0, 0, 255); // blue
936     Color color4(0, 255, 0); // green
937 
938     // init border object
939     border->SetDashWidth(1.0f);
940     border->SetDashGap(1.0f);
941     border->SetWidthFour(width);
942     border->SetRadiusFour(radius);
943 
944     // init borderGeo
945     RSBorderGeo borderGeo;
946     borderGeo.rrect.rect_.SetLeft(rect.GetLeft());
947     borderGeo.rrect.rect_.SetTop(rect.GetTop());
948     borderGeo.rrect.rect_.SetRight(rect.GetRight());
949     borderGeo.rrect.rect_.SetBottom(rect.GetBottom());
950     borderGeo.innerRRect.rect_.SetLeft(rect.GetLeft() + width[RSBorder::LEFT]);
951     borderGeo.innerRRect.rect_.SetTop(rect.GetTop() + width[RSBorder::TOP]);
952     borderGeo.innerRRect.rect_.SetRight(rect.GetRight() + width[RSBorder::RIGHT]);
953     borderGeo.innerRRect.rect_.SetBottom(rect.GetBottom() + width[RSBorder::BOTTOM]);
954     borderGeo.center = { (borderGeo.innerRRect.rect_.GetLeft() + borderGeo.innerRRect.rect_.GetRight()) * 0.5,
955         (borderGeo.innerRRect.rect_.GetTop() + borderGeo.innerRRect.rect_.GetBottom()) * 0.5 };
956 
957     Drawing::Canvas canvas;
958     Drawing::Pen pen;
959     pen.SetAntiAlias(true);
960 
961     border->CalcBorderPath(borderGeo);
962     Vector4<Color> vectorColor1(color1, color1, color1, color3);
963     border->SetColorFour(vectorColor1);
964     border->DrawBorderImpl(canvas, pen, borderGeo, RSBorder::LEFT, RSBorder::TOP, RSBorder::RIGHT);
965 
966     Vector4<Color> vectorColor2(color1, color2, color2, color2);
967     border->SetColorFour(vectorColor2);
968     border->DrawBorderImpl(canvas, pen, borderGeo, RSBorder::TOP, RSBorder::RIGHT, RSBorder::BOTTOM);
969 
970     Vector4<Color> vectorColor3(color3, color2, color3, color3);
971     border->SetColorFour(vectorColor3);
972     border->DrawBorderImpl(canvas, pen, borderGeo, RSBorder::RIGHT, RSBorder::BOTTOM, RSBorder::LEFT);
973 
974     Vector4<Color> vectorColor4(color4, color4, color3, color4);
975     border->SetColorFour(vectorColor4);
976     border->DrawBorderImpl(canvas, pen, borderGeo, RSBorder::BOTTOM, RSBorder::LEFT, RSBorder::TOP);
977     EXPECT_FALSE(border->styles_.empty());
978 }
979 
980 /**
981  * @tc.name: CalcBorderPathTest
982  * @tc.desc: Verify function
983  * @tc.type:FUNC
984  * @tc.require: issueI9I98H
985  */
986 HWTEST_F(RSBorderTest, CalcBorderPathTest, TestSize.Level1)
987 {
988     auto border = std::make_shared<RSBorder>(false);
989 
990     // set test para
991     RectF rect(-65.0f, -97.5f, 821.0f, 747.5f);
992     Vector4f width(60.0f, 61.0f, 62.0f, 63.0f);
993     Vector4f radius(65.0f, 65.0f, 65.0f, 65.0f);
994     border->SetStyle(BorderStyle::SOLID);
995     Color color1(255, 0, 0); // red
996     Color color2(0, 0, 0);   // black
997     Color color3(0, 0, 255); // blue
998     Color color4(0, 255, 0); // green
999 
1000     // init border object
1001     border->SetDashWidth(1.0f);
1002     border->SetDashGap(1.0f);
1003     border->SetWidthFour(width);
1004     border->SetRadiusFour(radius);
1005     Vector4<Color> vectorColor(color1, color1, color1, color3);
1006     border->SetColorFour(vectorColor);
1007 
1008     // init borderGeo
1009     RSBorderGeo borderGeo;
1010     borderGeo.rrect.rect_.SetLeft(rect.GetLeft());
1011     borderGeo.rrect.rect_.SetTop(rect.GetTop());
1012     borderGeo.rrect.rect_.SetRight(rect.GetRight());
1013     borderGeo.rrect.rect_.SetBottom(rect.GetBottom());
1014     borderGeo.innerRRect.rect_.SetLeft(rect.GetLeft() + width[RSBorder::LEFT]);
1015     borderGeo.innerRRect.rect_.SetTop(rect.GetTop() + width[RSBorder::TOP]);
1016     borderGeo.innerRRect.rect_.SetRight(rect.GetRight() + width[RSBorder::RIGHT]);
1017     borderGeo.innerRRect.rect_.SetBottom(rect.GetBottom() + width[RSBorder::BOTTOM]);
1018     borderGeo.center = { (borderGeo.innerRRect.rect_.GetLeft() + borderGeo.innerRRect.rect_.GetRight()) * 0.5,
1019         (borderGeo.innerRRect.rect_.GetTop() + borderGeo.innerRRect.rect_.GetBottom()) * 0.5 };
1020 
1021     Drawing::Canvas canvas;
1022     Drawing::Pen pen;
1023     pen.SetAntiAlias(true);
1024 
1025     border->CalcBorderPath(borderGeo);
1026     EXPECT_FALSE(border->styles_.empty());
1027 }
1028 
1029 /**
1030  * @tc.name: DrawTopBorderTest
1031  * @tc.desc: Verify function PaintTopPath
1032  * @tc.type:FUNC
1033  * @tc.require: issueI9I98H
1034  */
1035 HWTEST_F(RSBorderTest, DrawTopBorderTest, TestSize.Level1)
1036 {
1037     auto border = std::make_shared<RSBorder>(false);
1038 
1039     // set test para
1040     RectF rect(-65.0f, -97.5f, 821.0f, 747.5f);
1041     Vector4f width(60.0f, 61.0f, 62.0f, 63.0f);
1042     Vector4f radius(65.0f, 65.0f, 65.0f, 65.0f);
1043     Color color1(255, 0, 0); // red
1044     Color color2(0, 0, 0);   // black
1045     Color color3(0, 0, 255); // blue
1046     Color color4(0, 255, 0); // green
1047     Vector4<Color> vectorColor(color1, color2, color3, color4);
1048 
1049     // init border object
1050     border->SetDashWidth(1.0f);
1051     border->SetDashGap(1.0f);
1052     border->SetWidthFour(width);
1053     border->SetRadiusFour(radius);
1054     border->SetColorFour(vectorColor);
1055 
1056     // init borderGeo
1057     RSBorderGeo borderGeo;
1058     borderGeo.rrect.rect_.SetLeft(rect.GetLeft());
1059     borderGeo.rrect.rect_.SetTop(rect.GetTop());
1060     borderGeo.rrect.rect_.SetRight(rect.GetRight());
1061     borderGeo.rrect.rect_.SetBottom(rect.GetBottom());
1062     borderGeo.innerRRect.rect_.SetLeft(rect.GetLeft() + width[RSBorder::LEFT]);
1063     borderGeo.innerRRect.rect_.SetTop(rect.GetTop() + width[RSBorder::TOP]);
1064     borderGeo.innerRRect.rect_.SetRight(rect.GetRight() + width[RSBorder::RIGHT]);
1065     borderGeo.innerRRect.rect_.SetBottom(rect.GetBottom() + width[RSBorder::BOTTOM]);
1066     borderGeo.center = { (borderGeo.innerRRect.rect_.GetLeft() + borderGeo.innerRRect.rect_.GetRight()) * 0.5,
1067         (borderGeo.innerRRect.rect_.GetTop() + borderGeo.innerRRect.rect_.GetBottom()) * 0.5 };
1068 
1069     Drawing::Canvas canvas;
1070     Drawing::Pen pen;
1071     pen.SetAntiAlias(true);
1072     border->SetStyle(BorderStyle::SOLID);
1073     border->DrawTopBorder(canvas, pen, borderGeo);
1074     border->SetStyle(BorderStyle::DASHED);
1075     border->DrawTopBorder(canvas, pen, borderGeo);
1076     EXPECT_FALSE(border->styles_.empty());
1077 }
1078 
1079 /**
1080  * @tc.name: DrawRightBorderTest
1081  * @tc.desc: Verify function PaintRightPath
1082  * @tc.type:FUNC
1083  * @tc.require: issueI9I98H
1084  */
1085 HWTEST_F(RSBorderTest, DrawRightBorderTest, TestSize.Level1)
1086 {
1087     auto border = std::make_shared<RSBorder>(false);
1088 
1089     // set test para
1090     RectF rect(-65.0f, -97.5f, 821.0f, 747.5f);
1091     Vector4f width(60.0f, 61.0f, 62.0f, 63.0f);
1092     Vector4f radius(65.0f, 65.0f, 65.0f, 65.0f);
1093     Color color1(255, 0, 0); // red
1094     Color color2(0, 0, 0);   // black
1095     Color color3(0, 0, 255); // blue
1096     Color color4(0, 255, 0); // green
1097     Vector4<Color> vectorColor(color1, color2, color3, color4);
1098 
1099     // init border object
1100     border->SetDashWidth(1.0f);
1101     border->SetDashGap(1.0f);
1102     border->SetWidthFour(width);
1103     border->SetRadiusFour(radius);
1104     border->SetColorFour(vectorColor);
1105 
1106     // init borderGeo
1107     RSBorderGeo borderGeo;
1108     borderGeo.rrect.rect_.SetLeft(rect.GetLeft());
1109     borderGeo.rrect.rect_.SetTop(rect.GetTop());
1110     borderGeo.rrect.rect_.SetRight(rect.GetRight());
1111     borderGeo.rrect.rect_.SetBottom(rect.GetBottom());
1112     borderGeo.innerRRect.rect_.SetLeft(rect.GetLeft() + width[RSBorder::LEFT]);
1113     borderGeo.innerRRect.rect_.SetTop(rect.GetTop() + width[RSBorder::TOP]);
1114     borderGeo.innerRRect.rect_.SetRight(rect.GetRight() + width[RSBorder::RIGHT]);
1115     borderGeo.innerRRect.rect_.SetBottom(rect.GetBottom() + width[RSBorder::BOTTOM]);
1116     borderGeo.center = { (borderGeo.innerRRect.rect_.GetLeft() + borderGeo.innerRRect.rect_.GetRight()) * 0.5,
1117         (borderGeo.innerRRect.rect_.GetTop() + borderGeo.innerRRect.rect_.GetBottom()) * 0.5 };
1118 
1119     Drawing::Canvas canvas;
1120     Drawing::Pen pen;
1121     pen.SetAntiAlias(true);
1122     border->SetStyle(BorderStyle::SOLID);
1123     border->DrawRightBorder(canvas, pen, borderGeo);
1124     border->SetStyle(BorderStyle::DOTTED);
1125     border->DrawRightBorder(canvas, pen, borderGeo);
1126     EXPECT_FALSE(border->styles_.empty());
1127 }
1128 
1129 /**
1130  * @tc.name: DrawBottomBorderTest
1131  * @tc.desc: Verify function PaintBottomPath
1132  * @tc.type:FUNC
1133  * @tc.require: issueI9I98H
1134  */
1135 HWTEST_F(RSBorderTest, DrawBottomBorderTest, TestSize.Level1)
1136 {
1137     auto border = std::make_shared<RSBorder>(false);
1138 
1139     // set test para
1140     RectF rect(-65.0f, -97.5f, 821.0f, 747.5f);
1141     Vector4f width(60.0f, 61.0f, 62.0f, 63.0f);
1142     Vector4f radius(65.0f, 65.0f, 65.0f, 65.0f);
1143     Color color1(255, 0, 0); // red
1144     Color color2(0, 0, 0);   // black
1145     Color color3(0, 0, 255); // blue
1146     Color color4(0, 255, 0); // green
1147     Vector4<Color> vectorColor(color1, color2, color3, color4);
1148 
1149     // init border object
1150     border->SetDashWidth(1.0f);
1151     border->SetDashGap(1.0f);
1152     border->SetWidthFour(width);
1153     border->SetRadiusFour(radius);
1154     border->SetColorFour(vectorColor);
1155 
1156     // init borderGeo
1157     RSBorderGeo borderGeo;
1158     borderGeo.rrect.rect_.SetLeft(rect.GetLeft());
1159     borderGeo.rrect.rect_.SetTop(rect.GetTop());
1160     borderGeo.rrect.rect_.SetRight(rect.GetRight());
1161     borderGeo.rrect.rect_.SetBottom(rect.GetBottom());
1162     borderGeo.innerRRect.rect_.SetLeft(rect.GetLeft() + width[RSBorder::LEFT]);
1163     borderGeo.innerRRect.rect_.SetTop(rect.GetTop() + width[RSBorder::TOP]);
1164     borderGeo.innerRRect.rect_.SetRight(rect.GetRight() + width[RSBorder::RIGHT]);
1165     borderGeo.innerRRect.rect_.SetBottom(rect.GetBottom() + width[RSBorder::BOTTOM]);
1166     borderGeo.center = { (borderGeo.innerRRect.rect_.GetLeft() + borderGeo.innerRRect.rect_.GetRight()) * 0.5,
1167         (borderGeo.innerRRect.rect_.GetTop() + borderGeo.innerRRect.rect_.GetBottom()) * 0.5 };
1168 
1169     Drawing::Canvas canvas;
1170     Drawing::Pen pen;
1171     pen.SetAntiAlias(true);
1172     border->SetStyle(BorderStyle::SOLID);
1173     border->DrawBottomBorder(canvas, pen, borderGeo);
1174     border->SetStyle(BorderStyle::DOTTED);
1175     border->DrawBottomBorder(canvas, pen, borderGeo);
1176     EXPECT_FALSE(border->styles_.empty());
1177 }
1178 
1179 /**
1180  * @tc.name: DrawLeftBorderTest
1181  * @tc.desc: Verify function PaintLeftPath
1182  * @tc.type:FUNC
1183  * @tc.require: issueI9I98H
1184  */
1185 HWTEST_F(RSBorderTest, DrawLeftBorderTest, TestSize.Level1)
1186 {
1187     auto border = std::make_shared<RSBorder>(false);
1188 
1189     // set test para
1190     RectF rect(-65.0f, -97.5f, 821.0f, 747.5f);
1191     Vector4f width(60.0f, 61.0f, 62.0f, 63.0f);
1192     Vector4f radius(65.0f, 65.0f, 65.0f, 65.0f);
1193     Color color1(255, 0, 0); // red
1194     Color color2(0, 0, 0);   // black
1195     Color color3(0, 0, 255); // blue
1196     Color color4(0, 255, 0); // green
1197     Vector4<Color> vectorColor(color1, color2, color3, color4);
1198 
1199     // init border object
1200     border->SetDashWidth(1.0f);
1201     border->SetDashGap(1.0f);
1202     border->SetWidthFour(width);
1203     border->SetRadiusFour(radius);
1204     border->SetColorFour(vectorColor);
1205 
1206     // init borderGeo
1207     RSBorderGeo borderGeo;
1208     borderGeo.rrect.rect_.SetLeft(rect.GetLeft());
1209     borderGeo.rrect.rect_.SetTop(rect.GetTop());
1210     borderGeo.rrect.rect_.SetRight(rect.GetRight());
1211     borderGeo.rrect.rect_.SetBottom(rect.GetBottom());
1212     borderGeo.innerRRect.rect_.SetLeft(rect.GetLeft() + width[RSBorder::LEFT]);
1213     borderGeo.innerRRect.rect_.SetTop(rect.GetTop() + width[RSBorder::TOP]);
1214     borderGeo.innerRRect.rect_.SetRight(rect.GetRight() + width[RSBorder::RIGHT]);
1215     borderGeo.innerRRect.rect_.SetBottom(rect.GetBottom() + width[RSBorder::BOTTOM]);
1216     borderGeo.center = { (borderGeo.innerRRect.rect_.GetLeft() + borderGeo.innerRRect.rect_.GetRight()) * 0.5,
1217         (borderGeo.innerRRect.rect_.GetTop() + borderGeo.innerRRect.rect_.GetBottom()) * 0.5 };
1218 
1219     Drawing::Canvas canvas;
1220     Drawing::Pen pen;
1221     pen.SetAntiAlias(true);
1222     border->SetStyle(BorderStyle::SOLID);
1223     border->DrawLeftBorder(canvas, pen, borderGeo);
1224     border->SetStyle(BorderStyle::DASHED);
1225     border->DrawLeftBorder(canvas, pen, borderGeo);
1226     EXPECT_FALSE(border->styles_.empty());
1227 }
1228 } // namespace OHOS::Rosen
1229