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