1 /*
2 * Copyright (c) 2022 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 <cstddef>
17 #include "gtest/gtest.h"
18 #include "skia_adapter/skia_canvas.h"
19 #include "draw/core_canvas.h"
20 #include "skia_adapter/skia_canvas_autocache.h"
21 #include "skia_adapter/skia_oplist_handle.h"
22
23 using namespace testing;
24 using namespace testing::ext;
25
26 namespace OHOS {
27 namespace Rosen {
28 namespace Drawing {
29 class SkiaCanvasTest : public testing::Test {
30 public:
31 static void SetUpTestCase();
32 static void TearDownTestCase();
33 void SetUp() override;
34 void TearDown() override;
35 };
36
SetUpTestCase()37 void SkiaCanvasTest::SetUpTestCase() {}
TearDownTestCase()38 void SkiaCanvasTest::TearDownTestCase() {}
SetUp()39 void SkiaCanvasTest::SetUp() {}
TearDown()40 void SkiaCanvasTest::TearDown() {}
41
42 /**
43 * @tc.name: Bind001
44 * @tc.desc:
45 * @tc.type: FUNC
46 * @tc.author:
47 */
48 HWTEST_F(SkiaCanvasTest, Bind001, TestSize.Level1)
49 {
50 Bitmap bitmap;
51 SkiaCanvas skiaCanvas;
52 skiaCanvas.Bind(bitmap);
53
54 skiaCanvas.ImportSkCanvas(nullptr);
55 skiaCanvas.Bind(bitmap);
56 }
57
58 /**
59 * @tc.name: DrawPoint001
60 * @tc.desc:
61 * @tc.type: FUNC
62 * @tc.author:
63 */
64 HWTEST_F(SkiaCanvasTest, DrawPoint001, TestSize.Level1)
65 {
66 Point point;
67 Paint paint;
68 paint.SetStyle(Paint::PaintStyle::PAINT_FILL);
69 SkiaCanvas skiaCanvas;
70 skiaCanvas.DrawPoint(point, paint);
71
72 skiaCanvas.ImportSkCanvas(nullptr);
73 skiaCanvas.DrawPoint(point, paint);
74 }
75
76 /**
77 * @tc.name: DrawLine001
78 * @tc.desc:
79 * @tc.type: FUNC
80 * @tc.author:
81 */
82 HWTEST_F(SkiaCanvasTest, DrawLine001, TestSize.Level1)
83 {
84 Point startPt;
85 Point endPt;
86 Paint paint;
87 paint.SetStyle(Paint::PaintStyle::PAINT_FILL);
88 SkiaCanvas skiaCanvas;
89 skiaCanvas.DrawLine(startPt, endPt, paint);
90
91 skiaCanvas.ImportSkCanvas(nullptr);
92 skiaCanvas.DrawLine(startPt, endPt, paint);
93 }
94
95 /**
96 * @tc.name: DrawRect001
97 * @tc.desc:
98 * @tc.type: FUNC
99 * @tc.author:
100 */
101 HWTEST_F(SkiaCanvasTest, DrawRect001, TestSize.Level1)
102 {
103 Rect rect;
104 Paint paint;
105 paint.SetStyle(Paint::PaintStyle::PAINT_FILL);
106 SkiaCanvas skiaCanvas;
107 skiaCanvas.DrawRect(rect, paint);
108
109 skiaCanvas.ImportSkCanvas(nullptr);
110 skiaCanvas.DrawRect(rect, paint);
111 }
112
113 /**
114 * @tc.name: DrawRoundRect001
115 * @tc.desc:
116 * @tc.type: FUNC
117 * @tc.author:
118 */
119 HWTEST_F(SkiaCanvasTest, DrawRoundRect001, TestSize.Level1)
120 {
121 RoundRect roundRect;
122 Paint paint;
123 paint.SetStyle(Paint::PaintStyle::PAINT_FILL);
124 SkiaCanvas skiaCanvas;
125 skiaCanvas.DrawRoundRect(roundRect, paint);
126
127 skiaCanvas.ImportSkCanvas(nullptr);
128 skiaCanvas.DrawRoundRect(roundRect, paint);
129 }
130
131 /**
132 * @tc.name: DrawNestedRoundRect001
133 * @tc.desc:
134 * @tc.type: FUNC
135 * @tc.author:
136 */
137 HWTEST_F(SkiaCanvasTest, DrawNestedRoundRect001, TestSize.Level1)
138 {
139 RoundRect outer;
140 RoundRect inner;
141 Paint paint;
142 paint.SetStyle(Paint::PaintStyle::PAINT_FILL);
143 SkiaCanvas skiaCanvas;
144 skiaCanvas.DrawNestedRoundRect(outer, inner, paint);
145
146 skiaCanvas.ImportSkCanvas(nullptr);
147 skiaCanvas.DrawNestedRoundRect(outer, inner, paint);
148 }
149
150 /**
151 * @tc.name: DrawArc001
152 * @tc.desc:
153 * @tc.type: FUNC
154 * @tc.author:
155 */
156 HWTEST_F(SkiaCanvasTest, DrawArc001, TestSize.Level1)
157 {
158 Rect oval;
159 scalar startAngle = 30.0f;
160 scalar sweepAngle = 45.0f;
161 Paint paint;
162 paint.SetStyle(Paint::PaintStyle::PAINT_FILL);
163 SkiaCanvas skiaCanvas;
164 skiaCanvas.DrawArc(oval, startAngle, sweepAngle, paint);
165
166 skiaCanvas.ImportSkCanvas(nullptr);
167 skiaCanvas.DrawArc(oval, startAngle, sweepAngle, paint);
168 }
169
170 /**
171 * @tc.name: DrawPie001
172 * @tc.desc:
173 * @tc.type: FUNC
174 * @tc.author:
175 */
176 HWTEST_F(SkiaCanvasTest, DrawPie001, TestSize.Level1)
177 {
178 Rect oval;
179 scalar startAngle = 45.0f;
180 scalar sweepAngle = 60.0f;
181 Paint paint;
182 paint.SetStyle(Paint::PaintStyle::PAINT_FILL);
183 SkiaCanvas skiaCanvas;
184 skiaCanvas.DrawPie(oval, startAngle, sweepAngle, paint);
185
186 skiaCanvas.ImportSkCanvas(nullptr);
187 skiaCanvas.DrawPie(oval, startAngle, sweepAngle, paint);
188 }
189
190 /**
191 * @tc.name: DrawOval001
192 * @tc.desc:
193 * @tc.type: FUNC
194 * @tc.author:
195 */
196 HWTEST_F(SkiaCanvasTest, DrawOval001, TestSize.Level1)
197 {
198 Rect oval;
199 Paint paint;
200 paint.SetStyle(Paint::PaintStyle::PAINT_FILL);
201 SkiaCanvas skiaCanvas;
202 skiaCanvas.DrawOval(oval, paint);
203
204 skiaCanvas.ImportSkCanvas(nullptr);
205 skiaCanvas.DrawOval(oval, paint);
206 }
207
208 /**
209 * @tc.name: DrawCircle001
210 * @tc.desc:
211 * @tc.type: FUNC
212 * @tc.author:
213 */
214 HWTEST_F(SkiaCanvasTest, DrawCircle001, TestSize.Level1)
215 {
216 Point centerPt;
217 scalar radius = 20.0f;
218 Paint paint;
219 paint.SetStyle(Paint::PaintStyle::PAINT_FILL);
220 SkiaCanvas skiaCanvas;
221 skiaCanvas.DrawCircle(centerPt, radius, paint);
222
223 skiaCanvas.ImportSkCanvas(nullptr);
224 skiaCanvas.DrawCircle(centerPt, radius, paint);
225 }
226
227 /**
228 * @tc.name: DrawPath001
229 * @tc.desc:
230 * @tc.type: FUNC
231 * @tc.author:
232 */
233 HWTEST_F(SkiaCanvasTest, DrawPath001, TestSize.Level1)
234 {
235 Path path;
236 Paint paint;
237 paint.SetStyle(Paint::PaintStyle::PAINT_FILL);
238 SkiaCanvas skiaCanvas;
239 skiaCanvas.DrawPath(path, paint);
240
241 skiaCanvas.ImportSkCanvas(nullptr);
242 skiaCanvas.DrawPath(path, paint);
243 }
244
245 /**
246 * @tc.name: DrawBackground001
247 * @tc.desc: Draw Background Test
248 * @tc.type: FUNC
249 * @tc.require: issuel#I6Q4ZH
250 */
251 HWTEST_F(SkiaCanvasTest, DrawBackground001, TestSize.Level2)
252 {
253 Brush brush;
254 SkiaCanvas skiaCanvas;
255 skiaCanvas.DrawBackground(brush);
256
257 skiaCanvas.ImportSkCanvas(nullptr);
258 skiaCanvas.DrawBackground(brush);
259 }
260
261 /**
262 * @tc.name: DrawShadow001
263 * @tc.desc: Draw Shadow Test
264 * @tc.type: FUNC
265 * @tc.require: issuel#I6Q4ZH
266 */
267 HWTEST_F(SkiaCanvasTest, DrawShadow001, TestSize.Level2)
268 {
269 Path path;
270 Point3 planeParams;
271 Point3 devLightPos;
272 Color ambientColor;
273 Color spotColor;
274 SkiaCanvas skiaCanvas;
275 skiaCanvas.DrawShadow(path, planeParams, devLightPos, 1.0f, ambientColor, spotColor, ShadowFlags::NONE);
276
277 skiaCanvas.ImportSkCanvas(nullptr);
278 skiaCanvas.DrawShadow(path, planeParams, devLightPos, 1.0f, ambientColor, spotColor, ShadowFlags::NONE);
279 }
280
281 /**
282 * @tc.name: DrawShadowStyle001
283 * @tc.desc: Draw ShadowStyle Test
284 * @tc.type: FUNC
285 * @tc.require: issuel#I6Q4ZH
286 */
287 HWTEST_F(SkiaCanvasTest, DrawShadowStyle001, TestSize.Level2)
288 {
289 Path path;
290 Point3 planeParams;
291 Point3 devLightPos;
292 Color ambientColor;
293 Color spotColor;
294 SkiaCanvas skiaCanvas;
295 skiaCanvas.DrawShadowStyle(path, planeParams, devLightPos, 1.0f, ambientColor, spotColor, ShadowFlags::NONE, true);
296
297 skiaCanvas.ImportSkCanvas(nullptr);
298 skiaCanvas.DrawShadowStyle(path, planeParams, devLightPos, 1.0f, ambientColor, spotColor, ShadowFlags::NONE, true);
299 }
300
301 /**
302 * @tc.name: DrawBitmap001
303 * @tc.desc:
304 * @tc.type: FUNC
305 * @tc.author:
306 */
307 HWTEST_F(SkiaCanvasTest, DrawBitmap001, TestSize.Level1)
308 {
309 Bitmap bitmap;
310 scalar px = 60.0f;
311 scalar py = 30.0f;
312 Paint paint;
313 paint.SetStyle(Paint::PaintStyle::PAINT_FILL);
314 SkiaCanvas skiaCanvas;
315 skiaCanvas.DrawBitmap(bitmap, px, py, paint);
316
317 skiaCanvas.ImportSkCanvas(nullptr);
318 skiaCanvas.DrawBitmap(bitmap, px, py, paint);
319 }
320
321 /**
322 * @tc.name: DrawImage001
323 * @tc.desc:
324 * @tc.type: FUNC
325 * @tc.author:
326 */
327 HWTEST_F(SkiaCanvasTest, DrawImage001, TestSize.Level1)
328 {
329 Image image;
330 scalar px = 30.0f;
331 scalar py = 65.0f;
332 SamplingOptions sampling;
333 Paint paint;
334 paint.SetStyle(Paint::PaintStyle::PAINT_FILL);
335 SkiaCanvas skiaCanvas;
336 skiaCanvas.DrawImage(image, px, py, sampling, paint);
337
338 skiaCanvas.ImportSkCanvas(nullptr);
339 skiaCanvas.DrawImage(image, px, py, sampling, paint);
340 }
341
342 /**
343 * @tc.name: DrawImageRect001
344 * @tc.desc:
345 * @tc.type: FUNC
346 * @tc.author:
347 */
348 HWTEST_F(SkiaCanvasTest, DrawImageRect001, TestSize.Level1)
349 {
350 Image image;
351 Rect src;
352 Rect dst;
353 SamplingOptions sampling;
354 Paint paint;
355 paint.SetStyle(Paint::PaintStyle::PAINT_FILL);
356 SkiaCanvas skiaCanvas;
357 skiaCanvas.DrawImageRect(image, src, dst, sampling, SrcRectConstraint::STRICT_SRC_RECT_CONSTRAINT, paint);
358
359 skiaCanvas.ImportSkCanvas(nullptr);
360 skiaCanvas.DrawImageRect(image, src, dst, sampling, SrcRectConstraint::STRICT_SRC_RECT_CONSTRAINT, paint);
361 }
362
363 /**
364 * @tc.name: DrawImageRect002
365 * @tc.desc:
366 * @tc.type: FUNC
367 * @tc.author:
368 */
369 HWTEST_F(SkiaCanvasTest, DrawImageRect002, TestSize.Level1)
370 {
371 Image image;
372 Rect dst;
373 SamplingOptions sampling;
374 Paint paint;
375 paint.SetStyle(Paint::PaintStyle::PAINT_FILL);
376 SkiaCanvas skiaCanvas;
377 skiaCanvas.DrawImageRect(image, dst, sampling, paint);
378
379 skiaCanvas.ImportSkCanvas(nullptr);
380 skiaCanvas.DrawImageRect(image, dst, sampling, paint);
381 }
382
383 /**
384 * @tc.name: DrawPicture001
385 * @tc.desc:
386 * @tc.type: FUNC
387 * @tc.author:
388 */
389 HWTEST_F(SkiaCanvasTest, DrawPicture001, TestSize.Level1)
390 {
391 Picture picture;
392 SkiaCanvas skiaCanvas;
393 skiaCanvas.DrawPicture(picture);
394
395 skiaCanvas.ImportSkCanvas(nullptr);
396 skiaCanvas.DrawPicture(picture);
397 }
398
399 /**
400 * @tc.name: ClipRoundRect001
401 * @tc.desc: Clip Round Rect Test
402 * @tc.type: FUNC
403 * @tc.require: issuel#I6Q4ZH
404 */
405 HWTEST_F(SkiaCanvasTest, ClipRoundRect001, TestSize.Level2)
406 {
407 RoundRect roundRect;
408 SkiaCanvas skiaCanvas;
409 skiaCanvas.ClipRoundRect(roundRect, ClipOp::DIFFERENCE, false);
410
411 skiaCanvas.ImportSkCanvas(nullptr);
412 skiaCanvas.ClipRoundRect(roundRect, ClipOp::DIFFERENCE, false);
413 }
414
415 /**
416 * @tc.name: ClipPath001
417 * @tc.desc:
418 * @tc.type: FUNC
419 * @tc.author:
420 */
421 HWTEST_F(SkiaCanvasTest, ClipPath001, TestSize.Level1)
422 {
423 Path path;
424 SkiaCanvas skiaCanvas;
425 skiaCanvas.ClipPath(path, ClipOp::DIFFERENCE, false);
426
427 skiaCanvas.ImportSkCanvas(nullptr);
428 skiaCanvas.ClipPath(path, ClipOp::DIFFERENCE, false);
429 }
430
431 /**
432 * @tc.name: SetMatrix001
433 * @tc.desc:
434 * @tc.type: FUNC
435 * @tc.author:
436 */
437 HWTEST_F(SkiaCanvasTest, SetMatrix001, TestSize.Level1)
438 {
439 Matrix matrix;
440 SkiaCanvas skiaCanvas;
441 skiaCanvas.SetMatrix(matrix);
442
443 skiaCanvas.ImportSkCanvas(nullptr);
444 skiaCanvas.SetMatrix(matrix);
445 }
446
447 /**
448 * @tc.name: ResetMatrix001
449 * @tc.desc: Reset Matrix Test
450 * @tc.type: FUNC
451 * @tc.require: issuel#I6Q4ZH
452 */
453 HWTEST_F(SkiaCanvasTest, ResetMatrix001, TestSize.Level2)
454 {
455 Matrix matrix;
456 SkiaCanvas skiaCanvas;
457 skiaCanvas.SetMatrix(matrix);
458 skiaCanvas.ResetMatrix();
459
460 skiaCanvas.ImportSkCanvas(nullptr);
461 skiaCanvas.ResetMatrix();
462 }
463
464 /**
465 * @tc.name: ConcatMatrix001
466 * @tc.desc:
467 * @tc.type: FUNC
468 * @tc.author:
469 */
470 HWTEST_F(SkiaCanvasTest, ConcatMatrix001, TestSize.Level1)
471 {
472 Matrix matrix;
473 SkiaCanvas skiaCanvas;
474 skiaCanvas.ConcatMatrix(matrix);
475
476 skiaCanvas.ImportSkCanvas(nullptr);
477 skiaCanvas.ConcatMatrix(matrix);
478 }
479
480 /**
481 * @tc.name: Rotate001
482 * @tc.desc: Rotate Test
483 * @tc.type: FUNC
484 * @tc.require: issuel#I6Q4ZH
485 */
486 HWTEST_F(SkiaCanvasTest, Rotate001, TestSize.Level2)
487 {
488 SkiaCanvas skiaCanvas;
489 skiaCanvas.Rotate(0.1f, 0.2f, 0.3f);
490
491 skiaCanvas.ImportSkCanvas(nullptr);
492 skiaCanvas.Rotate(0.1f, 0.2f, 0.3f);
493 }
494
495 /**
496 * @tc.name: Shear001
497 * @tc.desc: Shear Test
498 * @tc.type: FUNC
499 * @tc.require: issuel#I6Q4ZH
500 */
501 HWTEST_F(SkiaCanvasTest, Shear001, TestSize.Level2)
502 {
503 SkiaCanvas skiaCanvas;
504 skiaCanvas.Shear(0.5f, 0.5f);
505
506 skiaCanvas.ImportSkCanvas(nullptr);
507 skiaCanvas.Shear(0.5f, 0.5f);
508 }
509
510 /**
511 * @tc.name: Flush001
512 * @tc.desc: Flush Test
513 * @tc.type: FUNC
514 * @tc.require: issuel#I6Q4ZH
515 */
516 HWTEST_F(SkiaCanvasTest, Flush001, TestSize.Level2)
517 {
518 SkiaCanvas skiaCanvas;
519 skiaCanvas.Flush();
520
521 skiaCanvas.ImportSkCanvas(nullptr);
522 skiaCanvas.Flush();
523 }
524
525 /**
526 * @tc.name: SaveLayer001
527 * @tc.desc: SaveLayer Test
528 * @tc.type: FUNC
529 * @tc.require: issuel#I6Q4ZH
530 */
531 HWTEST_F(SkiaCanvasTest, SaveLayer001, TestSize.Level2)
532 {
533 Rect rect;
534 Brush brush;
535 SaveLayerOps slo(&rect, &brush);
536 SkiaCanvas skiaCanvas;
537 skiaCanvas.SaveLayer(slo);
538
539 skiaCanvas.ImportSkCanvas(nullptr);
540 skiaCanvas.SaveLayer(slo);
541 }
542
543 /**
544 * @tc.name: GetTotalMatrixTest001
545 * @tc.desc: Test for geting the total matrix of SkiaCanvas to device.
546 * @tc.type: FUNC
547 * @tc.require: I782P9
548 */
549 HWTEST_F(SkiaCanvasTest, GetTotalMatrixTest001, TestSize.Level1)
550 {
551 auto skiaCanvas = std::make_shared<SkiaCanvas>();
552 ASSERT_TRUE(skiaCanvas != nullptr);
553
554 skiaCanvas->ImportSkCanvas(nullptr);
555 auto matrix = skiaCanvas->GetTotalMatrix();
556 }
557
558 /**
559 * @tc.name: GetLocalClipBoundsTest001
560 * @tc.desc: Test for geting bounds of clip in local coordinates.
561 * @tc.type: FUNC
562 * @tc.require: I782P9
563 */
564 HWTEST_F(SkiaCanvasTest, GetLocalClipBoundsTest001, TestSize.Level1)
565 {
566 auto skiaCanvas = std::make_shared<SkiaCanvas>();
567 ASSERT_TRUE(skiaCanvas != nullptr);
568
569 skiaCanvas->ImportSkCanvas(nullptr);
570 auto rect = skiaCanvas->GetLocalClipBounds();
571 }
572
573 /**
574 * @tc.name: GetDeviceClipBoundsTest001
575 * @tc.desc: Test for geting bounds of clip in device corrdinates.
576 * @tc.type: FUNC
577 * @tc.require: I782P9
578 */
579 HWTEST_F(SkiaCanvasTest, GetDeviceClipBoundsTest001, TestSize.Level1)
580 {
581 auto skiaCanvas = std::make_shared<SkiaCanvas>();
582 ASSERT_TRUE(skiaCanvas != nullptr);
583
584 skiaCanvas->ImportSkCanvas(nullptr);
585 auto rect = skiaCanvas->GetDeviceClipBounds();
586 }
587
588 /**
589 * @tc.name: GetRoundInDeviceClipBoundsTest001
590 * @tc.desc: Test for geting bounds of clip in device corrdinates.
591 * @tc.type: FUNC
592 * @tc.require: I782P9
593 */
594 HWTEST_F(SkiaCanvasTest, GetRoundInDeviceClipBoundsTest001, TestSize.Level1)
595 {
596 auto skiaCanvas = std::make_shared<SkiaCanvas>();
597 ASSERT_TRUE(skiaCanvas != nullptr);
598
599 skiaCanvas->ImportSkCanvas(nullptr);
600 auto rect = skiaCanvas->GetRoundInDeviceClipBounds();
601 }
602
603 #ifdef ACE_ENABLE_GPU
604 /**
605 * @tc.name: GetGPUContextTest001
606 * @tc.desc: Test for geting gpu context.
607 * @tc.type: FUNC
608 * @tc.require: I782P9
609 */
610 HWTEST_F(SkiaCanvasTest, GetGPUContextTest001, TestSize.Level1)
611 {
612 auto skiaCanvas = std::make_shared<SkiaCanvas>();
613 ASSERT_TRUE(skiaCanvas != nullptr);
614
615 skiaCanvas->ImportSkCanvas(nullptr);
616 auto gpuContetxt = skiaCanvas->GetGPUContext();
617 }
618 #endif
619
620 /**
621 * @tc.name: GetWidth001
622 * @tc.desc: Test GetWidth
623 * @tc.type: FUNC
624 * @tc.require: I91EH1
625 */
626 HWTEST_F(SkiaCanvasTest, GetWidth001, TestSize.Level1)
627 {
628 auto skiaCanvas = std::make_shared<SkiaCanvas>(nullptr);
629 ASSERT_TRUE(skiaCanvas != nullptr);
630 ASSERT_TRUE(skiaCanvas->GetWidth() >= 0);
631 }
632
633 /**
634 * @tc.name: GetHeight001
635 * @tc.desc: Test GetHeight
636 * @tc.type: FUNC
637 * @tc.require: I91EH1
638 */
639 HWTEST_F(SkiaCanvasTest, GetHeight001, TestSize.Level1)
640 {
641 auto skiaCanvas = std::make_shared<SkiaCanvas>(nullptr);
642 ASSERT_TRUE(skiaCanvas != nullptr);
643 ASSERT_TRUE(skiaCanvas->GetHeight() >= 0);
644 }
645
646 /**
647 * @tc.name: GetImageInfo001
648 * @tc.desc: Test GetImageInfo
649 * @tc.type: FUNC
650 * @tc.require: I91EH1
651 */
652 HWTEST_F(SkiaCanvasTest, GetImageInfo001, TestSize.Level1)
653 {
654 auto skiaCanvas = std::make_shared<SkiaCanvas>(nullptr);
655 ASSERT_TRUE(skiaCanvas != nullptr);
656 ASSERT_TRUE(skiaCanvas->GetImageInfo().GetWidth() >= 0);
657 }
658
659 /**
660 * @tc.name: ReadPixels001
661 * @tc.desc: Test ReadPixels
662 * @tc.type: FUNC
663 * @tc.require: I91EH1
664 */
665 HWTEST_F(SkiaCanvasTest, ReadPixels001, TestSize.Level1)
666 {
667 auto skiaCanvas1 = std::make_shared<SkiaCanvas>(nullptr);
668 ASSERT_TRUE(skiaCanvas1 != nullptr);
669 ImageInfo imageInfo;
670 ASSERT_TRUE(!skiaCanvas1->ReadPixels(imageInfo, nullptr, 0, 0, 0));
671 Bitmap bitmap;
672 ASSERT_TRUE(!skiaCanvas1->ReadPixels(bitmap, 0, 0));
673
674 auto skiaCanvas2 = std::make_shared<SkiaCanvas>();
675 ASSERT_TRUE(skiaCanvas2 != nullptr);
676 ASSERT_TRUE(!skiaCanvas2->ReadPixels(imageInfo, nullptr, 0, 0, 0));
677 ASSERT_TRUE(!skiaCanvas2->ReadPixels(bitmap, 0, 0));
678 }
679
680 /**
681 * @tc.name: DrawPoints001
682 * @tc.desc: Test DrawPoints
683 * @tc.type: FUNC
684 * @tc.require: I91EH1
685 */
686 HWTEST_F(SkiaCanvasTest, DrawPoints001, TestSize.Level1)
687 {
688 auto skiaCanvas = std::make_shared<SkiaCanvas>(nullptr);
689 ASSERT_TRUE(skiaCanvas != nullptr);
690 Paint paint;
691 paint.SetStyle(Paint::PaintStyle::PAINT_FILL);
692 skiaCanvas->DrawPoints(PointMode::POINTS_POINTMODE, 0, {}, paint);
693 }
694
695 /**
696 * @tc.name: DrawColor001
697 * @tc.desc: Test DrawColor
698 * @tc.type: FUNC
699 * @tc.require: I91EH1
700 */
701 HWTEST_F(SkiaCanvasTest, DrawColor001, TestSize.Level1)
702 {
703 auto skiaCanvas = std::make_shared<SkiaCanvas>(nullptr);
704 ASSERT_TRUE(skiaCanvas != nullptr);
705 skiaCanvas->DrawColor(0xFF000000, BlendMode::COLOR_BURN);
706 }
707
708 /**
709 * @tc.name: ClipRect001
710 * @tc.desc: Test ClipRect
711 * @tc.type: FUNC
712 * @tc.require: I91EH1
713 */
714 HWTEST_F(SkiaCanvasTest, ClipRect001, TestSize.Level1)
715 {
716 auto skiaCanvas = std::make_shared<SkiaCanvas>(nullptr);
717 ASSERT_TRUE(skiaCanvas != nullptr);
718 Rect rect;
719 skiaCanvas->ClipRect(rect, ClipOp::DIFFERENCE, true);
720 }
721
722 /**
723 * @tc.name: ClipIRect001
724 * @tc.desc: Test ClipIRect
725 * @tc.type: FUNC
726 * @tc.require: I91EH1
727 */
728 HWTEST_F(SkiaCanvasTest, ClipIRect001, TestSize.Level1)
729 {
730 auto skiaCanvas = std::make_shared<SkiaCanvas>(nullptr);
731 ASSERT_TRUE(skiaCanvas != nullptr);
732 RectI rect;
733 skiaCanvas->ClipIRect(rect, ClipOp::DIFFERENCE);
734 }
735
736 /**
737 * @tc.name: ClipRegion001
738 * @tc.desc: Test ClipRegion
739 * @tc.type: FUNC
740 * @tc.require: I91EH1
741 */
742 HWTEST_F(SkiaCanvasTest, ClipRegion001, TestSize.Level1)
743 {
744 auto skiaCanvas = std::make_shared<SkiaCanvas>(nullptr);
745 ASSERT_TRUE(skiaCanvas != nullptr);
746 Region region;
747 skiaCanvas->ClipRegion(region, ClipOp::DIFFERENCE);
748 }
749
750 /**
751 * @tc.name: IsClipEmpty001
752 * @tc.desc: Test IsClipEmpty
753 * @tc.type: FUNC
754 * @tc.require: I91EH1
755 */
756 HWTEST_F(SkiaCanvasTest, IsClipEmpty001, TestSize.Level1)
757 {
758 auto skiaCanvas = std::make_shared<SkiaCanvas>();
759 ASSERT_TRUE(skiaCanvas != nullptr);
760 ASSERT_TRUE(skiaCanvas->IsClipEmpty());
761 auto skiaCanvas2 = std::make_shared<SkiaCanvas>(nullptr);
762 ASSERT_TRUE(skiaCanvas2 != nullptr);
763 ASSERT_TRUE(!skiaCanvas2->IsClipEmpty());
764 }
765
766 /**
767 * @tc.name: IsClipRect001
768 * @tc.desc: Test IsClipRect
769 * @tc.type: FUNC
770 * @tc.require: I91EH1
771 */
772 HWTEST_F(SkiaCanvasTest, IsClipRect001, TestSize.Level1)
773 {
774 auto skiaCanvas = std::make_shared<SkiaCanvas>();
775 ASSERT_TRUE(skiaCanvas != nullptr);
776 ASSERT_TRUE(!skiaCanvas->IsClipRect());
777 auto skiaCanvas2 = std::make_shared<SkiaCanvas>(nullptr);
778 ASSERT_TRUE(skiaCanvas2 != nullptr);
779 ASSERT_TRUE(!skiaCanvas2->IsClipRect());
780 }
781
782 /**
783 * @tc.name: QuickReject001
784 * @tc.desc: Test QuickReject
785 * @tc.type: FUNC
786 * @tc.require: I91EH1
787 */
788 HWTEST_F(SkiaCanvasTest, QuickReject001, TestSize.Level1)
789 {
790 auto skiaCanvas = std::make_shared<SkiaCanvas>();
791 ASSERT_TRUE(skiaCanvas != nullptr);
792 Rect rect{0, 0, 1, 1};
793 ASSERT_TRUE(skiaCanvas->QuickReject(rect));
794 auto skiaCanvas2 = std::make_shared<SkiaCanvas>(nullptr);
795 ASSERT_TRUE(skiaCanvas2 != nullptr);
796 ASSERT_TRUE(!skiaCanvas2->QuickReject(rect));
797 }
798
799 /**
800 * @tc.name: Translate001
801 * @tc.desc: Test Translate
802 * @tc.type: FUNC
803 * @tc.require: I91EH1
804 */
805 HWTEST_F(SkiaCanvasTest, Translate001, TestSize.Level1)
806 {
807 auto skiaCanvas = std::make_shared<SkiaCanvas>(nullptr);
808 ASSERT_TRUE(skiaCanvas != nullptr);
809 skiaCanvas->Translate(1, 1);
810 }
811
812 /**
813 * @tc.name: Scale001
814 * @tc.desc: Test Scale
815 * @tc.type: FUNC
816 * @tc.require: I91EH1
817 */
818 HWTEST_F(SkiaCanvasTest, Scale001, TestSize.Level1)
819 {
820 auto skiaCanvas = std::make_shared<SkiaCanvas>(nullptr);
821 ASSERT_TRUE(skiaCanvas != nullptr);
822 skiaCanvas->Scale(1, 1);
823 }
824
825 /**
826 * @tc.name: Clear001
827 * @tc.desc: Test Clear
828 * @tc.type: FUNC
829 * @tc.require: I91EH1
830 */
831 HWTEST_F(SkiaCanvasTest, Clear001, TestSize.Level1)
832 {
833 auto skiaCanvas = std::make_shared<SkiaCanvas>(nullptr);
834 ASSERT_TRUE(skiaCanvas != nullptr);
835 skiaCanvas->Clear(0xFF000000); // 0xFF000000: color
836 }
837
838 /**
839 * @tc.name: Save001
840 * @tc.desc: Test Save
841 * @tc.type: FUNC
842 * @tc.require: I91EH1
843 */
844 HWTEST_F(SkiaCanvasTest, Save001, TestSize.Level1)
845 {
846 auto skiaCanvas = std::make_shared<SkiaCanvas>(nullptr);
847 ASSERT_TRUE(skiaCanvas != nullptr);
848 skiaCanvas->Save();
849 skiaCanvas->Restore();
850 ASSERT_TRUE(skiaCanvas->GetSaveCount() == 0);
851 }
852
853 /**
854 * @tc.name: DrawSymbol001
855 * @tc.desc: Test DrawSymbol
856 * @tc.type: FUNC
857 * @tc.require: I91EH1
858 */
859 HWTEST_F(SkiaCanvasTest, DrawSymbol001, TestSize.Level1)
860 {
861 auto skiaCanvas = std::make_shared<SkiaCanvas>();
862 ASSERT_TRUE(skiaCanvas != nullptr);
863 DrawingHMSymbolData drawingHMSymbolData;
864 Path path;
865 drawingHMSymbolData.path_ = path;
866 DrawingRenderGroup group;
867 DrawingGroupInfo info{{1, 1}, {1, 1}};
868 group.groupInfos = {info};
869 drawingHMSymbolData.symbolInfo_.renderGroups = {group};
870 Point locate;
871 Paint paint;
872 paint.SetStyle(Paint::PaintStyle::PAINT_FILL);
873 skiaCanvas->DrawSymbol(drawingHMSymbolData, locate, paint);
874 skiaCanvas->ImportSkCanvas(nullptr);
875 skiaCanvas->DrawSymbol(drawingHMSymbolData, locate, paint);
876 }
877
878 /**
879 * @tc.name: DrawTextBlob001
880 * @tc.desc: Test DrawTextBlob
881 * @tc.type: FUNC
882 * @tc.require: I91EH1
883 */
884 HWTEST_F(SkiaCanvasTest, DrawTextBlob001, TestSize.Level1)
885 {
886 auto skiaCanvas = std::make_shared<SkiaCanvas>();
887 ASSERT_TRUE(skiaCanvas != nullptr);
888 Paint paint;
889 paint.SetStyle(Paint::PaintStyle::PAINT_FILL);
890 skiaCanvas->DrawTextBlob(nullptr, 0, 0, paint);
891 Font font;
892 auto textBlob = TextBlob::MakeFromString("11", font, TextEncoding::UTF8);
893 skiaCanvas->DrawTextBlob(textBlob.get(), 0, 0, paint);
894 skiaCanvas->ImportSkCanvas(nullptr);
895 skiaCanvas->DrawTextBlob(nullptr, 0, 0, paint);
896 }
897
898 /**
899 * @tc.name: DrawPatch001
900 * @tc.desc: Test DrawPatch
901 * @tc.type: FUNC
902 * @tc.require: I91EH1
903 */
904 HWTEST_F(SkiaCanvasTest, DrawPatch001, TestSize.Level1)
905 {
906 auto skiaCanvas = std::make_shared<SkiaCanvas>();
907 ASSERT_TRUE(skiaCanvas != nullptr);
908 float width = 100.0;
909 float height = 100.0;
910 float segmentWidthOne = width / 3.0;
911 float segmentWidthTwo = width / 3.0 * 2.0;
912 float segmentHeightOne = height / 3.0;
913 float segmentHeightTwo = height / 3.0 * 2.0;
914 Point ctrlPoints[12] = {
915 // top edge control points
916 {0.0f, 0.0f}, {segmentWidthOne, 0.0f}, {segmentWidthTwo, 0.0f}, {width, 0.0f},
917 // right edge control points
918 {width, segmentHeightOne}, {width, segmentHeightTwo},
919 // bottom edge control points
920 {width, height}, {segmentWidthTwo, height}, {segmentWidthOne, height}, {0.0f, height},
921 // left edge control points
922 {0.0f, segmentHeightTwo}, {0.0f, segmentHeightOne}
923 };
924 ColorQuad colors[4] = {0xFF000000, 0xFF000000, 0xFF000000, 0xFF000000};
925 Point texCoords[4] = {
926 {0.0f, 0.0f}, {width, 0.0f}, {width, height}, {0.0f, height}
927 };
928 Paint paint;
929 paint.SetStyle(Paint::PaintStyle::PAINT_FILL);
930 skiaCanvas->DrawPatch(ctrlPoints, colors, texCoords, BlendMode::COLOR_BURN, paint);
931 skiaCanvas->DrawPatch(nullptr, nullptr, nullptr, BlendMode::COLOR_BURN, paint);
932 skiaCanvas->ImportSkCanvas(nullptr);
933 skiaCanvas->DrawPatch(nullptr, nullptr, nullptr, BlendMode::COLOR_BURN, paint);
934 }
935
936 /**
937 * @tc.name: DrawVertices001
938 * @tc.desc: Test DrawVertices
939 * @tc.type: FUNC
940 * @tc.require: I91EH1
941 */
942 HWTEST_F(SkiaCanvasTest, DrawVertices001, TestSize.Level1)
943 {
944 auto skiaCanvas = std::make_shared<SkiaCanvas>();
945 ASSERT_TRUE(skiaCanvas != nullptr);
946 Vertices vertices;
947 Paint paint;
948 paint.SetStyle(Paint::PaintStyle::PAINT_FILL);
949 skiaCanvas->DrawVertices(vertices, BlendMode::COLOR_BURN, paint);
950 skiaCanvas->ImportSkCanvas(nullptr);
951 skiaCanvas->DrawVertices(vertices, BlendMode::COLOR_BURN, paint);
952 }
953
954 /**
955 * @tc.name: DrawImageNine001
956 * @tc.desc: Test DrawImageNine
957 * @tc.type: FUNC
958 * @tc.require: I91EH1
959 */
960 HWTEST_F(SkiaCanvasTest, DrawImageNine001, TestSize.Level1)
961 {
962 auto skiaCanvas = std::make_shared<SkiaCanvas>();
963 ASSERT_TRUE(skiaCanvas != nullptr);
964 Image image;
965 RectI center;
966 Rect dst;
967 Brush brush;
968 skiaCanvas->DrawImageNine(&image, center, dst, FilterMode::LINEAR, &brush);
969 skiaCanvas->DrawImageNine(&image, center, dst, FilterMode::LINEAR, nullptr);
970 }
971
972 /**
973 * @tc.name: DrawImageLattice001
974 * @tc.desc: Test DrawImageLattice
975 * @tc.type: FUNC
976 * @tc.require: I91EH1
977 */
978 HWTEST_F(SkiaCanvasTest, DrawImageLattice001, TestSize.Level1)
979 {
980 auto skiaCanvas = std::make_shared<SkiaCanvas>();
981 ASSERT_TRUE(skiaCanvas != nullptr);
982 Image image;
983 Lattice lattice;
984 Rect dst;
985 Paint paint;
986 paint.SetStyle(Paint::PaintStyle::PAINT_FILL);
987 skiaCanvas->DrawImageLattice(&image, lattice, dst, FilterMode::LINEAR, paint);
988 }
989
990 /**
991 * @tc.name: OpCalculateBeforeTest001
992 * @tc.desc:
993 * @tc.type: FUNC
994 * @tc.author:
995 */
996 HWTEST_F(SkiaCanvasTest, OpCalculateBeforeTest001, TestSize.Level1)
997 {
998 SkiaCanvas skiaCanvas;
999 Matrix matrix;
1000 ASSERT_EQ(skiaCanvas.OpCalculateBefore(matrix), true);
1001 }
1002
1003 /**
1004 * @tc.name: OpCalculateAfterTest001
1005 * @tc.desc:
1006 * @tc.type: FUNC
1007 * @tc.author:
1008 */
1009 HWTEST_F(SkiaCanvasTest, OpCalculateAfterTest001, TestSize.Level1)
1010 {
1011 SkiaCanvas skiaCanvas;
1012 Rect rect;
1013 auto handle = skiaCanvas.OpCalculateAfter(rect);
1014 ASSERT_EQ(handle, nullptr);
1015 }
1016
1017 /**
1018 * @tc.name: OpCalculateAfterTest002
1019 * @tc.desc:
1020 * @tc.type: FUNC
1021 * @tc.author:
1022 */
1023 HWTEST_F(SkiaCanvasTest, OpCalculateAfterTest002, TestSize.Level1)
1024 {
1025 SkiaCanvas skiaCanvas;
1026 Matrix matrix;
1027 skiaCanvas.OpCalculateBefore(matrix);
1028 Rect rect;
1029 auto handle = skiaCanvas.OpCalculateAfter(rect);
1030 ASSERT_EQ(handle, nullptr);
1031 }
1032
1033 /**
1034 * @tc.name: GetOpsNumTest001
1035 * @tc.desc:
1036 * @tc.type: FUNC
1037 * @tc.author:
1038 */
1039 HWTEST_F(SkiaCanvasTest, GetOpsNumTest001, TestSize.Level1)
1040 {
1041 auto skiaCanvas = std::make_shared<SkCanvas>();
1042 ASSERT_NE(skiaCanvas, nullptr);
1043 Matrix matrix;
1044 auto m = matrix.GetImpl<SkiaMatrix>();
1045 ASSERT_NE(m, nullptr);
1046 auto tmp = std::make_shared<SkiaCanvasAutoCache>(skiaCanvas.get());
1047 ASSERT_NE(tmp, nullptr);
1048 tmp->Init(m->ExportSkiaMatrix());
1049 ASSERT_EQ(tmp->GetOpsNum(), 0);
1050 }
1051
1052 /**
1053 * @tc.name: GetOpsPercentTest001
1054 * @tc.desc:
1055 * @tc.type: FUNC
1056 * @tc.author:
1057 */
1058 HWTEST_F(SkiaCanvasTest, GetOpsPercentTest001, TestSize.Level1)
1059 {
1060 auto skiaCanvas = std::make_shared<SkCanvas>();
1061 ASSERT_NE(skiaCanvas, nullptr);
1062 Matrix matrix;
1063 auto m = matrix.GetImpl<SkiaMatrix>();
1064 ASSERT_NE(m, nullptr);
1065 auto tmp = std::make_shared<SkiaCanvasAutoCache>(skiaCanvas.get());
1066 ASSERT_NE(tmp, nullptr);
1067 tmp->Init(m->ExportSkiaMatrix());
1068 ASSERT_EQ(tmp->GetOpsPercent(), 0);
1069 }
1070 } // namespace Drawing
1071 } // namespace Rosen
1072 } // namespace OHOS