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 
18 #include "pipeline/rs_paint_filter_canvas.h"
19 
20 using namespace testing;
21 using namespace testing::ext;
22 
23 namespace OHOS {
24 namespace Rosen {
25 const float_t SET_ALPHA = 0.1f;
26 const float_t SET_XORY1 = 0.1f;
27 const float_t SET_XORY2 = 0.2f;
28 const float_t ANGLE_SWEEP_START = 1.0f;
29 const float_t SET_RADIUS = 1.0f;
30 const float_t SET_SCALAR = 1.0f;
31 const uint32_t NUMBER = 2;
32 const uint32_t SET_POINT_SIZE1 = 12;
33 const uint32_t SET_POINT_SIZE2 = 4;
34 const uint32_t SET_COLOR_QUAD_SIZE = 4;
35 const uint32_t SET_RIGHT = 10;
36 const uint32_t SET_TOP_BOTTOM = 80;
37 const uint32_t SCALAR_XORY = 255;
38 const uint32_t SET_COLOR = 0xFF000000;
39 const float_t SET_BRIGHTNESS_RATIO = 0.5f;
40 class RSPaintFilterCanvasTest : public testing::Test {
41 public:
42     static void SetUpTestCase();
43     static void TearDownTestCase();
44     void SetUp() override;
45     void TearDown() override;
46     static inline RSPaintFilterCanvas* paintFilterCanvas_;
47     static inline Drawing::Canvas drawingCanvas_;
48 
AlphaStackClear()49     inline bool AlphaStackClear()
50     {
51         while (!paintFilterCanvas_->alphaStack_.empty()) {
52             paintFilterCanvas_->alphaStack_.pop();
53         }
54         return true;
55     }
EnvStackClear()56     inline bool EnvStackClear()
57     {
58         while (!paintFilterCanvas_->envStack_.empty()) {
59             paintFilterCanvas_->envStack_.pop();
60         }
61         return true;
62     }
63 };
64 
SetUpTestCase()65 void RSPaintFilterCanvasTest::SetUpTestCase()
66 {
67     paintFilterCanvas_ = new RSPaintFilterCanvas(&drawingCanvas_);
68 }
TearDownTestCase()69 void RSPaintFilterCanvasTest::TearDownTestCase()
70 {
71     delete paintFilterCanvas_;
72     paintFilterCanvas_ = nullptr;
73 }
SetUp()74 void RSPaintFilterCanvasTest::SetUp() {}
TearDown()75 void RSPaintFilterCanvasTest::TearDown() {}
76 
77 class SDFShapeBaseTest : public Drawing::SDFShapeBase {
78 public:
Getshader() const79     std::string Getshader() const override
80     {
81         return "";
82     };
GetSize() const83     float GetSize() const override
84     {
85         return 0.0f;
86     };
SetSize(float size)87     void SetSize(float size) override
88     {
89         return;
90     };
SetTranslate(float dx,float dy)91     void SetTranslate(float dx, float dy) override
92     {
93         return;
94     };
GetTranslateX() const95     float GetTranslateX() const override
96     {
97         return 0.0f;
98     };
GetTranslateY() const99     float GetTranslateY() const override
100     {
101         return 0.0f;
102     };
GetParaNum() const103     int GetParaNum() const override
104     {
105         return 0;
106     };
GetFillType() const107     int GetFillType() const override
108     {
109         return 0;
110     };
GetPara() const111     std::vector<float> GetPara() const override
112     {
113         return {};
114     };
GetTransPara() const115     std::vector<float> GetTransPara() const override
116     {
117         return {};
118     };
GetColorPara() const119     std::vector<float> GetColorPara() const override
120     {
121         return {};
122     };
123 
UpdateTime(float time)124     void UpdateTime(float time) override
125     {
126         return;
127     };
BuildShader()128     void BuildShader() override
129     {
130         return;
131     };
SetColor(std::string fillColor,std::string strokeColor,float alpha)132     void SetColor(std::string fillColor, std::string strokeColor, float alpha)
133     {
134         return;
135     };
136 };
137 
138 class PaintFilterCanvasBaseTest : public RSPaintFilterCanvasBase {
139 public:
PaintFilterCanvasBaseTest(Drawing::Canvas * canvas)140     explicit PaintFilterCanvasBaseTest(Drawing::Canvas* canvas) : RSPaintFilterCanvasBase(canvas) {};
OnFilter() const141     bool OnFilter() const override
142     {
143         return true;
144     };
OnFilterWithBrush(Drawing::Brush & brush) const145     bool OnFilterWithBrush(Drawing::Brush& brush) const override
146     {
147         return true;
148     };
GetFilteredBrush() const149     Drawing::Brush* GetFilteredBrush() const override
150     {
151         return nullptr;
152     };
153 };
154 
155 /**
156  * @tc.name: SetHighContrastTest001
157  * @tc.desc: SetHighContrast Test
158  * @tc.type: FUNC
159  * @tc.require: issuesI9J2YE
160  */
161 HWTEST_F(RSPaintFilterCanvasTest, SetHighContrastTest001, TestSize.Level1)
162 {
163     bool mode = true;
164     paintFilterCanvas_->SetHighContrast(mode);
165     ASSERT_EQ(paintFilterCanvas_->isHighContrastEnabled(), mode);
166 
167     mode = false;
168     paintFilterCanvas_->SetHighContrast(mode);
169     ASSERT_EQ(paintFilterCanvas_->isHighContrastEnabled(), mode);
170 }
171 
172 /**
173  * @tc.name: RestoreAlphaTest001
174  * @tc.desc: RestoreAlpha Test
175  * @tc.type: FUNC
176  * @tc.require: issuesI9J2YE
177  */
178 HWTEST_F(RSPaintFilterCanvasTest, RestoreAlphaTest001, TestSize.Level1)
179 {
180     paintFilterCanvas_->RestoreAlpha();
181     ASSERT_EQ(paintFilterCanvas_->GetAlphaSaveCount(), 1);
182 }
183 
184 /**
185  * @tc.name: RestoreAlphaToCountTest
186  * @tc.desc: RestoreAlphaToCount Test
187  * @tc.type: FUNC
188  * @tc.require:issuesI9J2YE
189  */
190 HWTEST_F(RSPaintFilterCanvasTest, RestoreAlphaToCountTest, TestSize.Level1)
191 {
192     int count = 0;
193     paintFilterCanvas_->RestoreAlphaToCount(count);
194     ASSERT_EQ(paintFilterCanvas_->GetAlphaSaveCount(), 1);
195 }
196 
197 /**
198  * @tc.name: RestoreEnvTest
199  * @tc.desc: RestoreEnv Test
200  * @tc.type:FUNC
201  * @tc.require:issuesI9J2YE
202  */
203 HWTEST_F(RSPaintFilterCanvasTest, RestoreEnvTest, TestSize.Level1)
204 {
205     paintFilterCanvas_->RestoreEnv();
206     ASSERT_EQ(paintFilterCanvas_->GetAlphaSaveCount(), 1);
207 }
208 
209 /**
210  * @tc.name: RestoreEnvToCountTest
211  * @tc.desc: RestoreEnvToCount Test
212  * @tc.type: FUNC
213  * @tc.require: issuesI9J2YE
214  */
215 HWTEST_F(RSPaintFilterCanvasTest, RestoreEnvToCountTest, TestSize.Level1)
216 {
217     int count = 0;
218     paintFilterCanvas_->RestoreEnvToCount(count);
219     ASSERT_EQ(paintFilterCanvas_->GetAlphaSaveCount(), 1);
220 }
221 
222 /**
223  * @tc.name: SetEnvForegroundColorTest
224  * @tc.desc: SetEnvForegroundColor Test
225  * @tc.type: FUNC
226  * @tc.require: issuesI9J2YE
227  */
228 HWTEST_F(RSPaintFilterCanvasTest, SetEnvForegroundColorTest, TestSize.Level1)
229 {
230     Color color;
231     paintFilterCanvas_->SetEnvForegroundColor(color);
232     ASSERT_EQ(paintFilterCanvas_->GetEnvForegroundColor(), 0);
233 }
234 
235 /**
236  * @tc.name: GetEnvForegroundColorTest
237  * @tc.desc: GetEnvForegroundColor Test
238  * @tc.type: FUNC
239  * @tc.require: issuesI9J2YE
240  */
241 HWTEST_F(RSPaintFilterCanvasTest, GetEnvForegroundColorTest, TestSize.Level1)
242 {
243     Color color { SET_COLOR };
244     Color setColor {};
245     paintFilterCanvas_->SetEnvForegroundColor(setColor);
246     ASSERT_EQ(paintFilterCanvas_->GetEnvForegroundColor(), 0);
247 }
248 
249 /**
250  * @tc.name: onFilterTest
251  * @tc.desc: onFilter Test
252  * @tc.type: FUNC
253  * @tc.require: issuesI9J2YE
254  */
255 HWTEST_F(RSPaintFilterCanvasTest, onFilterTest, TestSize.Level1)
256 {
257     Drawing::Color color { 1 };
258     Drawing::Brush brush;
259     brush.SetColor(color);
260     ASSERT_TRUE(paintFilterCanvas_->OnFilterWithBrush(brush));
261 }
262 
263 /**
264  * @tc.name: DrawPointTest
265  * @tc.desc: DrawPoint Test
266  * @tc.type: FUNC
267  * @tc.require: issuesI9J2YE
268  */
269 HWTEST_F(RSPaintFilterCanvasTest, DrawPointTest, TestSize.Level1)
270 {
271     Drawing::Point point;
272     paintFilterCanvas_->SetAlpha(SET_ALPHA);
273     paintFilterCanvas_->DrawPoint(point);
274     EXPECT_EQ(paintFilterCanvas_->GetAlpha(), SET_ALPHA);
275 }
276 
277 /**
278  * @tc.name: DrawPointsTest
279  * @tc.desc: DrawPoints Test
280  * @tc.type: FUNC
281  * @tc.require: issuesI9J2YE
282  */
283 HWTEST_F(RSPaintFilterCanvasTest, DrawPointsTest, TestSize.Level1)
284 {
285     // fot test
286     Drawing::Point pts[] = { Drawing::Point(SET_XORY1, SET_XORY1), Drawing::Point(SET_XORY2, SET_XORY2) };
287     paintFilterCanvas_->DrawPoints(Drawing::PointMode::POINTS_POINTMODE, NUMBER, pts);
288     EXPECT_TRUE(paintFilterCanvas_);
289 }
290 
291 /**
292  * @tc.name: DrawLineTest
293  * @tc.desc: DrawLine Test
294  * @tc.type: FUNC
295  * @tc.require: issuesI9J2YE
296  */
297 HWTEST_F(RSPaintFilterCanvasTest, DrawLineTest, TestSize.Level1)
298 {
299     // fot test
300     Drawing::Point startPt(SET_XORY1, SET_XORY1);
301     Drawing::Point endPt(SET_XORY2, SET_XORY2);
302     paintFilterCanvas_->DrawLine(startPt, endPt);
303     EXPECT_TRUE(paintFilterCanvas_);
304 }
305 
306 /**
307  * @tc.name: DrawRectTest
308  * @tc.desc: DrawRect Test
309  * @tc.type: FUNC
310  * @tc.require: issuesI9J2YE
311  */
312 HWTEST_F(RSPaintFilterCanvasTest, DrawRectTest, TestSize.Level1)
313 {
314     Drawing::Rect rect;
315     paintFilterCanvas_->DrawRect(rect);
316     EXPECT_TRUE(paintFilterCanvas_);
317 }
318 
319 /**
320  * @tc.name: DrawRoundRectTest
321  * @tc.desc: DrawRoundRect Test
322  * @tc.type: FUNC
323  * @tc.require: issuesI9J2YE
324  */
325 HWTEST_F(RSPaintFilterCanvasTest, DrawRoundRectTest, TestSize.Level1)
326 {
327     Drawing::RoundRect roundRect;
328     paintFilterCanvas_->DrawRoundRect(roundRect);
329     EXPECT_TRUE(paintFilterCanvas_);
330 }
331 
332 /**
333  * @tc.name: DrawNestedRoundRectTest
334  * @tc.desc: DrawNestedRoundRect Test
335  * @tc.type: FUNC
336  * @tc.require: issuesI9J2YE
337  */
338 HWTEST_F(RSPaintFilterCanvasTest, DrawNestedRoundRectTest, TestSize.Level1)
339 {
340     Drawing::RoundRect outer;
341     Drawing::RoundRect inner;
342     paintFilterCanvas_->DrawNestedRoundRect(outer, inner);
343     EXPECT_TRUE(paintFilterCanvas_);
344 }
345 
346 /**
347  * @tc.name: DrawArcTest
348  * @tc.desc: DrawArc Test
349  * @tc.type:FUNC
350  * @tc.require:issuesI9J2YE
351  */
352 HWTEST_F(RSPaintFilterCanvasTest, DrawArcTest, TestSize.Level1)
353 {
354     Drawing::Rect oval;
355     paintFilterCanvas_->DrawArc(oval, ANGLE_SWEEP_START, ANGLE_SWEEP_START);
356     EXPECT_TRUE(paintFilterCanvas_);
357 }
358 
359 /**
360  * @tc.name: DrawPieTest
361  * @tc.desc: DrawPie Test
362  * @tc.type:FUNC
363  * @tc.require:issuesI9J2YE
364  */
365 HWTEST_F(RSPaintFilterCanvasTest, DrawPieTest, TestSize.Level1)
366 {
367     Drawing::Rect oval;
368     paintFilterCanvas_->DrawPie(oval, ANGLE_SWEEP_START, ANGLE_SWEEP_START);
369     EXPECT_TRUE(paintFilterCanvas_);
370 }
371 
372 /**
373  * @tc.name: DrawOvalTest
374  * @tc.desc: DrawOval Test
375  * @tc.type:FUNC
376  * @tc.require:issuesI9J2YE
377  */
378 HWTEST_F(RSPaintFilterCanvasTest, DrawOvalTest, TestSize.Level1)
379 {
380     Drawing::Rect oval;
381     paintFilterCanvas_->DrawOval(oval);
382     EXPECT_TRUE(paintFilterCanvas_);
383 }
384 
385 /**
386  * @tc.name: DrawCircleTest
387  * @tc.desc: DrawCircle Test
388  * @tc.type:FUNC
389  * @tc.require:issuesI9J2YE
390  */
391 HWTEST_F(RSPaintFilterCanvasTest, DrawCircleTest, TestSize.Level1)
392 {
393     Drawing::Point point;
394     paintFilterCanvas_->DrawCircle(point, SET_RADIUS);
395     EXPECT_TRUE(paintFilterCanvas_);
396 }
397 
398 /**
399  * @tc.name: DrawPathTest
400  * @tc.desc: DrawPath Test
401  * @tc.type:FUNC
402  * @tc.require:issuesI9J2YE
403  */
404 HWTEST_F(RSPaintFilterCanvasTest, DrawPathTest, TestSize.Level1)
405 {
406     Drawing::Path path;
407     paintFilterCanvas_->DrawPath(path);
408     EXPECT_TRUE(paintFilterCanvas_);
409 }
410 
411 /**
412  * @tc.name: DrawBackgroundTest
413  * @tc.desc: DrawBackground Test
414  * @tc.type:FUNC
415  * @tc.require:issuesI9J2YE
416  */
417 HWTEST_F(RSPaintFilterCanvasTest, DrawBackgroundTest, TestSize.Level1)
418 {
419     Drawing::Brush brush;
420     paintFilterCanvas_->DrawBackground(brush);
421     EXPECT_TRUE(paintFilterCanvas_);
422 }
423 
424 /**
425  * @tc.name: DrawShadowTest
426  * @tc.desc: DrawShadow Test
427  * @tc.type:FUNC
428  * @tc.require:issuesI9J2YE
429  */
430 HWTEST_F(RSPaintFilterCanvasTest, DrawShadowTest, TestSize.Level1)
431 {
432     Drawing::Path path;
433     Drawing::Point3 planeParams;
434     Drawing::Point3 devLightPos;
435     // for test
436     Drawing::Color ambientColor(0, 0, 0, 0);
437     Drawing::Color spotColor(SCALAR_XORY, 0, 0, 0);
438     paintFilterCanvas_->DrawShadow(
439         path, planeParams, devLightPos, 0.0f, ambientColor, spotColor, Drawing::ShadowFlags::NONE);
440     EXPECT_TRUE(paintFilterCanvas_);
441 }
442 
443 /**
444  * @tc.name: DrawShadowStyleTest
445  * @tc.desc: DrawShadowStyle Test
446  * @tc.type:FUNC
447  * @tc.require:issuesI9J2YE
448  */
449 HWTEST_F(RSPaintFilterCanvasTest, DrawShadowStyleTest, TestSize.Level1)
450 {
451     Drawing::Path path;
452     Drawing::Point3 planeParams;
453     Drawing::Point3 devLightPos;
454     // for test
455     Drawing::Color ambientColor(0, 0, 0, 0);
456     Drawing::Color spotColor(SCALAR_XORY, 0, 0, 0);
457     paintFilterCanvas_->DrawShadowStyle(
458         path, planeParams, devLightPos, 0.0f, ambientColor, spotColor, Drawing::ShadowFlags::NONE, true);
459     EXPECT_TRUE(paintFilterCanvas_);
460 }
461 
462 /**
463  * @tc.name: DrawColorTest
464  * @tc.desc: DrawColor Test
465  * @tc.type:FUNC
466  * @tc.require:issuesI9J2YE
467  */
468 HWTEST_F(RSPaintFilterCanvasTest, DrawColorTest, TestSize.Level1)
469 {
470     paintFilterCanvas_->DrawColor(1, Drawing::BlendMode::CLEAR);
471     EXPECT_TRUE(paintFilterCanvas_);
472 }
473 
474 /**
475  * @tc.name: DrawRegionTest
476  * @tc.desc: DrawRegion Test
477  * @tc.type:FUNC
478  * @tc.require:issuesI9J2YE
479  */
480 HWTEST_F(RSPaintFilterCanvasTest, DrawRegionTest, TestSize.Level1)
481 {
482     Drawing::Region region;
483     paintFilterCanvas_->DrawRegion(region);
484     EXPECT_TRUE(paintFilterCanvas_);
485 }
486 
487 /**
488  * @tc.name: DrawPatchTest
489  * @tc.desc: DrawPatch Test
490  * @tc.type:FUNC
491  * @tc.require:issuesI9J2YE
492  */
493 HWTEST_F(RSPaintFilterCanvasTest, DrawPatchTest, TestSize.Level1)
494 {
495     // for test
496     Drawing::Point cubics[SET_POINT_SIZE1];
497     Drawing::ColorQuad colors[SET_COLOR_QUAD_SIZE];
498     Drawing::Point texCoords[SET_POINT_SIZE2];
499     paintFilterCanvas_->DrawPatch(cubics, colors, texCoords, Drawing::BlendMode::CLEAR);
500     EXPECT_TRUE(paintFilterCanvas_);
501 }
502 
503 /**
504  * @tc.name: DrawVerticesTest
505  * @tc.desc: DrawVertices Test
506  * @tc.type:FUNC
507  * @tc.require:issuesI9J2YE
508  */
509 HWTEST_F(RSPaintFilterCanvasTest, DrawVerticesTest, TestSize.Level1)
510 {
511     Drawing::Vertices vertices;
512     paintFilterCanvas_->DrawVertices(vertices, Drawing::BlendMode::CLEAR);
513     EXPECT_TRUE(paintFilterCanvas_);
514 }
515 
516 /**
517  * @tc.name: OpCalculateBeforeTest
518  * @tc.desc: OpCalculateBefore Test
519  * @tc.type:FUNC
520  * @tc.require:issuesI9J2YE
521  */
522 HWTEST_F(RSPaintFilterCanvasTest, OpCalculateBeforeTest, TestSize.Level1)
523 {
524     Drawing::Matrix matrix;
525     paintFilterCanvas_->SetAlpha(SET_ALPHA);
526     EXPECT_TRUE(paintFilterCanvas_->OpCalculateBefore(matrix));
527 }
528 
529 /**
530  * @tc.name: OpCalculateAfterTest
531  * @tc.desc: OpCalculateAfter Test
532  * @tc.type:FUNC
533  * @tc.require:issuesI9J2YE
534  */
535 HWTEST_F(RSPaintFilterCanvasTest, OpCalculateAfterTest, TestSize.Level1)
536 {
537     Drawing::Rect bound;
538     EXPECT_FALSE(paintFilterCanvas_->OpCalculateAfter(bound));
539     paintFilterCanvas_->SetAlpha(0.0f);
540     EXPECT_FALSE(paintFilterCanvas_->OpCalculateAfter(bound));
541 }
542 
543 /**
544  * @tc.name: DrawBitmapTest
545  * @tc.desc: DrawBitmap Test
546  * @tc.type:FUNC
547  * @tc.require:issuesI9J2YE
548  */
549 HWTEST_F(RSPaintFilterCanvasTest, DrawBitmapTest, TestSize.Level1)
550 {
551     Drawing::Bitmap bitmap;
552     paintFilterCanvas_->DrawBitmap(bitmap, SET_XORY1, SET_XORY1);
553     paintFilterCanvas_->SetAlpha(SET_ALPHA);
554     paintFilterCanvas_->DrawBitmap(bitmap, SET_XORY1, SET_XORY1);
555     EXPECT_TRUE(paintFilterCanvas_);
556 }
557 
558 /**
559  * @tc.name: DrawImageNineTest
560  * @tc.desc: DrawImageNine Test
561  * @tc.type:FUNC
562  * @tc.require:issuesI9J2YE
563  */
564 HWTEST_F(RSPaintFilterCanvasTest, DrawImageNineTest, TestSize.Level1)
565 {
566     Drawing::Image image;
567     Drawing::RectI center;
568     Drawing::Rect dst;
569     Drawing::Brush brush;
570     paintFilterCanvas_->SetAlpha(SET_ALPHA);
571     paintFilterCanvas_->DrawImageNine(&image, center, dst, Drawing::FilterMode::LINEAR, &brush);
572     EXPECT_TRUE(paintFilterCanvas_);
573 }
574 
575 /**
576  * @tc.name: DrawImageNineTest002
577  * @tc.desc: DrawImageNine Test
578  * @tc.type:FUNC
579  * @tc.require:issueI9VT6E
580  */
581 HWTEST_F(RSPaintFilterCanvasTest, DrawImageNineTest002, TestSize.Level1)
582 {
583     Drawing::Image image;
584     Drawing::RectI center;
585     Drawing::Rect dst;
586     Drawing::Brush* brush = nullptr;
587     Drawing::Canvas canvas;
588     std::shared_ptr<RSPaintFilterCanvas> paintFilterCanvas = std::make_shared<RSPaintFilterCanvas>(&canvas);
589     EXPECT_NE(paintFilterCanvas, nullptr);
590     paintFilterCanvas->alphaStack_.push(1.0f);
591     paintFilterCanvas->DrawImageNine(&image, center, dst, Drawing::FilterMode::LINEAR, brush);
592 }
593 
594 /**
595  * @tc.name: DrawImageLatticeTest
596  * @tc.desc: DrawImageLattice Test
597  * @tc.type:FUNC
598  * @tc.require:issuesI9J2YE
599  */
600 HWTEST_F(RSPaintFilterCanvasTest, DrawImageLatticeTest, TestSize.Level1)
601 {
602     Drawing::Image image;
603     Drawing::Lattice lattice;
604     Drawing::Rect dst;
605     paintFilterCanvas_->DrawImageLattice(&image, lattice, dst, Drawing::FilterMode::LINEAR);
606     EXPECT_TRUE(paintFilterCanvas_);
607 }
608 
609 /**
610  * @tc.name: DrawImageLatticeTest
611  * @tc.desc: DrawImageLattice Test
612  * @tc.type:FUNC
613  * @tc.require:issueI9VT6E
614  */
615 HWTEST_F(RSPaintFilterCanvasTest, DrawImageLatticeTest002, TestSize.Level1)
616 {
617     Drawing::Image image;
618     Drawing::Lattice lattice;
619     Drawing::Rect dst;
620     Drawing::Canvas canvas;
621     std::shared_ptr<RSPaintFilterCanvas> paintFilterCanvas = std::make_shared<RSPaintFilterCanvas>(&canvas);
622     EXPECT_NE(paintFilterCanvas, nullptr);
623     paintFilterCanvas->alphaStack_.push(1.0f);
624     paintFilterCanvas->DrawImageLattice(&image, lattice, dst, Drawing::FilterMode::LINEAR);
625 }
626 
627 /**
628  * @tc.name: DrawImageTest
629  * @tc.desc: DrawImage Test
630  * @tc.type:FUNC
631  * @tc.require:issuesI9J2YE
632  */
633 HWTEST_F(RSPaintFilterCanvasTest, DrawImageTest, TestSize.Level1)
634 {
635     Drawing::Image image;
636     Drawing::SamplingOptions sampling;
637     paintFilterCanvas_->DrawImage(image, SET_XORY1, SET_XORY1, sampling);
638     EXPECT_TRUE(paintFilterCanvas_);
639 }
640 
641 /**
642  * @tc.name: DrawImageRectTest001
643  * @tc.desc: DrawImageRect Test
644  * @tc.type:FUNC
645  * @tc.require:issuesI9J2YE
646  */
647 HWTEST_F(RSPaintFilterCanvasTest, DrawImageRectTest001, TestSize.Level1)
648 {
649     Drawing::Image image;
650     Drawing::Rect src;
651     Drawing::Rect dst;
652     Drawing::SamplingOptions sampling;
653     paintFilterCanvas_->DrawImageRect(image, src, dst, sampling, Drawing::SrcRectConstraint::FAST_SRC_RECT_CONSTRAINT);
654     EXPECT_TRUE(paintFilterCanvas_);
655 }
656 
657 /**
658  * @tc.name: DrawImageRectTest002
659  * @tc.desc: DrawImageRect Test
660  * @tc.type:FUNC
661  * @tc.require:issuesI9J2YE
662  */
663 HWTEST_F(RSPaintFilterCanvasTest, DrawImageRectTest002, TestSize.Level1)
664 {
665     Drawing::Image image;
666     Drawing::Rect dst;
667     Drawing::SamplingOptions sampling;
668     paintFilterCanvas_->DrawImageRect(image, dst, sampling);
669     EXPECT_TRUE(paintFilterCanvas_);
670 }
671 
672 /**
673  * @tc.name: DrawPictureTest
674  * @tc.desc: DrawPicture Test
675  * @tc.type:FUNC
676  * @tc.require:issuesI9J2YE
677  */
678 HWTEST_F(RSPaintFilterCanvasTest, DrawPictureTest, TestSize.Level1)
679 {
680     Drawing::Picture picture;
681     paintFilterCanvas_->DrawPicture(picture);
682     EXPECT_TRUE(paintFilterCanvas_);
683 }
684 
685 /**
686  * @tc.name: DrawTextBlobTest
687  * @tc.desc: DrawTextBlob Test
688  * @tc.type:FUNC
689  * @tc.require:issuesI9J2YE
690  */
691 HWTEST_F(RSPaintFilterCanvasTest, DrawTextBlobTest, TestSize.Level1)
692 {
693     // for tset
694     const char* text = "text";
695     Drawing::Font font;
696     auto blob = Drawing::TextBlob::MakeFromString(text, font);
697     paintFilterCanvas_->DrawTextBlob(blob.get(), SET_XORY1, SET_XORY1);
698     EXPECT_TRUE(paintFilterCanvas_);
699 }
700 
701 /**
702  * @tc.name: ClipRectTest
703  * @tc.desc: ClipRect Test
704  * @tc.type:FUNC
705  * @tc.require:issuesI9J2YE
706  */
707 HWTEST_F(RSPaintFilterCanvasTest, ClipRectTest, TestSize.Level1)
708 {
709     Drawing::Rect rect;
710     paintFilterCanvas_->ClipRect(rect, Drawing::ClipOp::DIFFERENCE, true);
711     EXPECT_TRUE(paintFilterCanvas_);
712 }
713 
714 /**
715  * @tc.name: ClipIRectTest
716  * @tc.desc: ClipIRect Test
717  * @tc.type:FUNC
718  * @tc.require:issuesI9J2YE
719  */
720 HWTEST_F(RSPaintFilterCanvasTest, ClipIRectTest, TestSize.Level1)
721 {
722     Drawing::RectI rect;
723     paintFilterCanvas_->ClipIRect(rect, Drawing::ClipOp::DIFFERENCE);
724     EXPECT_TRUE(paintFilterCanvas_);
725 }
726 
727 /**
728  * @tc.name: ClipRoundRectTest001
729  * @tc.desc: ClipRoundRect Test
730  * @tc.type:FUNC
731  * @tc.require:issuesI9J2YE
732  */
733 HWTEST_F(RSPaintFilterCanvasTest, ClipRoundRectTest001, TestSize.Level1)
734 {
735     Drawing::RoundRect roundRect;
736     paintFilterCanvas_->ClipRoundRect(roundRect, Drawing::ClipOp::DIFFERENCE, true);
737     EXPECT_TRUE(paintFilterCanvas_);
738 }
739 
740 /**
741  * @tc.name: ClipRoundRectTest002
742  * @tc.desc: ClipRoundRect Test
743  * @tc.type:FUNC
744  * @tc.require:issuesI9J2YE
745  */
746 HWTEST_F(RSPaintFilterCanvasTest, ClipRoundRectTest002, TestSize.Level1)
747 {
748     Drawing::Rect rect;
749     std::vector<Drawing::Point> pts;
750     paintFilterCanvas_->ClipRoundRect(rect, pts, true);
751     EXPECT_TRUE(paintFilterCanvas_);
752 }
753 
754 /**
755  * @tc.name: ClipPathTest
756  * @tc.desc: ClipPath Test
757  * @tc.type:FUNC
758  * @tc.require:issuesI9J2YE
759  */
760 HWTEST_F(RSPaintFilterCanvasTest, ClipPathTest, TestSize.Level1)
761 {
762     Drawing::Path path;
763     paintFilterCanvas_->ClipPath(path, Drawing::ClipOp::DIFFERENCE, true);
764     EXPECT_TRUE(paintFilterCanvas_);
765 }
766 
767 /**
768  * @tc.name: ClipRegionTest
769  * @tc.desc: ClipRegion Test
770  * @tc.type:FUNC
771  * @tc.require:issuesI9J2YE
772  */
773 HWTEST_F(RSPaintFilterCanvasTest, ClipRegionTest, TestSize.Level1)
774 {
775     Drawing::Region region;
776     paintFilterCanvas_->ClipRegion(region, Drawing::ClipOp::DIFFERENCE);
777     EXPECT_TRUE(paintFilterCanvas_);
778 }
779 
780 /**
781  * @tc.name: SetMatrixTest
782  * @tc.desc: SetMatrix Test
783  * @tc.type:FUNC
784  * @tc.require:issuesI9J2YE
785  */
786 HWTEST_F(RSPaintFilterCanvasTest, SetMatrixTest, TestSize.Level1)
787 {
788     Drawing::Matrix matrix;
789     paintFilterCanvas_->SetMatrix(matrix);
790     EXPECT_TRUE(paintFilterCanvas_);
791 }
792 
793 /**
794  * @tc.name: ResetMatrixTest
795  * @tc.desc: ResetMatrix Test
796  * @tc.type:FUNC
797  * @tc.require:issuesI9J2YE
798  */
799 HWTEST_F(RSPaintFilterCanvasTest, ResetMatrixTest, TestSize.Level1)
800 {
801     paintFilterCanvas_->ResetMatrix();
802     EXPECT_TRUE(paintFilterCanvas_);
803 }
804 
805 /**
806  * @tc.name: ConcatMatrixTest
807  * @tc.desc: ConcatMatrix Test
808  * @tc.type:FUNC
809  * @tc.require:issuesI9J2YE
810  */
811 HWTEST_F(RSPaintFilterCanvasTest, ConcatMatrixTest, TestSize.Level1)
812 {
813     Drawing::Matrix matrix;
814     paintFilterCanvas_->ConcatMatrix(matrix);
815     EXPECT_TRUE(paintFilterCanvas_);
816 }
817 
818 /**
819  * @tc.name: TranslateTest
820  * @tc.desc: Verify function Translate
821  * @tc.type:FUNC
822  * @tc.require:issuesI9J2YE
823  */
824 HWTEST_F(RSPaintFilterCanvasTest, TranslateTest, TestSize.Level1)
825 {
826     paintFilterCanvas_->Translate(SET_XORY1, SET_XORY1);
827     EXPECT_TRUE(paintFilterCanvas_);
828 }
829 
830 /**
831  * @tc.name: ScaleTest
832  * @tc.desc: Scale Test
833  * @tc.type:FUNC
834  * @tc.require:issuesI9J2YE
835  */
836 HWTEST_F(RSPaintFilterCanvasTest, ScaleTest, TestSize.Level1)
837 {
838     paintFilterCanvas_->Scale(SET_XORY1, SET_XORY1);
839     EXPECT_TRUE(paintFilterCanvas_);
840 }
841 
842 /**
843  * @tc.name: RotateTest
844  * @tc.desc: Rotate Test
845  * @tc.type:FUNC
846  * @tc.require:issuesI9J2YE
847  */
848 HWTEST_F(RSPaintFilterCanvasTest, RotateTest, TestSize.Level1)
849 {
850     paintFilterCanvas_->Rotate(SET_SCALAR, SET_XORY1, SET_XORY1);
851     EXPECT_TRUE(paintFilterCanvas_);
852 }
853 
854 /**
855  * @tc.name: ShearTest
856  * @tc.desc: Shear Test
857  * @tc.type:FUNC
858  * @tc.require:issuesI9J2YE
859  */
860 HWTEST_F(RSPaintFilterCanvasTest, ShearTest, TestSize.Level1)
861 {
862     paintFilterCanvas_->Shear(SET_XORY1, SET_XORY1);
863     EXPECT_TRUE(paintFilterCanvas_);
864 }
865 
866 /**
867  * @tc.name: FlushTest
868  * @tc.desc: Flush Test
869  * @tc.type:FUNC
870  * @tc.require:issuesI9J2YE
871  */
872 HWTEST_F(RSPaintFilterCanvasTest, FlushTest, TestSize.Level1)
873 {
874     paintFilterCanvas_->Flush();
875     EXPECT_TRUE(paintFilterCanvas_);
876 }
877 
878 /**
879  * @tc.name: ClearTest
880  * @tc.desc: Clear Test
881  * @tc.type:FUNC
882  * @tc.require:issuesI9J2YE
883  */
884 HWTEST_F(RSPaintFilterCanvasTest, ClearTest, TestSize.Level1)
885 {
886     paintFilterCanvas_->Clear(1);
887     EXPECT_TRUE(paintFilterCanvas_);
888 }
889 
890 /**
891  * @tc.name: SaveTest
892  * @tc.desc: Save Test
893  * @tc.type:FUNC
894  * @tc.require:issuesI9J2YE
895  */
896 HWTEST_F(RSPaintFilterCanvasTest, SaveTest, TestSize.Level1)
897 {
898     EXPECT_EQ(paintFilterCanvas_->Save(), 1);
899     paintFilterCanvas_->canvas_ = nullptr;
900     EXPECT_EQ(paintFilterCanvas_->Save(), 0);
901 }
902 
903 /**
904  * @tc.name: SaveLayerTest
905  * @tc.desc: SaveLayer Test
906  * @tc.type:FUNC
907  * @tc.require:issuesI9J2YE
908  */
909 HWTEST_F(RSPaintFilterCanvasTest, SaveLayerTest, TestSize.Level1)
910 {
911     Drawing::SaveLayerOps saveLayerRec;
912     paintFilterCanvas_->SaveLayer(saveLayerRec);
913     paintFilterCanvas_->canvas_ = &drawingCanvas_;
914     paintFilterCanvas_->SaveLayer(saveLayerRec);
915     Drawing::Brush brush;
916     saveLayerRec.brush_ = &brush;
917     paintFilterCanvas_->SaveLayer(saveLayerRec);
918     EXPECT_TRUE(paintFilterCanvas_);
919 }
920 
921 /**
922  * @tc.name: RestoreTest
923  * @tc.desc: Restore Test
924  * @tc.type:FUNC
925  * @tc.require:issuesI9J2YE
926  */
927 HWTEST_F(RSPaintFilterCanvasTest, RestoreTest, TestSize.Level1)
928 {
929     paintFilterCanvas_->Restore();
930     EXPECT_TRUE(paintFilterCanvas_);
931 }
932 
933 /**
934  * @tc.name: DiscardTest
935  * @tc.desc: Discard Test
936  * @tc.type:FUNC
937  * @tc.require:issuesI9J2YE
938  */
939 HWTEST_F(RSPaintFilterCanvasTest, DiscardTest, TestSize.Level1)
940 {
941     paintFilterCanvas_->Discard();
942     EXPECT_TRUE(paintFilterCanvas_);
943 }
944 
945 /**
946  * @tc.name: AttachPenTest001
947  * @tc.desc: AttachPen Test
948  * @tc.type:FUNC
949  * @tc.require:issuesI9J2YE
950  */
951 HWTEST_F(RSPaintFilterCanvasTest, AttachPenTest001, TestSize.Level1)
952 {
953     Drawing::Pen pen;
954     EXPECT_TRUE(paintFilterCanvas_->AttachPen(pen).impl_);
955 }
956 
957 /**
958  * @tc.name: AttachBrushTest
959  * @tc.desc: AttachBrush Test
960  * @tc.type:FUNC
961  * @tc.require:issuesI9J2YE
962  */
963 HWTEST_F(RSPaintFilterCanvasTest, AttachBrushTest, TestSize.Level1)
964 {
965     Drawing::Brush brush;
966     EXPECT_TRUE(paintFilterCanvas_->AttachBrush(brush).impl_);
967 }
968 
969 /**
970  * @tc.name: AttachPaintTest
971  * @tc.desc: AttachPaint Test
972  * @tc.type:FUNC
973  * @tc.require:issuesI9J2YE
974  */
975 HWTEST_F(RSPaintFilterCanvasTest, AttachPaintTest, TestSize.Level1)
976 {
977     Drawing::Paint paint;
978     EXPECT_TRUE(paintFilterCanvas_->AttachPaint(paint).impl_);
979 }
980 
981 /**
982  * @tc.name: DetachPenTest
983  * @tc.desc: DetachPen Test
984  * @tc.type:FUNC
985  * @tc.require:issuesI9J2YE
986  */
987 HWTEST_F(RSPaintFilterCanvasTest, DetachPenTest, TestSize.Level1)
988 {
989     EXPECT_TRUE(paintFilterCanvas_->DetachPen().impl_);
990 }
991 
992 /**
993  * @tc.name: DetachBrushTest
994  * @tc.desc: DetachBrush Test
995  * @tc.type:FUNC
996  * @tc.require:issuesI9J2YE
997  */
998 HWTEST_F(RSPaintFilterCanvasTest, DetachBrushTest, TestSize.Level1)
999 {
1000     EXPECT_TRUE(paintFilterCanvas_->DetachBrush().impl_);
1001 }
1002 
1003 /**
1004  * @tc.name: DetachPaintTest
1005  * @tc.desc: DetachPaint Test
1006  * @tc.type:FUNC
1007  * @tc.require:issuesI9J2YE
1008  */
1009 HWTEST_F(RSPaintFilterCanvasTest, DetachPaintTest, TestSize.Level1)
1010 {
1011     EXPECT_TRUE(paintFilterCanvas_->DetachPaint().impl_);
1012 }
1013 
1014 /**
1015  * @tc.name: AttachPenTest002
1016  * @tc.desc: AttachPen Test
1017  * @tc.type:FUNC
1018  * @tc.require:issuesI9J2YE
1019  */
1020 HWTEST_F(RSPaintFilterCanvasTest, AttachPenTest002, TestSize.Level1)
1021 {
1022     Drawing::Pen pen;
1023 
1024     paintFilterCanvas_->canvas_ = nullptr;
1025     EXPECT_TRUE(paintFilterCanvas_->AttachPen(pen).impl_);
1026 
1027     paintFilterCanvas_->canvas_ = &drawingCanvas_;
1028     pen.SetColor(1);
1029 
1030     paintFilterCanvas_->SetAlpha(SET_ALPHA);
1031     paintFilterCanvas_->SetBlendMode(1);
1032     EXPECT_TRUE(paintFilterCanvas_->AttachPen(pen).impl_);
1033 }
1034 
1035 /**
1036  * @tc.name: AttachBrushTest001
1037  * @tc.desc: AttachBrush Test
1038  * @tc.type:FUNC
1039  * @tc.require:issuesI9J2YE
1040  */
1041 HWTEST_F(RSPaintFilterCanvasTest, AttachBrushTest001, TestSize.Level1)
1042 {
1043     Drawing::Brush brush;
1044     paintFilterCanvas_->canvas_ = nullptr;
1045     EXPECT_TRUE(paintFilterCanvas_->AttachBrush(brush).impl_);
1046 
1047     paintFilterCanvas_->canvas_ = &drawingCanvas_;
1048     brush.SetColor(1);
1049 
1050     paintFilterCanvas_->SetAlpha(SET_ALPHA);
1051     paintFilterCanvas_->SetBlendMode(1);
1052     EXPECT_TRUE(paintFilterCanvas_->AttachBrush(brush).impl_);
1053 }
1054 
1055 /**
1056  * @tc.name: AttachPaintTest001
1057  * @tc.desc: AttachPaint Test
1058  * @tc.type:FUNC
1059  * @tc.require:issuesI9J2YE
1060  */
1061 HWTEST_F(RSPaintFilterCanvasTest, AttachPaintTest001, TestSize.Level1)
1062 {
1063     Drawing::Paint paint;
1064     paintFilterCanvas_->canvas_ = nullptr;
1065     EXPECT_TRUE(paintFilterCanvas_->AttachPaint(paint).impl_);
1066 
1067     paintFilterCanvas_->canvas_ = &drawingCanvas_;
1068     paint.SetColor(1);
1069 
1070     paintFilterCanvas_->SetAlpha(SET_ALPHA);
1071     paintFilterCanvas_->SetBlendMode(1);
1072     EXPECT_TRUE(paintFilterCanvas_->AttachPaint(paint).impl_);
1073 }
1074 
1075 /**
1076  * @tc.name: AlphaStackToPushOrOutbackTest
1077  * @tc.desc: AlphaStackToPushOrOutback Test
1078  * @tc.type:FUNC
1079  * @tc.require:issueI9L0ZK
1080  */
1081 HWTEST_F(RSPaintFilterCanvasTest, AlphaStackToPushOrOutbackTest, TestSize.Level1)
1082 {
1083     // Ensure that the stack is empty before testing
1084     EXPECT_TRUE(AlphaStackClear());
1085     // RestoreAlpha Test
1086     paintFilterCanvas_->RestoreAlpha();
1087     paintFilterCanvas_->alphaStack_.push(SET_ALPHA);
1088     EXPECT_EQ(paintFilterCanvas_->SaveAlpha(), 1);
1089     EXPECT_EQ(paintFilterCanvas_->GetAlphaSaveCount(), NUMBER);
1090     paintFilterCanvas_->RestoreAlpha();
1091     EXPECT_EQ(paintFilterCanvas_->GetAlphaSaveCount(), 1);
1092 
1093     // RestoreAlphaToCount Test
1094     EXPECT_EQ(paintFilterCanvas_->SaveAlpha(), 1);
1095     paintFilterCanvas_->RestoreAlphaToCount(0);
1096     EXPECT_EQ(paintFilterCanvas_->GetAlphaSaveCount(), 1);
1097 
1098     // Ensure that the stack is empty after testing
1099     EXPECT_TRUE(AlphaStackClear());
1100 }
1101 
1102 /**
1103  * @tc.name: EnvStackToPushOrOutbackTest
1104  * @tc.desc: EnvStackToPushOrOutback Test
1105  * @tc.type:FUNC
1106  * @tc.require:issueI9L0ZK
1107  */
1108 HWTEST_F(RSPaintFilterCanvasTest, EnvStackToPushOrOutbackTest, TestSize.Level1)
1109 {
1110     // Ensure that the stack is empty before testing
1111     EXPECT_TRUE(EnvStackClear());
1112 
1113     Rosen::RSColor rsColor;
1114     RSPaintFilterCanvas::Env env;
1115 
1116     // envStack_ is empty
1117     EXPECT_EQ(paintFilterCanvas_->GetEnvForegroundColor(), Drawing::Color::COLOR_BLACK);
1118     paintFilterCanvas_->SetEnvForegroundColor(rsColor);
1119     paintFilterCanvas_->RestoreEnv();
1120 
1121     // envStack_ is not empty
1122     paintFilterCanvas_->envStack_.push(env);
1123     auto asArgbInt = paintFilterCanvas_->envStack_.top().envForegroundColor_.AsArgbInt();
1124     EXPECT_EQ(paintFilterCanvas_->GetEnvForegroundColor(), asArgbInt);
1125     paintFilterCanvas_->SetBlendMode(0);
1126     paintFilterCanvas_->SetEnvForegroundColor(rsColor);
1127     EXPECT_EQ(paintFilterCanvas_->GetEnvSaveCount(), 1);
1128     EXPECT_EQ(paintFilterCanvas_->SaveEnv(), 1);
1129 
1130     // envStack_ Outback
1131     paintFilterCanvas_->RestoreEnv();
1132     EXPECT_EQ(paintFilterCanvas_->GetEnvSaveCount(), 1);
1133     EXPECT_EQ(paintFilterCanvas_->SaveEnv(), 1);
1134     paintFilterCanvas_->RestoreEnvToCount(0);
1135 
1136     // Ensure that the stack is empty after testing
1137     EXPECT_TRUE(EnvStackClear());
1138 }
1139 
1140 /**
1141  * @tc.name: SaveAllStatusTest
1142  * @tc.desc: SaveAllStatus Test
1143  * @tc.type:FUNC
1144  * @tc.require:issueI9L0ZK
1145  */
1146 HWTEST_F(RSPaintFilterCanvasTest, SaveAllStatusTest, TestSize.Level1)
1147 {
1148     // The second condition of the ternary operation
1149     auto drawingCanvas = std::make_unique<Drawing::Canvas>();
1150     paintFilterCanvas_->canvas_ = drawingCanvas.get();
1151 
1152     RSPaintFilterCanvas::SaveStatus secondStatus = paintFilterCanvas_->SaveAllStatus(RSPaintFilterCanvas::kNone);
1153     EXPECT_EQ(paintFilterCanvas_->GetSaveCount(), secondStatus.canvasSaveCount);
1154     EXPECT_EQ(paintFilterCanvas_->GetAlphaSaveCount(), secondStatus.alphaSaveCount);
1155     EXPECT_EQ(paintFilterCanvas_->GetEnvSaveCount(), secondStatus.envSaveCount);
1156     // The first condition of the ternary operation
1157     paintFilterCanvas_->canvas_ = nullptr;
1158     RSPaintFilterCanvas::Env env;
1159     paintFilterCanvas_->envStack_.push(env);
1160     paintFilterCanvas_->alphaStack_.push(SET_ALPHA);
1161     RSPaintFilterCanvas::SaveStatus firstStatus = paintFilterCanvas_->SaveAllStatus(RSPaintFilterCanvas::kAll);
1162     EXPECT_EQ(paintFilterCanvas_->Save(), firstStatus.canvasSaveCount);
1163     EXPECT_EQ(paintFilterCanvas_->GetAlphaSaveCount() - 1, firstStatus.alphaSaveCount);
1164     EXPECT_EQ(paintFilterCanvas_->GetEnvSaveCount() - 1, firstStatus.envSaveCount);
1165 
1166     EXPECT_TRUE(AlphaStackClear());
1167     EXPECT_TRUE(EnvStackClear());
1168 }
1169 
1170 /**
1171  * @tc.name: CopyConfigurationToOffscreenCanvas
1172  * @tc.desc: CopyConfigurationToOffscreenCanvas Test
1173  * @tc.type:FUNC
1174  * @tc.require:issueI9L0ZK
1175  */
1176 HWTEST_F(RSPaintFilterCanvasTest, CopyConfigurationToOffscreenCanvasTest, TestSize.Level1)
1177 {
1178     // building a new RSPaintFilterCanvas object
1179     auto drawingCanvas = std::make_unique<Drawing::Canvas>();
1180     RSPaintFilterCanvas::Env env;
1181     RSPaintFilterCanvas::Env envOther;
1182     RSPaintFilterCanvas rsPaintFilterCanvas(drawingCanvas.get());
1183 
1184     paintFilterCanvas_->envStack_.push(env);
1185     rsPaintFilterCanvas.envStack_.push(envOther);
1186 
1187     rsPaintFilterCanvas.SetHighContrast(false);
1188     paintFilterCanvas_->CopyConfigurationToOffscreenCanvas(rsPaintFilterCanvas);
1189 
1190     rsPaintFilterCanvas.SetHighContrast(true);
1191     paintFilterCanvas_->CopyConfigurationToOffscreenCanvas(rsPaintFilterCanvas);
1192     EXPECT_TRUE(EnvStackClear());
1193 }
1194 
1195 /**
1196  * @tc.name: ReplaceOrSwapMainScreenTest
1197  * @tc.desc: ReplaceMainScreenData and SwapBackMainScreenData Test
1198  * @tc.type:FUNC
1199  * @tc.require:issueI9L0ZK
1200  */
1201 HWTEST_F(RSPaintFilterCanvasTest, ReplaceOrSwapMainScreenTest, TestSize.Level1)
1202 {
1203     Drawing::Surface surface;
1204     Drawing::Canvas canvas(&surface);
1205     RSPaintFilterCanvas paintFilterCanvas(&canvas);
1206     std::shared_ptr<Drawing::Surface> surfacePtr = std::make_shared<Drawing::Surface>();
1207     std::shared_ptr<RSPaintFilterCanvas> canvasPtr = std::make_shared<RSPaintFilterCanvas>(&canvas);
1208 
1209     // Replace data
1210     paintFilterCanvas.ReplaceMainScreenData(surfacePtr, canvasPtr);
1211     EXPECT_EQ(paintFilterCanvas.GetSurface(), surfacePtr.get());
1212     EXPECT_EQ(paintFilterCanvas.GetRecordingCanvas(), nullptr);
1213 
1214     // Swap data
1215     paintFilterCanvas.SwapBackMainScreenData();
1216     EXPECT_TRUE(paintFilterCanvas.offscreenDataList_.empty());
1217 }
1218 
1219 /**
1220  * @tc.name: SaveOrRestoreTest
1221  * @tc.desc: SavePCanvasList and RestorePCanvasList Test
1222  * @tc.type:FUNC
1223  * @tc.require:issueI9L0ZK
1224  */
1225 HWTEST_F(RSPaintFilterCanvasTest, SaveOrRestoreTest, TestSize.Level1)
1226 {
1227     paintFilterCanvas_->SavePCanvasList();
1228     EXPECT_EQ(paintFilterCanvas_->storedPCanvasList_.size(), 1);
1229     paintFilterCanvas_->RestorePCanvasList();
1230     EXPECT_TRUE(paintFilterCanvas_->storedPCanvasList_.empty());
1231     paintFilterCanvas_->pCanvasList_.clear();
1232     EXPECT_TRUE(paintFilterCanvas_->pCanvasList_.empty());
1233 }
1234 
1235 /**
1236  * @tc.name: BrightnessRatioTest
1237  * @tc.desc: SetBrightnessRatio and GetBrightnessRatio Test
1238  * @tc.type:FUNC
1239  * @tc.require:issueIAM268
1240  */
1241 HWTEST_F(RSPaintFilterCanvasTest, BrightnessRatioTest, TestSize.Level1)
1242 {
1243     paintFilterCanvas_->SetBrightnessRatio(SET_BRIGHTNESS_RATIO);
1244     EXPECT_EQ(paintFilterCanvas_->GetBrightnessRatio(), SET_BRIGHTNESS_RATIO);
1245 }
1246 
1247 /**
1248  * @tc.name: GetLocalClipBoundsTest
1249  * @tc.desc: GetLocalClipBounds Test
1250  * @tc.type:FUNC
1251  * @tc.require:issueI9L0ZK
1252  */
1253 HWTEST_F(RSPaintFilterCanvasTest, GetLocalClipBoundsTest, TestSize.Level1)
1254 {
1255     Drawing::Canvas canvas;
1256 
1257     Drawing::RectI* clipRects = nullptr;
1258     std::optional<Drawing::Rect> result = paintFilterCanvas_->GetLocalClipBounds(canvas, clipRects);
1259     EXPECT_FALSE(result.has_value());
1260 
1261     Drawing::RectI clipRect;
1262     Drawing::RectI* clipRectPtr = &clipRect;
1263     result = paintFilterCanvas_->GetLocalClipBounds(canvas, clipRectPtr);
1264     EXPECT_FALSE(result.has_value());
1265 
1266     Drawing::RectI rectI = { 0, SET_RIGHT, SET_TOP_BOTTOM, SET_TOP_BOTTOM };
1267     result = paintFilterCanvas_->GetLocalClipBounds(canvas, &rectI);
1268     EXPECT_TRUE(result.has_value());
1269 }
1270 
1271 /**
1272  * @tc.name: SetBlenderTest
1273  * @tc.desc: SetBlender
1274  * @tc.type:FUNC
1275  * @tc.require:issuesI9J2YE
1276  */
1277 HWTEST_F(RSPaintFilterCanvasTest, SetBlenderTest, TestSize.Level1)
1278 {
1279     std::shared_ptr<Drawing::Blender> blender = nullptr;
1280     auto mode = Drawing::BlendMode::SRC;
1281     blender = Drawing::Blender::CreateWithBlendMode(mode);
1282     EXPECT_TRUE(blender != nullptr);
1283     Drawing::Brush brush;
1284     brush.SetBlender(blender);
1285 }
1286 
1287 /**
1288  * @tc.name: DrawSdfTest001
1289  * @tc.desc: DrawSdf Test
1290  * @tc.type:FUNC
1291  * @tc.require: issueI9VT6E
1292  */
1293 HWTEST_F(RSPaintFilterCanvasTest, DrawSdfTest001, TestSize.Level1)
1294 {
1295     Drawing::Canvas canvas;
1296     std::shared_ptr<RSPaintFilterCanvas> paintFilterCanvasBase = std::make_shared<RSPaintFilterCanvas>(&canvas);
1297     EXPECT_NE(paintFilterCanvasBase, nullptr);
1298 
1299     SDFShapeBaseTest shape;
1300     Drawing::Canvas canvasTest;
1301     paintFilterCanvasBase->pCanvasList_.emplace_back(&canvasTest);
1302     paintFilterCanvasBase->alphaStack_.push(1.0f);
1303     paintFilterCanvasBase->DrawSdf(shape);
1304 }
1305 
1306 /**
1307  * @tc.name: DrawAtlasTest002
1308  * @tc.desc: DrawAtlas Test
1309  * @tc.type:FUNC
1310  * @tc.require: issueI9VT6E
1311  */
1312 HWTEST_F(RSPaintFilterCanvasTest, DrawAtlasTest002, TestSize.Level1)
1313 {
1314     Drawing::Canvas canvas;
1315     std::shared_ptr<RSPaintFilterCanvas> paintFilterCanvasBase = std::make_shared<RSPaintFilterCanvas>(&canvas);
1316     EXPECT_NE(paintFilterCanvasBase, nullptr);
1317 
1318     paintFilterCanvasBase->alphaStack_.push(1.0f);
1319     Drawing::Image atlas;
1320     Drawing::RSXform xform;
1321     xform.Make(0.0f, 0.0f, 1.0f, 1.0f);
1322     Drawing::Rect tex = { 0.0f, 0.0f, 1.0f, 1.0f };
1323     Drawing::SamplingOptions samplingOptions;
1324     Drawing::Rect cullRect = { 0.0f, 0.0f, 1.0f, 1.0f };
1325     Drawing::ColorQuad colors = 0;
1326     paintFilterCanvasBase->DrawAtlas(
1327         &atlas, &xform, &tex, &colors, 0, Drawing::BlendMode::CLEAR, samplingOptions, &cullRect);
1328 }
1329 
1330 /**
1331  * @tc.name: DrawBlurImageTest003
1332  * @tc.desc: DrawBlurImage Test
1333  * @tc.type:FUNC
1334  * @tc.require: issueI9VT6E
1335  */
1336 HWTEST_F(RSPaintFilterCanvasTest, DrawBlurImageTest003, TestSize.Level1)
1337 {
1338     Drawing::Canvas canvas;
1339     std::shared_ptr<PaintFilterCanvasBaseTest> paintFilterCanvasBase =
1340         std::make_shared<PaintFilterCanvasBaseTest>(&canvas);
1341     EXPECT_NE(paintFilterCanvasBase, nullptr);
1342 
1343     Drawing::Image image;
1344     Drawing::Rect s = { 0.0f, 0.0f, 1.0f, 1.0f };
1345     Drawing::Rect d = { 0.0f, 0.0f, 1.0f, 1.0f };
1346     Drawing::HpsBlurParameter blurParams = { s, d, 0.0f, 0.0f, 1.0f };
1347     paintFilterCanvasBase->DrawBlurImage(image, blurParams);
1348 }
1349 
1350 /**
1351  * @tc.name: AttachPenTest004
1352  * @tc.desc: AttachPen Test
1353  * @tc.type:FUNC
1354  * @tc.require: issueI9VT6E
1355  */
1356 HWTEST_F(RSPaintFilterCanvasTest, AttachPenTest004, TestSize.Level1)
1357 {
1358     Drawing::Canvas canvas;
1359     std::shared_ptr<RSPaintFilterCanvas> paintFilterCanvas = std::make_shared<RSPaintFilterCanvas>(&canvas);
1360     EXPECT_NE(paintFilterCanvas, nullptr);
1361 
1362     Drawing::Pen pen;
1363     Drawing::Canvas canvasTest;
1364     paintFilterCanvas->canvas_ = &canvasTest;
1365     paintFilterCanvas->isCapture_ = false;
1366     paintFilterCanvas->alphaStack_.push(1.0f);
1367     pen.brush_.color_ = 0x00000001;
1368     std::shared_ptr<RSPaintFilterCanvas::CachedEffectData> effectData = nullptr;
1369     std::shared_ptr<Drawing::Blender> blender = std::make_shared<Drawing::Blender>();
1370     RSPaintFilterCanvas::Env env = { RSColor(), nullptr, nullptr, blender, false };
1371     paintFilterCanvas->envStack_.push(env);
1372     paintFilterCanvas->AttachPen(pen);
1373 
1374     paintFilterCanvas->canvas_ = nullptr;
1375     paintFilterCanvas->AttachPen(pen);
1376 }
1377 
1378 /**
1379  * @tc.name: AttachBrushTest005
1380  * @tc.desc: AttachBrush Test
1381  * @tc.type:FUNC
1382  * @tc.require: issueI9VT6E
1383  */
1384 HWTEST_F(RSPaintFilterCanvasTest, AttachBrushTest005, TestSize.Level1)
1385 {
1386     Drawing::Canvas canvas;
1387     std::shared_ptr<RSPaintFilterCanvas> paintFilterCanvas = std::make_shared<RSPaintFilterCanvas>(&canvas);
1388     EXPECT_NE(paintFilterCanvas, nullptr);
1389 
1390     Drawing::Brush brush;
1391     Drawing::Canvas canvasTest;
1392     paintFilterCanvas->canvas_ = &canvasTest;
1393     paintFilterCanvas->isCapture_ = false;
1394     paintFilterCanvas->alphaStack_.push(1.0f);
1395     brush.color_ = 0x00000001;
1396     std::shared_ptr<RSPaintFilterCanvas::CachedEffectData> effectData = nullptr;
1397     std::shared_ptr<Drawing::Blender> blender = std::make_shared<Drawing::Blender>();
1398     RSPaintFilterCanvas::Env env = { RSColor(), nullptr, nullptr, blender, false };
1399     paintFilterCanvas->envStack_.push(env);
1400     paintFilterCanvas->AttachBrush(brush);
1401 
1402     paintFilterCanvas->canvas_ = nullptr;
1403     paintFilterCanvas->AttachBrush(brush);
1404 }
1405 
1406 /**
1407  * @tc.name: AttachPaintTest006
1408  * @tc.desc: AttachPaint Test
1409  * @tc.type:FUNC
1410  * @tc.require: issueI9VT6E
1411  */
1412 HWTEST_F(RSPaintFilterCanvasTest, AttachPaintTest006, TestSize.Level1)
1413 {
1414     Drawing::Canvas canvas;
1415     std::shared_ptr<RSPaintFilterCanvas> paintFilterCanvas = std::make_shared<RSPaintFilterCanvas>(&canvas);
1416     EXPECT_NE(paintFilterCanvas, nullptr);
1417 
1418     Drawing::Paint paint;
1419     Drawing::Canvas canvasTest;
1420     paintFilterCanvas->canvas_ = &canvasTest;
1421     paintFilterCanvas->isCapture_ = false;
1422     paintFilterCanvas->alphaStack_.push(1.0f);
1423     paint.color_ = 0x00000001;
1424     std::shared_ptr<RSPaintFilterCanvas::CachedEffectData> effectData = nullptr;
1425     std::shared_ptr<Drawing::Blender> blender = std::make_shared<Drawing::Blender>();
1426     RSPaintFilterCanvas::Env env = { RSColor(), nullptr, nullptr, blender, false };
1427     paintFilterCanvas->AttachPaint(paint);
1428 
1429     paintFilterCanvas->canvas_ = nullptr;
1430     paintFilterCanvas->AttachPaint(paint);
1431 }
1432 
1433 /**
1434  * @tc.name: AttachBrushAndAttachBrushTest007
1435  * @tc.desc: RSPaintFilterCanvasBase AttachBrush and AttachBrush Test
1436  * @tc.type:FUNC
1437  * @tc.require: issueI9VT6E
1438  */
1439 HWTEST_F(RSPaintFilterCanvasTest, AttachBrushAndAttachBrushTest007, TestSize.Level1)
1440 {
1441     Drawing::Canvas canvas;
1442     std::shared_ptr<PaintFilterCanvasBaseTest> paintFilterCanvasBase =
1443         std::make_shared<PaintFilterCanvasBaseTest>(&canvas);
1444     EXPECT_NE(paintFilterCanvasBase, nullptr);
1445     Drawing::Pen pen;
1446     paintFilterCanvasBase->AttachPen(pen);
1447     Drawing::Brush brush;
1448     paintFilterCanvasBase->AttachBrush(brush);
1449     Drawing::Paint paint;
1450     paintFilterCanvasBase->AttachPaint(paint);
1451 
1452     Drawing::SaveLayerOps saveLayerRec;
1453     paintFilterCanvasBase->canvas_ = nullptr;
1454     paintFilterCanvasBase->SaveLayer(saveLayerRec);
1455 
1456     Drawing::Canvas canvasTest;
1457     paintFilterCanvasBase->canvas_ = &canvasTest;
1458     paintFilterCanvasBase->SaveLayer(saveLayerRec);
1459     Drawing::Brush brushTest;
1460     saveLayerRec.brush_ = &brushTest;
1461     paintFilterCanvasBase->SaveLayer(saveLayerRec);
1462 }
1463 
1464 /**
1465  * @tc.name: BehindWindowDataTest
1466  * @tc.desc: SetBehindWindowData and GetBehindWindowData
1467  * @tc.type: FUNC
1468  * @tc.require: issueIB0UQV
1469  */
1470 HWTEST_F(RSPaintFilterCanvasTest, BehindWindowDataTest, TestSize.Level1)
1471 {
1472     RSPaintFilterCanvas::Env env;
1473     paintFilterCanvas_->envStack_.push(env);
1474     auto data = std::make_shared<RSPaintFilterCanvas::CachedEffectData>();
1475     data->cachedImage_ = std::make_shared<Drawing::Image>();
1476     paintFilterCanvas_->SetBehindWindowData(data);
1477     ASSERT_NE(paintFilterCanvas_->envStack_.top().behindWindowData_, nullptr);
1478     ASSERT_NE(paintFilterCanvas_->GetBehindWindowData(), nullptr);
1479     EXPECT_TRUE(EnvStackClear());
1480 }
1481 } // namespace Rosen
1482 } // namespace OHOS