1 /*
2 * Copyright (c) 2022-2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, Hardware
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "gtest/gtest.h"
17
18 #include "drawing_bitmap.h"
19 #include "drawing_brush.h"
20 #include "drawing_canvas.h"
21 #include "drawing_color.h"
22 #include "drawing_color_filter.h"
23 #include "drawing_filter.h"
24 #include "drawing_font.h"
25 #include "drawing_image.h"
26 #include "drawing_mask_filter.h"
27 #include "drawing_matrix.h"
28 #include "drawing_path.h"
29 #include "drawing_pen.h"
30 #include "drawing_point.h"
31 #include "drawing_rect.h"
32 #include "drawing_region.h"
33 #include "drawing_round_rect.h"
34 #include "drawing_sampling_options.h"
35 #include "drawing_shader_effect.h"
36 #include "drawing_text_blob.h"
37 #include "drawing_typeface.h"
38 #include "drawing_memory_stream.h"
39 #include "effect/color_filter.h"
40 #include "effect/filter.h"
41
42 using namespace testing;
43 using namespace testing::ext;
44
45 namespace OHOS {
46 namespace Rosen {
47 namespace Drawing {
48 class NativeDrawingCanvasTest : public testing::Test {
49 public:
50 static void SetUpTestCase();
51 static void TearDownTestCase();
52 void SetUp() override;
53 void TearDown() override;
54 protected:
55 OH_Drawing_Canvas *canvas_ = nullptr;
56 OH_Drawing_Brush *brush_ = nullptr;
57 };
58
59 constexpr uint32_t POINT_PARAMETER = 3;
60 constexpr uint32_t COLOR_PARAMETER = 3;
61
SetUpTestCase()62 void NativeDrawingCanvasTest::SetUpTestCase() {}
TearDownTestCase()63 void NativeDrawingCanvasTest::TearDownTestCase() {}
SetUp()64 void NativeDrawingCanvasTest::SetUp()
65 {
66 canvas_ = OH_Drawing_CanvasCreate();
67 ASSERT_NE(nullptr, canvas_);
68 OH_Drawing_CanvasClear(canvas_, OH_Drawing_ColorSetArgb(0xFF, 0xFF, 0xFF, 0xFF));
69 brush_ = OH_Drawing_BrushCreate();
70 EXPECT_NE(brush_, nullptr);
71 OH_Drawing_BrushSetColor(brush_, 0xffff0000);
72 OH_Drawing_CanvasAttachBrush(canvas_, brush_);
73 }
74
TearDown()75 void NativeDrawingCanvasTest::TearDown()
76 {
77 if (canvas_ != nullptr) {
78 OH_Drawing_CanvasDetachBrush(canvas_);
79 OH_Drawing_BrushDestroy(brush_);
80 brush_ = nullptr;
81 OH_Drawing_CanvasDestroy(canvas_);
82 canvas_ = nullptr;
83 }
84 }
85
86 /*
87 * @tc.name: NativeDrawingCanvasTest_CanvasNULLPTR001
88 * @tc.desc: test for OH_Drawing_CanvasBind.
89 * @tc.size : MediumTest
90 * @tc.type : Function
91 * @tc.level : Level 1
92 */
HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_CanvasNULLPTR001, TestSize.Level1)93 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_CanvasNULLPTR001, TestSize.Level1)
94 {
95 OH_Drawing_Bitmap* bitmap = OH_Drawing_BitmapCreate();
96 EXPECT_NE(bitmap, nullptr);
97 OH_Drawing_CanvasBind(nullptr, bitmap);
98 OH_Drawing_BitmapDestroy(bitmap);
99 OH_Drawing_CanvasAttachPen(canvas_, nullptr);
100 OH_Drawing_CanvasTranslate(canvas_, INT32_MIN, INT32_MIN);
101 OH_Drawing_CanvasTranslate(canvas_, INT32_MAX, INT32_MAX);
102 OH_Drawing_CanvasDrawLine(nullptr, 0, 0, 20, 20);
103 OH_Drawing_CanvasDrawLine(canvas_, 0, 0, INT32_MAX, INT32_MAX);
104 OH_Drawing_CanvasDrawLine(canvas_, 0, 0, INT32_MIN, INT32_MIN);
105 OH_Drawing_Path* path = OH_Drawing_PathCreate();
106 OH_Drawing_PathMoveTo(path, INT32_MAX, INT32_MIN);
107 OH_Drawing_PathMoveTo(nullptr, 9999, -1000);
108 OH_Drawing_PathClose(nullptr);
109 OH_Drawing_PathClose(path);
110 OH_Drawing_CanvasDrawPath(nullptr, path);
111 OH_Drawing_CanvasDrawPath(canvas_, nullptr);
112 OH_Drawing_PathDestroy(path);
113 }
114
115 /*
116 * @tc.name: NativeDrawingCanvasTest_CanvasBind002
117 * @tc.desc: test for OH_Drawing_CanvasBind.
118 * @tc.size : MediumTest
119 * @tc.type : Function
120 * @tc.level : Level 1
121 */
HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_CanvasBind002, TestSize.Level1)122 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_CanvasBind002, TestSize.Level1)
123 {
124 OH_Drawing_Bitmap* bitmap = OH_Drawing_BitmapCreate();
125 EXPECT_NE(bitmap, nullptr);
126 OH_Drawing_CanvasBind(canvas_, bitmap);
127 OH_Drawing_BitmapDestroy(bitmap);
128 }
129
130 /*
131 * @tc.name: NativeDrawingCanvasTest_canvas003
132 * @tc.desc: test for OH_Drawing_CanvasAttachPen & OH_Drawing_CanvasDetachPen.
133 * @tc.size : MediumTest
134 * @tc.type : Function
135 * @tc.level : Level 1
136 */
HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_canvas003, TestSize.Level1)137 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_canvas003, TestSize.Level1)
138 {
139 OH_Drawing_Pen* pen = OH_Drawing_PenCreate();
140 EXPECT_NE(pen, nullptr);
141 OH_Drawing_CanvasAttachPen(canvas_, pen);
142 OH_Drawing_CanvasDetachPen(canvas_);
143 OH_Drawing_PenDestroy(pen);
144 }
145
146 /*
147 * @tc.name: NativeDrawingCanvasTest_DrawLine004
148 * @tc.desc: test for OH_Drawing_CanvasDrawLine.
149 * @tc.size : MediumTest
150 * @tc.type : Function
151 * @tc.level : Level 1
152 */
HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_DrawLine004, TestSize.Level1)153 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_DrawLine004, TestSize.Level1)
154 {
155 OH_Drawing_CanvasDrawLine(canvas_, 0, 0, 20, 20);
156 OH_Drawing_CanvasDrawLine(canvas_, -15.2f, -1, 0, 20);
157 }
158
159 /*
160 * @tc.name: NativeDrawingCanvasTest_DrawPath005
161 * @tc.desc: test for OH_Drawing_CanvasDrawPath.
162 * @tc.size : MediumTest
163 * @tc.type : Function
164 * @tc.level : Level 1
165 */
HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_DrawPath005, TestSize.Level1)166 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_DrawPath005, TestSize.Level1)
167 {
168 OH_Drawing_Path* path = OH_Drawing_PathCreate();
169 EXPECT_NE(path, nullptr);
170 constexpr int height = 300;
171 constexpr int width = 300;
172 constexpr float arc = 18.0f;
173 int len = height / 4;
174 float aX = width / 2;
175 float aY = height / 4;
176 float dX = aX - len * std::sin(arc);
177 float dY = aY + len * std::cos(arc);
178 float cX = aX + len * std::sin(arc);
179 float cY = dY;
180 float bX = aX + (len / 2.0);
181 float bY = aY + std::sqrt((cX - dX) * (cX - dX) + (len / 2.0) * (len / 2.0));
182 float eX = aX - (len / 2.0);
183 float eY = bY;
184 OH_Drawing_PathMoveTo(path, aX, aY);
185 OH_Drawing_PathLineTo(path, bX, bY);
186 OH_Drawing_PathLineTo(path, cX, cY);
187 OH_Drawing_PathLineTo(path, dX, dY);
188 OH_Drawing_PathLineTo(path, eX, eY);
189 OH_Drawing_PathClose(path);
190 OH_Drawing_CanvasDrawPath(canvas_, path);
191 OH_Drawing_PathDestroy(path);
192 }
193
194 /*
195 * @tc.name: NativeDrawingCanvasTest_DrawPoints006
196 * @tc.desc: test for OH_Drawing_CanvasDrawPoints.
197 * @tc.size : MediumTest
198 * @tc.type : Function
199 * @tc.level : Level 1
200 */
HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_DrawPoints006, TestSize.Level1)201 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_DrawPoints006, TestSize.Level1)
202 {
203 OH_Drawing_Point2D pointOne={250, 500};
204 OH_Drawing_Point2D pointTwo={200, 500};
205 OH_Drawing_Point2D pointThree={500, 700};
206 OH_Drawing_Point2D points[POINT_PARAMETER] = {pointOne, pointTwo, pointThree};
207 OH_Drawing_CanvasDrawPoints(canvas_, POINT_MODE_POINTS, POINT_PARAMETER, nullptr);
208 OH_Drawing_CanvasDrawPoints(nullptr, POINT_MODE_POINTS, POINT_PARAMETER, nullptr);
209 OH_Drawing_CanvasDrawPoints(canvas_, POINT_MODE_POINTS, POINT_PARAMETER, points);
210 }
211
212 /*
213 * @tc.name: NativeDrawingCanvasTest_DrawVertices007
214 * @tc.desc: test for OH_Drawing_CanvasDrawVertices.
215 * @tc.size : MediumTest
216 * @tc.type : Function
217 * @tc.level : Level 1
218 */
HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_DrawVertices007, TestSize.Level1)219 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_DrawVertices007, TestSize.Level1)
220 {
221 OH_Drawing_Point2D point_one = {0, 0};
222 OH_Drawing_Point2D point_two = {100, 100};
223 OH_Drawing_Point2D point_three = {300, 100};
224 OH_Drawing_Point2D points_vertices[POINT_PARAMETER] = {point_one, point_two, point_three};
225
226 OH_Drawing_Point2D texs_one = {0, 0};
227 OH_Drawing_Point2D texs_two = {1, 1};
228 OH_Drawing_Point2D texs_three = {2, 0};
229 OH_Drawing_Point2D texs_vertices[POINT_PARAMETER] = {texs_one, texs_two, texs_three};
230 uint32_t colors[COLOR_PARAMETER] = {0xFFFF0000, 0xFFFF0000, 0xFFFF0000};
231
232 uint16_t indices[COLOR_PARAMETER] = {0, 1, 2};
233 OH_Drawing_CanvasDrawVertices(nullptr, VERTEX_MODE_TRIANGLES, POINT_PARAMETER, points_vertices, texs_vertices,
234 colors, POINT_PARAMETER, indices, BLEND_MODE_COLOR);
235 OH_Drawing_CanvasDrawVertices(canvas_, VERTEX_MODE_TRIANGLES, POINT_PARAMETER, nullptr, texs_vertices, colors,
236 POINT_PARAMETER, indices, BLEND_MODE_COLOR);
237 OH_Drawing_CanvasDrawVertices(canvas_, VERTEX_MODE_TRIANGLES, POINT_PARAMETER, points_vertices, nullptr, colors,
238 POINT_PARAMETER, indices, BLEND_MODE_COLOR);
239 OH_Drawing_CanvasDrawVertices(canvas_, VERTEX_MODE_TRIANGLES, POINT_PARAMETER, points_vertices, texs_vertices,
240 nullptr, POINT_PARAMETER, indices, BLEND_MODE_COLOR);
241 OH_Drawing_CanvasDrawVertices(canvas_, VERTEX_MODE_TRIANGLES, POINT_PARAMETER, points_vertices, texs_vertices,
242 colors, POINT_PARAMETER, nullptr, BLEND_MODE_COLOR);
243 OH_Drawing_CanvasDrawVertices(nullptr, VERTEX_MODE_TRIANGLES, POINT_PARAMETER, nullptr, nullptr, nullptr,
244 POINT_PARAMETER, nullptr, BLEND_MODE_COLOR);
245 OH_Drawing_CanvasDrawVertices(canvas_, VERTEX_MODE_TRIANGLES, POINT_PARAMETER, points_vertices, texs_vertices,
246 colors, POINT_PARAMETER, indices, BLEND_MODE_COLOR);
247 }
248
249 /*
250 * @tc.name: NativeDrawingCanvasTest_SaveAndRestore008
251 * @tc.desc: test for OH_Drawing_CanvasSave & OH_Drawing_CanvasRestore.
252 * @tc.size : MediumTest
253 * @tc.type : Function
254 * @tc.level : Level 1
255 */
HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_SaveAndRestore008, TestSize.Level1)256 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_SaveAndRestore008, TestSize.Level1)
257 {
258 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(100, 200, 500, 300);
259 EXPECT_NE(nullptr, rect);
260 OH_Drawing_CanvasSave(nullptr);
261 OH_Drawing_CanvasSave(canvas_);
262 OH_Drawing_CanvasTranslate(nullptr, 100, 100);
263 OH_Drawing_CanvasTranslate(canvas_, 100, 100);
264 OH_Drawing_CanvasDrawArc(nullptr, rect, 10, 200);
265 OH_Drawing_CanvasDrawArc(canvas_, nullptr, 10, 200);
266 OH_Drawing_CanvasDrawArc(canvas_, rect, 10, 200);
267 OH_Drawing_CanvasRestore(nullptr);
268 OH_Drawing_CanvasRestore(canvas_);
269 OH_Drawing_CanvasTranslate(canvas_, 200, 200);
270 OH_Drawing_CanvasDrawOval(nullptr, rect);
271 OH_Drawing_CanvasDrawOval(canvas_, nullptr);
272 OH_Drawing_CanvasDrawOval(canvas_, rect);
273 OH_Drawing_RectDestroy(nullptr);
274 OH_Drawing_RectDestroy(rect);
275 }
276
277 /*
278 * @tc.name: NativeDrawingCanvasTest_Clear009
279 * @tc.desc: test for OH_Drawing_CanvasClear.
280 * @tc.size : MediumTest
281 * @tc.type : Function
282 * @tc.level : Level 1
283 */
HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_Clear009, TestSize.Level1)284 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_Clear009, TestSize.Level1)
285 {
286 OH_Drawing_CanvasClear(nullptr, OH_Drawing_ColorSetArgb(0xFF, 0xFF, 0x00, 0x00));
287 OH_Drawing_CanvasClear(canvas_, -100);
288 OH_Drawing_CanvasClear(canvas_, OH_Drawing_ColorSetArgb(INT32_MAX, INT32_MAX, INT32_MIN, INT32_MIN));
289 OH_Drawing_CanvasClear(canvas_, OH_Drawing_ColorSetArgb(0xFF, 0xFF, 0x00, 0x00));
290 }
291
292 /*
293 * @tc.name: NativeDrawingCanvasTest_RestoreToCount010
294 * @tc.desc: test for OH_Drawing_CanvasRestoreToCount.
295 * @tc.size : MediumTest
296 * @tc.type : Function
297 * @tc.level : Level 1
298 */
HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_RestoreToCount010, TestSize.Level1)299 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_RestoreToCount010, TestSize.Level1)
300 {
301 OH_Drawing_CanvasSave(canvas_);
302 OH_Drawing_CanvasTranslate(canvas_, 300, 300);
303 OH_Drawing_CanvasSave(canvas_);
304 OH_Drawing_CanvasTranslate(canvas_, 100, 100);
305 OH_Drawing_CanvasSave(canvas_);
306 OH_Drawing_CanvasTranslate(canvas_, 100, 100);
307 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0, 0, 100, 100);
308 OH_Drawing_CanvasDrawRect(canvas_, rect);
309 int count = OH_Drawing_CanvasGetSaveCount(canvas_);
310 EXPECT_EQ(count, 4);
311 OH_Drawing_CanvasRestoreToCount(nullptr, count - 2);
312 OH_Drawing_CanvasRestoreToCount(canvas_, count - 2);
313 EXPECT_EQ(2, OH_Drawing_CanvasGetSaveCount(canvas_));
314 OH_Drawing_RoundRect *roundRect = OH_Drawing_RoundRectCreate(nullptr, 20, 20);
315 EXPECT_EQ(roundRect, nullptr);
316 roundRect = OH_Drawing_RoundRectCreate(rect, 20, 20);
317 EXPECT_NE(roundRect, nullptr);
318 OH_Drawing_CanvasDrawRoundRect(nullptr, roundRect);
319 OH_Drawing_CanvasDrawRoundRect(canvas_, nullptr);
320 OH_Drawing_CanvasDrawRoundRect(canvas_, roundRect);
321 OH_Drawing_CanvasRestoreToCount(canvas_, 1);
322 OH_Drawing_CanvasDrawRect(canvas_, rect);
323 OH_Drawing_RoundRectDestroy(roundRect);
324 OH_Drawing_RectDestroy(rect);
325 OH_Drawing_RoundRectDestroy(nullptr);
326 OH_Drawing_RectDestroy(nullptr);
327 }
328
329 /*
330 * @tc.name: NativeDrawingCanvasTest_Scale011
331 * @tc.desc: test for OH_Drawing_CanvasScale.
332 * @tc.size : MediumTest
333 * @tc.type : Function
334 * @tc.level : Level 1
335 */
HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_Scale011, TestSize.Level1)336 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_Scale011, TestSize.Level1)
337 {
338 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(10, 20, 60, 120);
339 OH_Drawing_CanvasTranslate(canvas_, 20, 20);
340 OH_Drawing_CanvasDrawRect(canvas_, rect);
341 OH_Drawing_CanvasScale(nullptr, 2, .5f);
342 OH_Drawing_CanvasScale(canvas_, 2, .5f);
343 OH_Drawing_BrushSetColor(nullptr, 0xFF67C23A);
344 OH_Drawing_BrushSetColor(brush_, 0xFF67C23A);
345 OH_Drawing_CanvasDrawRect(canvas_, rect);
346 }
347 /*
348 * @tc.name : NativeDrawingCanvasTest_Skew012
349 * @tc.desc : test for OH_Drawing_CanvasSkew.
350 * @tc.size : MediumTest
351 * @tc.type : Function
352 * @tc.level : Level 1
353 */
HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_Skew012, TestSize.Level1)354 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_Skew012, TestSize.Level1)
355 {
356 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(100, 100, 300, 300);
357 ASSERT_NE(rect, nullptr);
358 OH_Drawing_CanvasSkew(nullptr, 0, 0.3f);
359 OH_Drawing_BrushSetColor(brush_, 0xFF67C23A);
360 OH_Drawing_CanvasSkew(canvas_, 0, 0.3f);
361 OH_Drawing_CanvasDrawRect(canvas_, rect);
362
363 OH_Drawing_Matrix* matrixSkew= OH_Drawing_MatrixCreate();
364 OH_Drawing_MatrixReset(matrixSkew);
365 Matrix* cMatrix = reinterpret_cast<Matrix*>(matrixSkew);
366 EXPECT_NE(cMatrix, nullptr);
367 cMatrix->SetSkew(0, 0.3f);
368
369 OH_Drawing_Matrix* matrixTotal = OH_Drawing_MatrixCreate();
370 OH_Drawing_CanvasGetTotalMatrix(canvas_, nullptr);
371 OH_Drawing_CanvasGetTotalMatrix(nullptr, matrixTotal);
372 float valueMatrixSkew;
373 float valueCanvasSkew;
374 valueMatrixSkew = OH_Drawing_MatrixGetValue(matrixSkew, 0);
375 valueCanvasSkew = OH_Drawing_MatrixGetValue(matrixTotal, 0);
376 EXPECT_TRUE(IsScalarAlmostEqual(valueMatrixSkew, valueCanvasSkew));
377
378 OH_Drawing_CanvasGetTotalMatrix(canvas_, matrixTotal);
379 EXPECT_NE(matrixTotal, nullptr);
380
381 valueMatrixSkew = OH_Drawing_MatrixGetValue(matrixSkew, 0);
382 valueCanvasSkew = OH_Drawing_MatrixGetValue(matrixTotal, 0);
383 EXPECT_TRUE(IsScalarAlmostEqual(valueMatrixSkew, valueCanvasSkew));
384
385 valueMatrixSkew = OH_Drawing_MatrixGetValue(matrixSkew, 1);
386 valueCanvasSkew = OH_Drawing_MatrixGetValue(matrixTotal, 1);
387 EXPECT_TRUE(IsScalarAlmostEqual(valueMatrixSkew, valueCanvasSkew));
388
389 valueMatrixSkew = OH_Drawing_MatrixGetValue(matrixSkew, 2);
390 valueCanvasSkew = OH_Drawing_MatrixGetValue(matrixTotal, 2);
391 EXPECT_TRUE(IsScalarAlmostEqual(valueMatrixSkew, valueCanvasSkew));
392
393 valueMatrixSkew = OH_Drawing_MatrixGetValue(matrixSkew, 3);
394 valueCanvasSkew = OH_Drawing_MatrixGetValue(matrixTotal, 3);
395 EXPECT_TRUE(IsScalarAlmostEqual(valueMatrixSkew, valueCanvasSkew));
396
397 valueMatrixSkew = OH_Drawing_MatrixGetValue(matrixSkew, 4);
398 valueCanvasSkew = OH_Drawing_MatrixGetValue(matrixTotal, 4);
399 EXPECT_TRUE(IsScalarAlmostEqual(valueMatrixSkew, valueCanvasSkew));
400
401 valueMatrixSkew = OH_Drawing_MatrixGetValue(matrixSkew, 5);
402 valueCanvasSkew = OH_Drawing_MatrixGetValue(matrixTotal, 5);
403 EXPECT_TRUE(IsScalarAlmostEqual(valueMatrixSkew, valueCanvasSkew));
404
405 valueMatrixSkew = OH_Drawing_MatrixGetValue(matrixSkew, 6);
406 valueCanvasSkew = OH_Drawing_MatrixGetValue(matrixTotal, 6);
407 EXPECT_TRUE(IsScalarAlmostEqual(valueMatrixSkew, valueCanvasSkew));
408
409 valueMatrixSkew = OH_Drawing_MatrixGetValue(matrixSkew, 7);
410 valueCanvasSkew = OH_Drawing_MatrixGetValue(matrixTotal, 7);
411 EXPECT_TRUE(IsScalarAlmostEqual(valueMatrixSkew, valueCanvasSkew));
412
413 valueMatrixSkew = OH_Drawing_MatrixGetValue(matrixSkew, 8);
414 valueCanvasSkew = OH_Drawing_MatrixGetValue(matrixTotal, 8);
415 EXPECT_TRUE(IsScalarAlmostEqual(valueMatrixSkew, valueCanvasSkew));
416
417 OH_Drawing_RectDestroy(rect);
418 OH_Drawing_MatrixDestroy(matrixSkew);
419 OH_Drawing_MatrixDestroy(matrixTotal);
420 }
421 /*
422 * @tc.name: NativeDrawingCanvasTest_ClipRect013
423 * @tc.desc: test for OH_Drawing_CanvasClipRect.
424 * @tc.size : MediumTest
425 * @tc.type : Function
426 * @tc.level : Level 1
427 */
HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_ClipRect013, TestSize.Level1)428 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_ClipRect013, TestSize.Level1)
429 {
430 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0, 0, 90, 90);
431 OH_Drawing_CanvasRotate(nullptr, 10, 0, 0);
432 OH_Drawing_CanvasRotate(canvas_, 10, 0, 0);
433 OH_Drawing_Point *point = OH_Drawing_PointCreate(100, 60);
434 OH_Drawing_BrushSetAntiAlias(nullptr, true);
435 OH_Drawing_BrushSetAntiAlias(brush_, true);
436 for (auto alias : {false, true}) {
437 OH_Drawing_CanvasSave(canvas_);
438 OH_Drawing_CanvasClipRect(nullptr, rect, OH_Drawing_CanvasClipOp::INTERSECT, alias);
439 OH_Drawing_CanvasClipRect(canvas_, nullptr, OH_Drawing_CanvasClipOp::INTERSECT, alias);
440 OH_Drawing_CanvasClipRect(canvas_, rect, OH_Drawing_CanvasClipOp::INTERSECT, alias);
441 OH_Drawing_CanvasDrawCircle(canvas_, nullptr, 60);
442 OH_Drawing_CanvasDrawCircle(nullptr, point, 60);
443 OH_Drawing_CanvasDrawCircle(canvas_, point, 60);
444 OH_Drawing_CanvasRestore(canvas_);
445 OH_Drawing_CanvasTranslate(canvas_, 80, 0);
446 }
447 OH_Drawing_RectDestroy(rect);
448 OH_Drawing_PointDestroy(point);
449 }
450
451 /*
452 * @tc.name: NativeDrawingCanvasTest_ClipPath014
453 * @tc.desc: test for OH_Drawing_CanvasClipPath.
454 * @tc.size : MediumTest
455 * @tc.type : Function
456 * @tc.level : Level 1
457 */
HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_ClipPath014, TestSize.Level1)458 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_ClipPath014, TestSize.Level1)
459 {
460 OH_Drawing_Path *path = OH_Drawing_PathCreate();
461 OH_Drawing_PathMoveTo(path, 100, 300);
462 OH_Drawing_PathLineTo(path, 200, 300);
463 OH_Drawing_PathLineTo(path, 200, 400);
464 OH_Drawing_PathLineTo(path, 100, 350);
465 OH_Drawing_PathClose(nullptr);
466 OH_Drawing_PathClose(path);
467 OH_Drawing_CanvasClipPath(nullptr, path, OH_Drawing_CanvasClipOp::DIFFERENCE, true);
468 OH_Drawing_CanvasClipPath(canvas_, nullptr, OH_Drawing_CanvasClipOp::DIFFERENCE, true);
469 OH_Drawing_CanvasClipPath(canvas_, path, OH_Drawing_CanvasClipOp::DIFFERENCE, true);
470 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(100, 300, 200, 400);
471 OH_Drawing_CanvasDrawRect(canvas_, rect);
472 OH_Drawing_RectDestroy(rect);
473 OH_Drawing_PathDestroy(path);
474 }
475
476 /*
477 * @tc.name: NativeDrawingCanvasTest_LinearGradient015
478 * @tc.desc: test for LinearGradient
479 * @tc.size : MediumTest
480 * @tc.type : Function
481 * @tc.level : Level 1
482 */
HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_LinearGradient015, TestSize.Level1)483 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_LinearGradient015, TestSize.Level1)
484 {
485 OH_Drawing_Point* startPt = OH_Drawing_PointCreate(100, 400);
486 OH_Drawing_Point* endPt = OH_Drawing_PointCreate(200, 500);
487 uint32_t color[] = {0xffff0000, 0xff00ff00};
488 float pos[] = {0., 1.0};
489 OH_Drawing_ShaderEffect* linearGradient = OH_Drawing_ShaderEffectCreateLinearGradient(startPt, endPt,
490 color, pos, 2, OH_Drawing_TileMode::CLAMP);
491 OH_Drawing_BrushSetShaderEffect(nullptr, linearGradient);
492 OH_Drawing_BrushSetShaderEffect(brush_, nullptr);
493 OH_Drawing_BrushSetShaderEffect(brush_, linearGradient);
494 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(200, 500, 300, 600);
495 OH_Drawing_CanvasDrawRect(canvas_, rect);
496 OH_Drawing_RectDestroy(rect);
497 OH_Drawing_ShaderEffectDestroy(nullptr);
498 OH_Drawing_ShaderEffectDestroy(linearGradient);
499 OH_Drawing_PointDestroy(startPt);
500 OH_Drawing_PointDestroy(endPt);
501 }
502
503 /*
504 * @tc.name: NativeDrawingCanvasTest_SweepGradient016
505 * @tc.desc: test for sweep gradient shader effect
506 * @tc.size : MediumTest
507 * @tc.type : Function
508 * @tc.level : Level 1
509 */
HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_SweepGradient016, TestSize.Level1)510 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_SweepGradient016, TestSize.Level1)
511 {
512 OH_Drawing_Point* centerPt = OH_Drawing_PointCreate(350, 450);
513 uint32_t colors[] = {0xffff00ff, 0xff00ff00};
514 float pos[] = {0., 1.0};
515 OH_Drawing_ShaderEffect* sweepGradient = OH_Drawing_ShaderEffectCreateSweepGradient(nullptr, nullptr,
516 nullptr, -2, OH_Drawing_TileMode::MIRROR);
517 EXPECT_EQ(sweepGradient, nullptr);
518 sweepGradient = OH_Drawing_ShaderEffectCreateSweepGradient(centerPt, colors,
519 pos, 2, OH_Drawing_TileMode::MIRROR);
520 EXPECT_NE(sweepGradient, nullptr);
521 OH_Drawing_BrushSetShaderEffect(brush_, sweepGradient);
522 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(300, 400, 500, 500);
523 OH_Drawing_CanvasDrawRect(canvas_, rect);
524 OH_Drawing_RectDestroy(rect);
525 OH_Drawing_ShaderEffectDestroy(sweepGradient);
526 OH_Drawing_PointDestroy(centerPt);
527 }
528 /*
529 * @tc.name: NativeDrawingCanvasTest_ImageShader017
530 * @tc.desc: test for image shader effect
531 * @tc.size : MediumTest
532 * @tc.type : Function
533 * @tc.level : Level 1
534 */
HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_ImageShader017, TestSize.Level1)535 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_ImageShader017, TestSize.Level1)
536 {
537 OH_Drawing_Image *image = OH_Drawing_ImageCreate();
538 OH_Drawing_Brush *brush = OH_Drawing_BrushCreate();
539 OH_Drawing_BrushSetColor(brush, OH_Drawing_ColorSetArgb(0xFF, 0xFF, 0xFF, 0x00));
540 OH_Drawing_SamplingOptions *options = OH_Drawing_SamplingOptionsCreate(FILTER_MODE_LINEAR, MIPMAP_MODE_LINEAR);
541 OH_Drawing_Matrix *matrix = OH_Drawing_MatrixCreate();
542 OH_Drawing_ShaderEffect *effect = nullptr;
543 effect = OH_Drawing_ShaderEffectCreateImageShader(nullptr, CLAMP, CLAMP, nullptr, nullptr);
544 EXPECT_EQ(effect, nullptr);
545 effect = OH_Drawing_ShaderEffectCreateImageShader(image, CLAMP, CLAMP, options, matrix);
546 OH_Drawing_BrushSetShaderEffect(brush, effect);
547 OH_Drawing_CanvasAttachBrush(canvas_, brush);
548 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(300, 400, 500, 500);
549 OH_Drawing_CanvasDrawRect(canvas_, rect);
550 OH_Drawing_RectDestroy(rect);
551 OH_Drawing_ShaderEffectDestroy(effect);
552 OH_Drawing_MatrixDestroy(matrix);
553 OH_Drawing_SamplingOptionsDestroy(options);
554 OH_Drawing_BrushDestroy(brush);
555 OH_Drawing_ImageDestroy(image);
556 }
557
558 /*
559 * @tc.name: NativeDrawingCanvasTest_RadialGradient
560 * @tc.desc: test for Radial gradient shader effect
561 * @tc.size : MediumTest
562 * @tc.type : Function
563 * @tc.level : Level 1
564 */
HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_RadialGradient, TestSize.Level1)565 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_RadialGradient, TestSize.Level1)
566 {
567 OH_Drawing_Point* centerPt = OH_Drawing_PointCreate(350, 450);
568 uint32_t colors[] = {0xffff00ff, 0xff00ff00};
569 float pos[] = {0., 1.0};
570 OH_Drawing_ShaderEffect* radialGradient = OH_Drawing_ShaderEffectCreateRadialGradient(nullptr, 20,
571 nullptr, nullptr, -2, OH_Drawing_TileMode::MIRROR);
572 EXPECT_EQ(radialGradient, nullptr);
573 radialGradient = OH_Drawing_ShaderEffectCreateRadialGradient(centerPt, 30, colors,
574 pos, 2, OH_Drawing_TileMode::MIRROR);
575 EXPECT_NE(radialGradient, nullptr);
576 OH_Drawing_BrushSetShaderEffect(brush_, radialGradient);
577 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(300, 400, 500, 500);
578 OH_Drawing_CanvasDrawRect(canvas_, rect);
579 OH_Drawing_RectDestroy(rect);
580 OH_Drawing_ShaderEffectDestroy(radialGradient);
581 OH_Drawing_PointDestroy(centerPt);
582 }
583
584 /*
585 * @tc.name: NativeDrawingCanvasTest_MaskFilter018
586 * @tc.desc: test for maskfilter
587 * @tc.size : MediumTest
588 * @tc.type : Function
589 * @tc.level : Level 1
590 */
HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_MaskFilter018, TestSize.Level1)591 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_MaskFilter018, TestSize.Level1)
592 {
593 EXPECT_EQ(OH_Drawing_BrushGetColor(brush_), 0xFFFF0000);
594 OH_Drawing_MaskFilter* maskFilter = OH_Drawing_MaskFilterCreateBlur(OH_Drawing_BlurType::NORMAL, 10, true);
595 OH_Drawing_Filter* filter = OH_Drawing_FilterCreate();
596 OH_Drawing_FilterSetMaskFilter(nullptr, maskFilter);
597 OH_Drawing_FilterSetMaskFilter(filter, nullptr);
598 OH_Drawing_FilterSetMaskFilter(filter, maskFilter);
599 OH_Drawing_BrushSetFilter(brush_, filter);
600 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(200, 500, 300, 600);
601 OH_Drawing_CanvasDrawRect(canvas_, rect);
602 OH_Drawing_RectDestroy(rect);
603 OH_Drawing_MaskFilterDestroy(maskFilter);
604 OH_Drawing_FilterDestroy(filter);
605 }
606
607 /*
608 * @tc.name: NativeDrawingCanvasTest_ColorFilter019
609 * @tc.desc: test for colorfilter create blend mode, linear to srgb gamma, luma, matrix
610 * @tc.size : MediumTest
611 * @tc.type : Function
612 * @tc.level : Level 1
613 */
HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_ColorFilterCreateBlendMode019, TestSize.Level1)614 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_ColorFilterCreateBlendMode019, TestSize.Level1)
615 {
616 EXPECT_EQ(OH_Drawing_BrushGetColor(brush_), 0xFFFF0000);
617 OH_Drawing_ColorFilter* colorFilter = OH_Drawing_ColorFilterCreateBlendMode(0xff0000ff,
618 OH_Drawing_BlendMode::BLEND_MODE_SRC);
619 EXPECT_NE(colorFilter, nullptr);
620 OH_Drawing_ColorFilter* colorFilterTmp = OH_Drawing_ColorFilterCreateLinearToSrgbGamma();
621 EXPECT_NE(colorFilterTmp, nullptr);
622 OH_Drawing_Filter* filter = OH_Drawing_FilterCreate();
623 EXPECT_NE(filter, nullptr);
624
625 OH_Drawing_FilterSetColorFilter(nullptr, colorFilter);
626 OH_Drawing_FilterSetColorFilter(filter, nullptr);
627 OH_Drawing_FilterGetColorFilter(filter, colorFilterTmp);
628 EXPECT_EQ(reinterpret_cast<ColorFilter*>(colorFilterTmp)->GetType(), ColorFilter::FilterType::NO_TYPE);
629
630 OH_Drawing_FilterSetColorFilter(filter, colorFilter);
631 OH_Drawing_FilterGetColorFilter(filter, colorFilterTmp);
632 EXPECT_EQ(reinterpret_cast<ColorFilter*>(colorFilterTmp)->GetType(), ColorFilter::FilterType::BLEND_MODE);
633
634 OH_Drawing_BrushSetFilter(brush_, nullptr);
635 OH_Drawing_BrushSetFilter(brush_, filter);
636 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0, 0, 100, 100);
637 OH_Drawing_CanvasDrawRect(canvas_, rect);
638 OH_Drawing_ColorFilter* linear = OH_Drawing_ColorFilterCreateLinearToSrgbGamma();
639 OH_Drawing_FilterSetColorFilter(filter, linear);
640 OH_Drawing_CanvasTranslate(canvas_, 100, 100);
641 OH_Drawing_CanvasDrawRect(canvas_, rect);
642 OH_Drawing_ColorFilter* luma = OH_Drawing_ColorFilterCreateLuma();
643 OH_Drawing_FilterSetColorFilter(filter, luma);
644 OH_Drawing_CanvasTranslate(canvas_, 200, 200);
645 OH_Drawing_CanvasDrawRect(canvas_, rect);
646 const float matrix[20] = {
647 1, 0, 0, 0, 0,
648 0, 1, 0, 0, 0,
649 0, 0, 1, 0, 0,
650 0, 0, 0, 0.5f, 0
651 };
652 OH_Drawing_ColorFilter* matrixFilter = OH_Drawing_ColorFilterCreateMatrix(nullptr);
653 EXPECT_EQ(matrixFilter, nullptr);
654 matrixFilter = OH_Drawing_ColorFilterCreateMatrix(matrix);
655 EXPECT_NE(matrixFilter, nullptr);
656 OH_Drawing_FilterSetColorFilter(filter, matrixFilter);
657 OH_Drawing_CanvasTranslate(canvas_, 300, 300);
658 OH_Drawing_CanvasDrawRect(canvas_, rect);
659 OH_Drawing_RectDestroy(rect);
660 OH_Drawing_ColorFilterDestroy(colorFilter);
661 OH_Drawing_ColorFilterDestroy(luma);
662 OH_Drawing_ColorFilterDestroy(matrixFilter);
663 OH_Drawing_ColorFilterDestroy(linear);
664 OH_Drawing_ColorFilterDestroy(colorFilterTmp);
665 OH_Drawing_FilterDestroy(filter);
666 OH_Drawing_FilterDestroy(nullptr);
667 }
668
669 /*
670 * @tc.name: NativeDrawingCanvasTest_ColorFilterCreateCompose020
671 * @tc.desc: test for create compose color filter
672 * @tc.size : MediumTest
673 * @tc.type : Function
674 * @tc.level : Level 1
675 */
HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_ColorFilterCreateCompose020, TestSize.Level1)676 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_ColorFilterCreateCompose020, TestSize.Level1)
677 {
678 EXPECT_EQ(OH_Drawing_BrushGetColor(brush_), 0xFFFF0000);
679 OH_Drawing_ColorFilter* outerFilter = OH_Drawing_ColorFilterCreateLuma();
680 OH_Drawing_ColorFilter* innerFilter = OH_Drawing_ColorFilterCreateSrgbGammaToLinear();
681 OH_Drawing_ColorFilter* compose = OH_Drawing_ColorFilterCreateCompose(nullptr, nullptr);
682 EXPECT_EQ(compose, nullptr);
683 compose = OH_Drawing_ColorFilterCreateCompose(outerFilter, innerFilter);
684 EXPECT_NE(compose, nullptr);
685 OH_Drawing_Filter* filter = OH_Drawing_FilterCreate();
686 OH_Drawing_FilterSetColorFilter(filter, compose);
687 OH_Drawing_BrushSetFilter(brush_, filter);
688 OH_Drawing_Canvas* canvas_ = OH_Drawing_CanvasCreate();
689 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(200, 500, 300, 600);
690 OH_Drawing_CanvasDrawRect(canvas_, rect);
691 OH_Drawing_RectDestroy(rect);
692 OH_Drawing_ColorFilterDestroy(outerFilter);
693 OH_Drawing_ColorFilterDestroy(innerFilter);
694 OH_Drawing_ColorFilterDestroy(compose);
695 OH_Drawing_FilterDestroy(filter);
696 }
697
698 /*
699 * @tc.name: NativeDrawingCanvasTest_DrawBitmap021
700 * @tc.desc: test for DrawBitmap
701 * @tc.size : MediumTest
702 * @tc.type : Function
703 * @tc.level : Level 1
704 */
HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_DrawBitmap021, TestSize.Level1)705 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_DrawBitmap021, TestSize.Level1)
706 {
707 OH_Drawing_Bitmap* bitmap = OH_Drawing_BitmapCreate();
708 OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE};
709 constexpr uint32_t width = 200;
710 constexpr uint32_t height = 200;
711 OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat);
712 OH_Drawing_CanvasBind(canvas_, bitmap);
713 OH_Drawing_CanvasDrawBitmap(canvas_, bitmap, 0, 0);
714 OH_Drawing_CanvasClear(canvas_, OH_Drawing_ColorSetArgb(0xFF, 0xFF, 0xFF, 0xFF));
715 OH_Drawing_BitmapDestroy(bitmap);
716 }
717 /*
718 * @tc.name: NativeDrawingCanvasTest_DrawBitmapRect022
719 * @tc.desc: test for DrawBitmapRect
720 * @tc.size : MediumTest
721 * @tc.type : Function
722 * @tc.level : Level 1
723 */
HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_DrawBitmapRect022, TestSize.Level1)724 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_DrawBitmapRect022, TestSize.Level1)
725 {
726 OH_Drawing_Bitmap* bitmap = OH_Drawing_BitmapCreate();
727 EXPECT_NE(bitmap, nullptr);
728 OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE};
729 constexpr uint32_t width = 200;
730 constexpr uint32_t height = 200;
731 OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat);
732 OH_Drawing_Rect* src = OH_Drawing_RectCreate(0, 0, 200, 200);
733 EXPECT_NE(src, nullptr);
734 OH_Drawing_Rect* dst = OH_Drawing_RectCreate(0, 0, 200, 200);
735 EXPECT_NE(dst, nullptr);
736 OH_Drawing_SamplingOptions* options = OH_Drawing_SamplingOptionsCreate(
737 OH_Drawing_FilterMode::FILTER_MODE_NEAREST, OH_Drawing_MipmapMode::MIPMAP_MODE_NEAREST);
738 EXPECT_NE(options, nullptr);
739 OH_Drawing_CanvasDrawBitmapRect(canvas_, bitmap, src, dst, options);
740 OH_Drawing_CanvasDrawBitmapRect(canvas_, bitmap, src, dst, nullptr);
741 OH_Drawing_CanvasDrawBitmapRect(canvas_, bitmap, src, nullptr, nullptr);
742 OH_Drawing_CanvasDrawBitmapRect(canvas_, bitmap, nullptr, nullptr, nullptr);
743 OH_Drawing_CanvasDrawBitmapRect(canvas_, nullptr, nullptr, nullptr, nullptr);
744 OH_Drawing_CanvasDrawBitmapRect(nullptr, nullptr, nullptr, nullptr, nullptr);
745 OH_Drawing_BitmapDestroy(bitmap);
746 }
747
748 /*
749 * @tc.name: NativeDrawingCanvasTest_SetMatrix023
750 * @tc.desc: test for SetMatrix
751 * @tc.size : MediumTest
752 * @tc.type : Function
753 * @tc.level : Level 1
754 */
HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_SetMatrix023, TestSize.Level1)755 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_SetMatrix023, TestSize.Level1)
756 {
757 OH_Drawing_Matrix* matrix = OH_Drawing_MatrixCreate();
758 EXPECT_NE(matrix, nullptr);
759 OH_Drawing_MatrixSetMatrix(
760 matrix,
761 1, 0, 0,
762 0, -1, 0,
763 0, 0, 1);
764 OH_Drawing_CanvasSetMatrix(canvas_, matrix);
765 OH_Drawing_CanvasSetMatrix(canvas_, nullptr);
766 OH_Drawing_CanvasSetMatrix(nullptr, nullptr);
767 OH_Drawing_MatrixDestroy(matrix);
768 }
769
770 /*
771 * @tc.name: NativeDrawingCanvasTest_ResetMatrix024
772 * @tc.desc: test for ResetMatrix
773 * @tc.size : MediumTest
774 * @tc.type : Function
775 * @tc.level : Level 1
776 */
HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_ResetMatrix024, TestSize.Level1)777 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_ResetMatrix024, TestSize.Level1)
778 {
779 OH_Drawing_CanvasResetMatrix(nullptr);
780 OH_Drawing_CanvasResetMatrix(canvas_);
781 }
782
783 /*
784 * @tc.name: NativeDrawingCanvasTest_DrawImageRect025
785 * @tc.desc: test for DrawImageRect
786 * @tc.size : MediumTest
787 * @tc.type : Function
788 * @tc.level : Level 1
789 */
HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_DrawImageRect025, TestSize.Level1)790 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_DrawImageRect025, TestSize.Level1)
791 {
792 OH_Drawing_Rect* rect = OH_Drawing_RectCreate(0, 0, 200, 200);
793 EXPECT_NE(rect, nullptr);
794 OH_Drawing_Image* image = OH_Drawing_ImageCreate();
795 EXPECT_NE(image, nullptr);
796 OH_Drawing_Bitmap* bitmap = OH_Drawing_BitmapCreate();
797 EXPECT_NE(bitmap, nullptr);
798 OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE};
799 constexpr uint32_t width = 200;
800 constexpr uint32_t height = 200;
801 OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat);
802 OH_Drawing_ImageBuildFromBitmap(image, bitmap);
803 OH_Drawing_SamplingOptions* options = OH_Drawing_SamplingOptionsCreate(
804 OH_Drawing_FilterMode::FILTER_MODE_NEAREST, OH_Drawing_MipmapMode::MIPMAP_MODE_NEAREST);
805 EXPECT_NE(options, nullptr);
806 OH_Drawing_CanvasDrawImageRect(canvas_, image, rect, options);
807 OH_Drawing_CanvasDrawImageRect(canvas_, image, rect, nullptr);
808 OH_Drawing_CanvasDrawImageRect(canvas_, image, nullptr, nullptr);
809 OH_Drawing_CanvasDrawImageRect(canvas_, nullptr, nullptr, nullptr);
810 OH_Drawing_CanvasDrawImageRect(nullptr, nullptr, nullptr, nullptr);
811 OH_Drawing_CanvasDrawImageRectWithSrc(canvas_, image, rect, rect, options, STRICT_SRC_RECT_CONSTRAINT);
812 OH_Drawing_CanvasDrawImageRectWithSrc(nullptr, nullptr, nullptr, nullptr, nullptr, STRICT_SRC_RECT_CONSTRAINT);
813 OH_Drawing_SamplingOptionsDestroy(options);
814 OH_Drawing_BitmapDestroy(bitmap);
815 OH_Drawing_ImageDestroy(image);
816 }
817
818 /*
819 * @tc.name: NativeDrawingCanvasTest_ReadPixelsToBitmap026
820 * @tc.desc: test for ReadPixelsToBitmap
821 * @tc.size : MediumTest
822 * @tc.type : Function
823 * @tc.level : Level 1
824 */
HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_ReadPixelsToBitmap026, TestSize.Level1)825 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_ReadPixelsToBitmap026, TestSize.Level1)
826 {
827 OH_Drawing_Bitmap* bitmap = OH_Drawing_BitmapCreate();
828 EXPECT_NE(bitmap, nullptr);
829 EXPECT_TRUE(!OH_Drawing_CanvasReadPixelsToBitmap(canvas_, bitmap, 100, 100));
830 EXPECT_TRUE(!OH_Drawing_CanvasReadPixelsToBitmap(canvas_, nullptr, 100, 100));
831 EXPECT_TRUE(!OH_Drawing_CanvasReadPixelsToBitmap(nullptr, nullptr, 100, 100));
832 OH_Drawing_BitmapDestroy(bitmap);
833 }
834
835 /*
836 * @tc.name: NativeDrawingCanvasTest_ReadPixels027
837 * @tc.desc: test for ReadPixels
838 * @tc.size : MediumTest
839 * @tc.type : Function
840 * @tc.level : Level 1
841 */
HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_ReadPixels027, TestSize.Level1)842 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_ReadPixels027, TestSize.Level1)
843 {
844 OH_Drawing_Image_Info imageInfo;
845 OH_Drawing_Bitmap* bitmap = OH_Drawing_BitmapCreate();
846 EXPECT_NE(bitmap, nullptr);
847 OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE};
848 constexpr uint32_t width = 200;
849 constexpr uint32_t height = 200;
850 OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat);
851 void* pixels = OH_Drawing_BitmapGetPixels(bitmap);
852 EXPECT_TRUE(!OH_Drawing_CanvasReadPixels(canvas_, &imageInfo, pixels, 0, 0, 0));
853 EXPECT_TRUE(!OH_Drawing_CanvasReadPixels(canvas_, &imageInfo, nullptr, 0, 0, 0));
854 EXPECT_TRUE(!OH_Drawing_CanvasReadPixels(canvas_, nullptr, nullptr, 0, 0, 0));
855 EXPECT_TRUE(!OH_Drawing_CanvasReadPixels(nullptr, nullptr, nullptr, 0, 0, 0));
856 OH_Drawing_BitmapDestroy(bitmap);
857 }
858
859 /*
860 * @tc.name: NativeDrawingCanvasTest_GetWidth028
861 * @tc.desc: test for GetWidth
862 * @tc.size : MediumTest
863 * @tc.type : Function
864 * @tc.level : Level 1
865 */
HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_GetWidth028, TestSize.Level1)866 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_GetWidth028, TestSize.Level1)
867 {
868 EXPECT_TRUE(OH_Drawing_CanvasGetWidth(nullptr) == 0);
869 EXPECT_TRUE(OH_Drawing_CanvasGetWidth(canvas_) >= 0);
870 }
871
872 /*
873 * @tc.name: NativeDrawingCanvasTest_GetHeight029
874 * @tc.desc: test for GetHeight
875 * @tc.size : MediumTest
876 * @tc.type : Function
877 * @tc.level : Level 1
878 */
HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_GetHeight029, TestSize.Level1)879 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_GetHeight029, TestSize.Level1)
880 {
881 EXPECT_TRUE(OH_Drawing_CanvasGetHeight(nullptr) == 0);
882 EXPECT_TRUE(OH_Drawing_CanvasGetHeight(canvas_) >= 0);
883 }
884
885 /*
886 * @tc.name: NativeDrawingCanvasTest_GetLocalClipBounds030
887 * @tc.desc: test for GetLocalClipBounds
888 * @tc.size : MediumTest
889 * @tc.type : Function
890 * @tc.level : Level 1
891 */
HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_GetLocalClipBounds030, TestSize.Level1)892 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_GetLocalClipBounds030, TestSize.Level1)
893 {
894 OH_Drawing_CanvasGetLocalClipBounds(nullptr, nullptr);
895 OH_Drawing_Rect* rect = OH_Drawing_RectCreate(0, 0, 1, 1);
896 EXPECT_NE(rect, nullptr);
897 OH_Drawing_CanvasGetLocalClipBounds(nullptr, rect);
898 OH_Drawing_CanvasGetLocalClipBounds(canvas_, rect);
899 OH_Drawing_RectDestroy(rect);
900 }
901
902 /*
903 * @tc.name: NativeDrawingCanvasTest_ConcatMatrix031
904 * @tc.desc: test for ConcatMatrix
905 * @tc.size : MediumTest
906 * @tc.type : Function
907 * @tc.level : Level 1
908 */
HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_ConcatMatrix031, TestSize.Level1)909 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_ConcatMatrix031, TestSize.Level1)
910 {
911 OH_Drawing_Matrix* matrix = OH_Drawing_MatrixCreate();
912 EXPECT_NE(matrix, nullptr);
913 OH_Drawing_MatrixSetMatrix(
914 matrix,
915 1, 0, 0,
916 0, -1, 0,
917 0, 0, 1);
918 OH_Drawing_CanvasConcatMatrix(canvas_, matrix);
919 OH_Drawing_CanvasConcatMatrix(canvas_, nullptr);
920 OH_Drawing_CanvasConcatMatrix(nullptr, nullptr);
921 OH_Drawing_MatrixDestroy(matrix);
922 }
923
924 /*
925 * @tc.name: NativeDrawingCanvasTest_DrawShadow032
926 * @tc.desc: test for DrawShadow
927 * @tc.size : MediumTest
928 * @tc.type : Function
929 * @tc.level : Level 1
930 */
HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_DrawShadow032, TestSize.Level1)931 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_DrawShadow032, TestSize.Level1)
932 {
933 OH_Drawing_Point3D p1{0.0, 0.0, 0.0};
934 OH_Drawing_Point3D p2{10.0, 10.0, 10.0};
935 OH_Drawing_CanvasDrawShadow(nullptr, nullptr, p1, p2, 0, 0xFF000000,
936 0xFF000000, OH_Drawing_CanvasShadowFlags::SHADOW_FLAGS_ALL);
937
938 OH_Drawing_Path* path = OH_Drawing_PathCreate();
939 EXPECT_NE(path, nullptr);
940 OH_Drawing_CanvasDrawShadow(canvas_, path, p1, p2, 10, 0xFF000000, 0xFF000000,
941 OH_Drawing_CanvasShadowFlags::SHADOW_FLAGS_ALL);
942 }
943 /*
944 * @tc.name: NativeDrawingCanvasTest_DrawTextBlob033
945 * @tc.desc: test for DrawTextBlob
946 * @tc.size : MediumTest
947 * @tc.type : Function
948 * @tc.level : Level 1
949 */
HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_DrawTextBlob033, TestSize.Level1)950 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_DrawTextBlob033, TestSize.Level1)
951 {
952 OH_Drawing_Font *font = OH_Drawing_FontCreate();
953 OH_Drawing_FontSetFakeBoldText(font, true);
954 OH_Drawing_FontSetTextSize(font, 20);
955 OH_Drawing_FontSetTextSkewX(font, 0.25);
956 OH_Drawing_Typeface *typeSurface = OH_Drawing_TypefaceCreateDefault();
957 OH_Drawing_FontSetTypeface(font, typeSurface);
958 auto *builder = OH_Drawing_TextBlobBuilderCreate();
959 EXPECT_EQ(nullptr, OH_Drawing_TextBlobBuilderAllocRunPos(nullptr, nullptr, INT32_MAX, nullptr));
960 EXPECT_EQ(nullptr, OH_Drawing_TextBlobBuilderAllocRunPos(builder, font, INT32_MIN, nullptr));
961 const OH_Drawing_RunBuffer* runBuffer = OH_Drawing_TextBlobBuilderAllocRunPos(builder, font, 9, nullptr);
962 ASSERT_NE(runBuffer, nullptr);
963 runBuffer->glyphs[0] = 65;
964 runBuffer->pos[0] = 0;
965 runBuffer->pos[1] = 0;
966 runBuffer->glyphs[1] = 227;
967 runBuffer->pos[2] = 14.9;
968 runBuffer->pos[3] = 0;
969 runBuffer->glyphs[2] = 283;
970 runBuffer->pos[4] = 25.84;
971 runBuffer->pos[5] = 0;
972 runBuffer->glyphs[3] = 283;
973 runBuffer->pos[6] = 30.62;
974 runBuffer->pos[7] = 0;
975 runBuffer->glyphs[4] = 299;
976 runBuffer->pos[8] = 35.4;
977 runBuffer->pos[9] = 0;
978 runBuffer->glyphs[5] = 2;
979 runBuffer->pos[10] = 47.22;
980 runBuffer->pos[11] = 0;
981 runBuffer->glyphs[6]= 94;
982 runBuffer->pos[12] = 52.62;
983 runBuffer->pos[13] = 0;
984 runBuffer->glyphs[7] = 37;
985 runBuffer->pos[14] = 67.42;
986 runBuffer->pos[15] = 0;
987 runBuffer->glyphs[8] = 84;
988 runBuffer->pos[16] = 81.7;
989 runBuffer->pos[17] = 0;
990 OH_Drawing_TextBlob *textBlob = OH_Drawing_TextBlobBuilderMake(builder);
991 OH_Drawing_CanvasDrawTextBlob(canvas_, textBlob, 100, 700);
992 OH_Drawing_TextBlobDestroy(textBlob);
993 OH_Drawing_TextBlobBuilderDestroy(builder);
994 OH_Drawing_FontDestroy(font);
995 OH_Drawing_TypefaceDestroy(typeSurface);
996 OH_Drawing_TextBlobDestroy(nullptr);
997 OH_Drawing_TextBlobBuilderDestroy(nullptr);
998 OH_Drawing_FontDestroy(nullptr);
999 OH_Drawing_TypefaceDestroy(nullptr);
1000 }
1001
1002 /*
1003 * @tc.name: NativeDrawingCanvasTest_DrawTextBlob034
1004 * @tc.desc: test for DrawTextBlob2
1005 * @tc.size : MediumTest
1006 * @tc.type : Function
1007 * @tc.level : Level 1
1008 */
HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_DrawTextBlob034, TestSize.Level1)1009 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_DrawTextBlob034, TestSize.Level1)
1010 {
1011 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0, 0, 0, 0);
1012 EXPECT_NE(rect, nullptr);
1013 OH_Drawing_Font *font = OH_Drawing_FontCreate();
1014 EXPECT_NE(font, nullptr);
1015 const char* str = "123456";
1016 EXPECT_EQ(nullptr, OH_Drawing_TextBlobCreateFromString(nullptr,
1017 font, OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8));
1018 EXPECT_EQ(nullptr, OH_Drawing_TextBlobCreateFromString(str,
1019 nullptr, OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8));
1020 OH_Drawing_TextBlob *textBlob = OH_Drawing_TextBlobCreateFromString(str,
1021 font, OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8);
1022 EXPECT_NE(textBlob, nullptr);
1023 OH_Drawing_CanvasDrawTextBlob(canvas_, textBlob, 0, 0);
1024 OH_Drawing_TextBlobGetBounds(textBlob, nullptr);
1025 OH_Drawing_TextBlobGetBounds(textBlob, rect);
1026 OH_Drawing_CanvasDrawRect(canvas_, rect);
1027 OH_Drawing_TextBlobDestroy(textBlob);
1028 OH_Drawing_FontDestroy(font);
1029 OH_Drawing_RectDestroy(rect);
1030 }
1031
1032 /*
1033 * @tc.name: NativeDrawingCanvasTest_DrawTextBlob035
1034 * @tc.desc: test for DrawTextBlob3
1035 * @tc.size : MediumTest
1036 * @tc.type : Function
1037 * @tc.level : Level 1
1038 */
HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_DrawTextBlob035, TestSize.Level1)1039 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_DrawTextBlob035, TestSize.Level1)
1040 {
1041 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0, 0, 0, 0);
1042 EXPECT_NE(rect, nullptr);
1043 OH_Drawing_Font *font = OH_Drawing_FontCreate();
1044 EXPECT_NE(font, nullptr);
1045 OH_Drawing_Typeface* typeface = OH_Drawing_TypefaceCreateFromFile(nullptr, 0);
1046 EXPECT_EQ(nullptr, typeface);
1047 // sub test 1, OH_Drawing_FontGetTypeface
1048 OH_Drawing_FontGetTypeface(nullptr);
1049 EXPECT_EQ(nullptr, typeface);
1050 OH_Drawing_Typeface *typeSurface = OH_Drawing_TypefaceCreateDefault();
1051 OH_Drawing_FontSetTypeface(font, typeSurface);
1052 EXPECT_NE(nullptr, OH_Drawing_FontGetTypeface(font));
1053 // sub test 2, OH_Drawing_FontCountText
1054 const char* str = "123456";
1055 int count = 0;
1056 count = OH_Drawing_FontCountText(nullptr, str, strlen(str),
1057 OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8);
1058 EXPECT_EQ(0, count);
1059 count = OH_Drawing_FontCountText(font, nullptr, strlen(str),
1060 OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8);
1061 EXPECT_EQ(0, count);
1062 count = OH_Drawing_FontCountText(font, str, strlen(str),
1063 OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8);
1064 EXPECT_EQ(strlen(str), count);
1065 // sub test 3, OH_Drawing_TextBlobCreateFromText
1066 EXPECT_EQ(nullptr, OH_Drawing_TextBlobCreateFromText(nullptr, strlen(str),
1067 font, OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8));
1068 EXPECT_EQ(nullptr, OH_Drawing_TextBlobCreateFromText(str, strlen(str),
1069 nullptr, OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8));
1070 OH_Drawing_TextBlob *textBlob = OH_Drawing_TextBlobCreateFromText(str, strlen(str),
1071 font, OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8);
1072 EXPECT_NE(textBlob, nullptr);
1073 EXPECT_TRUE(OH_Drawing_TextBlobUniqueID(nullptr) == 0);
1074 EXPECT_TRUE(OH_Drawing_TextBlobUniqueID(textBlob) > 0);
1075 // draw textblob
1076 OH_Drawing_CanvasDrawTextBlob(canvas_, textBlob, 0, 0);
1077
1078 OH_Drawing_TextBlobDestroy(textBlob);
1079 OH_Drawing_FontDestroy(font);
1080 OH_Drawing_TypefaceDestroy(typeSurface);
1081 }
1082
1083 /*
1084 * @tc.name: NativeDrawingCanvasTest_DrawTextBlob036
1085 * @tc.desc: test for DrawTextBlob4
1086 * @tc.size : MediumTest
1087 * @tc.type : Function
1088 * @tc.level : Level 1
1089 */
HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_DrawTextBlob036, TestSize.Level1)1090 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_DrawTextBlob036, TestSize.Level1)
1091 {
1092 size_t length = 1;
1093 OH_Drawing_Font *font = OH_Drawing_FontCreate();
1094 EXPECT_NE(font, nullptr);
1095 OH_Drawing_MemoryStream* memoryStream = OH_Drawing_MemoryStreamCreate(nullptr,
1096 length, false);
1097 OH_Drawing_MemoryStreamDestroy(memoryStream);
1098 EXPECT_EQ(nullptr, memoryStream);
1099 OH_Drawing_Typeface* typeface = OH_Drawing_TypefaceCreateFromStream(
1100 memoryStream, 0);
1101 EXPECT_EQ(nullptr, typeface);
1102 OH_Drawing_Typeface *typeSurface = OH_Drawing_TypefaceCreateDefault();
1103 OH_Drawing_FontSetTypeface(font, typeSurface);
1104 EXPECT_NE(nullptr, OH_Drawing_FontGetTypeface(font));
1105 const char* str = "123456";
1106 int count = strlen(str);
1107 OH_Drawing_Point2D pts[count];
1108 EXPECT_EQ(nullptr, OH_Drawing_TextBlobCreateFromPosText(nullptr, count, &pts[0],
1109 font, OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8));
1110 EXPECT_EQ(nullptr, OH_Drawing_TextBlobCreateFromPosText(str, count, nullptr,
1111 font, OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8));
1112 EXPECT_EQ(nullptr, OH_Drawing_TextBlobCreateFromPosText(str, count, &pts[0],
1113 nullptr, OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8));
1114 OH_Drawing_TextBlob *textBlob = OH_Drawing_TextBlobCreateFromPosText(str, count, &pts[0],
1115 font, OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8);
1116 EXPECT_NE(textBlob, nullptr);
1117 OH_Drawing_CanvasDrawTextBlob(canvas_, textBlob, 0, 0);
1118
1119 OH_Drawing_TextBlobDestroy(textBlob);
1120 OH_Drawing_FontDestroy(font);
1121 OH_Drawing_TypefaceDestroy(typeSurface);
1122 }
1123
1124 /*
1125 * @tc.name: NativeDrawingCanvasTest_SaveLayer037
1126 * @tc.desc: test for SaveLayer
1127 * @tc.size : MediumTest
1128 * @tc.type : Function
1129 * @tc.level : Level 1
1130 */
HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_SaveLayer037, TestSize.Level1)1131 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_SaveLayer037, TestSize.Level1)
1132 {
1133 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(200, 500, 300, 600);
1134 EXPECT_NE(rect, nullptr);
1135 OH_Drawing_Brush* brush = OH_Drawing_BrushCreate();
1136 EXPECT_NE(brush, nullptr);
1137 // test exception
1138 OH_Drawing_CanvasSaveLayer(nullptr, rect, brush);
1139 OH_Drawing_CanvasSaveLayer(canvas_, rect, brush);
1140 OH_Drawing_CanvasRestore(canvas_);
1141 OH_Drawing_RectDestroy(rect);
1142 }
1143 /*
1144 * @tc.name: NativeDrawingTest001
1145 * @tc.desc: test for fontSetLinearText
1146 * @tc.size : MediumTest
1147 * @tc.type : Function
1148 * @tc.level : Level 1
1149 */
HWTEST_F(NativeDrawingCanvasTest, OH_Drawing_FontSetLinearText_001, TestSize.Level1)1150 HWTEST_F(NativeDrawingCanvasTest, OH_Drawing_FontSetLinearText_001, TestSize.Level1)
1151 {
1152 OH_Drawing_Font *font = OH_Drawing_FontCreate();
1153 OH_Drawing_FontSetTextSize(font, 20);
1154 OH_Drawing_FontSetTextSkewX(font, 0.25);
1155 OH_Drawing_FontSetLinearText(font, true);
1156 OH_Drawing_FontDestroy(font);
1157 }
1158
1159 /*
1160 * @tc.name: NativeDrawingTest002
1161 * @tc.desc: test for penSetFilter
1162 * @tc.size : MediumTest
1163 * @tc.type : Function
1164 * @tc.level : Level 1
1165 */
HWTEST_F(NativeDrawingCanvasTest, OH_Drawing_PenSetFilter_001, TestSize.Level1)1166 HWTEST_F(NativeDrawingCanvasTest, OH_Drawing_PenSetFilter_001, TestSize.Level1)
1167 {
1168 OH_Drawing_Canvas* canvas = OH_Drawing_CanvasCreate();
1169 EXPECT_EQ(canvas == nullptr, false);
1170 OH_Drawing_ColorFilter* colorFilter = OH_Drawing_ColorFilterCreateBlendMode(0xff0000ff,
1171 OH_Drawing_BlendMode::BLEND_MODE_SRC);
1172 OH_Drawing_Filter* filter = OH_Drawing_FilterCreate();
1173 OH_Drawing_FilterSetColorFilter(filter, colorFilter);
1174 OH_Drawing_Pen* pen = OH_Drawing_PenCreate();
1175 OH_Drawing_PenSetColor(pen, 0xff00ff00);
1176 OH_Drawing_PenSetFilter(pen, filter);
1177 OH_Drawing_CanvasAttachPen(canvas, pen);
1178 OH_Drawing_Rect* rect = OH_Drawing_RectCreate(100, 400, 200, 500);
1179 OH_Drawing_CanvasDrawRect(canvas, rect);
1180 OH_Drawing_RectDestroy(rect);
1181 OH_Drawing_PenDestroy(pen);
1182 OH_Drawing_ColorFilterDestroy(colorFilter);
1183 OH_Drawing_FilterDestroy(filter);
1184 OH_Drawing_CanvasDestroy(canvas);
1185 }
1186
1187 /*
1188 * @tc.name: NativeDrawingTest003
1189 * @tc.desc: test for penSetFilter
1190 * @tc.size : MediumTest
1191 * @tc.type : Function
1192 * @tc.level : Level 1
1193 */
HWTEST_F(NativeDrawingCanvasTest, OH_Drawing_PenSetshaderEffect, TestSize.Level1)1194 HWTEST_F(NativeDrawingCanvasTest, OH_Drawing_PenSetshaderEffect, TestSize.Level1)
1195 {
1196 OH_Drawing_Canvas* canvas = OH_Drawing_CanvasCreate();
1197 EXPECT_EQ(canvas == nullptr, false);
1198 OH_Drawing_Point* startPt = OH_Drawing_PointCreate(100, 400);
1199 OH_Drawing_Point* endPt = OH_Drawing_PointCreate(200, 500);
1200 uint32_t color[] = {0xffff0000, 0xff00ff00};
1201 float pos[] = {0., 1.0};
1202 OH_Drawing_ShaderEffect* linearGradient = OH_Drawing_ShaderEffectCreateLinearGradient(startPt, endPt,
1203 color, pos, 2, OH_Drawing_TileMode::CLAMP);
1204 OH_Drawing_Pen* pen = OH_Drawing_PenCreate();
1205 OH_Drawing_PenSetShaderEffect(pen, linearGradient);
1206 OH_Drawing_CanvasAttachPen(canvas, pen);
1207 OH_Drawing_Rect* rect = OH_Drawing_RectCreate(100, 400, 200, 500);
1208 OH_Drawing_CanvasDrawRect(canvas, rect);
1209 OH_Drawing_RectDestroy(rect);
1210 OH_Drawing_PenDestroy(pen);
1211 OH_Drawing_ShaderEffectDestroy(linearGradient);
1212 OH_Drawing_PointDestroy(startPt);
1213 OH_Drawing_PointDestroy(endPt);
1214 OH_Drawing_CanvasDestroy(canvas);
1215 }
1216 /*
1217 * @tc.name: NativeDrawingCanvasTest_DrawRegion038
1218 * @tc.desc: test for DrawRegion
1219 * @tc.size : MediumTest
1220 * @tc.type : Function
1221 * @tc.level : Level 1
1222 */
HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_DrawRegion038, TestSize.Level1)1223 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_DrawRegion038, TestSize.Level1)
1224 {
1225 OH_Drawing_Region* region=OH_Drawing_RegionCreate();
1226 OH_Drawing_Rect* rect=OH_Drawing_RectCreate(0.0f, 0.0f, 256.0f, 256.0f);
1227 OH_Drawing_RegionSetRect(region, rect);
1228 OH_Drawing_CanvasDrawRegion(canvas_, region);
1229 }
1230
1231 /*
1232 * @tc.name: NativeDrawingCanvasTest_DrawBackground039
1233 * @tc.desc: test for DrawBackground
1234 * @tc.size : MediumTest
1235 * @tc.type : Function
1236 * @tc.level : Level 1
1237 */
HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_DrawBackground039, TestSize.Level1)1238 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_DrawBackground039, TestSize.Level1)
1239 {
1240 OH_Drawing_Brush* brush = OH_Drawing_BrushCreate();
1241 OH_Drawing_BrushSetColor(brush, OH_Drawing_ColorSetArgb(0xFF, 0xFF, 0x00, 0x00));
1242 OH_Drawing_CanvasDrawBackground(canvas_, brush);
1243 }
1244
1245 /*
1246 * @tc.name: NativeDrawingCanvasTest_DrawColor046
1247 * @tc.desc: test for DrawColor
1248 * @tc.type: FUNC
1249 * @tc.require: SR000S9F0C
1250 */
HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_DrawColor046, TestSize.Level1)1251 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_DrawColor046, TestSize.Level1)
1252 {
1253 EXPECT_EQ(OH_Drawing_CanvasDrawColor(nullptr, 0xFFFF0000, OH_Drawing_BlendMode::BLEND_MODE_SRC),
1254 OH_DRAWING_ERROR_INVALID_PARAMETER);
1255 EXPECT_EQ(OH_Drawing_CanvasDrawColor(canvas_, 0xFFFF0000, OH_Drawing_BlendMode::BLEND_MODE_COLOR),
1256 OH_DRAWING_SUCCESS);
1257 }
1258
1259 /*
1260 * @tc.name: NativeDrawingCanvasTest_IsClipEmpty042
1261 * @tc.desc: test for if clip is empty
1262 * @tc.type: FUNC
1263 * @tc.require: AR000GTO5R
1264 */
HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_IsClipEmpty042, TestSize.Level1)1265 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_IsClipEmpty042, TestSize.Level1)
1266 {
1267 OH_Drawing_Bitmap* bitmap = OH_Drawing_BitmapCreate();
1268 OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE};
1269 // 720: bitmap's width, 720: bitmap's height
1270 constexpr uint32_t width = 720;
1271 constexpr uint32_t height = 720;
1272 OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat);
1273 OH_Drawing_CanvasBind(canvas_, bitmap);
1274
1275 // 150.0f: rect's left, 100.0f: rect's top, 500.0f: rect's right, 500.0f: rect's bottom
1276 OH_Drawing_Rect* rect = OH_Drawing_RectCreate(150.0f, 100.0f, 500.f, 500.f);
1277
1278 OH_Drawing_CanvasClipRect(canvas_, rect, OH_Drawing_CanvasClipOp::INTERSECT, false);
1279
1280 bool isClipEmpty = false;
1281 EXPECT_EQ(OH_Drawing_CanvasIsClipEmpty(canvas_, &isClipEmpty), OH_DRAWING_SUCCESS);
1282 EXPECT_EQ(isClipEmpty, false);
1283
1284 OH_Drawing_RectDestroy(rect);
1285 OH_Drawing_BitmapDestroy(bitmap);
1286 }
1287
1288 /*
1289 * @tc.name: NativeDrawingCanvasTest_GetImageInfo043
1290 * @tc.desc: test for Gets ImageInfo of Canvas.
1291 * @tc.type: FUNC
1292 * @tc.require: AR000GTO5R
1293 */
HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_GetImageInfo043, TestSize.Level1)1294 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_GetImageInfo043, TestSize.Level1)
1295 {
1296 OH_Drawing_Bitmap* bitmap = OH_Drawing_BitmapCreate();
1297 OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE};
1298 // 720: bitmap's width, 720: bitmap's height
1299 constexpr uint32_t width = 720;
1300 constexpr uint32_t height = 720;
1301 OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat);
1302 OH_Drawing_CanvasBind(canvas_, bitmap);
1303 OH_Drawing_Image_Info* imageInfo = new OH_Drawing_Image_Info();
1304 EXPECT_EQ(OH_Drawing_CanvasGetImageInfo(canvas_, imageInfo), OH_DRAWING_SUCCESS);
1305 EXPECT_EQ(720, imageInfo->width);
1306 EXPECT_EQ(720, imageInfo->height);
1307 EXPECT_EQ(1, imageInfo->alphaType);
1308 EXPECT_EQ(4, imageInfo->colorType);
1309 delete imageInfo;
1310 }
1311
1312
1313 /*
1314 * @tc.name: NativeDrawingCanvasTest_ClipRegion044
1315 * @tc.desc: test for Drawing Canvas Clip Region.
1316 * @tc.type: FUNC
1317 * @tc.require: AR000GTO5R
1318 */
HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_ClipRegion044, TestSize.Level1)1319 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_ClipRegion044, TestSize.Level1)
1320 {
1321 OH_Drawing_Bitmap* bitmap = OH_Drawing_BitmapCreate();
1322 OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE};
1323 constexpr uint32_t width = 720; // 720: width of canvas
1324 constexpr uint32_t height = 720; // 720: height of canvas
1325 OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat);
1326 OH_Drawing_CanvasBind(canvas_, bitmap);
1327
1328 OH_Drawing_Region *region = OH_Drawing_RegionCreate();
1329 // 0.0f: rect's left, 0.0f: rect's top, 720.0f: rect's right, 720.0f: rect's bottom
1330 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0.0f, 0.0f, 720.f, 720.f);
1331 OH_Drawing_RegionSetRect(region, rect);
1332 EXPECT_EQ(OH_Drawing_CanvasClipRegion(canvas_, region, OH_Drawing_CanvasClipOp::INTERSECT), OH_DRAWING_SUCCESS);
1333 EXPECT_EQ(OH_Drawing_CanvasClipRegion(nullptr, region, OH_Drawing_CanvasClipOp::INTERSECT),
1334 OH_DRAWING_ERROR_INVALID_PARAMETER);
1335
1336 EXPECT_EQ(720, OH_Drawing_CanvasGetWidth(canvas_));
1337 EXPECT_EQ(720, OH_Drawing_CanvasGetHeight(canvas_));
1338
1339 OH_Drawing_RegionDestroy(region);
1340 OH_Drawing_RectDestroy(rect);
1341 OH_Drawing_BitmapDestroy(bitmap);
1342 }
1343 } // namespace Drawing
1344 } // namespace Rosen
1345 } // namespace OHOS