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