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: DrawBackground001
258 * @tc.desc: Draw Background Test
259 * @tc.type: FUNC
260 * @tc.require: issuel#I6Q4ZH
261 */
262 HWTEST_F(SkiaCanvasTest, DrawBackground001, TestSize.Level2)
263 {
264 Brush brush;
265 SkiaCanvas skiaCanvas;
266 ASSERT_TRUE(skiaCanvas.ExportSkCanvas() != nullptr);
267 skiaCanvas.DrawBackground(brush);
268
269 skiaCanvas.ImportSkCanvas(nullptr);
270 skiaCanvas.DrawBackground(brush);
271 }
272
273 /**
274 * @tc.name: DrawShadow001
275 * @tc.desc: Draw Shadow Test
276 * @tc.type: FUNC
277 * @tc.require: issuel#I6Q4ZH
278 */
279 HWTEST_F(SkiaCanvasTest, DrawShadow001, TestSize.Level2)
280 {
281 Path path;
282 Point3 planeParams;
283 Point3 devLightPos;
284 Color ambientColor;
285 Color spotColor;
286 SkiaCanvas skiaCanvas;
287 ASSERT_TRUE(skiaCanvas.ExportSkCanvas() != nullptr);
288 skiaCanvas.DrawShadow(path, planeParams, devLightPos, 1.0f, ambientColor, spotColor, ShadowFlags::NONE);
289
290 skiaCanvas.ImportSkCanvas(nullptr);
291 skiaCanvas.DrawShadow(path, planeParams, devLightPos, 1.0f, ambientColor, spotColor, ShadowFlags::NONE);
292 }
293
294 /**
295 * @tc.name: DrawShadowStyle001
296 * @tc.desc: Draw ShadowStyle Test
297 * @tc.type: FUNC
298 * @tc.require: issuel#I6Q4ZH
299 */
300 HWTEST_F(SkiaCanvasTest, DrawShadowStyle001, TestSize.Level2)
301 {
302 Path path;
303 Point3 planeParams;
304 Point3 devLightPos;
305 Color ambientColor;
306 Color spotColor;
307 SkiaCanvas skiaCanvas;
308 ASSERT_TRUE(skiaCanvas.ExportSkCanvas() != nullptr);
309 skiaCanvas.DrawShadowStyle(path, planeParams, devLightPos, 1.0f, ambientColor, spotColor, ShadowFlags::NONE, true);
310
311 skiaCanvas.ImportSkCanvas(nullptr);
312 skiaCanvas.DrawShadowStyle(path, planeParams, devLightPos, 1.0f, ambientColor, spotColor, ShadowFlags::NONE, true);
313 }
314
315 /**
316 * @tc.name: DrawBitmap001
317 * @tc.desc:
318 * @tc.type: FUNC
319 * @tc.author:
320 */
321 HWTEST_F(SkiaCanvasTest, DrawBitmap001, TestSize.Level1)
322 {
323 Bitmap bitmap;
324 scalar px = 60.0f;
325 scalar py = 30.0f;
326 Paint paint;
327 paint.SetStyle(Paint::PaintStyle::PAINT_FILL);
328 SkiaCanvas skiaCanvas;
329 ASSERT_TRUE(skiaCanvas.ExportSkCanvas() != nullptr);
330 skiaCanvas.DrawBitmap(bitmap, px, py, paint);
331
332 skiaCanvas.ImportSkCanvas(nullptr);
333 skiaCanvas.DrawBitmap(bitmap, px, py, paint);
334 }
335
336 /**
337 * @tc.name: DrawImage001
338 * @tc.desc:
339 * @tc.type: FUNC
340 * @tc.author:
341 */
342 HWTEST_F(SkiaCanvasTest, DrawImage001, TestSize.Level1)
343 {
344 Image image;
345 scalar px = 30.0f;
346 scalar py = 65.0f;
347 SamplingOptions sampling;
348 Paint paint;
349 paint.SetStyle(Paint::PaintStyle::PAINT_FILL);
350 SkiaCanvas skiaCanvas;
351 ASSERT_TRUE(skiaCanvas.ExportSkCanvas() != nullptr);
352 skiaCanvas.DrawImage(image, px, py, sampling, paint);
353
354 skiaCanvas.ImportSkCanvas(nullptr);
355 skiaCanvas.DrawImage(image, px, py, sampling, paint);
356 }
357
358 /**
359 * @tc.name: DrawImageRect001
360 * @tc.desc:
361 * @tc.type: FUNC
362 * @tc.author:
363 */
364 HWTEST_F(SkiaCanvasTest, DrawImageRect001, TestSize.Level1)
365 {
366 Image image;
367 Rect src;
368 Rect dst;
369 SamplingOptions sampling;
370 Paint paint;
371 paint.SetStyle(Paint::PaintStyle::PAINT_FILL);
372 SkiaCanvas skiaCanvas;
373 ASSERT_TRUE(skiaCanvas.ExportSkCanvas() != nullptr);
374 skiaCanvas.DrawImageRect(image, src, dst, sampling, SrcRectConstraint::STRICT_SRC_RECT_CONSTRAINT, paint);
375
376 skiaCanvas.ImportSkCanvas(nullptr);
377 skiaCanvas.DrawImageRect(image, src, dst, sampling, SrcRectConstraint::STRICT_SRC_RECT_CONSTRAINT, paint);
378 }
379
380 /**
381 * @tc.name: DrawImageRect002
382 * @tc.desc:
383 * @tc.type: FUNC
384 * @tc.author:
385 */
386 HWTEST_F(SkiaCanvasTest, DrawImageRect002, TestSize.Level1)
387 {
388 Image image;
389 Rect dst;
390 SamplingOptions sampling;
391 Paint paint;
392 paint.SetStyle(Paint::PaintStyle::PAINT_FILL);
393 SkiaCanvas skiaCanvas;
394 ASSERT_TRUE(skiaCanvas.ExportSkCanvas() != nullptr);
395 skiaCanvas.DrawImageRect(image, dst, sampling, paint);
396
397 skiaCanvas.ImportSkCanvas(nullptr);
398 skiaCanvas.DrawImageRect(image, dst, sampling, paint);
399 }
400
401 /**
402 * @tc.name: DrawPicture001
403 * @tc.desc:
404 * @tc.type: FUNC
405 * @tc.author:
406 */
407 HWTEST_F(SkiaCanvasTest, DrawPicture001, TestSize.Level1)
408 {
409 Picture picture;
410 SkiaCanvas skiaCanvas;
411 ASSERT_TRUE(skiaCanvas.ExportSkCanvas() != nullptr);
412 skiaCanvas.DrawPicture(picture);
413
414 skiaCanvas.ImportSkCanvas(nullptr);
415 skiaCanvas.DrawPicture(picture);
416 }
417
418 /**
419 * @tc.name: ClipRoundRect001
420 * @tc.desc: Clip Round Rect Test
421 * @tc.type: FUNC
422 * @tc.require: issuel#I6Q4ZH
423 */
424 HWTEST_F(SkiaCanvasTest, ClipRoundRect001, TestSize.Level2)
425 {
426 RoundRect roundRect;
427 SkiaCanvas skiaCanvas;
428 ASSERT_TRUE(skiaCanvas.ExportSkCanvas() != nullptr);
429 skiaCanvas.ClipRoundRect(roundRect, ClipOp::DIFFERENCE, false);
430
431 skiaCanvas.ImportSkCanvas(nullptr);
432 skiaCanvas.ClipRoundRect(roundRect, ClipOp::DIFFERENCE, false);
433 }
434
435 /**
436 * @tc.name: ClipPath001
437 * @tc.desc:
438 * @tc.type: FUNC
439 * @tc.author:
440 */
441 HWTEST_F(SkiaCanvasTest, ClipPath001, TestSize.Level1)
442 {
443 Path path;
444 SkiaCanvas skiaCanvas;
445 ASSERT_TRUE(skiaCanvas.ExportSkCanvas() != nullptr);
446 skiaCanvas.ClipPath(path, ClipOp::DIFFERENCE, false);
447
448 skiaCanvas.ImportSkCanvas(nullptr);
449 skiaCanvas.ClipPath(path, ClipOp::DIFFERENCE, false);
450 }
451
452 /**
453 * @tc.name: SetMatrix001
454 * @tc.desc:
455 * @tc.type: FUNC
456 * @tc.author:
457 */
458 HWTEST_F(SkiaCanvasTest, SetMatrix001, TestSize.Level1)
459 {
460 Matrix matrix;
461 SkiaCanvas skiaCanvas;
462 ASSERT_TRUE(skiaCanvas.ExportSkCanvas() != nullptr);
463 skiaCanvas.SetMatrix(matrix);
464
465 skiaCanvas.ImportSkCanvas(nullptr);
466 skiaCanvas.SetMatrix(matrix);
467 }
468
469 /**
470 * @tc.name: ResetMatrix001
471 * @tc.desc: Reset Matrix Test
472 * @tc.type: FUNC
473 * @tc.require: issuel#I6Q4ZH
474 */
475 HWTEST_F(SkiaCanvasTest, ResetMatrix001, TestSize.Level2)
476 {
477 Matrix matrix;
478 SkiaCanvas skiaCanvas;
479 ASSERT_TRUE(skiaCanvas.ExportSkCanvas() != nullptr);
480 skiaCanvas.SetMatrix(matrix);
481 skiaCanvas.ResetMatrix();
482
483 skiaCanvas.ImportSkCanvas(nullptr);
484 skiaCanvas.ResetMatrix();
485 }
486
487 /**
488 * @tc.name: ConcatMatrix001
489 * @tc.desc:
490 * @tc.type: FUNC
491 * @tc.author:
492 */
493 HWTEST_F(SkiaCanvasTest, ConcatMatrix001, TestSize.Level1)
494 {
495 Matrix matrix;
496 SkiaCanvas skiaCanvas;
497 ASSERT_TRUE(skiaCanvas.ExportSkCanvas() != nullptr);
498 skiaCanvas.ConcatMatrix(matrix);
499
500 skiaCanvas.ImportSkCanvas(nullptr);
501 skiaCanvas.ConcatMatrix(matrix);
502 }
503
504 /**
505 * @tc.name: Rotate001
506 * @tc.desc: Rotate Test
507 * @tc.type: FUNC
508 * @tc.require: issuel#I6Q4ZH
509 */
510 HWTEST_F(SkiaCanvasTest, Rotate001, TestSize.Level2)
511 {
512 SkiaCanvas skiaCanvas;
513 ASSERT_TRUE(skiaCanvas.ExportSkCanvas() != nullptr);
514 skiaCanvas.Rotate(0.1f, 0.2f, 0.3f);
515
516 skiaCanvas.ImportSkCanvas(nullptr);
517 ASSERT_TRUE(skiaCanvas.ExportSkCanvas() == nullptr);
518 skiaCanvas.Rotate(0.1f, 0.2f, 0.3f);
519 }
520
521 /**
522 * @tc.name: Shear001
523 * @tc.desc: Shear Test
524 * @tc.type: FUNC
525 * @tc.require: issuel#I6Q4ZH
526 */
527 HWTEST_F(SkiaCanvasTest, Shear001, TestSize.Level2)
528 {
529 SkiaCanvas skiaCanvas;
530 ASSERT_TRUE(skiaCanvas.ExportSkCanvas() != nullptr);
531 skiaCanvas.Shear(0.5f, 0.5f);
532
533 skiaCanvas.ImportSkCanvas(nullptr);
534 ASSERT_TRUE(skiaCanvas.ExportSkCanvas() == nullptr);
535 skiaCanvas.Shear(0.5f, 0.5f);
536 }
537
538 /**
539 * @tc.name: Flush001
540 * @tc.desc: Flush Test
541 * @tc.type: FUNC
542 * @tc.require: issuel#I6Q4ZH
543 */
544 HWTEST_F(SkiaCanvasTest, Flush001, TestSize.Level2)
545 {
546 SkiaCanvas skiaCanvas;
547 ASSERT_TRUE(skiaCanvas.ExportSkCanvas() != nullptr);
548 skiaCanvas.Flush();
549
550 skiaCanvas.ImportSkCanvas(nullptr);
551 skiaCanvas.Flush();
552 }
553
554 /**
555 * @tc.name: SaveLayer001
556 * @tc.desc: SaveLayer Test
557 * @tc.type: FUNC
558 * @tc.require: issuel#I6Q4ZH
559 */
560 HWTEST_F(SkiaCanvasTest, SaveLayer001, TestSize.Level2)
561 {
562 Rect rect;
563 Brush brush;
564 SaveLayerOps slo(&rect, &brush);
565 SkiaCanvas skiaCanvas;
566 ASSERT_TRUE(skiaCanvas.ExportSkCanvas() != nullptr);
567 skiaCanvas.SaveLayer(slo);
568
569 skiaCanvas.ImportSkCanvas(nullptr);
570 skiaCanvas.SaveLayer(slo);
571 }
572
573 /**
574 * @tc.name: GetTotalMatrixTest001
575 * @tc.desc: Test for geting the total matrix of SkiaCanvas to device.
576 * @tc.type: FUNC
577 * @tc.require: I782P9
578 */
579 HWTEST_F(SkiaCanvasTest, GetTotalMatrixTest001, TestSize.Level1)
580 {
581 auto skiaCanvas = std::make_shared<SkiaCanvas>();
582 ASSERT_TRUE(skiaCanvas != nullptr);
583
584 skiaCanvas->ImportSkCanvas(nullptr);
585 auto matrix = skiaCanvas->GetTotalMatrix();
586 }
587
588 /**
589 * @tc.name: GetLocalClipBoundsTest001
590 * @tc.desc: Test for geting bounds of clip in local coordinates.
591 * @tc.type: FUNC
592 * @tc.require: I782P9
593 */
594 HWTEST_F(SkiaCanvasTest, GetLocalClipBoundsTest001, TestSize.Level1)
595 {
596 auto skiaCanvas = std::make_shared<SkiaCanvas>();
597 ASSERT_TRUE(skiaCanvas != nullptr);
598
599 skiaCanvas->ImportSkCanvas(nullptr);
600 auto rect = skiaCanvas->GetLocalClipBounds();
601 }
602
603 /**
604 * @tc.name: GetDeviceClipBoundsTest001
605 * @tc.desc: Test for geting bounds of clip in device corrdinates.
606 * @tc.type: FUNC
607 * @tc.require: I782P9
608 */
609 HWTEST_F(SkiaCanvasTest, GetDeviceClipBoundsTest001, TestSize.Level1)
610 {
611 auto skiaCanvas = std::make_shared<SkiaCanvas>();
612 ASSERT_TRUE(skiaCanvas != nullptr);
613
614 skiaCanvas->ImportSkCanvas(nullptr);
615 auto rect = skiaCanvas->GetDeviceClipBounds();
616 }
617
618 /**
619 * @tc.name: GetRoundInDeviceClipBoundsTest001
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, GetRoundInDeviceClipBoundsTest001, TestSize.Level1)
625 {
626 auto skiaCanvas = std::make_shared<SkiaCanvas>();
627 ASSERT_TRUE(skiaCanvas != nullptr);
628
629 skiaCanvas->ImportSkCanvas(nullptr);
630 auto rect = skiaCanvas->GetRoundInDeviceClipBounds();
631 }
632
633 #ifdef RS_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 Paint paint;
721 paint.SetStyle(Paint::PaintStyle::PAINT_FILL);
722 skiaCanvas->DrawPoints(PointMode::POINTS_POINTMODE, 0, {}, paint);
723 }
724
725 /**
726 * @tc.name: DrawColor001
727 * @tc.desc: Test DrawColor
728 * @tc.type: FUNC
729 * @tc.require: I91EH1
730 */
731 HWTEST_F(SkiaCanvasTest, DrawColor001, TestSize.Level1)
732 {
733 auto skiaCanvas = std::make_shared<SkiaCanvas>(nullptr);
734 ASSERT_TRUE(skiaCanvas != nullptr);
735 skiaCanvas->DrawColor(0xFF000000, BlendMode::COLOR_BURN);
736 }
737
738 /**
739 * @tc.name: ClipRect001
740 * @tc.desc: Test ClipRect
741 * @tc.type: FUNC
742 * @tc.require: I91EH1
743 */
744 HWTEST_F(SkiaCanvasTest, ClipRect001, TestSize.Level1)
745 {
746 auto skiaCanvas = std::make_shared<SkiaCanvas>(nullptr);
747 ASSERT_TRUE(skiaCanvas != nullptr);
748 Rect rect;
749 skiaCanvas->ClipRect(rect, ClipOp::DIFFERENCE, true);
750 }
751
752 /**
753 * @tc.name: ClipIRect001
754 * @tc.desc: Test ClipIRect
755 * @tc.type: FUNC
756 * @tc.require: I91EH1
757 */
758 HWTEST_F(SkiaCanvasTest, ClipIRect001, TestSize.Level1)
759 {
760 auto skiaCanvas = std::make_shared<SkiaCanvas>(nullptr);
761 ASSERT_TRUE(skiaCanvas != nullptr);
762 RectI rect;
763 skiaCanvas->ClipIRect(rect, ClipOp::DIFFERENCE);
764 }
765
766 /**
767 * @tc.name: ClipRegion001
768 * @tc.desc: Test ClipRegion
769 * @tc.type: FUNC
770 * @tc.require: I91EH1
771 */
772 HWTEST_F(SkiaCanvasTest, ClipRegion001, TestSize.Level1)
773 {
774 auto skiaCanvas = std::make_shared<SkiaCanvas>(nullptr);
775 ASSERT_TRUE(skiaCanvas != nullptr);
776 Region region;
777 skiaCanvas->ClipRegion(region, ClipOp::DIFFERENCE);
778 }
779
780 /**
781 * @tc.name: IsClipEmpty001
782 * @tc.desc: Test IsClipEmpty
783 * @tc.type: FUNC
784 * @tc.require: I91EH1
785 */
786 HWTEST_F(SkiaCanvasTest, IsClipEmpty001, TestSize.Level1)
787 {
788 auto skiaCanvas = std::make_shared<SkiaCanvas>();
789 ASSERT_TRUE(skiaCanvas != nullptr);
790 ASSERT_TRUE(skiaCanvas->IsClipEmpty());
791 auto skiaCanvas2 = std::make_shared<SkiaCanvas>(nullptr);
792 ASSERT_TRUE(skiaCanvas2 != nullptr);
793 ASSERT_TRUE(!skiaCanvas2->IsClipEmpty());
794 }
795
796 /**
797 * @tc.name: IsClipRect001
798 * @tc.desc: Test IsClipRect
799 * @tc.type: FUNC
800 * @tc.require: I91EH1
801 */
802 HWTEST_F(SkiaCanvasTest, IsClipRect001, TestSize.Level1)
803 {
804 auto skiaCanvas = std::make_shared<SkiaCanvas>();
805 ASSERT_TRUE(skiaCanvas != nullptr);
806 ASSERT_TRUE(!skiaCanvas->IsClipRect());
807 auto skiaCanvas2 = std::make_shared<SkiaCanvas>(nullptr);
808 ASSERT_TRUE(skiaCanvas2 != nullptr);
809 ASSERT_TRUE(!skiaCanvas2->IsClipRect());
810 }
811
812 /**
813 * @tc.name: QuickReject001
814 * @tc.desc: Test QuickReject
815 * @tc.type: FUNC
816 * @tc.require: I91EH1
817 */
818 HWTEST_F(SkiaCanvasTest, QuickReject001, TestSize.Level1)
819 {
820 auto skiaCanvas = std::make_shared<SkiaCanvas>();
821 ASSERT_TRUE(skiaCanvas != nullptr);
822 Rect rect{0, 0, 1, 1};
823 ASSERT_TRUE(skiaCanvas->QuickReject(rect));
824 auto skiaCanvas2 = std::make_shared<SkiaCanvas>(nullptr);
825 ASSERT_TRUE(skiaCanvas2 != nullptr);
826 ASSERT_TRUE(!skiaCanvas2->QuickReject(rect));
827 }
828
829 /**
830 * @tc.name: Translate001
831 * @tc.desc: Test Translate
832 * @tc.type: FUNC
833 * @tc.require: I91EH1
834 */
835 HWTEST_F(SkiaCanvasTest, Translate001, TestSize.Level1)
836 {
837 auto skiaCanvas = std::make_shared<SkiaCanvas>(nullptr);
838 ASSERT_TRUE(skiaCanvas != nullptr);
839 skiaCanvas->Translate(1, 1);
840 }
841
842 /**
843 * @tc.name: Scale001
844 * @tc.desc: Test Scale
845 * @tc.type: FUNC
846 * @tc.require: I91EH1
847 */
848 HWTEST_F(SkiaCanvasTest, Scale001, TestSize.Level1)
849 {
850 auto skiaCanvas = std::make_shared<SkiaCanvas>(nullptr);
851 ASSERT_TRUE(skiaCanvas != nullptr);
852 skiaCanvas->Scale(1, 1);
853 }
854
855 /**
856 * @tc.name: Clear001
857 * @tc.desc: Test Clear
858 * @tc.type: FUNC
859 * @tc.require: I91EH1
860 */
861 HWTEST_F(SkiaCanvasTest, Clear001, TestSize.Level1)
862 {
863 auto skiaCanvas = std::make_shared<SkiaCanvas>(nullptr);
864 ASSERT_TRUE(skiaCanvas != nullptr);
865 skiaCanvas->Clear(0xFF000000); // 0xFF000000: color
866 }
867
868 /**
869 * @tc.name: Save001
870 * @tc.desc: Test Save
871 * @tc.type: FUNC
872 * @tc.require: I91EH1
873 */
874 HWTEST_F(SkiaCanvasTest, Save001, TestSize.Level1)
875 {
876 auto skiaCanvas = std::make_shared<SkiaCanvas>(nullptr);
877 ASSERT_TRUE(skiaCanvas != nullptr);
878 skiaCanvas->Save();
879 skiaCanvas->Restore();
880 ASSERT_TRUE(skiaCanvas->GetSaveCount() == 0);
881 }
882
883 /**
884 * @tc.name: DrawSymbol001
885 * @tc.desc: Test DrawSymbol
886 * @tc.type: FUNC
887 * @tc.require: I91EH1
888 */
889 HWTEST_F(SkiaCanvasTest, DrawSymbol001, TestSize.Level1)
890 {
891 auto skiaCanvas = std::make_shared<SkiaCanvas>();
892 ASSERT_TRUE(skiaCanvas != nullptr);
893 DrawingHMSymbolData drawingHMSymbolData;
894 Path path;
895 drawingHMSymbolData.path_ = path;
896 DrawingRenderGroup group;
897 DrawingGroupInfo info{{1, 1}, {1, 1}};
898 group.groupInfos = {info};
899 drawingHMSymbolData.symbolInfo_.renderGroups = {group};
900 Point locate;
901 Paint paint;
902 paint.SetStyle(Paint::PaintStyle::PAINT_FILL);
903 skiaCanvas->DrawSymbol(drawingHMSymbolData, locate, paint);
904 skiaCanvas->ImportSkCanvas(nullptr);
905 skiaCanvas->DrawSymbol(drawingHMSymbolData, locate, paint);
906 }
907
908 /**
909 * @tc.name: DrawTextBlob001
910 * @tc.desc: Test DrawTextBlob
911 * @tc.type: FUNC
912 * @tc.require: I91EH1
913 */
914 HWTEST_F(SkiaCanvasTest, DrawTextBlob001, TestSize.Level1)
915 {
916 auto skiaCanvas = std::make_shared<SkiaCanvas>();
917 ASSERT_TRUE(skiaCanvas != nullptr);
918 Paint paint;
919 paint.SetStyle(Paint::PaintStyle::PAINT_FILL);
920 skiaCanvas->DrawTextBlob(nullptr, 0, 0, paint);
921 Font font;
922 auto textBlob = TextBlob::MakeFromString("11", font, TextEncoding::UTF8);
923 skiaCanvas->DrawTextBlob(textBlob.get(), 0, 0, paint);
924 skiaCanvas->ImportSkCanvas(nullptr);
925 skiaCanvas->DrawTextBlob(nullptr, 0, 0, paint);
926 }
927
928 /**
929 * @tc.name: DrawPatch001
930 * @tc.desc: Test DrawPatch
931 * @tc.type: FUNC
932 * @tc.require: I91EH1
933 */
934 HWTEST_F(SkiaCanvasTest, DrawPatch001, TestSize.Level1)
935 {
936 auto skiaCanvas = std::make_shared<SkiaCanvas>();
937 ASSERT_TRUE(skiaCanvas != nullptr);
938 float width = 100.0;
939 float height = 100.0;
940 float segmentWidthOne = width / 3.0;
941 float segmentWidthTwo = width / 3.0 * 2.0;
942 float segmentHeightOne = height / 3.0;
943 float segmentHeightTwo = height / 3.0 * 2.0;
944 Point ctrlPoints[12] = {
945 // top edge control points
946 {0.0f, 0.0f}, {segmentWidthOne, 0.0f}, {segmentWidthTwo, 0.0f}, {width, 0.0f},
947 // right edge control points
948 {width, segmentHeightOne}, {width, segmentHeightTwo},
949 // bottom edge control points
950 {width, height}, {segmentWidthTwo, height}, {segmentWidthOne, height}, {0.0f, height},
951 // left edge control points
952 {0.0f, segmentHeightTwo}, {0.0f, segmentHeightOne}
953 };
954 ColorQuad colors[4] = {0xFF000000, 0xFF000000, 0xFF000000, 0xFF000000};
955 Point texCoords[4] = {
956 {0.0f, 0.0f}, {width, 0.0f}, {width, height}, {0.0f, height}
957 };
958 Paint paint;
959 paint.SetStyle(Paint::PaintStyle::PAINT_FILL);
960 skiaCanvas->DrawPatch(ctrlPoints, colors, texCoords, BlendMode::COLOR_BURN, paint);
961 skiaCanvas->DrawPatch(nullptr, nullptr, nullptr, BlendMode::COLOR_BURN, paint);
962 skiaCanvas->ImportSkCanvas(nullptr);
963 skiaCanvas->DrawPatch(nullptr, nullptr, nullptr, BlendMode::COLOR_BURN, paint);
964 }
965
966 /**
967 * @tc.name: DrawVertices001
968 * @tc.desc: Test DrawVertices
969 * @tc.type: FUNC
970 * @tc.require: I91EH1
971 */
972 HWTEST_F(SkiaCanvasTest, DrawVertices001, TestSize.Level1)
973 {
974 auto skiaCanvas = std::make_shared<SkiaCanvas>();
975 ASSERT_TRUE(skiaCanvas != nullptr);
976 Vertices vertices;
977 Paint paint;
978 paint.SetStyle(Paint::PaintStyle::PAINT_FILL);
979 skiaCanvas->DrawVertices(vertices, BlendMode::COLOR_BURN, paint);
980 skiaCanvas->ImportSkCanvas(nullptr);
981 skiaCanvas->DrawVertices(vertices, BlendMode::COLOR_BURN, paint);
982 }
983
984 /**
985 * @tc.name: DrawImageNine001
986 * @tc.desc: Test DrawImageNine
987 * @tc.type: FUNC
988 * @tc.require: I91EH1
989 */
990 HWTEST_F(SkiaCanvasTest, DrawImageNine001, TestSize.Level1)
991 {
992 auto skiaCanvas = std::make_shared<SkiaCanvas>();
993 ASSERT_TRUE(skiaCanvas != nullptr);
994 Image image;
995 RectI center;
996 Rect dst;
997 Brush brush;
998 skiaCanvas->DrawImageNine(&image, center, dst, FilterMode::LINEAR, &brush);
999 skiaCanvas->DrawImageNine(&image, center, dst, FilterMode::LINEAR, nullptr);
1000 }
1001
1002 /**
1003 * @tc.name: DrawImageLattice001
1004 * @tc.desc: Test DrawImageLattice
1005 * @tc.type: FUNC
1006 * @tc.require: I91EH1
1007 */
1008 HWTEST_F(SkiaCanvasTest, DrawImageLattice001, TestSize.Level1)
1009 {
1010 auto skiaCanvas = std::make_shared<SkiaCanvas>();
1011 ASSERT_TRUE(skiaCanvas != nullptr);
1012 Image image;
1013 Lattice lattice;
1014 Rect dst;
1015 Paint paint;
1016 paint.SetStyle(Paint::PaintStyle::PAINT_FILL);
1017 skiaCanvas->DrawImageLattice(&image, lattice, dst, FilterMode::LINEAR, paint);
1018 }
1019
1020 /**
1021 * @tc.name: OpCalculateBeforeTest001
1022 * @tc.desc: Test OpCalculateBefore
1023 * @tc.type: FUNC
1024 * @tc.require: I9B0X4
1025 */
1026 HWTEST_F(SkiaCanvasTest, OpCalculateBeforeTest001, TestSize.Level1)
1027 {
1028 SkiaCanvas skiaCanvas;
1029 Matrix matrix;
1030 ASSERT_EQ(skiaCanvas.OpCalculateBefore(matrix), true);
1031 }
1032
1033 /**
1034 * @tc.name: OpCalculateAfterTest001
1035 * @tc.desc: Test OpCalculateAfter
1036 * @tc.type: FUNC
1037 * @tc.require: I9B0X4
1038 */
1039 HWTEST_F(SkiaCanvasTest, OpCalculateAfterTest001, TestSize.Level1)
1040 {
1041 SkiaCanvas skiaCanvas;
1042 Rect rect;
1043 auto handle = skiaCanvas.OpCalculateAfter(rect);
1044 ASSERT_EQ(handle, nullptr);
1045 }
1046
1047 /**
1048 * @tc.name: OpCalculateAfterTest002
1049 * @tc.desc: Test OpCalculateAfter
1050 * @tc.type: FUNC
1051 * @tc.require: I9B0X4
1052 */
1053 HWTEST_F(SkiaCanvasTest, OpCalculateAfterTest002, TestSize.Level1)
1054 {
1055 SkiaCanvas skiaCanvas;
1056 Matrix matrix;
1057 skiaCanvas.OpCalculateBefore(matrix);
1058 Rect rect;
1059 auto handle = skiaCanvas.OpCalculateAfter(rect);
1060 ASSERT_EQ(handle, nullptr);
1061 }
1062
1063 /**
1064 * @tc.name: GetOpsNumTest001
1065 * @tc.desc: Test GetOpsNum
1066 * @tc.type: FUNC
1067 * @tc.require: I9B0X4
1068 */
1069 HWTEST_F(SkiaCanvasTest, GetOpsNumTest001, TestSize.Level1)
1070 {
1071 auto skiaCanvas = std::make_shared<SkCanvas>();
1072 ASSERT_NE(skiaCanvas, nullptr);
1073 Matrix matrix;
1074 auto m = matrix.GetImpl<SkiaMatrix>();
1075 ASSERT_NE(m, nullptr);
1076 auto tmp = std::make_shared<SkiaCanvasAutoCache>(skiaCanvas.get());
1077 ASSERT_NE(tmp, nullptr);
1078 tmp->Init(m->ExportSkiaMatrix());
1079 ASSERT_EQ(tmp->GetOpsNum(), 0);
1080 }
1081
1082 /**
1083 * @tc.name: GetOpsPercentTest001
1084 * @tc.desc: Test GetOpsPercent
1085 * @tc.type: FUNC
1086 * @tc.require: I9B0X4
1087 */
1088 HWTEST_F(SkiaCanvasTest, GetOpsPercentTest001, TestSize.Level1)
1089 {
1090 auto skiaCanvas = std::make_shared<SkCanvas>();
1091 ASSERT_NE(skiaCanvas, nullptr);
1092 Matrix matrix;
1093 auto m = matrix.GetImpl<SkiaMatrix>();
1094 ASSERT_NE(m, nullptr);
1095 auto tmp = std::make_shared<SkiaCanvasAutoCache>(skiaCanvas.get());
1096 ASSERT_NE(tmp, nullptr);
1097 tmp->Init(m->ExportSkiaMatrix());
1098 ASSERT_EQ(tmp->GetOpsPercent(), 0);
1099 }
1100
1101 } // namespace Drawing
1102 } // namespace Rosen
1103 } // namespace OHOS