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 #include "render/rs_filter.h"
20
21 using namespace testing;
22 using namespace testing::ext;
23
24 namespace OHOS {
25 namespace Rosen {
26 const float_t SET_ALPHA = 0.1f;
27 const float_t SET_XORY1 = 0.1f;
28 const float_t SET_XORY2 = 0.2f;
29 const float_t ANGLE_SWEEP_START = 1.0f;
30 const float_t SET_RADIUS = 1.0f;
31 const float_t SET_SCALAR = 1.0f;
32 const uint32_t NUMBER = 2;
33 const uint32_t SET_POINT_SIZE1 = 12;
34 const uint32_t SET_POINT_SIZE2 = 4;
35 const uint32_t SET_COLOR_QUAD_SIZE = 4;
36 const uint32_t SET_RIGHT = 10;
37 const uint32_t SET_TOP_BOTTOM = 80;
38 const uint32_t SCALAR_XORY = 255;
39 const uint32_t SET_COLOR = 0xFF000000;
40 const float_t SET_BRIGHTNESS_RATIO = 0.5f;
41 class RSPaintFilterCanvasTest : public testing::Test {
42 public:
43 static void SetUpTestCase();
44 static void TearDownTestCase();
45 void SetUp() override;
46 void TearDown() override;
47 static inline RSPaintFilterCanvas* paintFilterCanvas_;
48 static inline Drawing::Canvas drawingCanvas_;
49
AlphaStackClear()50 inline bool AlphaStackClear()
51 {
52 while (!paintFilterCanvas_->alphaStack_.empty()) {
53 paintFilterCanvas_->alphaStack_.pop();
54 }
55 return true;
56 }
EnvStackClear()57 inline bool EnvStackClear()
58 {
59 while (!paintFilterCanvas_->envStack_.empty()) {
60 paintFilterCanvas_->envStack_.pop();
61 }
62 return true;
63 }
64 };
65
SetUpTestCase()66 void RSPaintFilterCanvasTest::SetUpTestCase()
67 {
68 paintFilterCanvas_ = new RSPaintFilterCanvas(&drawingCanvas_);
69 }
TearDownTestCase()70 void RSPaintFilterCanvasTest::TearDownTestCase()
71 {
72 delete paintFilterCanvas_;
73 paintFilterCanvas_ = nullptr;
74 }
SetUp()75 void RSPaintFilterCanvasTest::SetUp() {}
TearDown()76 void RSPaintFilterCanvasTest::TearDown() {}
77
78 class SDFShapeBaseTest : public Drawing::SDFShapeBase {
79 public:
Getshader() const80 const std::string& Getshader() const override
81 {
82 return std::nullptr_t();
83 };
GetSize() const84 float GetSize() const override
85 {
86 return 0.0f;
87 };
SetSize(float size)88 void SetSize(float size) override
89 {
90 return;
91 };
SetTranslate(float dx,float dy)92 void SetTranslate(float dx, float dy) override
93 {
94 return;
95 };
GetTranslateX() const96 float GetTranslateX() const override
97 {
98 return 0.0f;
99 };
GetTranslateY() const100 float GetTranslateY() const override
101 {
102 return 0.0f;
103 };
SetBoundsRect(const Rosen::Drawing::Rect & rect)104 void SetBoundsRect(const Rosen::Drawing::Rect& rect) override
105 {
106 return;
107 };
GetBoundsRect() const108 Rosen::Drawing::Rect GetBoundsRect() const override
109 {
110 Rosen::Drawing::Rect temp;
111 return temp;
112 };
GetShapeId() const113 int GetShapeId() const override
114 {
115 return 0;
116 };
SetTransparent(int transparent)117 void SetTransparent(int transparent) override
118 {
119 return;
120 };
GetTransparent() const121 int GetTransparent() const override
122 {
123 return 0;
124 };
GetPaintPara() const125 std::vector<float> GetPaintPara() const override
126 {
127 return {};
128 };
GetPointAndColorPara() const129 std::vector<float> GetPointAndColorPara() const override
130 {
131 return {};
132 };
GetParaNum() const133 int GetParaNum() const override
134 {
135 return 0;
136 };
GetFillType() const137 int GetFillType() const override
138 {
139 return 0;
140 };
GetPara() const141 std::vector<float> GetPara() const override
142 {
143 return {};
144 };
GetTransPara() const145 std::vector<float> GetTransPara() const override
146 {
147 return {};
148 };
GetColorPara() const149 std::vector<float> GetColorPara() const override
150 {
151 return {};
152 };
153
UpdateTime(float time)154 void UpdateTime(float time) override
155 {
156 return;
157 };
BuildShader()158 void BuildShader() override
159 {
160 return;
161 };
SetColor(std::string fillColor,std::string strokeColor,float alpha)162 void SetColor(std::string fillColor, std::string strokeColor, float alpha)
163 {
164 return;
165 };
166 };
167
168 class PaintFilterCanvasBaseTest : public RSPaintFilterCanvasBase {
169 public:
PaintFilterCanvasBaseTest(Drawing::Canvas * canvas)170 explicit PaintFilterCanvasBaseTest(Drawing::Canvas* canvas) : RSPaintFilterCanvasBase(canvas) {};
OnFilter() const171 bool OnFilter() const override
172 {
173 return true;
174 };
OnFilterWithBrush(Drawing::Brush & brush) const175 bool OnFilterWithBrush(Drawing::Brush& brush) const override
176 {
177 return true;
178 };
GetFilteredBrush() const179 Drawing::Brush* GetFilteredBrush() const override
180 {
181 return nullptr;
182 };
183 };
184
185 /**
186 * @tc.name: SetHighContrastTest001
187 * @tc.desc: SetHighContrast Test
188 * @tc.type: FUNC
189 * @tc.require: issuesI9J2YE
190 */
191 HWTEST_F(RSPaintFilterCanvasTest, SetHighContrastTest001, TestSize.Level1)
192 {
193 bool mode = true;
194 paintFilterCanvas_->SetHighContrast(mode);
195 ASSERT_EQ(paintFilterCanvas_->isHighContrastEnabled(), mode);
196
197 mode = false;
198 paintFilterCanvas_->SetHighContrast(mode);
199 ASSERT_EQ(paintFilterCanvas_->isHighContrastEnabled(), mode);
200 }
201
202 /**
203 * @tc.name: RestoreAlphaTest001
204 * @tc.desc: RestoreAlpha Test
205 * @tc.type: FUNC
206 * @tc.require: issuesI9J2YE
207 */
208 HWTEST_F(RSPaintFilterCanvasTest, RestoreAlphaTest001, TestSize.Level1)
209 {
210 paintFilterCanvas_->RestoreAlpha();
211 ASSERT_EQ(paintFilterCanvas_->GetAlphaSaveCount(), 1);
212 }
213
214 /**
215 * @tc.name: RestoreAlphaToCountTest
216 * @tc.desc: RestoreAlphaToCount Test
217 * @tc.type: FUNC
218 * @tc.require:issuesI9J2YE
219 */
220 HWTEST_F(RSPaintFilterCanvasTest, RestoreAlphaToCountTest, TestSize.Level1)
221 {
222 int count = 0;
223 paintFilterCanvas_->RestoreAlphaToCount(count);
224 ASSERT_EQ(paintFilterCanvas_->GetAlphaSaveCount(), 1);
225 }
226
227 /**
228 * @tc.name: RestoreEnvTest
229 * @tc.desc: RestoreEnv Test
230 * @tc.type:FUNC
231 * @tc.require:issuesI9J2YE
232 */
233 HWTEST_F(RSPaintFilterCanvasTest, RestoreEnvTest, TestSize.Level1)
234 {
235 paintFilterCanvas_->RestoreEnv();
236 ASSERT_EQ(paintFilterCanvas_->GetAlphaSaveCount(), 1);
237 }
238
239 /**
240 * @tc.name: RestoreEnvToCountTest
241 * @tc.desc: RestoreEnvToCount Test
242 * @tc.type: FUNC
243 * @tc.require: issuesI9J2YE
244 */
245 HWTEST_F(RSPaintFilterCanvasTest, RestoreEnvToCountTest, TestSize.Level1)
246 {
247 int count = 0;
248 paintFilterCanvas_->RestoreEnvToCount(count);
249 ASSERT_EQ(paintFilterCanvas_->GetAlphaSaveCount(), 1);
250 }
251
252 /**
253 * @tc.name: SetEnvForegroundColorTest
254 * @tc.desc: SetEnvForegroundColor Test
255 * @tc.type: FUNC
256 * @tc.require: issuesI9J2YE
257 */
258 HWTEST_F(RSPaintFilterCanvasTest, SetEnvForegroundColorTest, TestSize.Level1)
259 {
260 Color color;
261 paintFilterCanvas_->SetEnvForegroundColor(color);
262 ASSERT_EQ(paintFilterCanvas_->GetEnvForegroundColor(), 0);
263 }
264
265 /**
266 * @tc.name: GetEnvForegroundColorTest
267 * @tc.desc: GetEnvForegroundColor Test
268 * @tc.type: FUNC
269 * @tc.require: issuesI9J2YE
270 */
271 HWTEST_F(RSPaintFilterCanvasTest, GetEnvForegroundColorTest, TestSize.Level1)
272 {
273 Color color { SET_COLOR };
274 Color setColor {};
275 paintFilterCanvas_->SetEnvForegroundColor(setColor);
276 ASSERT_EQ(paintFilterCanvas_->GetEnvForegroundColor(), 0);
277 }
278
279 /**
280 * @tc.name: onFilterTest
281 * @tc.desc: onFilter Test
282 * @tc.type: FUNC
283 * @tc.require: issuesI9J2YE
284 */
285 HWTEST_F(RSPaintFilterCanvasTest, onFilterTest, TestSize.Level1)
286 {
287 Drawing::Color color { 1 };
288 Drawing::Brush brush;
289 brush.SetColor(color);
290 ASSERT_TRUE(paintFilterCanvas_->OnFilterWithBrush(brush));
291 }
292
293 /**
294 * @tc.name: DrawPointTest
295 * @tc.desc: DrawPoint Test
296 * @tc.type: FUNC
297 * @tc.require: issuesI9J2YE
298 */
299 HWTEST_F(RSPaintFilterCanvasTest, DrawPointTest, TestSize.Level1)
300 {
301 Drawing::Point point;
302 paintFilterCanvas_->SetAlpha(SET_ALPHA);
303 paintFilterCanvas_->DrawPoint(point);
304 EXPECT_EQ(paintFilterCanvas_->GetAlpha(), SET_ALPHA);
305 }
306
307 /**
308 * @tc.name: DrawPointsTest
309 * @tc.desc: DrawPoints Test
310 * @tc.type: FUNC
311 * @tc.require: issuesI9J2YE
312 */
313 HWTEST_F(RSPaintFilterCanvasTest, DrawPointsTest, TestSize.Level1)
314 {
315 // fot test
316 Drawing::Point pts[] = { Drawing::Point(SET_XORY1, SET_XORY1), Drawing::Point(SET_XORY2, SET_XORY2) };
317 paintFilterCanvas_->DrawPoints(Drawing::PointMode::POINTS_POINTMODE, NUMBER, pts);
318 EXPECT_TRUE(paintFilterCanvas_);
319 }
320
321 /**
322 * @tc.name: DrawLineTest
323 * @tc.desc: DrawLine Test
324 * @tc.type: FUNC
325 * @tc.require: issuesI9J2YE
326 */
327 HWTEST_F(RSPaintFilterCanvasTest, DrawLineTest, TestSize.Level1)
328 {
329 // fot test
330 Drawing::Point startPt(SET_XORY1, SET_XORY1);
331 Drawing::Point endPt(SET_XORY2, SET_XORY2);
332 paintFilterCanvas_->DrawLine(startPt, endPt);
333 EXPECT_TRUE(paintFilterCanvas_);
334 }
335
336 /**
337 * @tc.name: DrawRectTest
338 * @tc.desc: DrawRect Test
339 * @tc.type: FUNC
340 * @tc.require: issuesI9J2YE
341 */
342 HWTEST_F(RSPaintFilterCanvasTest, DrawRectTest, TestSize.Level1)
343 {
344 Drawing::Rect rect;
345 paintFilterCanvas_->DrawRect(rect);
346 EXPECT_TRUE(paintFilterCanvas_);
347 }
348
349 /**
350 * @tc.name: DrawRoundRectTest
351 * @tc.desc: DrawRoundRect Test
352 * @tc.type: FUNC
353 * @tc.require: issuesI9J2YE
354 */
355 HWTEST_F(RSPaintFilterCanvasTest, DrawRoundRectTest, TestSize.Level1)
356 {
357 Drawing::RoundRect roundRect;
358 paintFilterCanvas_->DrawRoundRect(roundRect);
359 EXPECT_TRUE(paintFilterCanvas_);
360 }
361
362 /**
363 * @tc.name: DrawNestedRoundRectTest
364 * @tc.desc: DrawNestedRoundRect Test
365 * @tc.type: FUNC
366 * @tc.require: issuesI9J2YE
367 */
368 HWTEST_F(RSPaintFilterCanvasTest, DrawNestedRoundRectTest, TestSize.Level1)
369 {
370 Drawing::RoundRect outer;
371 Drawing::RoundRect inner;
372 paintFilterCanvas_->DrawNestedRoundRect(outer, inner);
373 EXPECT_TRUE(paintFilterCanvas_);
374 }
375
376 /**
377 * @tc.name: DrawArcTest
378 * @tc.desc: DrawArc Test
379 * @tc.type:FUNC
380 * @tc.require:issuesI9J2YE
381 */
382 HWTEST_F(RSPaintFilterCanvasTest, DrawArcTest, TestSize.Level1)
383 {
384 Drawing::Rect oval;
385 paintFilterCanvas_->DrawArc(oval, ANGLE_SWEEP_START, ANGLE_SWEEP_START);
386 EXPECT_TRUE(paintFilterCanvas_);
387 }
388
389 /**
390 * @tc.name: DrawPieTest
391 * @tc.desc: DrawPie Test
392 * @tc.type:FUNC
393 * @tc.require:issuesI9J2YE
394 */
395 HWTEST_F(RSPaintFilterCanvasTest, DrawPieTest, TestSize.Level1)
396 {
397 Drawing::Rect oval;
398 paintFilterCanvas_->DrawPie(oval, ANGLE_SWEEP_START, ANGLE_SWEEP_START);
399 EXPECT_TRUE(paintFilterCanvas_);
400 }
401
402 /**
403 * @tc.name: DrawOvalTest
404 * @tc.desc: DrawOval Test
405 * @tc.type:FUNC
406 * @tc.require:issuesI9J2YE
407 */
408 HWTEST_F(RSPaintFilterCanvasTest, DrawOvalTest, TestSize.Level1)
409 {
410 Drawing::Rect oval;
411 paintFilterCanvas_->DrawOval(oval);
412 EXPECT_TRUE(paintFilterCanvas_);
413 }
414
415 /**
416 * @tc.name: DrawCircleTest
417 * @tc.desc: DrawCircle Test
418 * @tc.type:FUNC
419 * @tc.require:issuesI9J2YE
420 */
421 HWTEST_F(RSPaintFilterCanvasTest, DrawCircleTest, TestSize.Level1)
422 {
423 Drawing::Point point;
424 paintFilterCanvas_->DrawCircle(point, SET_RADIUS);
425 EXPECT_TRUE(paintFilterCanvas_);
426 }
427
428 /**
429 * @tc.name: DrawPathTest
430 * @tc.desc: DrawPath Test
431 * @tc.type:FUNC
432 * @tc.require:issuesI9J2YE
433 */
434 HWTEST_F(RSPaintFilterCanvasTest, DrawPathTest, TestSize.Level1)
435 {
436 Drawing::Path path;
437 paintFilterCanvas_->DrawPath(path);
438 EXPECT_TRUE(paintFilterCanvas_);
439 }
440
441 /**
442 * @tc.name: DrawPathWithStencil
443 * @tc.desc: DrawPathWithStencil Test
444 * @tc.type:FUNC
445 * @tc.require:issuesIBROZ2
446 */
447 HWTEST_F(RSPaintFilterCanvasTest, DrawPathWithStencilTest, TestSize.Level1)
448 {
449 Drawing::Path path;
450 constexpr uint32_t stencilVal{10};
451 ASSERT_TRUE(paintFilterCanvas_ != nullptr);
452 paintFilterCanvas_->DrawPathWithStencil(path, stencilVal);
453 EXPECT_TRUE(paintFilterCanvas_->canvas_ != nullptr);
454 }
455
456 /**
457 * @tc.name: DrawBackgroundTest
458 * @tc.desc: DrawBackground Test
459 * @tc.type:FUNC
460 * @tc.require:issuesI9J2YE
461 */
462 HWTEST_F(RSPaintFilterCanvasTest, DrawBackgroundTest, TestSize.Level1)
463 {
464 Drawing::Brush brush;
465 paintFilterCanvas_->DrawBackground(brush);
466 EXPECT_TRUE(paintFilterCanvas_);
467 }
468
469 /**
470 * @tc.name: DrawShadowTest
471 * @tc.desc: DrawShadow Test
472 * @tc.type:FUNC
473 * @tc.require:issuesI9J2YE
474 */
475 HWTEST_F(RSPaintFilterCanvasTest, DrawShadowTest, TestSize.Level1)
476 {
477 Drawing::Path path;
478 Drawing::Point3 planeParams;
479 Drawing::Point3 devLightPos;
480 // for test
481 Drawing::Color ambientColor(0, 0, 0, 0);
482 Drawing::Color spotColor(SCALAR_XORY, 0, 0, 0);
483 paintFilterCanvas_->DrawShadow(
484 path, planeParams, devLightPos, 0.0f, ambientColor, spotColor, Drawing::ShadowFlags::NONE);
485 EXPECT_TRUE(paintFilterCanvas_);
486 }
487
488 /**
489 * @tc.name: DrawShadowStyleTest
490 * @tc.desc: DrawShadowStyle Test
491 * @tc.type:FUNC
492 * @tc.require:issuesI9J2YE
493 */
494 HWTEST_F(RSPaintFilterCanvasTest, DrawShadowStyleTest, TestSize.Level1)
495 {
496 Drawing::Path path;
497 Drawing::Point3 planeParams;
498 Drawing::Point3 devLightPos;
499 // for test
500 Drawing::Color ambientColor(0, 0, 0, 0);
501 Drawing::Color spotColor(SCALAR_XORY, 0, 0, 0);
502 paintFilterCanvas_->DrawShadowStyle(
503 path, planeParams, devLightPos, 0.0f, ambientColor, spotColor, Drawing::ShadowFlags::NONE, true);
504 EXPECT_TRUE(paintFilterCanvas_);
505 }
506
507 /**
508 * @tc.name: DrawColorTest
509 * @tc.desc: DrawColor Test
510 * @tc.type:FUNC
511 * @tc.require:issuesI9J2YE
512 */
513 HWTEST_F(RSPaintFilterCanvasTest, DrawColorTest, TestSize.Level1)
514 {
515 paintFilterCanvas_->DrawColor(1, Drawing::BlendMode::CLEAR);
516 EXPECT_TRUE(paintFilterCanvas_);
517 }
518
519 /**
520 * @tc.name: DrawRegionTest
521 * @tc.desc: DrawRegion Test
522 * @tc.type:FUNC
523 * @tc.require:issuesI9J2YE
524 */
525 HWTEST_F(RSPaintFilterCanvasTest, DrawRegionTest, TestSize.Level1)
526 {
527 Drawing::Region region;
528 paintFilterCanvas_->DrawRegion(region);
529 EXPECT_TRUE(paintFilterCanvas_);
530 }
531
532 /**
533 * @tc.name: DrawPatchTest
534 * @tc.desc: DrawPatch Test
535 * @tc.type:FUNC
536 * @tc.require:issuesI9J2YE
537 */
538 HWTEST_F(RSPaintFilterCanvasTest, DrawPatchTest, TestSize.Level1)
539 {
540 // for test
541 Drawing::Point cubics[SET_POINT_SIZE1];
542 Drawing::ColorQuad colors[SET_COLOR_QUAD_SIZE];
543 Drawing::Point texCoords[SET_POINT_SIZE2];
544 paintFilterCanvas_->DrawPatch(cubics, colors, texCoords, Drawing::BlendMode::CLEAR);
545 EXPECT_TRUE(paintFilterCanvas_);
546 }
547
548 /**
549 * @tc.name: DrawVerticesTest
550 * @tc.desc: DrawVertices Test
551 * @tc.type:FUNC
552 * @tc.require:issuesI9J2YE
553 */
554 HWTEST_F(RSPaintFilterCanvasTest, DrawVerticesTest, TestSize.Level1)
555 {
556 Drawing::Vertices vertices;
557 paintFilterCanvas_->DrawVertices(vertices, Drawing::BlendMode::CLEAR);
558 EXPECT_TRUE(paintFilterCanvas_);
559 }
560
561 /**
562 * @tc.name: OpCalculateBeforeTest
563 * @tc.desc: OpCalculateBefore Test
564 * @tc.type:FUNC
565 * @tc.require:issuesI9J2YE
566 */
567 HWTEST_F(RSPaintFilterCanvasTest, OpCalculateBeforeTest, TestSize.Level1)
568 {
569 Drawing::Matrix matrix;
570 paintFilterCanvas_->SetAlpha(SET_ALPHA);
571 EXPECT_TRUE(paintFilterCanvas_->OpCalculateBefore(matrix));
572 }
573
574 /**
575 * @tc.name: OpCalculateAfterTest
576 * @tc.desc: OpCalculateAfter Test
577 * @tc.type:FUNC
578 * @tc.require:issuesI9J2YE
579 */
580 HWTEST_F(RSPaintFilterCanvasTest, OpCalculateAfterTest, TestSize.Level1)
581 {
582 Drawing::Rect bound;
583 EXPECT_FALSE(paintFilterCanvas_->OpCalculateAfter(bound));
584 paintFilterCanvas_->SetAlpha(0.0f);
585 EXPECT_FALSE(paintFilterCanvas_->OpCalculateAfter(bound));
586 }
587
588 /**
589 * @tc.name: DrawBitmapTest
590 * @tc.desc: DrawBitmap Test
591 * @tc.type:FUNC
592 * @tc.require:issuesI9J2YE
593 */
594 HWTEST_F(RSPaintFilterCanvasTest, DrawBitmapTest, TestSize.Level1)
595 {
596 Drawing::Bitmap bitmap;
597 paintFilterCanvas_->DrawBitmap(bitmap, SET_XORY1, SET_XORY1);
598 paintFilterCanvas_->SetAlpha(SET_ALPHA);
599 paintFilterCanvas_->DrawBitmap(bitmap, SET_XORY1, SET_XORY1);
600 EXPECT_TRUE(paintFilterCanvas_);
601 }
602
603 /**
604 * @tc.name: DrawImageNineTest
605 * @tc.desc: DrawImageNine Test
606 * @tc.type:FUNC
607 * @tc.require:issuesI9J2YE
608 */
609 HWTEST_F(RSPaintFilterCanvasTest, DrawImageNineTest, TestSize.Level1)
610 {
611 Drawing::Image image;
612 Drawing::RectI center;
613 Drawing::Rect dst;
614 Drawing::Brush brush;
615 paintFilterCanvas_->SetAlpha(SET_ALPHA);
616 paintFilterCanvas_->DrawImageNine(&image, center, dst, Drawing::FilterMode::LINEAR, &brush);
617 EXPECT_TRUE(paintFilterCanvas_);
618 }
619
620 /**
621 * @tc.name: DrawImageNineTest002
622 * @tc.desc: DrawImageNine Test
623 * @tc.type:FUNC
624 * @tc.require:issueI9VT6E
625 */
626 HWTEST_F(RSPaintFilterCanvasTest, DrawImageNineTest002, TestSize.Level1)
627 {
628 Drawing::Image image;
629 Drawing::RectI center;
630 Drawing::Rect dst;
631 Drawing::Brush* brush = nullptr;
632 Drawing::Canvas canvas;
633 std::shared_ptr<RSPaintFilterCanvas> paintFilterCanvas = std::make_shared<RSPaintFilterCanvas>(&canvas);
634 EXPECT_NE(paintFilterCanvas, nullptr);
635 paintFilterCanvas->alphaStack_.push(1.0f);
636 paintFilterCanvas->DrawImageNine(&image, center, dst, Drawing::FilterMode::LINEAR, brush);
637 }
638
639 /**
640 * @tc.name: DrawImageLatticeTest
641 * @tc.desc: DrawImageLattice Test
642 * @tc.type:FUNC
643 * @tc.require:issuesI9J2YE
644 */
645 HWTEST_F(RSPaintFilterCanvasTest, DrawImageLatticeTest, TestSize.Level1)
646 {
647 Drawing::Image image;
648 Drawing::Lattice lattice;
649 Drawing::Rect dst;
650 paintFilterCanvas_->DrawImageLattice(&image, lattice, dst, Drawing::FilterMode::LINEAR);
651 EXPECT_TRUE(paintFilterCanvas_);
652 }
653
654 /**
655 * @tc.name: DrawImageLatticeTest
656 * @tc.desc: DrawImageLattice Test
657 * @tc.type:FUNC
658 * @tc.require:issueI9VT6E
659 */
660 HWTEST_F(RSPaintFilterCanvasTest, DrawImageLatticeTest002, TestSize.Level1)
661 {
662 Drawing::Image image;
663 Drawing::Lattice lattice;
664 Drawing::Rect dst;
665 Drawing::Canvas canvas;
666 std::shared_ptr<RSPaintFilterCanvas> paintFilterCanvas = std::make_shared<RSPaintFilterCanvas>(&canvas);
667 EXPECT_NE(paintFilterCanvas, nullptr);
668 paintFilterCanvas->alphaStack_.push(1.0f);
669 paintFilterCanvas->DrawImageLattice(&image, lattice, dst, Drawing::FilterMode::LINEAR);
670 }
671
672 /**
673 * @tc.name: DrawImageTest
674 * @tc.desc: DrawImage Test
675 * @tc.type:FUNC
676 * @tc.require:issuesI9J2YE
677 */
678 HWTEST_F(RSPaintFilterCanvasTest, DrawImageTest, TestSize.Level1)
679 {
680 Drawing::Image image;
681 Drawing::SamplingOptions sampling;
682 paintFilterCanvas_->DrawImage(image, SET_XORY1, SET_XORY1, sampling);
683 EXPECT_TRUE(paintFilterCanvas_);
684 }
685
686 /**
687 * @tc.name: DrawImageWithStencilTest
688 * @tc.desc: DrawImageWithStencil Test
689 * @tc.type:FUNC
690 * @tc.require:issuesIBROZ2
691 */
692 HWTEST_F(RSPaintFilterCanvasTest, DrawImageWithStencilTest, TestSize.Level1)
693 {
694 Drawing::Image image;
695 Drawing::SamplingOptions sampling;
696 constexpr uint32_t stencilVal{10};
697 ASSERT_TRUE(paintFilterCanvas_ != nullptr);
698 paintFilterCanvas_->DrawImageWithStencil(image, SET_XORY1, SET_XORY1, sampling, stencilVal);
699 EXPECT_TRUE(paintFilterCanvas_->canvas_ != nullptr);
700 }
701
702 /**
703 * @tc.name: DrawImageRectTest001
704 * @tc.desc: DrawImageRect Test
705 * @tc.type:FUNC
706 * @tc.require:issuesI9J2YE
707 */
708 HWTEST_F(RSPaintFilterCanvasTest, DrawImageRectTest001, TestSize.Level1)
709 {
710 Drawing::Image image;
711 Drawing::Rect src;
712 Drawing::Rect dst;
713 Drawing::SamplingOptions sampling;
714 paintFilterCanvas_->DrawImageRect(image, src, dst, sampling, Drawing::SrcRectConstraint::FAST_SRC_RECT_CONSTRAINT);
715 EXPECT_TRUE(paintFilterCanvas_);
716 }
717
718 /**
719 * @tc.name: DrawImageRectTest002
720 * @tc.desc: DrawImageRect Test
721 * @tc.type:FUNC
722 * @tc.require:issuesI9J2YE
723 */
724 HWTEST_F(RSPaintFilterCanvasTest, DrawImageRectTest002, TestSize.Level1)
725 {
726 Drawing::Image image;
727 Drawing::Rect dst;
728 Drawing::SamplingOptions sampling;
729 paintFilterCanvas_->DrawImageRect(image, dst, sampling);
730 EXPECT_TRUE(paintFilterCanvas_);
731 }
732
733 /**
734 * @tc.name: DrawPictureTest
735 * @tc.desc: DrawPicture Test
736 * @tc.type:FUNC
737 * @tc.require:issuesI9J2YE
738 */
739 HWTEST_F(RSPaintFilterCanvasTest, DrawPictureTest, TestSize.Level1)
740 {
741 Drawing::Picture picture;
742 paintFilterCanvas_->DrawPicture(picture);
743 EXPECT_TRUE(paintFilterCanvas_);
744 }
745
746 /**
747 * @tc.name: DrawTextBlobTest
748 * @tc.desc: DrawTextBlob Test
749 * @tc.type:FUNC
750 * @tc.require:issuesI9J2YE
751 */
752 HWTEST_F(RSPaintFilterCanvasTest, DrawTextBlobTest, TestSize.Level1)
753 {
754 // for tset
755 const char* text = "text";
756 Drawing::Font font;
757 auto blob = Drawing::TextBlob::MakeFromString(text, font);
758 paintFilterCanvas_->DrawTextBlob(blob.get(), SET_XORY1, SET_XORY1);
759 EXPECT_TRUE(paintFilterCanvas_);
760 }
761
762 /**
763 * @tc.name: ClipRectTest
764 * @tc.desc: ClipRect Test
765 * @tc.type:FUNC
766 * @tc.require:issuesI9J2YE
767 */
768 HWTEST_F(RSPaintFilterCanvasTest, ClipRectTest, TestSize.Level1)
769 {
770 Drawing::Rect rect;
771 paintFilterCanvas_->ClipRect(rect, Drawing::ClipOp::DIFFERENCE, true);
772 EXPECT_TRUE(paintFilterCanvas_);
773 }
774
775 /**
776 * @tc.name: ClearStencilTest
777 * @tc.desc: ClearStencil Test
778 * @tc.type:FUNC
779 * @tc.require:issuesIBROZ2
780 */
781 HWTEST_F(RSPaintFilterCanvasTest, ClearStencilTest, TestSize.Level1)
782 {
783 Drawing::RectI rect;
784 constexpr uint32_t stencilVal{10};
785 ASSERT_TRUE(paintFilterCanvas_ != nullptr);
786 paintFilterCanvas_->ClearStencil(rect, stencilVal);
787 EXPECT_TRUE(paintFilterCanvas_->canvas_ != nullptr);
788 }
789
790 /**
791 * @tc.name: ClipIRectTest
792 * @tc.desc: ClipIRect Test
793 * @tc.type:FUNC
794 * @tc.require:issuesI9J2YE
795 */
796 HWTEST_F(RSPaintFilterCanvasTest, ClipIRectTest, TestSize.Level1)
797 {
798 Drawing::RectI rect;
799 paintFilterCanvas_->ClipIRect(rect, Drawing::ClipOp::DIFFERENCE);
800 EXPECT_TRUE(paintFilterCanvas_);
801 }
802
803 /**
804 * @tc.name: ClipRoundRectTest001
805 * @tc.desc: ClipRoundRect Test
806 * @tc.type:FUNC
807 * @tc.require:issuesI9J2YE
808 */
809 HWTEST_F(RSPaintFilterCanvasTest, ClipRoundRectTest001, TestSize.Level1)
810 {
811 Drawing::RoundRect roundRect;
812 paintFilterCanvas_->ClipRoundRect(roundRect, Drawing::ClipOp::DIFFERENCE, true);
813 EXPECT_TRUE(paintFilterCanvas_);
814 }
815
816 /**
817 * @tc.name: ClipRoundRectTest002
818 * @tc.desc: ClipRoundRect Test
819 * @tc.type:FUNC
820 * @tc.require:issuesI9J2YE
821 */
822 HWTEST_F(RSPaintFilterCanvasTest, ClipRoundRectTest002, TestSize.Level1)
823 {
824 Drawing::Rect rect;
825 std::vector<Drawing::Point> pts;
826 paintFilterCanvas_->ClipRoundRect(rect, pts, true);
827 EXPECT_TRUE(paintFilterCanvas_);
828 }
829
830 /**
831 * @tc.name: ClipPathTest
832 * @tc.desc: ClipPath Test
833 * @tc.type:FUNC
834 * @tc.require:issuesI9J2YE
835 */
836 HWTEST_F(RSPaintFilterCanvasTest, ClipPathTest, TestSize.Level1)
837 {
838 Drawing::Path path;
839 paintFilterCanvas_->ClipPath(path, Drawing::ClipOp::DIFFERENCE, true);
840 EXPECT_TRUE(paintFilterCanvas_);
841 }
842
843 /**
844 * @tc.name: ClipRegionTest
845 * @tc.desc: ClipRegion Test
846 * @tc.type:FUNC
847 * @tc.require:issuesI9J2YE
848 */
849 HWTEST_F(RSPaintFilterCanvasTest, ClipRegionTest, TestSize.Level1)
850 {
851 Drawing::Region region;
852 paintFilterCanvas_->ClipRegion(region, Drawing::ClipOp::DIFFERENCE);
853 EXPECT_TRUE(paintFilterCanvas_);
854 }
855
856 /**
857 * @tc.name: SetMatrixTest
858 * @tc.desc: SetMatrix Test
859 * @tc.type:FUNC
860 * @tc.require:issuesI9J2YE
861 */
862 HWTEST_F(RSPaintFilterCanvasTest, SetMatrixTest, TestSize.Level1)
863 {
864 Drawing::Matrix matrix;
865 paintFilterCanvas_->SetMatrix(matrix);
866 EXPECT_TRUE(paintFilterCanvas_);
867 }
868
869 /**
870 * @tc.name: ResetMatrixTest
871 * @tc.desc: ResetMatrix Test
872 * @tc.type:FUNC
873 * @tc.require:issuesI9J2YE
874 */
875 HWTEST_F(RSPaintFilterCanvasTest, ResetMatrixTest, TestSize.Level1)
876 {
877 paintFilterCanvas_->ResetMatrix();
878 EXPECT_TRUE(paintFilterCanvas_);
879 }
880
881 /**
882 * @tc.name: ConcatMatrixTest
883 * @tc.desc: ConcatMatrix Test
884 * @tc.type:FUNC
885 * @tc.require:issuesI9J2YE
886 */
887 HWTEST_F(RSPaintFilterCanvasTest, ConcatMatrixTest, TestSize.Level1)
888 {
889 Drawing::Matrix matrix;
890 paintFilterCanvas_->ConcatMatrix(matrix);
891 EXPECT_TRUE(paintFilterCanvas_);
892 }
893
894 /**
895 * @tc.name: TranslateTest
896 * @tc.desc: Verify function Translate
897 * @tc.type:FUNC
898 * @tc.require:issuesI9J2YE
899 */
900 HWTEST_F(RSPaintFilterCanvasTest, TranslateTest, TestSize.Level1)
901 {
902 paintFilterCanvas_->Translate(SET_XORY1, SET_XORY1);
903 EXPECT_TRUE(paintFilterCanvas_);
904 }
905
906 /**
907 * @tc.name: ScaleTest
908 * @tc.desc: Scale Test
909 * @tc.type:FUNC
910 * @tc.require:issuesI9J2YE
911 */
912 HWTEST_F(RSPaintFilterCanvasTest, ScaleTest, TestSize.Level1)
913 {
914 paintFilterCanvas_->Scale(SET_XORY1, SET_XORY1);
915 EXPECT_TRUE(paintFilterCanvas_);
916 }
917
918 /**
919 * @tc.name: RotateTest
920 * @tc.desc: Rotate Test
921 * @tc.type:FUNC
922 * @tc.require:issuesI9J2YE
923 */
924 HWTEST_F(RSPaintFilterCanvasTest, RotateTest, TestSize.Level1)
925 {
926 paintFilterCanvas_->Rotate(SET_SCALAR, SET_XORY1, SET_XORY1);
927 EXPECT_TRUE(paintFilterCanvas_);
928 }
929
930 /**
931 * @tc.name: ShearTest
932 * @tc.desc: Shear Test
933 * @tc.type:FUNC
934 * @tc.require:issuesI9J2YE
935 */
936 HWTEST_F(RSPaintFilterCanvasTest, ShearTest, TestSize.Level1)
937 {
938 paintFilterCanvas_->Shear(SET_XORY1, SET_XORY1);
939 EXPECT_TRUE(paintFilterCanvas_);
940 }
941
942 /**
943 * @tc.name: FlushTest
944 * @tc.desc: Flush Test
945 * @tc.type:FUNC
946 * @tc.require:issuesI9J2YE
947 */
948 HWTEST_F(RSPaintFilterCanvasTest, FlushTest, TestSize.Level1)
949 {
950 paintFilterCanvas_->Flush();
951 EXPECT_TRUE(paintFilterCanvas_);
952 }
953
954 /**
955 * @tc.name: ClearTest
956 * @tc.desc: Clear Test
957 * @tc.type:FUNC
958 * @tc.require:issuesI9J2YE
959 */
960 HWTEST_F(RSPaintFilterCanvasTest, ClearTest, TestSize.Level1)
961 {
962 paintFilterCanvas_->Clear(1);
963 EXPECT_TRUE(paintFilterCanvas_);
964 }
965
966 /**
967 * @tc.name: SaveTest
968 * @tc.desc: Save Test
969 * @tc.type:FUNC
970 * @tc.require:issuesI9J2YE
971 */
972 HWTEST_F(RSPaintFilterCanvasTest, SaveTest, TestSize.Level1)
973 {
974 EXPECT_EQ(paintFilterCanvas_->Save(), 1);
975 paintFilterCanvas_->canvas_ = nullptr;
976 EXPECT_EQ(paintFilterCanvas_->Save(), 0);
977 }
978
979 /**
980 * @tc.name: OnMultipleScreenTest
981 * @tc.desc: OnMultipleScreen Test
982 * @tc.type:FUNC
983 * @tc.require:issuesI9J2YE
984 */
985 HWTEST_F(RSPaintFilterCanvasTest, OnMultipleScreenTest, TestSize.Level1)
986 {
987 ASSERT_NE(paintFilterCanvas_, nullptr);
988 paintFilterCanvas_->SetOnMultipleScreen(true);
989 EXPECT_EQ(paintFilterCanvas_->IsOnMultipleScreen(), true);
990 paintFilterCanvas_->SetOnMultipleScreen(false);
991 EXPECT_EQ(paintFilterCanvas_->IsOnMultipleScreen(), false);
992 }
993
994 /**
995 * @tc.name: SaveLayerTest
996 * @tc.desc: SaveLayer Test
997 * @tc.type:FUNC
998 * @tc.require:issuesI9J2YE
999 */
1000 HWTEST_F(RSPaintFilterCanvasTest, SaveLayerTest, TestSize.Level1)
1001 {
1002 Drawing::SaveLayerOps saveLayerRec;
1003 paintFilterCanvas_->SaveLayer(saveLayerRec);
1004 paintFilterCanvas_->canvas_ = &drawingCanvas_;
1005 paintFilterCanvas_->SaveLayer(saveLayerRec);
1006 Drawing::Brush brush;
1007 saveLayerRec.brush_ = &brush;
1008 paintFilterCanvas_->SaveLayer(saveLayerRec);
1009 EXPECT_TRUE(paintFilterCanvas_);
1010 }
1011
1012 /**
1013 * @tc.name: RestoreTest
1014 * @tc.desc: Restore Test
1015 * @tc.type:FUNC
1016 * @tc.require:issuesI9J2YE
1017 */
1018 HWTEST_F(RSPaintFilterCanvasTest, RestoreTest, TestSize.Level1)
1019 {
1020 paintFilterCanvas_->Restore();
1021 EXPECT_TRUE(paintFilterCanvas_);
1022 }
1023
1024 /**
1025 * @tc.name: DiscardTest
1026 * @tc.desc: Discard Test
1027 * @tc.type:FUNC
1028 * @tc.require:issuesI9J2YE
1029 */
1030 HWTEST_F(RSPaintFilterCanvasTest, DiscardTest, TestSize.Level1)
1031 {
1032 paintFilterCanvas_->Discard();
1033 EXPECT_TRUE(paintFilterCanvas_);
1034 }
1035
1036 /**
1037 * @tc.name: AttachPenTest001
1038 * @tc.desc: AttachPen Test
1039 * @tc.type:FUNC
1040 * @tc.require:issuesI9J2YE
1041 */
1042 HWTEST_F(RSPaintFilterCanvasTest, AttachPenTest001, TestSize.Level1)
1043 {
1044 Drawing::Pen pen;
1045 EXPECT_TRUE(paintFilterCanvas_->AttachPen(pen).impl_);
1046 }
1047
1048 /**
1049 * @tc.name: AttachBrushTest
1050 * @tc.desc: AttachBrush Test
1051 * @tc.type:FUNC
1052 * @tc.require:issuesI9J2YE
1053 */
1054 HWTEST_F(RSPaintFilterCanvasTest, AttachBrushTest, TestSize.Level1)
1055 {
1056 Drawing::Brush brush;
1057 EXPECT_TRUE(paintFilterCanvas_->AttachBrush(brush).impl_);
1058 }
1059
1060 /**
1061 * @tc.name: AttachPaintTest
1062 * @tc.desc: AttachPaint Test
1063 * @tc.type:FUNC
1064 * @tc.require:issuesI9J2YE
1065 */
1066 HWTEST_F(RSPaintFilterCanvasTest, AttachPaintTest, TestSize.Level1)
1067 {
1068 Drawing::Paint paint;
1069 EXPECT_TRUE(paintFilterCanvas_->AttachPaint(paint).impl_);
1070 }
1071
1072 /**
1073 * @tc.name: DetachPenTest
1074 * @tc.desc: DetachPen Test
1075 * @tc.type:FUNC
1076 * @tc.require:issuesI9J2YE
1077 */
1078 HWTEST_F(RSPaintFilterCanvasTest, DetachPenTest, TestSize.Level1)
1079 {
1080 EXPECT_TRUE(paintFilterCanvas_->DetachPen().impl_);
1081 }
1082
1083 /**
1084 * @tc.name: DetachBrushTest
1085 * @tc.desc: DetachBrush Test
1086 * @tc.type:FUNC
1087 * @tc.require:issuesI9J2YE
1088 */
1089 HWTEST_F(RSPaintFilterCanvasTest, DetachBrushTest, TestSize.Level1)
1090 {
1091 EXPECT_TRUE(paintFilterCanvas_->DetachBrush().impl_);
1092 }
1093
1094 /**
1095 * @tc.name: DetachPaintTest
1096 * @tc.desc: DetachPaint Test
1097 * @tc.type:FUNC
1098 * @tc.require:issuesI9J2YE
1099 */
1100 HWTEST_F(RSPaintFilterCanvasTest, DetachPaintTest, TestSize.Level1)
1101 {
1102 EXPECT_TRUE(paintFilterCanvas_->DetachPaint().impl_);
1103 }
1104
1105 /**
1106 * @tc.name: AttachPenTest002
1107 * @tc.desc: AttachPen Test
1108 * @tc.type:FUNC
1109 * @tc.require:issuesI9J2YE
1110 */
1111 HWTEST_F(RSPaintFilterCanvasTest, AttachPenTest002, TestSize.Level1)
1112 {
1113 Drawing::Pen pen;
1114
1115 paintFilterCanvas_->canvas_ = nullptr;
1116 EXPECT_TRUE(paintFilterCanvas_->AttachPen(pen).impl_);
1117
1118 paintFilterCanvas_->canvas_ = &drawingCanvas_;
1119 pen.SetColor(1);
1120
1121 paintFilterCanvas_->SetAlpha(SET_ALPHA);
1122 paintFilterCanvas_->SetBlendMode(1);
1123 EXPECT_TRUE(paintFilterCanvas_->AttachPen(pen).impl_);
1124 }
1125
1126 /**
1127 * @tc.name: AttachBrushTest001
1128 * @tc.desc: AttachBrush Test
1129 * @tc.type:FUNC
1130 * @tc.require:issuesI9J2YE
1131 */
1132 HWTEST_F(RSPaintFilterCanvasTest, AttachBrushTest001, TestSize.Level1)
1133 {
1134 Drawing::Brush brush;
1135 paintFilterCanvas_->canvas_ = nullptr;
1136 EXPECT_TRUE(paintFilterCanvas_->AttachBrush(brush).impl_);
1137
1138 paintFilterCanvas_->canvas_ = &drawingCanvas_;
1139 brush.SetColor(1);
1140
1141 paintFilterCanvas_->SetAlpha(SET_ALPHA);
1142 paintFilterCanvas_->SetBlendMode(1);
1143 EXPECT_TRUE(paintFilterCanvas_->AttachBrush(brush).impl_);
1144 }
1145
1146 /**
1147 * @tc.name: AttachPaintTest001
1148 * @tc.desc: AttachPaint Test
1149 * @tc.type:FUNC
1150 * @tc.require:issuesI9J2YE
1151 */
1152 HWTEST_F(RSPaintFilterCanvasTest, AttachPaintTest001, TestSize.Level1)
1153 {
1154 Drawing::Paint paint;
1155 paintFilterCanvas_->canvas_ = nullptr;
1156 EXPECT_TRUE(paintFilterCanvas_->AttachPaint(paint).impl_);
1157
1158 paintFilterCanvas_->canvas_ = &drawingCanvas_;
1159 paint.SetColor(1);
1160
1161 paintFilterCanvas_->SetAlpha(SET_ALPHA);
1162 paintFilterCanvas_->SetBlendMode(1);
1163 EXPECT_TRUE(paintFilterCanvas_->AttachPaint(paint).impl_);
1164
1165 paint.SetBlenderEnabled(false);
1166 paintFilterCanvas_->SetAlpha(SET_ALPHA);
1167 paintFilterCanvas_->SetBlendMode(1);
1168 EXPECT_TRUE(paintFilterCanvas_->AttachPaint(paint).impl_);
1169
1170 EXPECT_TRUE(paintFilterCanvas_->AttachPaint(paint).impl_);
1171
1172 paintFilterCanvas_->alphaStack_.pop();
1173 paintFilterCanvas_->alphaStack_.push(1.f);
1174 EXPECT_TRUE(paintFilterCanvas_->AttachPaint(paint).impl_);
1175 }
1176
1177 /**
1178 * @tc.name: AlphaStackToPushOrOutbackTest
1179 * @tc.desc: AlphaStackToPushOrOutback Test
1180 * @tc.type:FUNC
1181 * @tc.require:issueI9L0ZK
1182 */
1183 HWTEST_F(RSPaintFilterCanvasTest, AlphaStackToPushOrOutbackTest, TestSize.Level1)
1184 {
1185 // Ensure that the stack is empty before testing
1186 EXPECT_TRUE(AlphaStackClear());
1187 // RestoreAlpha Test
1188 paintFilterCanvas_->RestoreAlpha();
1189 paintFilterCanvas_->alphaStack_.push(SET_ALPHA);
1190 EXPECT_EQ(paintFilterCanvas_->SaveAlpha(), 1);
1191 EXPECT_EQ(paintFilterCanvas_->GetAlphaSaveCount(), NUMBER);
1192 paintFilterCanvas_->RestoreAlpha();
1193 EXPECT_EQ(paintFilterCanvas_->GetAlphaSaveCount(), 1);
1194
1195 // RestoreAlphaToCount Test
1196 EXPECT_EQ(paintFilterCanvas_->SaveAlpha(), 1);
1197 paintFilterCanvas_->RestoreAlphaToCount(0);
1198 EXPECT_EQ(paintFilterCanvas_->GetAlphaSaveCount(), 1);
1199
1200 // Ensure that the stack is empty after testing
1201 EXPECT_TRUE(AlphaStackClear());
1202 }
1203
1204 /**
1205 * @tc.name: EnvStackToPushOrOutbackTest
1206 * @tc.desc: EnvStackToPushOrOutback Test
1207 * @tc.type:FUNC
1208 * @tc.require:issueI9L0ZK
1209 */
1210 HWTEST_F(RSPaintFilterCanvasTest, EnvStackToPushOrOutbackTest, TestSize.Level1)
1211 {
1212 // Ensure that the stack is empty before testing
1213 EXPECT_TRUE(EnvStackClear());
1214
1215 Rosen::RSColor rsColor;
1216 RSPaintFilterCanvas::Env env;
1217
1218 // envStack_ is empty
1219 EXPECT_EQ(paintFilterCanvas_->GetEnvForegroundColor(), Drawing::Color::COLOR_BLACK);
1220 paintFilterCanvas_->SetEnvForegroundColor(rsColor);
1221 paintFilterCanvas_->RestoreEnv();
1222
1223 // envStack_ is not empty
1224 paintFilterCanvas_->envStack_.push(env);
1225 auto asArgbInt = paintFilterCanvas_->envStack_.top().envForegroundColor_.AsArgbInt();
1226 EXPECT_EQ(paintFilterCanvas_->GetEnvForegroundColor(), asArgbInt);
1227 paintFilterCanvas_->SetBlendMode(0);
1228 paintFilterCanvas_->SetEnvForegroundColor(rsColor);
1229 EXPECT_EQ(paintFilterCanvas_->GetEnvSaveCount(), 1);
1230 EXPECT_EQ(paintFilterCanvas_->SaveEnv(), 1);
1231
1232 // envStack_ Outback
1233 paintFilterCanvas_->RestoreEnv();
1234 EXPECT_EQ(paintFilterCanvas_->GetEnvSaveCount(), 1);
1235 EXPECT_EQ(paintFilterCanvas_->SaveEnv(), 1);
1236 paintFilterCanvas_->RestoreEnvToCount(0);
1237
1238 // Ensure that the stack is empty after testing
1239 EXPECT_TRUE(EnvStackClear());
1240 }
1241
1242 /**
1243 * @tc.name: SaveAllStatusTest
1244 * @tc.desc: SaveAllStatus Test
1245 * @tc.type:FUNC
1246 * @tc.require:issueI9L0ZK
1247 */
1248 HWTEST_F(RSPaintFilterCanvasTest, SaveAllStatusTest, TestSize.Level1)
1249 {
1250 // The second condition of the ternary operation
1251 auto drawingCanvas = std::make_unique<Drawing::Canvas>();
1252 paintFilterCanvas_->canvas_ = drawingCanvas.get();
1253
1254 RSPaintFilterCanvas::SaveStatus secondStatus = paintFilterCanvas_->SaveAllStatus(RSPaintFilterCanvas::kNone);
1255 EXPECT_EQ(paintFilterCanvas_->GetSaveCount(), secondStatus.canvasSaveCount);
1256 EXPECT_EQ(paintFilterCanvas_->GetAlphaSaveCount(), secondStatus.alphaSaveCount);
1257 EXPECT_EQ(paintFilterCanvas_->GetEnvSaveCount(), secondStatus.envSaveCount);
1258 // The first condition of the ternary operation
1259 paintFilterCanvas_->canvas_ = nullptr;
1260 RSPaintFilterCanvas::Env env;
1261 paintFilterCanvas_->envStack_.push(env);
1262 paintFilterCanvas_->alphaStack_.push(SET_ALPHA);
1263 RSPaintFilterCanvas::SaveStatus firstStatus = paintFilterCanvas_->SaveAllStatus(RSPaintFilterCanvas::kAll);
1264 EXPECT_EQ(paintFilterCanvas_->Save(), firstStatus.canvasSaveCount);
1265 EXPECT_EQ(paintFilterCanvas_->GetAlphaSaveCount() - 1, firstStatus.alphaSaveCount);
1266 EXPECT_EQ(paintFilterCanvas_->GetEnvSaveCount() - 1, firstStatus.envSaveCount);
1267
1268 EXPECT_TRUE(AlphaStackClear());
1269 EXPECT_TRUE(EnvStackClear());
1270 }
1271
1272 /**
1273 * @tc.name: CopyConfigurationToOffscreenCanvas
1274 * @tc.desc: CopyConfigurationToOffscreenCanvas Test
1275 * @tc.type:FUNC
1276 * @tc.require:issueI9L0ZK
1277 */
1278 HWTEST_F(RSPaintFilterCanvasTest, CopyConfigurationToOffscreenCanvasTest, TestSize.Level1)
1279 {
1280 // building a new RSPaintFilterCanvas object
1281 auto drawingCanvas = std::make_unique<Drawing::Canvas>();
1282 RSPaintFilterCanvas::Env env;
1283 RSPaintFilterCanvas::Env envOther;
1284 RSPaintFilterCanvas rsPaintFilterCanvas(drawingCanvas.get());
1285
1286 paintFilterCanvas_->envStack_.push(env);
1287 rsPaintFilterCanvas.envStack_.push(envOther);
1288
1289 rsPaintFilterCanvas.SetHighContrast(false);
1290 paintFilterCanvas_->CopyConfigurationToOffscreenCanvas(rsPaintFilterCanvas);
1291
1292 rsPaintFilterCanvas.SetHighContrast(true);
1293 paintFilterCanvas_->CopyConfigurationToOffscreenCanvas(rsPaintFilterCanvas);
1294
1295 envOther.effectData_ = std::make_shared<RSPaintFilterCanvas::CachedEffectData>();
1296 envOther.effectData_->cachedImage_ = std::make_shared<Drawing::Image>();
1297 env.effectData_ = std::make_shared<RSPaintFilterCanvas::CachedEffectData>();
1298 env.effectData_->cachedImage_ = std::make_shared<Drawing::Image>();
1299 paintFilterCanvas_->envStack_.push(env);
1300 rsPaintFilterCanvas.envStack_.push(envOther);
1301
1302 EXPECT_TRUE(rsPaintFilterCanvas.envStack_.top().effectData_ != nullptr);
1303 rsPaintFilterCanvas.SetHighContrast(false);
1304
1305 paintFilterCanvas_->CopyConfigurationToOffscreenCanvas(rsPaintFilterCanvas);
1306 rsPaintFilterCanvas.SetHighContrast(true);
1307 paintFilterCanvas_->CopyConfigurationToOffscreenCanvas(rsPaintFilterCanvas);
1308 EXPECT_TRUE(EnvStackClear());
1309 }
1310
1311 /**
1312 * @tc.name: ReplaceOrSwapMainScreenTest001
1313 * @tc.desc: ReplaceMainScreenData and SwapBackMainScreenData Test
1314 * @tc.type:FUNC
1315 * @tc.require:issueI9L0ZK
1316 */
1317 HWTEST_F(RSPaintFilterCanvasTest, ReplaceOrSwapMainScreenTest001, TestSize.Level1)
1318 {
1319 auto canvas = std::make_unique<Drawing::Canvas>();
1320 RSPaintFilterCanvas paintFilterCanvas(canvas.get());
1321 EXPECT_TRUE(paintFilterCanvas.storeMainScreenSurface_.empty());
1322 EXPECT_TRUE(paintFilterCanvas.storeMainScreenCanvas_.empty());
1323 EXPECT_TRUE(paintFilterCanvas.offscreenDataList_.empty());
1324 paintFilterCanvas.SwapBackMainScreenData();
1325 EXPECT_TRUE(paintFilterCanvas.storeMainScreenCanvas_.empty());
1326
1327 std::shared_ptr<Drawing::Surface> surfacePtr = std::make_shared<Drawing::Surface>();
1328 std::shared_ptr<RSPaintFilterCanvas> canvasPtr = std::make_shared<RSPaintFilterCanvas>(canvas.get());
1329
1330 // Replace data
1331 paintFilterCanvas.ReplaceMainScreenData(surfacePtr, canvasPtr);
1332 EXPECT_EQ(paintFilterCanvas.GetSurface(), surfacePtr.get());
1333 EXPECT_EQ(paintFilterCanvas.GetRecordingCanvas(), nullptr);
1334
1335 // Swap data
1336 EXPECT_FALSE(paintFilterCanvas.storeMainScreenSurface_.empty());
1337 EXPECT_FALSE(paintFilterCanvas.storeMainScreenCanvas_.empty());
1338 EXPECT_FALSE(paintFilterCanvas.offscreenDataList_.empty());
1339 paintFilterCanvas.SwapBackMainScreenData();
1340 EXPECT_TRUE(paintFilterCanvas.storeMainScreenCanvas_.empty());
1341
1342 paintFilterCanvas.ReplaceMainScreenData(surfacePtr, canvasPtr);
1343 paintFilterCanvas.storeMainScreenSurface_.pop();
1344 EXPECT_TRUE(paintFilterCanvas.storeMainScreenSurface_.empty());
1345 EXPECT_FALSE(paintFilterCanvas.storeMainScreenCanvas_.empty());
1346 EXPECT_FALSE(paintFilterCanvas.offscreenDataList_.empty());
1347 paintFilterCanvas.SwapBackMainScreenData();
1348 paintFilterCanvas.storeMainScreenCanvas_.pop();
1349 paintFilterCanvas.offscreenDataList_.pop();
1350 EXPECT_TRUE(paintFilterCanvas.storeMainScreenCanvas_.empty());
1351
1352 paintFilterCanvas.ReplaceMainScreenData(surfacePtr, canvasPtr);
1353 paintFilterCanvas.storeMainScreenCanvas_.pop();
1354 EXPECT_FALSE(paintFilterCanvas.storeMainScreenSurface_.empty());
1355 EXPECT_TRUE(paintFilterCanvas.storeMainScreenCanvas_.empty());
1356 EXPECT_FALSE(paintFilterCanvas.offscreenDataList_.empty());
1357 paintFilterCanvas.SwapBackMainScreenData();
1358 paintFilterCanvas.storeMainScreenSurface_.pop();
1359 paintFilterCanvas.offscreenDataList_.pop();
1360 EXPECT_TRUE(paintFilterCanvas.storeMainScreenCanvas_.empty());
1361
1362 paintFilterCanvas.ReplaceMainScreenData(surfacePtr, canvasPtr);
1363 paintFilterCanvas.offscreenDataList_.pop();
1364 EXPECT_FALSE(paintFilterCanvas.storeMainScreenSurface_.empty());
1365 EXPECT_FALSE(paintFilterCanvas.storeMainScreenCanvas_.empty());
1366 EXPECT_TRUE(paintFilterCanvas.offscreenDataList_.empty());
1367 paintFilterCanvas.SwapBackMainScreenData();
1368 paintFilterCanvas.storeMainScreenSurface_.pop();
1369 paintFilterCanvas.storeMainScreenCanvas_.pop();
1370 EXPECT_TRUE(paintFilterCanvas.storeMainScreenCanvas_.empty());
1371 }
1372
1373 /**
1374 * @tc.name: ReplaceOrSwapMainScreenTest002
1375 * @tc.desc: ReplaceMainScreenData and SwapBackMainScreenData Test
1376 * @tc.type:FUNC
1377 * @tc.require:issueI9L0ZK
1378 */
1379 HWTEST_F(RSPaintFilterCanvasTest, ReplaceOrSwapMainScreenTest002, TestSize.Level1)
1380 {
1381 auto canvas = std::make_unique<Drawing::Canvas>();
1382 RSPaintFilterCanvas paintFilterCanvas(canvas.get());
1383 std::shared_ptr<Drawing::Surface> surfacePtr = nullptr;
1384 std::shared_ptr<RSPaintFilterCanvas> canvasPtr = nullptr;
1385 paintFilterCanvas.ReplaceMainScreenData(surfacePtr, canvasPtr);
1386 surfacePtr = nullptr;
1387 canvasPtr = std::make_shared<RSPaintFilterCanvas>(canvas.get());
1388 paintFilterCanvas.ReplaceMainScreenData(surfacePtr, canvasPtr);
1389 surfacePtr = std::make_shared<Drawing::Surface>();
1390 canvasPtr = nullptr;
1391 paintFilterCanvas.ReplaceMainScreenData(surfacePtr, canvasPtr);
1392 EXPECT_TRUE(paintFilterCanvas.storeMainScreenSurface_.empty());
1393 EXPECT_TRUE(paintFilterCanvas.storeMainScreenCanvas_.empty());
1394 EXPECT_TRUE(paintFilterCanvas.offscreenDataList_.empty());
1395
1396 surfacePtr = std::make_shared<Drawing::Surface>();
1397 canvasPtr = std::make_shared<RSPaintFilterCanvas>(canvas.get());
1398 paintFilterCanvas.ReplaceMainScreenData(surfacePtr, canvasPtr);
1399 paintFilterCanvas.storeMainScreenSurface_.pop();
1400 paintFilterCanvas.storeMainScreenCanvas_.pop();
1401 EXPECT_TRUE(paintFilterCanvas.storeMainScreenSurface_.empty());
1402 EXPECT_TRUE(paintFilterCanvas.storeMainScreenCanvas_.empty());
1403 EXPECT_FALSE(paintFilterCanvas.offscreenDataList_.empty());
1404 paintFilterCanvas.SwapBackMainScreenData();
1405 paintFilterCanvas.offscreenDataList_.pop();
1406 EXPECT_TRUE(paintFilterCanvas.storeMainScreenCanvas_.empty());
1407
1408 paintFilterCanvas.ReplaceMainScreenData(surfacePtr, canvasPtr);
1409 paintFilterCanvas.storeMainScreenSurface_.pop();
1410 paintFilterCanvas.offscreenDataList_.pop();
1411 EXPECT_TRUE(paintFilterCanvas.storeMainScreenSurface_.empty());
1412 EXPECT_FALSE(paintFilterCanvas.storeMainScreenCanvas_.empty());
1413 EXPECT_TRUE(paintFilterCanvas.offscreenDataList_.empty());
1414 paintFilterCanvas.SwapBackMainScreenData();
1415 paintFilterCanvas.storeMainScreenCanvas_.pop();
1416 EXPECT_TRUE(paintFilterCanvas.storeMainScreenCanvas_.empty());
1417
1418 paintFilterCanvas.ReplaceMainScreenData(surfacePtr, canvasPtr);
1419 paintFilterCanvas.offscreenDataList_.pop();
1420 paintFilterCanvas.storeMainScreenCanvas_.pop();
1421 EXPECT_FALSE(paintFilterCanvas.storeMainScreenSurface_.empty());
1422 EXPECT_TRUE(paintFilterCanvas.storeMainScreenCanvas_.empty());
1423 EXPECT_TRUE(paintFilterCanvas.offscreenDataList_.empty());
1424 paintFilterCanvas.SwapBackMainScreenData();
1425 paintFilterCanvas.storeMainScreenSurface_.pop();
1426 EXPECT_TRUE(paintFilterCanvas.storeMainScreenCanvas_.empty());
1427 }
1428
1429 /**
1430 * @tc.name: SaveOrRestoreTest
1431 * @tc.desc: SavePCanvasList and RestorePCanvasList Test
1432 * @tc.type:FUNC
1433 * @tc.require:issueI9L0ZK
1434 */
1435 HWTEST_F(RSPaintFilterCanvasTest, SaveOrRestoreTest, TestSize.Level1)
1436 {
1437 paintFilterCanvas_->SavePCanvasList();
1438 EXPECT_EQ(paintFilterCanvas_->storedPCanvasList_.size(), 1);
1439 paintFilterCanvas_->RestorePCanvasList();
1440 EXPECT_TRUE(paintFilterCanvas_->storedPCanvasList_.empty());
1441 paintFilterCanvas_->pCanvasList_.clear();
1442 EXPECT_TRUE(paintFilterCanvas_->pCanvasList_.empty());
1443 }
1444
1445 /**
1446 * @tc.name: BrightnessRatioTest
1447 * @tc.desc: SetBrightnessRatio and GetBrightnessRatio Test
1448 * @tc.type:FUNC
1449 * @tc.require:issueIAM268
1450 */
1451 HWTEST_F(RSPaintFilterCanvasTest, BrightnessRatioTest, TestSize.Level1)
1452 {
1453 paintFilterCanvas_->SetBrightnessRatio(SET_BRIGHTNESS_RATIO);
1454 EXPECT_EQ(paintFilterCanvas_->GetBrightnessRatio(), SET_BRIGHTNESS_RATIO);
1455 }
1456
1457 /**
1458 * @tc.name: GetLocalClipBoundsTest
1459 * @tc.desc: GetLocalClipBounds Test
1460 * @tc.type:FUNC
1461 * @tc.require:issueI9L0ZK
1462 */
1463 HWTEST_F(RSPaintFilterCanvasTest, GetLocalClipBoundsTest, TestSize.Level1)
1464 {
1465 Drawing::Canvas canvas;
1466
1467 Drawing::RectI* clipRects = nullptr;
1468 std::optional<Drawing::Rect> result = paintFilterCanvas_->GetLocalClipBounds(canvas, clipRects);
1469 EXPECT_FALSE(result.has_value());
1470
1471 Drawing::RectI clipRect;
1472 Drawing::RectI* clipRectPtr = &clipRect;
1473 result = paintFilterCanvas_->GetLocalClipBounds(canvas, clipRectPtr);
1474 EXPECT_FALSE(result.has_value());
1475
1476 Drawing::RectI rectI = { 0, SET_RIGHT, SET_TOP_BOTTOM, SET_TOP_BOTTOM };
1477 result = paintFilterCanvas_->GetLocalClipBounds(canvas, &rectI);
1478 EXPECT_TRUE(result.has_value());
1479 }
1480
1481 /**
1482 * @tc.name: SetBlenderTest
1483 * @tc.desc: SetBlender
1484 * @tc.type:FUNC
1485 * @tc.require:issuesI9J2YE
1486 */
1487 HWTEST_F(RSPaintFilterCanvasTest, SetBlenderTest, TestSize.Level1)
1488 {
1489 std::shared_ptr<Drawing::Blender> blender = nullptr;
1490 auto mode = Drawing::BlendMode::SRC;
1491 blender = Drawing::Blender::CreateWithBlendMode(mode);
1492 EXPECT_TRUE(blender != nullptr);
1493 Drawing::Brush brush;
1494 brush.SetBlender(blender);
1495 }
1496
1497 /**
1498 * @tc.name: HdrOnTest
1499 * @tc.desc: GetHdrOn/SetHdrOn
1500 * @tc.type:FUNC
1501 * @tc.require:issuesI9J2YE
1502 */
1503 HWTEST_F(RSPaintFilterCanvasTest, HdrOnTest, TestSize.Level1)
1504 {
1505 ASSERT_NE(paintFilterCanvas_, nullptr);
1506 paintFilterCanvas_->SetHdrOn(false);
1507 EXPECT_EQ(paintFilterCanvas_->GetHdrOn(), false);
1508 paintFilterCanvas_->SetHdrOn(true);
1509 EXPECT_EQ(paintFilterCanvas_->GetHdrOn(), true);
1510 }
1511
1512 /**
1513 * @tc.name: SetHDRBrightness GetHDRBrightness
1514 * @tc.desc: SetHDRBrightness/GetHDRBrightness
1515 * @tc.type:FUNC
1516 * @tc.require:issuesI9J2YE
1517 */
1518 HWTEST_F(RSPaintFilterCanvasTest, HDRBrightnessTest, TestSize.Level1)
1519 {
1520 ASSERT_NE(paintFilterCanvas_, nullptr);
1521 paintFilterCanvas_->SetHDRBrightness(1.0f);
1522 EXPECT_EQ(paintFilterCanvas_->GetHDRBrightness(), 1.0f);
1523 paintFilterCanvas_->SetHDRBrightness(0.2f);
1524 EXPECT_EQ(paintFilterCanvas_->GetHDRBrightness(), 0.2f);
1525 }
1526
1527 /**
1528 * @tc.name: DrawSdfTest001
1529 * @tc.desc: DrawSdf Test
1530 * @tc.type:FUNC
1531 * @tc.require: issueI9VT6E
1532 */
1533 HWTEST_F(RSPaintFilterCanvasTest, DrawSdfTest001, TestSize.Level1)
1534 {
1535 #ifdef RS_ENABLE_UNI_RENDER
1536 Drawing::Canvas canvas;
1537 std::shared_ptr<RSPaintFilterCanvas> paintFilterCanvasBase = std::make_shared<RSPaintFilterCanvas>(&canvas);
1538 EXPECT_NE(paintFilterCanvasBase, nullptr);
1539
1540 SDFShapeBaseTest shape;
1541 Drawing::Canvas canvasTest;
1542 paintFilterCanvasBase->pCanvasList_.emplace_back(&canvasTest);
1543 paintFilterCanvasBase->alphaStack_.push(1.0f);
1544 paintFilterCanvasBase->DrawSdf(shape);
1545 #endif
1546 }
1547
1548 /**
1549 * @tc.name: DrawAtlasTest002
1550 * @tc.desc: DrawAtlas Test
1551 * @tc.type:FUNC
1552 * @tc.require: issueI9VT6E
1553 */
1554 HWTEST_F(RSPaintFilterCanvasTest, DrawAtlasTest002, TestSize.Level1)
1555 {
1556 Drawing::Canvas canvas;
1557 std::shared_ptr<RSPaintFilterCanvas> paintFilterCanvasBase = std::make_shared<RSPaintFilterCanvas>(&canvas);
1558 EXPECT_NE(paintFilterCanvasBase, nullptr);
1559
1560 paintFilterCanvasBase->alphaStack_.push(1.0f);
1561 Drawing::Image atlas;
1562 Drawing::RSXform xform;
1563 xform.Make(0.0f, 0.0f, 1.0f, 1.0f);
1564 Drawing::Rect tex = { 0.0f, 0.0f, 1.0f, 1.0f };
1565 Drawing::SamplingOptions samplingOptions;
1566 Drawing::Rect cullRect = { 0.0f, 0.0f, 1.0f, 1.0f };
1567 Drawing::ColorQuad colors = 0;
1568 paintFilterCanvasBase->DrawAtlas(
1569 &atlas, &xform, &tex, &colors, 0, Drawing::BlendMode::CLEAR, samplingOptions, &cullRect);
1570 }
1571
1572 /**
1573 * @tc.name: DrawBlurImageTest003
1574 * @tc.desc: DrawBlurImage Test
1575 * @tc.type:FUNC
1576 * @tc.require: issueI9VT6E
1577 */
1578 HWTEST_F(RSPaintFilterCanvasTest, DrawBlurImageTest003, TestSize.Level1)
1579 {
1580 Drawing::Canvas canvas;
1581 std::shared_ptr<PaintFilterCanvasBaseTest> paintFilterCanvasBase =
1582 std::make_shared<PaintFilterCanvasBaseTest>(&canvas);
1583 EXPECT_NE(paintFilterCanvasBase, nullptr);
1584
1585 Drawing::Image image;
1586 Drawing::Rect s = { 0.0f, 0.0f, 1.0f, 1.0f };
1587 Drawing::Rect d = { 0.0f, 0.0f, 1.0f, 1.0f };
1588 Drawing::HpsBlurParameter blurParams = { s, d, 0.0f, 0.0f, 1.0f };
1589 paintFilterCanvasBase->DrawBlurImage(image, blurParams);
1590 }
1591
1592 #ifdef SUBTREE_PARALLEL_ENABLE
1593 /**
1594 * @tc.name: SetParallelRender
1595 * @tc.desc: Test SetParallelRender
1596 * @tc.type:FUNC
1597 * @tc.require: issueI9VT6E
1598 */
1599 HWTEST_F(RSPaintFilterCanvasTest, SetParallelRender, TestSize.Level1)
1600 {
1601 Drawing::Canvas canvas;
1602 std::shared_ptr<PaintFilterCanvasBaseTest> paintFilterCanvasBase =
1603 std::make_shared<PaintFilterCanvasBaseTest>(&canvas);
1604 EXPECT_NE(paintFilterCanvasBase, nullptr);
1605 paintFilterCanvasBase->SetParallelRender(true);
1606 }
1607
1608 /**
1609 * @tc.name: DrawBlurImageTest004
1610 * @tc.desc: DrawBlurImage Test
1611 * @tc.type:FUNC
1612 * @tc.require: issueI9VT6E
1613 */
1614 HWTEST_F(RSPaintFilterCanvasTest, DrawBlurImageTest004, TestSize.Level1)
1615 {
1616 Drawing::Canvas canvas;
1617 auto paintFilterCanvasBase = std::make_shared<RSPaintFilterCanvas>(&canvas);
1618 EXPECT_NE(paintFilterCanvasBase, nullptr);
1619
1620 Drawing::Image image;
1621 Drawing::Rect s = { 0.0f, 0.0f, 1.0f, 1.0f };
1622 Drawing::Rect d = { 0.0f, 0.0f, 1.0f, 1.0f };
1623 Drawing::HpsBlurParameter blurParams = { s, d, 0.0f, 0.0f, 1.0f };
1624 paintFilterCanvasBase->pCanvasList_.push_back(&canvas);
1625 paintFilterCanvasBase->pCanvasList_.push_back(nullptr);
1626 paintFilterCanvasBase->DrawBlurImage(image, blurParams);
1627
1628 paintFilterCanvasBase->isQuickDraw_ = true;
1629 paintFilterCanvasBase->DrawBlurImage(image, blurParams);
1630 }
1631 #endif
1632
1633 /**
1634 * @tc.name: AttachPenTest004
1635 * @tc.desc: AttachPen Test
1636 * @tc.type:FUNC
1637 * @tc.require: issueI9VT6E
1638 */
1639 HWTEST_F(RSPaintFilterCanvasTest, AttachPenTest004, TestSize.Level1)
1640 {
1641 Drawing::Canvas canvas;
1642 std::shared_ptr<RSPaintFilterCanvas> paintFilterCanvas = std::make_shared<RSPaintFilterCanvas>(&canvas);
1643 EXPECT_NE(paintFilterCanvas, nullptr);
1644
1645 Drawing::Pen pen;
1646 Drawing::Canvas canvasTest;
1647 paintFilterCanvas->canvas_ = &canvasTest;
1648 paintFilterCanvas->multipleScreen_ = false;
1649 paintFilterCanvas->alphaStack_.push(1.0f);
1650 pen.brush_.color_ = 0x00000001;
1651 std::shared_ptr<RSPaintFilterCanvas::CachedEffectData> effectData = nullptr;
1652 std::shared_ptr<Drawing::Blender> blender = std::make_shared<Drawing::Blender>();
1653 RSPaintFilterCanvas::Env env = { RSColor(), nullptr, nullptr, blender, false };
1654 paintFilterCanvas->envStack_.push(env);
1655 paintFilterCanvas->AttachPen(pen);
1656
1657 paintFilterCanvas->canvas_ = nullptr;
1658 paintFilterCanvas->AttachPen(pen);
1659 }
1660
1661 /**
1662 * @tc.name: AttachBrushTest005
1663 * @tc.desc: AttachBrush Test
1664 * @tc.type:FUNC
1665 * @tc.require: issueI9VT6E
1666 */
1667 HWTEST_F(RSPaintFilterCanvasTest, AttachBrushTest005, TestSize.Level1)
1668 {
1669 Drawing::Canvas canvas;
1670 std::shared_ptr<RSPaintFilterCanvas> paintFilterCanvas = std::make_shared<RSPaintFilterCanvas>(&canvas);
1671 EXPECT_NE(paintFilterCanvas, nullptr);
1672
1673 Drawing::Brush brush;
1674 Drawing::Canvas canvasTest;
1675 paintFilterCanvas->canvas_ = &canvasTest;
1676 paintFilterCanvas->multipleScreen_ = false;
1677 paintFilterCanvas->alphaStack_.push(1.0f);
1678 brush.color_ = 0x00000001;
1679 std::shared_ptr<RSPaintFilterCanvas::CachedEffectData> effectData = nullptr;
1680 std::shared_ptr<Drawing::Blender> blender = std::make_shared<Drawing::Blender>();
1681 RSPaintFilterCanvas::Env env = { RSColor(), nullptr, nullptr, blender, false };
1682 paintFilterCanvas->envStack_.push(env);
1683 paintFilterCanvas->AttachBrush(brush);
1684 brush.SetBlenderEnabled(false);
1685 paintFilterCanvas->AttachBrush(brush);
1686 paintFilterCanvas->canvas_ = nullptr;
1687 paintFilterCanvas->AttachBrush(brush);
1688 }
1689
1690 /**
1691 * @tc.name: AttachPaintTest006
1692 * @tc.desc: AttachPaint Test
1693 * @tc.type:FUNC
1694 * @tc.require: issueI9VT6E
1695 */
1696 HWTEST_F(RSPaintFilterCanvasTest, AttachPaintTest006, TestSize.Level1)
1697 {
1698 Drawing::Canvas canvas;
1699 std::shared_ptr<RSPaintFilterCanvas> paintFilterCanvas = std::make_shared<RSPaintFilterCanvas>(&canvas);
1700 EXPECT_NE(paintFilterCanvas, nullptr);
1701
1702 Drawing::Paint paint;
1703 Drawing::Canvas canvasTest;
1704 paintFilterCanvas->canvas_ = &canvasTest;
1705 paintFilterCanvas->multipleScreen_ = false;
1706 paintFilterCanvas->alphaStack_.push(1.0f);
1707 paint.color_ = 0x00000001;
1708 std::shared_ptr<RSPaintFilterCanvas::CachedEffectData> effectData = nullptr;
1709 std::shared_ptr<Drawing::Blender> blender = std::make_shared<Drawing::Blender>();
1710 RSPaintFilterCanvas::Env env = { RSColor(), nullptr, nullptr, blender, false };
1711 paintFilterCanvas->AttachPaint(paint);
1712
1713 paintFilterCanvas->canvas_ = nullptr;
1714 paintFilterCanvas->AttachPaint(paint);
1715 }
1716
1717 /**
1718 * @tc.name: AttachBrushAndAttachBrushTest007
1719 * @tc.desc: RSPaintFilterCanvasBase AttachBrush and AttachBrush Test
1720 * @tc.type:FUNC
1721 * @tc.require: issueI9VT6E
1722 */
1723 HWTEST_F(RSPaintFilterCanvasTest, AttachBrushAndAttachBrushTest007, TestSize.Level1)
1724 {
1725 Drawing::Canvas canvas;
1726 std::shared_ptr<PaintFilterCanvasBaseTest> paintFilterCanvasBase =
1727 std::make_shared<PaintFilterCanvasBaseTest>(&canvas);
1728 EXPECT_NE(paintFilterCanvasBase, nullptr);
1729 Drawing::Pen pen;
1730 paintFilterCanvasBase->AttachPen(pen);
1731 Drawing::Brush brush;
1732 paintFilterCanvasBase->AttachBrush(brush);
1733 Drawing::Paint paint;
1734 paintFilterCanvasBase->AttachPaint(paint);
1735
1736 Drawing::SaveLayerOps saveLayerRec;
1737 paintFilterCanvasBase->canvas_ = nullptr;
1738 paintFilterCanvasBase->SaveLayer(saveLayerRec);
1739
1740 Drawing::Canvas canvasTest;
1741 paintFilterCanvasBase->canvas_ = &canvasTest;
1742 paintFilterCanvasBase->SaveLayer(saveLayerRec);
1743 Drawing::Brush brushTest;
1744 saveLayerRec.brush_ = &brushTest;
1745 paintFilterCanvasBase->SaveLayer(saveLayerRec);
1746 }
1747
1748 /**
1749 * @tc.name: DirtyRegionTest
1750 * @tc.desc: RSPaintFilterCanvas PushDirtyRegion and PopDirtyRegion Test
1751 * @tc.type:FUNC
1752 * @tc.require:
1753 */
1754 HWTEST_F(RSPaintFilterCanvasTest, DirtyRegionTest, TestSize.Level1)
1755 {
1756 Drawing::Canvas canvas;
1757 auto filterCanvas = std::make_shared<RSPaintFilterCanvas>(&canvas);
1758 EXPECT_NE(filterCanvas, nullptr);
1759 EXPECT_TRUE(filterCanvas->dirtyRegionStack_.empty());
1760 filterCanvas->PopDirtyRegion();
1761 EXPECT_TRUE(filterCanvas->dirtyRegionStack_.empty());
1762 Drawing::Region region;
1763 filterCanvas->PushDirtyRegion(region);
1764 EXPECT_FALSE(filterCanvas->dirtyRegionStack_.empty());
1765 filterCanvas->PopDirtyRegion();
1766 EXPECT_TRUE(filterCanvas->dirtyRegionStack_.empty());
1767 }
1768
1769 /**
1770 * @tc.name: BehindWindowDataTest
1771 * @tc.desc: SetBehindWindowData and GetBehindWindowData
1772 * @tc.type: FUNC
1773 * @tc.require: issueIB0UQV
1774 */
1775 HWTEST_F(RSPaintFilterCanvasTest, BehindWindowDataTest, TestSize.Level1)
1776 {
1777 RSPaintFilterCanvas::Env env;
1778 paintFilterCanvas_->envStack_.push(env);
1779 auto data = std::make_shared<RSPaintFilterCanvas::CachedEffectData>();
1780 data->cachedImage_ = std::make_shared<Drawing::Image>();
1781 paintFilterCanvas_->SetBehindWindowData(data);
1782 ASSERT_NE(paintFilterCanvas_->envStack_.top().behindWindowData_, nullptr);
1783 ASSERT_NE(paintFilterCanvas_->GetBehindWindowData(), nullptr);
1784 EXPECT_TRUE(EnvStackClear());
1785 }
1786
1787 /**
1788 * @tc.name: IsWindowFreezeCaptureTest
1789 * @tc.desc: GetIsWindowFreezeCapture/SetIsWindowFreezeCapture
1790 * @tc.type:FUNC
1791 * @tc.require:issuesIBHUQ7
1792 */
1793 HWTEST_F(RSPaintFilterCanvasTest, IsWindowFreezeCaptureTest, TestSize.Level1)
1794 {
1795 ASSERT_NE(paintFilterCanvas_, nullptr);
1796 paintFilterCanvas_->SetIsWindowFreezeCapture(false);
1797 EXPECT_EQ(paintFilterCanvas_->GetIsWindowFreezeCapture(), false);
1798 paintFilterCanvas_->SetIsWindowFreezeCapture(true);
1799 EXPECT_EQ(paintFilterCanvas_->GetIsWindowFreezeCapture(), true);
1800 }
1801
1802 /**
1803 * @tc.name: IsDrawingCacheTest
1804 * @tc.desc: GetIsDrawingCache/SetIsDrawingCache
1805 * @tc.type:FUNC
1806 * @tc.require:issuesIC0HM8
1807 */
1808 HWTEST_F(RSPaintFilterCanvasTest, IsDrawingCacheTest, TestSize.Level1)
1809 {
1810 ASSERT_NE(paintFilterCanvas_, nullptr);
1811 paintFilterCanvas_->SetIsDrawingCache(false);
1812 EXPECT_EQ(paintFilterCanvas_->isDrawingCache_, false);
1813 paintFilterCanvas_->SetIsDrawingCache(true);
1814 EXPECT_EQ(paintFilterCanvas_->isDrawingCache_, true);
1815 EXPECT_EQ(paintFilterCanvas_->GetIsDrawingCache(), true);
1816 }
1817
1818 /**
1819 * @tc.name: CacheBehindWindowDataTest
1820 * @tc.desc: GetCacheBehindWindowData/SetCacheBehindWindowData
1821 * @tc.type:FUNC
1822 * @tc.require:issuesIC0HM8
1823 */
1824 HWTEST_F(RSPaintFilterCanvasTest, CacheBehindWindowDataTest, TestSize.Level1)
1825 {
1826 auto data = std::make_shared<RSPaintFilterCanvas::CacheBehindWindowData>();
1827 data->filter_ = RSFilter::RSFilter::CreateMaterialFilter(80.0f, 1.9f, 1.0f, 0xFFFFFFE5);
1828 paintFilterCanvas_->SetCacheBehindWindowData(data);
1829 ASSERT_NE(paintFilterCanvas_->cacheBehindWindowData_, nullptr);
1830 ASSERT_NE(paintFilterCanvas_->GetCacheBehindWindowData(), nullptr);
1831 paintFilterCanvas_->cacheBehindWindowData_ = nullptr;
1832 }
1833
1834 /**
1835 * @tc.name: SetParallelRender
1836 * @tc.desc: Test SetParallelRender
1837 * @tc.type:FUNC
1838 * @tc.require: IC8TIV
1839 */
1840 HWTEST_F(RSPaintFilterCanvasTest, SetParallelRender, TestSize.Level1)
1841 {
1842 Drawing::Canvas canvas;
1843 std::shared_ptr<RSPaintFilterCanvas> paintFilterCanvasBase = std::make_shared<RSPaintFilterCanvas>(&canvas);
1844 EXPECT_NE(paintFilterCanvasBase, nullptr);
1845 paintFilterCanvasBase->SetParallelRender(true);
1846 }
1847
1848 /**
1849 * @tc.name: isEffectIntersectWithDRMTest
1850 * @tc.desc: SetEffectIntersectWithDRM/GetIntersectWithDRM
1851 * @tc.type:FUNC
1852 * @tc.require:issuesIC0HM8
1853 */
1854 HWTEST_F(RSPaintFilterCanvasTest, IsEffectIntersectWithDRMTest, TestSize.Level1)
1855 {
1856 ASSERT_NE(paintFilterCanvas_, nullptr);
1857 paintFilterCanvas_->SetEffectIntersectWithDRM(false);
1858 EXPECT_EQ(paintFilterCanvas_->isIntersectWithDRM_, false);
1859 paintFilterCanvas_->SetEffectIntersectWithDRM(true);
1860 EXPECT_EQ(paintFilterCanvas_->isIntersectWithDRM_, true);
1861 }
1862
1863 /**
1864 * @tc.name: IsDarkColorModeTest
1865 * @tc.desc: SetDarkColorMode/GetDarkColorMode
1866 * @tc.type:FUNC
1867 * @tc.require:issuesIC0HM8
1868 */
1869 HWTEST_F(RSPaintFilterCanvasTest, IsDarkColorModeTestTest, TestSize.Level1)
1870 {
1871 ASSERT_NE(paintFilterCanvas_, nullptr);
1872 paintFilterCanvas_->SetDarkColorMode(false);
1873 EXPECT_EQ(paintFilterCanvas_->isDarkColorMode_, false);
1874 paintFilterCanvas_->SetDarkColorMode(true);
1875 EXPECT_EQ(paintFilterCanvas_->isDarkColorMode_, true);
1876 }
1877
1878 /**
1879 * @tc.name: DrawImageEffectHPSTest
1880 * @tc.desc: DrawImageEffectHPS test
1881 * @tc.type: FUNC
1882 * @tc.require:issuesICI3Q0
1883 */
1884 HWTEST_F(RSPaintFilterCanvasTest, DrawImageEffectHPSTest, TestSize.Level1)
1885 {
1886 Drawing::Canvas canvas;
1887 std::shared_ptr<PaintFilterCanvasBaseTest> paintFilterCanvasBase =
1888 std::make_shared<PaintFilterCanvasBaseTest>(&canvas);
1889 EXPECT_NE(paintFilterCanvasBase, nullptr);
1890
1891 Drawing::Image image;
1892 std::vector<std::shared_ptr<Drawing::HpsEffectParameter>> hpsEffectParams{};
1893 paintFilterCanvasBase->DrawImageEffectHPS(image, hpsEffectParams);
1894 }
1895
1896 } // namespace Rosen
1897 } // namespace OHOS