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