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_error_code.h"
24 #include "drawing_filter.h"
25 #include "drawing_font.h"
26 #include "drawing_image.h"
27 #include "drawing_image_filter.h"
28 #include "drawing_mask_filter.h"
29 #include "drawing_matrix.h"
30 #include "drawing_path.h"
31 #include "drawing_pen.h"
32 #include "drawing_pixel_map.h"
33 #include "drawing_point.h"
34 #include "drawing_record_cmd.h"
35 #include "drawing_rect.h"
36 #include "drawing_region.h"
37 #include "drawing_round_rect.h"
38 #include "drawing_sampling_options.h"
39 #include "drawing_shader_effect.h"
40 #include "drawing_text_blob.h"
41 #include "drawing_typeface.h"
42 #include "drawing_memory_stream.h"
43 #include "effect/color_filter.h"
44 #include "effect/filter.h"
45 #include "recording/recording_canvas.h"
46 #include "image/pixelmap_native.h"
47
48 using namespace testing;
49 using namespace testing::ext;
50
51 namespace OHOS {
52 namespace Rosen {
53 namespace Drawing {
54 class NativeDrawingCanvasTest : public testing::Test {
55 public:
56 static void SetUpTestCase();
57 static void TearDownTestCase();
58 void SetUp() override;
59 void TearDown() override;
60 protected:
61 OH_Drawing_Canvas *canvas_ = nullptr;
62 OH_Drawing_Brush *brush_ = nullptr;
63 };
64
65 constexpr uint32_t POINT_PARAMETER = 3;
66 constexpr uint32_t COLOR_PARAMETER = 3;
67 constexpr uint32_t INTNUM_TEN = 10;
68 constexpr int32_t NEGATIVE_ONE = -1;
69
SetUpTestCase()70 void NativeDrawingCanvasTest::SetUpTestCase() {}
TearDownTestCase()71 void NativeDrawingCanvasTest::TearDownTestCase() {}
SetUp()72 void NativeDrawingCanvasTest::SetUp()
73 {
74 canvas_ = OH_Drawing_CanvasCreate();
75 ASSERT_NE(nullptr, canvas_);
76 OH_Drawing_CanvasClear(canvas_, OH_Drawing_ColorSetArgb(0xFF, 0xFF, 0xFF, 0xFF));
77 brush_ = OH_Drawing_BrushCreate();
78 EXPECT_NE(brush_, nullptr);
79 OH_Drawing_BrushSetColor(brush_, 0xffff0000);
80 OH_Drawing_CanvasAttachBrush(canvas_, brush_);
81 }
82
TearDown()83 void NativeDrawingCanvasTest::TearDown()
84 {
85 if (canvas_ != nullptr) {
86 OH_Drawing_CanvasDetachBrush(canvas_);
87 OH_Drawing_BrushDestroy(brush_);
88 brush_ = nullptr;
89 OH_Drawing_CanvasDestroy(canvas_);
90 canvas_ = nullptr;
91 }
92 }
93
94 /*
95 * @tc.name: NativeDrawingCanvasTest_CanvasNULLPTR001
96 * @tc.desc: test for OH_Drawing_CanvasBind.
97 * @tc.type: FUNC
98 * @tc.require: AR000GTO5R
99 */
100 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_CanvasNULLPTR001, TestSize.Level1)
101 {
102 OH_Drawing_Bitmap* bitmap = OH_Drawing_BitmapCreate();
103 EXPECT_NE(bitmap, nullptr);
104 OH_Drawing_CanvasBind(nullptr, bitmap);
105 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
106 OH_Drawing_BitmapDestroy(bitmap);
107 OH_Drawing_CanvasAttachPen(canvas_, nullptr);
108 OH_Drawing_CanvasTranslate(canvas_, INT32_MIN, INT32_MIN);
109 OH_Drawing_CanvasTranslate(canvas_, INT32_MAX, INT32_MAX);
110 OH_Drawing_CanvasDrawLine(nullptr, 0, 0, 20, 20);
111 OH_Drawing_CanvasDrawLine(canvas_, 0, 0, INT32_MAX, INT32_MAX);
112 OH_Drawing_CanvasDrawLine(canvas_, 0, 0, INT32_MIN, INT32_MIN);
113 OH_Drawing_Path* path = OH_Drawing_PathCreate();
114 OH_Drawing_PathMoveTo(path, INT32_MAX, INT32_MIN);
115 OH_Drawing_PathMoveTo(nullptr, 9999, -1000);
116 OH_Drawing_PathClose(nullptr);
117 OH_Drawing_PathClose(path);
118 OH_Drawing_CanvasDrawPath(nullptr, path);
119 OH_Drawing_CanvasDrawPath(canvas_, nullptr);
120 OH_Drawing_PathDestroy(path);
121 }
122
123 /*
124 * @tc.name: NativeDrawingCanvasTest_CanvasBind002
125 * @tc.desc: test for OH_Drawing_CanvasBind.
126 * @tc.type: FUNC
127 * @tc.require: AR000GTO5R
128 */
129 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_CanvasBind002, TestSize.Level1)
130 {
131 OH_Drawing_Bitmap* bitmap = OH_Drawing_BitmapCreate();
132 EXPECT_NE(bitmap, nullptr);
133 OH_Drawing_CanvasBind(canvas_, bitmap);
134 OH_Drawing_CanvasBind(canvas_, nullptr);
135 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
136 OH_Drawing_BitmapDestroy(bitmap);
137 }
138
139 /*
140 * @tc.name: NativeDrawingCanvasTest_canvas003
141 * @tc.desc: test for OH_Drawing_CanvasAttachPen & OH_Drawing_CanvasDetachPen.
142 * @tc.type: FUNC
143 * @tc.require: AR000GTO5R
144 */
145 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_canvas003, TestSize.Level1)
146 {
147 OH_Drawing_Pen* pen = OH_Drawing_PenCreate();
148 EXPECT_NE(pen, nullptr);
149 OH_Drawing_CanvasAttachPen(nullptr, pen);
150 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
151 OH_Drawing_CanvasAttachPen(canvas_, nullptr);
152 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
153 OH_Drawing_CanvasAttachPen(canvas_, pen);
154 OH_Drawing_CanvasDetachPen(canvas_);
155 OH_Drawing_CanvasDetachPen(nullptr);
156 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
157 OH_Drawing_PenDestroy(pen);
158 }
159
160 /*
161 * @tc.name: NativeDrawingCanvasTest_DrawLine004
162 * @tc.desc: test for OH_Drawing_CanvasDrawLine.
163 * @tc.type: FUNC
164 * @tc.require: AR000GTO5R
165 */
166 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_DrawLine004, TestSize.Level1)
167 {
168 OH_Drawing_CanvasDrawLine(nullptr, 0, 0, 20, 20);
169 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
170 OH_Drawing_CanvasDrawLine(canvas_, 0, 0, 20, 20);
171 OH_Drawing_CanvasDrawLine(canvas_, -15.2f, -1, 0, 20);
172 }
173
174 /*
175 * @tc.name: NativeDrawingCanvasTest_DrawPath005
176 * @tc.desc: test for OH_Drawing_CanvasDrawPath.
177 * @tc.type: FUNC
178 * @tc.require: AR000GTO5R
179 */
180 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_DrawPath005, TestSize.Level1)
181 {
182 OH_Drawing_Path* path = OH_Drawing_PathCreate();
183 EXPECT_NE(path, nullptr);
184 constexpr int height = 300;
185 constexpr int width = 300;
186 constexpr float arc = 18.0f;
187 int len = height / 4;
188 float aX = width / 2;
189 float aY = height / 4;
190 float dX = aX - len * std::sin(arc);
191 float dY = aY + len * std::cos(arc);
192 float cX = aX + len * std::sin(arc);
193 float cY = dY;
194 float bX = aX + (len / 2.0);
195 float bY = aY + std::sqrt((cX - dX) * (cX - dX) + (len / 2.0) * (len / 2.0));
196 float eX = aX - (len / 2.0);
197 float eY = bY;
198 OH_Drawing_PathMoveTo(path, aX, aY);
199 OH_Drawing_PathLineTo(path, bX, bY);
200 OH_Drawing_PathLineTo(path, cX, cY);
201 OH_Drawing_PathLineTo(path, dX, dY);
202 OH_Drawing_PathLineTo(path, eX, eY);
203 OH_Drawing_PathClose(path);
204 OH_Drawing_CanvasDrawPath(canvas_, path);
205 OH_Drawing_CanvasDrawPath(nullptr, path);
206 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
207 OH_Drawing_CanvasDrawPath(canvas_, nullptr);
208 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
209 OH_Drawing_PathDestroy(path);
210 }
211
212 /*
213 * @tc.name: NativeDrawingCanvasTest_DrawPoints006
214 * @tc.desc: test for OH_Drawing_CanvasDrawPoints.
215 * @tc.type: FUNC
216 * @tc.require: AR000GTO5R
217 */
218 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_DrawPoints006, TestSize.Level1)
219 {
220 OH_Drawing_Point2D pointOne={250, 500};
221 OH_Drawing_Point2D pointTwo={200, 500};
222 OH_Drawing_Point2D pointThree={500, 700};
223 OH_Drawing_Point2D points[POINT_PARAMETER] = {pointOne, pointTwo, pointThree};
224 OH_Drawing_CanvasDrawPoints(canvas_, POINT_MODE_POINTS, POINT_PARAMETER, nullptr);
225 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
226 OH_Drawing_CanvasDrawPoints(nullptr, POINT_MODE_POINTS, POINT_PARAMETER, nullptr);
227 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
228 OH_Drawing_CanvasDrawPoints(canvas_, POINT_MODE_POINTS, 0, nullptr);
229 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
230 OH_Drawing_CanvasDrawPoints(canvas_, POINT_MODE_POINTS, POINT_PARAMETER, points);
231 }
232
233 /*
234 * @tc.name: NativeDrawingCanvasTest_DrawVertices007
235 * @tc.desc: test for OH_Drawing_CanvasDrawVertices.
236 * @tc.type: FUNC
237 * @tc.require: AR000GTO5R
238 */
239 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_DrawVertices007, TestSize.Level1)
240 {
241 OH_Drawing_Point2D point_one = {0, 0};
242 OH_Drawing_Point2D point_two = {100, 100};
243 OH_Drawing_Point2D point_three = {300, 100};
244 OH_Drawing_Point2D points_vertices[POINT_PARAMETER] = {point_one, point_two, point_three};
245
246 OH_Drawing_Point2D texs_one = {0, 0};
247 OH_Drawing_Point2D texs_two = {1, 1};
248 OH_Drawing_Point2D texs_three = {2, 0};
249 OH_Drawing_Point2D texs_vertices[POINT_PARAMETER] = {texs_one, texs_two, texs_three};
250 uint32_t colors[COLOR_PARAMETER] = {0xFFFF0000, 0xFFFF0000, 0xFFFF0000};
251
252 uint16_t indices[COLOR_PARAMETER] = {0, 1, 2};
253
254 // test canvas == nullptr
255 OH_Drawing_CanvasDrawVertices(nullptr, VERTEX_MODE_TRIANGLES, POINT_PARAMETER, points_vertices, texs_vertices,
256 colors, POINT_PARAMETER, indices, BLEND_MODE_COLOR);
257 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
258
259 // test vertexCount < 3
260 OH_Drawing_CanvasDrawVertices(canvas_, VERTEX_MODE_TRIANGLES, 1, points_vertices, texs_vertices,
261 colors, POINT_PARAMETER, indices, BLEND_MODE_COLOR);
262 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
263
264 // test position == nullptr
265 OH_Drawing_CanvasDrawVertices(canvas_, VERTEX_MODE_TRIANGLES, POINT_PARAMETER, nullptr, texs_vertices, colors,
266 POINT_PARAMETER, indices, BLEND_MODE_COLOR);
267 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
268
269 // test indexCount != 0 && indexCount < 3
270 OH_Drawing_CanvasDrawVertices(canvas_, VERTEX_MODE_TRIANGLES, POINT_PARAMETER, points_vertices, texs_vertices,
271 colors, 1, indices, BLEND_MODE_COLOR);
272 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
273 }
274
275 /*
276 * @tc.name: NativeDrawingCanvasTest_SaveAndRestore008
277 * @tc.desc: test for OH_Drawing_CanvasSave & OH_Drawing_CanvasRestore.
278 * @tc.type: FUNC
279 * @tc.require: AR000GTO5R
280 */
281 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_SaveAndRestore008, TestSize.Level1)
282 {
283 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(100, 200, 500, 300);
284 EXPECT_NE(nullptr, rect);
285 OH_Drawing_CanvasSave(nullptr);
286 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
287 OH_Drawing_CanvasSave(canvas_);
288 OH_Drawing_CanvasTranslate(nullptr, 100, 100);
289 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
290 OH_Drawing_CanvasTranslate(canvas_, 100, 100);
291 OH_Drawing_CanvasDrawArc(nullptr, rect, 10, 200);
292 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
293 OH_Drawing_CanvasDrawArc(canvas_, nullptr, 10, 200);
294 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
295 OH_Drawing_CanvasDrawArc(canvas_, rect, 10, 200);
296 OH_Drawing_CanvasRestore(nullptr);
297 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
298 OH_Drawing_CanvasRestore(canvas_);
299 OH_Drawing_CanvasTranslate(canvas_, 200, 200);
300 OH_Drawing_CanvasDrawOval(nullptr, rect);
301 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
302 OH_Drawing_CanvasDrawOval(canvas_, nullptr);
303 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
304 OH_Drawing_CanvasDrawOval(canvas_, rect);
305 OH_Drawing_RectDestroy(nullptr);
306 OH_Drawing_RectDestroy(rect);
307 }
308
309 /*
310 * @tc.name: NativeDrawingCanvasTest_Clear009
311 * @tc.desc: test for OH_Drawing_CanvasClear.
312 * @tc.type: FUNC
313 * @tc.require: AR000GTO5R
314 */
315 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_Clear009, TestSize.Level1)
316 {
317 OH_Drawing_CanvasClear(nullptr, OH_Drawing_ColorSetArgb(0xFF, 0xFF, 0x00, 0x00));
318 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
319 OH_Drawing_CanvasClear(canvas_, -100);
320 OH_Drawing_CanvasClear(canvas_, OH_Drawing_ColorSetArgb(INT32_MAX, INT32_MAX, INT32_MIN, INT32_MIN));
321 OH_Drawing_CanvasClear(canvas_, OH_Drawing_ColorSetArgb(0xFF, 0xFF, 0x00, 0x00));
322 }
323
324 /*
325 * @tc.name: NativeDrawingCanvasTest_RestoreToCount010
326 * @tc.desc: test for OH_Drawing_CanvasRestoreToCount.
327 * @tc.type: FUNC
328 * @tc.require: AR000GTO5R
329 */
330 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_RestoreToCount010, TestSize.Level1)
331 {
332 OH_Drawing_CanvasSave(canvas_);
333 OH_Drawing_CanvasTranslate(canvas_, 300, 300);
334 OH_Drawing_CanvasSave(canvas_);
335 OH_Drawing_CanvasTranslate(canvas_, 100, 100);
336 OH_Drawing_CanvasSave(canvas_);
337 OH_Drawing_CanvasTranslate(canvas_, 100, 100);
338 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0, 0, 100, 100);
339 OH_Drawing_CanvasDrawRect(canvas_, rect);
340 int count = OH_Drawing_CanvasGetSaveCount(canvas_);
341 EXPECT_EQ(count, 4);
342 OH_Drawing_CanvasRestoreToCount(nullptr, count - 2);
343 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
344 OH_Drawing_CanvasRestoreToCount(canvas_, count - 2);
345 EXPECT_EQ(2, OH_Drawing_CanvasGetSaveCount(canvas_));
346 OH_Drawing_RoundRect *roundRect = OH_Drawing_RoundRectCreate(nullptr, 20, 20);
347 EXPECT_EQ(roundRect, nullptr);
348 roundRect = OH_Drawing_RoundRectCreate(rect, 20, 20);
349 EXPECT_NE(roundRect, nullptr);
350 OH_Drawing_CanvasDrawRoundRect(nullptr, roundRect);
351 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
352 OH_Drawing_CanvasDrawRoundRect(canvas_, nullptr);
353 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
354 OH_Drawing_CanvasDrawRoundRect(canvas_, roundRect);
355 OH_Drawing_CanvasRestoreToCount(canvas_, 1);
356 OH_Drawing_CanvasDrawRect(canvas_, rect);
357 OH_Drawing_RoundRectDestroy(roundRect);
358 OH_Drawing_RectDestroy(rect);
359 OH_Drawing_RoundRectDestroy(nullptr);
360 OH_Drawing_RectDestroy(nullptr);
361 }
362
363 /*
364 * @tc.name: NativeDrawingCanvasTest_Scale011
365 * @tc.desc: test for OH_Drawing_CanvasScale.
366 * @tc.type: FUNC
367 * @tc.require: AR000GTO5R
368 */
369 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_Scale011, TestSize.Level1)
370 {
371 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(10, 20, 60, 120);
372 OH_Drawing_CanvasTranslate(canvas_, 20, 20);
373 OH_Drawing_CanvasDrawRect(canvas_, rect);
374 OH_Drawing_CanvasScale(nullptr, 2, .5f);
375 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
376 OH_Drawing_CanvasScale(canvas_, 2, .5f);
377 OH_Drawing_BrushSetColor(nullptr, 0xFF67C23A);
378 OH_Drawing_BrushSetColor(brush_, 0xFF67C23A);
379 OH_Drawing_CanvasDrawRect(canvas_, rect);
380 }
381
382 /*
383 * @tc.name: NativeDrawingCanvasTest_Skew012
384 * @tc.desc: test for OH_Drawing_CanvasSkew.
385 * @tc.type: FUNC
386 * @tc.require: AR000GTO5R
387 */
388 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_Skew012, TestSize.Level1)
389 {
390 /**
391 * @tc.steps: step1. test OH_Drawing_CanvasSkew with an nullptr.
392 * @tc.expected: function works well not crash.
393 */
394 OH_Drawing_CanvasSkew(nullptr, 0, 0.3f);
395 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
396 /**
397 * @tc.steps: step2. test OH_Drawing_CanvasSkew with canvas.
398 * @tc.expected: function works well.
399 */
400 OH_Drawing_CanvasSkew(canvas_, 0, 0.3f);
401
402 OH_Drawing_Matrix* matrixSkew= OH_Drawing_MatrixCreate();
403 Matrix* cMatrix = reinterpret_cast<Matrix*>(matrixSkew);
404 EXPECT_NE(cMatrix, nullptr);
405 cMatrix->SetSkew(0, 0.3f);
406
407 OH_Drawing_Matrix* matrixTotal = OH_Drawing_MatrixCreate();
408 OH_Drawing_CanvasGetTotalMatrix(canvas_, nullptr);
409 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
410 OH_Drawing_CanvasGetTotalMatrix(nullptr, matrixTotal);
411 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
412 float valueMatrixSkew;
413 float valueCanvasSkew;
414 valueMatrixSkew = OH_Drawing_MatrixGetValue(matrixSkew, 0);
415 valueCanvasSkew = OH_Drawing_MatrixGetValue(matrixTotal, 0);
416 EXPECT_TRUE(IsScalarAlmostEqual(valueMatrixSkew, valueCanvasSkew));
417
418 OH_Drawing_CanvasGetTotalMatrix(canvas_, matrixTotal);
419 EXPECT_NE(matrixTotal, nullptr);
420
421 valueMatrixSkew = OH_Drawing_MatrixGetValue(matrixSkew, 0);
422 valueCanvasSkew = OH_Drawing_MatrixGetValue(matrixTotal, 0);
423 EXPECT_TRUE(IsScalarAlmostEqual(valueMatrixSkew, valueCanvasSkew));
424
425 valueMatrixSkew = OH_Drawing_MatrixGetValue(matrixSkew, 1);
426 valueCanvasSkew = OH_Drawing_MatrixGetValue(matrixTotal, 1);
427 EXPECT_TRUE(IsScalarAlmostEqual(valueMatrixSkew, valueCanvasSkew));
428
429 valueMatrixSkew = OH_Drawing_MatrixGetValue(matrixSkew, 2);
430 valueCanvasSkew = OH_Drawing_MatrixGetValue(matrixTotal, 2);
431 EXPECT_TRUE(IsScalarAlmostEqual(valueMatrixSkew, valueCanvasSkew));
432
433 valueMatrixSkew = OH_Drawing_MatrixGetValue(matrixSkew, 3);
434 valueCanvasSkew = OH_Drawing_MatrixGetValue(matrixTotal, 3);
435 EXPECT_TRUE(IsScalarAlmostEqual(valueMatrixSkew, valueCanvasSkew));
436
437 valueMatrixSkew = OH_Drawing_MatrixGetValue(matrixSkew, 4);
438 valueCanvasSkew = OH_Drawing_MatrixGetValue(matrixTotal, 4);
439 EXPECT_TRUE(IsScalarAlmostEqual(valueMatrixSkew, valueCanvasSkew));
440
441 valueMatrixSkew = OH_Drawing_MatrixGetValue(matrixSkew, 5);
442 valueCanvasSkew = OH_Drawing_MatrixGetValue(matrixTotal, 5);
443 EXPECT_TRUE(IsScalarAlmostEqual(valueMatrixSkew, valueCanvasSkew));
444
445 valueMatrixSkew = OH_Drawing_MatrixGetValue(matrixSkew, 6);
446 valueCanvasSkew = OH_Drawing_MatrixGetValue(matrixTotal, 6);
447 EXPECT_TRUE(IsScalarAlmostEqual(valueMatrixSkew, valueCanvasSkew));
448
449 valueMatrixSkew = OH_Drawing_MatrixGetValue(matrixSkew, 7);
450 valueCanvasSkew = OH_Drawing_MatrixGetValue(matrixTotal, 7);
451 EXPECT_TRUE(IsScalarAlmostEqual(valueMatrixSkew, valueCanvasSkew));
452
453 valueMatrixSkew = OH_Drawing_MatrixGetValue(matrixSkew, 8);
454 valueCanvasSkew = OH_Drawing_MatrixGetValue(matrixTotal, 8);
455 EXPECT_TRUE(IsScalarAlmostEqual(valueMatrixSkew, valueCanvasSkew));
456
457 OH_Drawing_MatrixDestroy(matrixSkew);
458 OH_Drawing_MatrixDestroy(matrixTotal);
459 }
460
461 /*
462 * @tc.name: NativeDrawingCanvasTest_ClipRect013
463 * @tc.desc: test for OH_Drawing_CanvasClipRect.
464 * @tc.type: FUNC
465 * @tc.require: AR000GTO5R
466 */
467 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_ClipRect013, TestSize.Level1)
468 {
469 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0, 0, 90, 90);
470 OH_Drawing_CanvasRotate(nullptr, 10, 0, 0);
471 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
472 OH_Drawing_CanvasRotate(canvas_, 10, 0, 0);
473 OH_Drawing_Point *point = OH_Drawing_PointCreate(100, 60);
474 OH_Drawing_BrushSetAntiAlias(nullptr, true);
475 OH_Drawing_BrushSetAntiAlias(brush_, true);
476 for (auto alias : {false, true}) {
477 OH_Drawing_CanvasSave(canvas_);
478 OH_Drawing_CanvasClipRect(nullptr, rect, OH_Drawing_CanvasClipOp::INTERSECT, alias);
479 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
480 OH_Drawing_CanvasClipRect(canvas_, nullptr, OH_Drawing_CanvasClipOp::INTERSECT, alias);
481 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
482 OH_Drawing_CanvasClipRect(canvas_, rect, OH_Drawing_CanvasClipOp::INTERSECT, alias);
483 OH_Drawing_CanvasDrawCircle(canvas_, nullptr, 60);
484 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
485 OH_Drawing_CanvasDrawCircle(nullptr, point, 60);
486 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
487 OH_Drawing_CanvasDrawCircle(canvas_, point, 0);
488 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_PARAMETER_OUT_OF_RANGE);
489 OH_Drawing_CanvasDrawCircle(canvas_, point, 60);
490 OH_Drawing_CanvasRestore(canvas_);
491 OH_Drawing_CanvasTranslate(canvas_, 80, 0);
492 }
493 OH_Drawing_RectDestroy(rect);
494 OH_Drawing_PointDestroy(point);
495 }
496
497 /*
498 * @tc.name: NativeDrawingCanvasTest_ClipPath014
499 * @tc.desc: test for OH_Drawing_CanvasClipPath.
500 * @tc.type: FUNC
501 * @tc.require: AR000GTO5R
502 */
503 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_ClipPath014, TestSize.Level1)
504 {
505 OH_Drawing_Path *path = OH_Drawing_PathCreate();
506 OH_Drawing_PathMoveTo(path, 100, 300);
507 OH_Drawing_PathLineTo(path, 200, 300);
508 OH_Drawing_PathLineTo(path, 200, 400);
509 OH_Drawing_PathLineTo(path, 100, 350);
510 OH_Drawing_PathClose(nullptr);
511 OH_Drawing_PathClose(path);
512 OH_Drawing_CanvasClipPath(nullptr, path, OH_Drawing_CanvasClipOp::DIFFERENCE, true);
513 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
514 OH_Drawing_CanvasClipPath(canvas_, nullptr, OH_Drawing_CanvasClipOp::DIFFERENCE, true);
515 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
516 OH_Drawing_CanvasClipPath(canvas_, path, OH_Drawing_CanvasClipOp::DIFFERENCE, true);
517 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(100, 300, 200, 400);
518 OH_Drawing_CanvasDrawRect(nullptr, rect);
519 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
520 OH_Drawing_CanvasDrawRect(canvas_, nullptr);
521 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
522 OH_Drawing_CanvasDrawRect(canvas_, rect);
523 OH_Drawing_RectDestroy(rect);
524 OH_Drawing_PathDestroy(path);
525 }
526
527 /*
528 * @tc.name: NativeDrawingCanvasTest_LinearGradient015
529 * @tc.desc: test for LinearGradient
530 * @tc.type: FUNC
531 * @tc.require: AR000GTO5R
532 */
533 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_LinearGradient015, TestSize.Level1)
534 {
535 OH_Drawing_Point* startPt = OH_Drawing_PointCreate(100, 400);
536 OH_Drawing_Point* endPt = OH_Drawing_PointCreate(200, 500);
537 uint32_t color[] = {0xffff0000, 0xff00ff00};
538 float pos[] = {0., 1.0};
539 OH_Drawing_ShaderEffect* linearGradient = OH_Drawing_ShaderEffectCreateLinearGradient(startPt, endPt,
540 color, pos, 2, OH_Drawing_TileMode::CLAMP);
541 OH_Drawing_BrushSetShaderEffect(nullptr, linearGradient);
542 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
543 OH_Drawing_BrushSetShaderEffect(brush_, nullptr);
544 OH_Drawing_BrushSetShaderEffect(brush_, linearGradient);
545 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(200, 500, 300, 600);
546 OH_Drawing_CanvasDrawRect(canvas_, rect);
547 OH_Drawing_RectDestroy(rect);
548 OH_Drawing_ShaderEffectDestroy(nullptr);
549 OH_Drawing_ShaderEffectDestroy(linearGradient);
550 OH_Drawing_PointDestroy(startPt);
551 OH_Drawing_PointDestroy(endPt);
552 }
553
554 /*
555 * @tc.name: NativeDrawingCanvasTest_SweepGradient016
556 * @tc.desc: test for sweep gradient shader effect
557 * @tc.type: FUNC
558 * @tc.require: AR000GTO5R
559 */
560 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_SweepGradient016, TestSize.Level1)
561 {
562 OH_Drawing_Point* centerPt = OH_Drawing_PointCreate(350, 450);
563 uint32_t colors[] = {0xffff00ff, 0xff00ff00};
564 float pos[] = {0., 1.0};
565 OH_Drawing_ShaderEffect* sweepGradient = OH_Drawing_ShaderEffectCreateSweepGradient(nullptr, nullptr,
566 nullptr, -2, OH_Drawing_TileMode::MIRROR);
567 EXPECT_EQ(sweepGradient, nullptr);
568 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
569 sweepGradient = OH_Drawing_ShaderEffectCreateSweepGradient(centerPt, colors,
570 pos, 2, OH_Drawing_TileMode::MIRROR);
571 EXPECT_NE(sweepGradient, nullptr);
572 OH_Drawing_BrushSetShaderEffect(brush_, sweepGradient);
573 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(300, 400, 500, 500);
574 OH_Drawing_CanvasDrawRect(canvas_, rect);
575 OH_Drawing_RectDestroy(rect);
576 OH_Drawing_ShaderEffectDestroy(sweepGradient);
577 OH_Drawing_PointDestroy(centerPt);
578 }
579
580 /*
581 * @tc.name: NativeDrawingCanvasTest_ImageShader017
582 * @tc.desc: test for image shader effect
583 * @tc.type: FUNC
584 * @tc.require: AR000GTO5R
585 */
586 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_ImageShader017, TestSize.Level1)
587 {
588 OH_Drawing_Image *image = OH_Drawing_ImageCreate();
589 OH_Drawing_Brush *brush = OH_Drawing_BrushCreate();
590 OH_Drawing_BrushSetColor(brush, OH_Drawing_ColorSetArgb(0xFF, 0xFF, 0xFF, 0x00));
591 OH_Drawing_SamplingOptions *options = OH_Drawing_SamplingOptionsCreate(FILTER_MODE_LINEAR, MIPMAP_MODE_LINEAR);
592 OH_Drawing_Matrix *matrix = OH_Drawing_MatrixCreate();
593 OH_Drawing_ShaderEffect *effect = nullptr;
594 effect = OH_Drawing_ShaderEffectCreateImageShader(nullptr, CLAMP, CLAMP, nullptr, nullptr);
595 EXPECT_EQ(effect, nullptr);
596 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
597 effect = OH_Drawing_ShaderEffectCreateImageShader(image, CLAMP, CLAMP, options, matrix);
598 OH_Drawing_BrushSetShaderEffect(brush, effect);
599 OH_Drawing_CanvasAttachBrush(nullptr, brush);
600 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
601 OH_Drawing_CanvasAttachBrush(canvas_, nullptr);
602 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
603 OH_Drawing_CanvasAttachBrush(canvas_, brush);
604 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(300, 400, 500, 500);
605 OH_Drawing_CanvasDrawRect(canvas_, rect);
606 OH_Drawing_RectDestroy(rect);
607 OH_Drawing_ShaderEffectDestroy(effect);
608 OH_Drawing_MatrixDestroy(matrix);
609 OH_Drawing_SamplingOptionsDestroy(options);
610 OH_Drawing_BrushDestroy(brush);
611 OH_Drawing_ImageDestroy(image);
612 }
613
614 /*
615 * @tc.name: NativeDrawingCanvasTest_MaskFilter018
616 * @tc.desc: test for maskfilter
617 * @tc.type: FUNC
618 * @tc.require: AR000GTO5R
619 */
620 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_MaskFilter018, TestSize.Level1)
621 {
622 EXPECT_EQ(OH_Drawing_BrushGetColor(brush_), 0xFFFF0000);
623 OH_Drawing_MaskFilter* maskFilter = OH_Drawing_MaskFilterCreateBlur(OH_Drawing_BlurType::NORMAL, 10, true);
624 OH_Drawing_Filter* filter = OH_Drawing_FilterCreate();
625 OH_Drawing_FilterSetMaskFilter(nullptr, maskFilter);
626 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
627 OH_Drawing_FilterSetMaskFilter(filter, nullptr);
628 OH_Drawing_FilterSetMaskFilter(filter, maskFilter);
629 OH_Drawing_BrushSetFilter(brush_, filter);
630 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(200, 500, 300, 600);
631 OH_Drawing_CanvasDrawRect(canvas_, rect);
632 OH_Drawing_RectDestroy(rect);
633 OH_Drawing_MaskFilterDestroy(maskFilter);
634 OH_Drawing_FilterDestroy(filter);
635 }
636
637 /*
638 * @tc.name: NativeDrawingCanvasTest_ColorFilter019
639 * @tc.desc: test for colorfilter create blend mode, linear to srgb gamma, luma, matrix
640 * @tc.type: FUNC
641 * @tc.require: AR000GTO5R
642 */
643 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_ColorFilterCreateBlendMode019, TestSize.Level1)
644 {
645 EXPECT_EQ(OH_Drawing_BrushGetColor(brush_), 0xFFFF0000);
646 OH_Drawing_ColorFilter* colorFilter = OH_Drawing_ColorFilterCreateBlendMode(0xff0000ff,
647 OH_Drawing_BlendMode::BLEND_MODE_SRC);
648 EXPECT_NE(colorFilter, nullptr);
649 OH_Drawing_ColorFilter* colorFilterTmp = OH_Drawing_ColorFilterCreateLinearToSrgbGamma();
650 EXPECT_NE(colorFilterTmp, nullptr);
651 OH_Drawing_Filter* filter = OH_Drawing_FilterCreate();
652 EXPECT_NE(filter, nullptr);
653
654 OH_Drawing_FilterSetColorFilter(nullptr, colorFilter);
655 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
656 OH_Drawing_FilterSetColorFilter(filter, nullptr);
657 OH_Drawing_FilterGetColorFilter(filter, colorFilterTmp);
658 EXPECT_EQ(reinterpret_cast<ColorFilter*>(colorFilterTmp)->GetType(), ColorFilter::FilterType::NO_TYPE);
659
660 OH_Drawing_FilterSetColorFilter(filter, colorFilter);
661 OH_Drawing_FilterGetColorFilter(filter, colorFilterTmp);
662 EXPECT_EQ(reinterpret_cast<ColorFilter*>(colorFilterTmp)->GetType(), ColorFilter::FilterType::BLEND_MODE);
663
664 OH_Drawing_BrushSetFilter(brush_, nullptr);
665 OH_Drawing_BrushSetFilter(brush_, filter);
666 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0, 0, 100, 100);
667 OH_Drawing_CanvasDrawRect(canvas_, rect);
668 OH_Drawing_ColorFilter* linear = OH_Drawing_ColorFilterCreateLinearToSrgbGamma();
669 OH_Drawing_FilterSetColorFilter(filter, linear);
670 OH_Drawing_CanvasTranslate(canvas_, 100, 100);
671 OH_Drawing_CanvasDrawRect(canvas_, rect);
672 OH_Drawing_ColorFilter* luma = OH_Drawing_ColorFilterCreateLuma();
673 OH_Drawing_FilterSetColorFilter(filter, luma);
674 OH_Drawing_CanvasTranslate(canvas_, 200, 200);
675 OH_Drawing_CanvasDrawRect(canvas_, rect);
676 const float matrix[20] = {
677 1, 0, 0, 0, 0,
678 0, 1, 0, 0, 0,
679 0, 0, 1, 0, 0,
680 0, 0, 0, 0.5f, 0
681 };
682 OH_Drawing_ColorFilter* matrixFilter = OH_Drawing_ColorFilterCreateMatrix(nullptr);
683 EXPECT_EQ(matrixFilter, nullptr);
684 matrixFilter = OH_Drawing_ColorFilterCreateMatrix(matrix);
685 EXPECT_NE(matrixFilter, nullptr);
686 OH_Drawing_FilterSetColorFilter(filter, matrixFilter);
687 OH_Drawing_CanvasTranslate(canvas_, 300, 300);
688 OH_Drawing_CanvasDrawRect(canvas_, rect);
689 OH_Drawing_RectDestroy(rect);
690 OH_Drawing_ColorFilterDestroy(colorFilter);
691 OH_Drawing_ColorFilterDestroy(luma);
692 OH_Drawing_ColorFilterDestroy(matrixFilter);
693 OH_Drawing_ColorFilterDestroy(linear);
694 OH_Drawing_ColorFilterDestroy(colorFilterTmp);
695 OH_Drawing_FilterDestroy(filter);
696 OH_Drawing_FilterDestroy(nullptr);
697 }
698
699 /*
700 * @tc.name: NativeDrawingCanvasTest_ColorFilterCreateCompose020
701 * @tc.desc: test for create compose color filter
702 * @tc.type: FUNC
703 * @tc.require: AR000GTO5R
704 */
705 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_ColorFilterCreateCompose020, TestSize.Level1)
706 {
707 EXPECT_EQ(OH_Drawing_BrushGetColor(brush_), 0xFFFF0000);
708 OH_Drawing_ColorFilter* outerFilter = OH_Drawing_ColorFilterCreateLuma();
709 OH_Drawing_ColorFilter* innerFilter = OH_Drawing_ColorFilterCreateSrgbGammaToLinear();
710 OH_Drawing_ColorFilter* compose = OH_Drawing_ColorFilterCreateCompose(nullptr, nullptr);
711 EXPECT_EQ(compose, nullptr);
712 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
713 compose = OH_Drawing_ColorFilterCreateCompose(outerFilter, innerFilter);
714 EXPECT_NE(compose, nullptr);
715 OH_Drawing_Filter* filter = OH_Drawing_FilterCreate();
716 OH_Drawing_FilterSetColorFilter(filter, compose);
717 OH_Drawing_BrushSetFilter(brush_, filter);
718 OH_Drawing_Canvas* canvas_ = OH_Drawing_CanvasCreate();
719 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(200, 500, 300, 600);
720 OH_Drawing_CanvasDrawRect(canvas_, rect);
721 OH_Drawing_RectDestroy(rect);
722 OH_Drawing_ColorFilterDestroy(outerFilter);
723 OH_Drawing_ColorFilterDestroy(innerFilter);
724 OH_Drawing_ColorFilterDestroy(compose);
725 OH_Drawing_FilterDestroy(filter);
726 }
727
728 /*
729 * @tc.name: NativeDrawingCanvasTest_DrawBitmap021
730 * @tc.desc: test for DrawBitmap
731 * @tc.type: FUNC
732 * @tc.require: AR000GTO5R
733 */
734 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_DrawBitmap021, TestSize.Level1)
735 {
736 OH_Drawing_Bitmap* bitmap = OH_Drawing_BitmapCreate();
737 OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE};
738 constexpr uint32_t width = 200;
739 constexpr uint32_t height = 200;
740 OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat);
741 OH_Drawing_CanvasBind(canvas_, bitmap);
742 OH_Drawing_CanvasDrawBitmap(nullptr, bitmap, 0, 0);
743 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
744 OH_Drawing_CanvasDrawBitmap(canvas_, nullptr, 0, 0);
745 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
746 OH_Drawing_CanvasDrawBitmap(canvas_, bitmap, 0, 0);
747 OH_Drawing_CanvasClear(canvas_, OH_Drawing_ColorSetArgb(0xFF, 0xFF, 0xFF, 0xFF));
748 OH_Drawing_BitmapDestroy(bitmap);
749 }
750
751 /*
752 * @tc.name: NativeDrawingCanvasTest_DrawBitmapRect022
753 * @tc.desc: test for DrawBitmapRect
754 * @tc.type: FUNC
755 * @tc.require: AR000GTO5R
756 */
757 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_DrawBitmapRect022, TestSize.Level1)
758 {
759 OH_Drawing_Bitmap* bitmap = OH_Drawing_BitmapCreate();
760 EXPECT_NE(bitmap, nullptr);
761 OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE};
762 constexpr uint32_t width = 200;
763 constexpr uint32_t height = 200;
764 OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat);
765 OH_Drawing_Rect* src = OH_Drawing_RectCreate(0, 0, 200, 200);
766 EXPECT_NE(src, nullptr);
767 OH_Drawing_Rect* dst = OH_Drawing_RectCreate(0, 0, 200, 200);
768 EXPECT_NE(dst, nullptr);
769 OH_Drawing_SamplingOptions* options = OH_Drawing_SamplingOptionsCreate(
770 OH_Drawing_FilterMode::FILTER_MODE_NEAREST, OH_Drawing_MipmapMode::MIPMAP_MODE_NEAREST);
771 EXPECT_NE(options, nullptr);
772 OH_Drawing_CanvasDrawBitmapRect(canvas_, bitmap, src, dst, options);
773 OH_Drawing_CanvasDrawBitmapRect(canvas_, bitmap, src, dst, nullptr);
774 OH_Drawing_CanvasDrawBitmapRect(canvas_, bitmap, src, nullptr, nullptr);
775 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
776 OH_Drawing_CanvasDrawBitmapRect(canvas_, bitmap, nullptr, nullptr, nullptr);
777 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
778 OH_Drawing_CanvasDrawBitmapRect(canvas_, nullptr, nullptr, nullptr, nullptr);
779 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
780 OH_Drawing_CanvasDrawBitmapRect(nullptr, nullptr, nullptr, nullptr, nullptr);
781 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
782 OH_Drawing_BitmapDestroy(bitmap);
783 }
784
785 /*
786 * @tc.name: NativeDrawingCanvasTest_SetMatrix023
787 * @tc.desc: test for SetMatrix
788 * @tc.type: FUNC
789 * @tc.require: AR000GTO5R
790 */
791 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_SetMatrix023, TestSize.Level1)
792 {
793 OH_Drawing_Matrix* matrix = OH_Drawing_MatrixCreate();
794 EXPECT_NE(matrix, nullptr);
795 OH_Drawing_MatrixSetMatrix(
796 matrix,
797 1, 0, 0,
798 0, -1, 0,
799 0, 0, 1);
800 OH_Drawing_CanvasSetMatrix(canvas_, matrix);
801 OH_Drawing_CanvasSetMatrix(canvas_, nullptr);
802 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
803 OH_Drawing_CanvasSetMatrix(nullptr, nullptr);
804 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
805 OH_Drawing_MatrixDestroy(matrix);
806 }
807
808 /*
809 * @tc.name: NativeDrawingCanvasTest_ResetMatrix024
810 * @tc.desc: test for ResetMatrix
811 * @tc.type: FUNC
812 * @tc.require: AR000GTO5R
813 */
814 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_ResetMatrix024, TestSize.Level1)
815 {
816 OH_Drawing_CanvasResetMatrix(nullptr);
817 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
818 OH_Drawing_CanvasResetMatrix(canvas_);
819 }
820
821 /*
822 * @tc.name: NativeDrawingCanvasTest_DrawImageRect025
823 * @tc.desc: test for DrawImageRect
824 * @tc.type: FUNC
825 * @tc.require: AR000GTO5R
826 */
827 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_DrawImageRect025, TestSize.Level1)
828 {
829 OH_Drawing_Rect* rect = OH_Drawing_RectCreate(0, 0, 200, 200);
830 EXPECT_NE(rect, nullptr);
831 OH_Drawing_Image* image = OH_Drawing_ImageCreate();
832 EXPECT_NE(image, nullptr);
833 OH_Drawing_Bitmap* bitmap = OH_Drawing_BitmapCreate();
834 EXPECT_NE(bitmap, nullptr);
835 OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE};
836 constexpr uint32_t width = 200;
837 constexpr uint32_t height = 200;
838 OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat);
839 OH_Drawing_ImageBuildFromBitmap(image, bitmap);
840 OH_Drawing_SamplingOptions* options = OH_Drawing_SamplingOptionsCreate(
841 OH_Drawing_FilterMode::FILTER_MODE_NEAREST, OH_Drawing_MipmapMode::MIPMAP_MODE_NEAREST);
842 EXPECT_NE(options, nullptr);
843 OH_Drawing_CanvasDrawImageRect(canvas_, image, rect, options);
844 OH_Drawing_CanvasDrawImageRect(canvas_, image, rect, nullptr);
845 OH_Drawing_CanvasDrawImageRect(canvas_, image, nullptr, nullptr);
846 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
847 OH_Drawing_CanvasDrawImageRect(canvas_, nullptr, nullptr, nullptr);
848 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
849 OH_Drawing_CanvasDrawImageRect(nullptr, nullptr, nullptr, nullptr);
850 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
851 OH_Drawing_CanvasDrawImageRectWithSrc(canvas_, image, rect, rect, options, STRICT_SRC_RECT_CONSTRAINT);
852 OH_Drawing_CanvasDrawImageRectWithSrc(nullptr, image, rect, rect, options, STRICT_SRC_RECT_CONSTRAINT);
853 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
854 OH_Drawing_CanvasDrawImageRectWithSrc(canvas_, nullptr, rect, rect, options, STRICT_SRC_RECT_CONSTRAINT);
855 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
856 OH_Drawing_CanvasDrawImageRectWithSrc(canvas_, image, nullptr, rect, options, STRICT_SRC_RECT_CONSTRAINT);
857 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
858 OH_Drawing_CanvasDrawImageRectWithSrc(nullptr, nullptr, nullptr, nullptr, nullptr, STRICT_SRC_RECT_CONSTRAINT);
859 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
860 OH_Drawing_SamplingOptionsDestroy(options);
861 OH_Drawing_BitmapDestroy(bitmap);
862 OH_Drawing_ImageDestroy(image);
863 }
864
865 /*
866 * @tc.name: NativeDrawingCanvasTest_ReadPixelsToBitmap026
867 * @tc.desc: test for ReadPixelsToBitmap
868 * @tc.type: FUNC
869 * @tc.require: AR000GTO5R
870 */
871 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_ReadPixelsToBitmap026, TestSize.Level1)
872 {
873 OH_Drawing_Bitmap* bitmap = OH_Drawing_BitmapCreate();
874 EXPECT_NE(bitmap, nullptr);
875 EXPECT_TRUE(!OH_Drawing_CanvasReadPixelsToBitmap(canvas_, bitmap, 100, 100));
876 EXPECT_TRUE(!OH_Drawing_CanvasReadPixelsToBitmap(canvas_, nullptr, 100, 100));
877 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
878 EXPECT_TRUE(!OH_Drawing_CanvasReadPixelsToBitmap(nullptr, nullptr, 100, 100));
879 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
880 OH_Drawing_BitmapDestroy(bitmap);
881 }
882
883 /*
884 * @tc.name: NativeDrawingCanvasTest_ReadPixels027
885 * @tc.desc: test for ReadPixels
886 * @tc.type: FUNC
887 * @tc.require: AR000GTO5R
888 */
889 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_ReadPixels027, TestSize.Level1)
890 {
891 OH_Drawing_Image_Info imageInfo;
892 OH_Drawing_Bitmap* bitmap = OH_Drawing_BitmapCreate();
893 EXPECT_NE(bitmap, nullptr);
894 OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE};
895 constexpr uint32_t width = 200;
896 constexpr uint32_t height = 200;
897 OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat);
898 void* pixels = OH_Drawing_BitmapGetPixels(bitmap);
899 EXPECT_TRUE(!OH_Drawing_CanvasReadPixels(canvas_, &imageInfo, pixels, 0, 0, 0));
900 EXPECT_TRUE(!OH_Drawing_CanvasReadPixels(canvas_, &imageInfo, nullptr, 0, 0, 0));
901 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
902 EXPECT_TRUE(!OH_Drawing_CanvasReadPixels(canvas_, nullptr, nullptr, 0, 0, 0));
903 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
904 EXPECT_TRUE(!OH_Drawing_CanvasReadPixels(nullptr, nullptr, nullptr, 0, 0, 0));
905 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
906 OH_Drawing_BitmapDestroy(bitmap);
907 }
908
909 /*
910 * @tc.name: NativeDrawingCanvasTest_GetWidth028
911 * @tc.desc: test for GetWidth
912 * @tc.type: FUNC
913 * @tc.require: AR000GTO5R
914 */
915 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_GetWidth028, TestSize.Level1)
916 {
917 EXPECT_TRUE(OH_Drawing_CanvasGetWidth(nullptr) == 0);
918 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
919 EXPECT_TRUE(OH_Drawing_CanvasGetWidth(canvas_) >= 0);
920 }
921
922 /*
923 * @tc.name: NativeDrawingCanvasTest_GetHeight029
924 * @tc.desc: test for GetHeight
925 * @tc.type: FUNC
926 * @tc.require: AR000GTO5R
927 */
928 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_GetHeight029, TestSize.Level1)
929 {
930 EXPECT_TRUE(OH_Drawing_CanvasGetHeight(nullptr) == 0);
931 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
932 EXPECT_TRUE(OH_Drawing_CanvasGetHeight(canvas_) >= 0);
933 }
934
935 /*
936 * @tc.name: NativeDrawingCanvasTest_GetLocalClipBounds030
937 * @tc.desc: test for GetLocalClipBounds
938 * @tc.type: FUNC
939 * @tc.require: AR000GTO5R
940 */
941 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_GetLocalClipBounds030, TestSize.Level1)
942 {
943 OH_Drawing_CanvasGetLocalClipBounds(nullptr, nullptr);
944 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
945 OH_Drawing_Rect* rect = OH_Drawing_RectCreate(0, 0, 1, 1);
946 EXPECT_NE(rect, nullptr);
947 OH_Drawing_CanvasGetLocalClipBounds(nullptr, rect);
948 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
949 OH_Drawing_CanvasGetLocalClipBounds(canvas_, rect);
950 OH_Drawing_RectDestroy(rect);
951 }
952
953 /*
954 * @tc.name: NativeDrawingCanvasTest_ConcatMatrix031
955 * @tc.desc: test for ConcatMatrix
956 * @tc.type: FUNC
957 * @tc.require: AR000GTO5R
958 */
959 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_ConcatMatrix031, TestSize.Level1)
960 {
961 OH_Drawing_Matrix* matrix = OH_Drawing_MatrixCreate();
962 EXPECT_NE(matrix, nullptr);
963 OH_Drawing_MatrixSetMatrix(
964 matrix,
965 1, 0, 0,
966 0, -1, 0,
967 0, 0, 1);
968 OH_Drawing_CanvasConcatMatrix(canvas_, matrix);
969 OH_Drawing_CanvasConcatMatrix(canvas_, nullptr);
970 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
971 OH_Drawing_CanvasConcatMatrix(nullptr, nullptr);
972 OH_Drawing_MatrixDestroy(matrix);
973 }
974
975 /*
976 * @tc.name: NativeDrawingCanvasTest_DrawShadow032
977 * @tc.desc: test for DrawShadow
978 * @tc.type: FUNC
979 * @tc.require: AR000GTO5R
980 */
981 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_DrawShadow032, TestSize.Level1)
982 {
983 OH_Drawing_Point3D p1{0.0, 0.0, 0.0};
984 OH_Drawing_Point3D p2{10.0, 10.0, 10.0};
985 OH_Drawing_CanvasDrawShadow(nullptr, nullptr, p1, p2, 0, 0xFF000000,
986 0xFF000000, OH_Drawing_CanvasShadowFlags::SHADOW_FLAGS_ALL);
987 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
988 OH_Drawing_CanvasDrawShadow(canvas_, nullptr, p1, p2, 0, 0xFF000000,
989 0xFF000000, OH_Drawing_CanvasShadowFlags::SHADOW_FLAGS_ALL);
990 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
991
992 OH_Drawing_Path* path = OH_Drawing_PathCreate();
993 EXPECT_NE(path, nullptr);
994 OH_Drawing_CanvasDrawShadow(canvas_, path, p1, p2, 10, 0xFF000000, 0xFF000000,
995 OH_Drawing_CanvasShadowFlags::SHADOW_FLAGS_ALL);
996 OH_Drawing_CanvasDrawShadow(canvas_, path, p1, p2, 10, 0xFF000000, 0xFF000000,
997 static_cast<OH_Drawing_CanvasShadowFlags>(NEGATIVE_ONE));
998 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_PARAMETER_OUT_OF_RANGE);
999 OH_Drawing_CanvasDrawShadow(canvas_, path, p1, p2, 10, 0xFF000000, 0xFF000000,
1000 static_cast<OH_Drawing_CanvasShadowFlags>(INTNUM_TEN));
1001 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_PARAMETER_OUT_OF_RANGE);
1002 }
1003
1004 /*
1005 * @tc.name: NativeDrawingCanvasTest_DrawTextBlob033
1006 * @tc.desc: test for DrawTextBlob
1007 * @tc.type: FUNC
1008 * @tc.require: AR000GTO5R
1009 */
1010 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_DrawTextBlob033, TestSize.Level1)
1011 {
1012 OH_Drawing_Font *font = OH_Drawing_FontCreate();
1013 OH_Drawing_FontSetFakeBoldText(font, true);
1014 OH_Drawing_FontSetTextSize(font, 20);
1015 OH_Drawing_FontSetTextSkewX(font, 0.25);
1016 OH_Drawing_Typeface *typeSurface = OH_Drawing_TypefaceCreateDefault();
1017 OH_Drawing_FontSetTypeface(font, typeSurface);
1018 auto *builder = OH_Drawing_TextBlobBuilderCreate();
1019 EXPECT_EQ(nullptr, OH_Drawing_TextBlobBuilderAllocRunPos(nullptr, nullptr, INT32_MAX, nullptr));
1020 EXPECT_EQ(nullptr, OH_Drawing_TextBlobBuilderAllocRunPos(builder, font, INT32_MIN, nullptr));
1021 const OH_Drawing_RunBuffer* runBuffer = OH_Drawing_TextBlobBuilderAllocRunPos(builder, font, 9, nullptr);
1022 ASSERT_NE(runBuffer, nullptr);
1023 runBuffer->glyphs[0] = 65;
1024 runBuffer->pos[0] = 0;
1025 runBuffer->pos[1] = 0;
1026 runBuffer->glyphs[1] = 227;
1027 runBuffer->pos[2] = 14.9;
1028 runBuffer->pos[3] = 0;
1029 runBuffer->glyphs[2] = 283;
1030 runBuffer->pos[4] = 25.84;
1031 runBuffer->pos[5] = 0;
1032 runBuffer->glyphs[3] = 283;
1033 runBuffer->pos[6] = 30.62;
1034 runBuffer->pos[7] = 0;
1035 runBuffer->glyphs[4] = 299;
1036 runBuffer->pos[8] = 35.4;
1037 runBuffer->pos[9] = 0;
1038 runBuffer->glyphs[5] = 2;
1039 runBuffer->pos[10] = 47.22;
1040 runBuffer->pos[11] = 0;
1041 runBuffer->glyphs[6]= 94;
1042 runBuffer->pos[12] = 52.62;
1043 runBuffer->pos[13] = 0;
1044 runBuffer->glyphs[7] = 37;
1045 runBuffer->pos[14] = 67.42;
1046 runBuffer->pos[15] = 0;
1047 runBuffer->glyphs[8] = 84;
1048 runBuffer->pos[16] = 81.7;
1049 runBuffer->pos[17] = 0;
1050 OH_Drawing_TextBlob *textBlob = OH_Drawing_TextBlobBuilderMake(builder);
1051 OH_Drawing_CanvasDrawTextBlob(canvas_, textBlob, 100, 700);
1052 OH_Drawing_TextBlobDestroy(textBlob);
1053 OH_Drawing_TextBlobBuilderDestroy(builder);
1054 OH_Drawing_FontDestroy(font);
1055 OH_Drawing_TypefaceDestroy(typeSurface);
1056 OH_Drawing_TextBlobDestroy(nullptr);
1057 OH_Drawing_TextBlobBuilderDestroy(nullptr);
1058 OH_Drawing_FontDestroy(nullptr);
1059 OH_Drawing_TypefaceDestroy(nullptr);
1060 }
1061
1062 /*
1063 * @tc.name: NativeDrawingCanvasTest_DrawTextBlob034
1064 * @tc.desc: test for DrawTextBlob2
1065 * @tc.type: FUNC
1066 * @tc.require: SR000S9F0C
1067 */
1068 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_DrawTextBlob034, TestSize.Level1)
1069 {
1070 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0, 0, 0, 0);
1071 EXPECT_NE(rect, nullptr);
1072 OH_Drawing_Font *font = OH_Drawing_FontCreate();
1073 EXPECT_NE(font, nullptr);
1074 const char* str = "123456";
1075 EXPECT_EQ(nullptr, OH_Drawing_TextBlobCreateFromString(nullptr,
1076 font, OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8));
1077 EXPECT_EQ(nullptr, OH_Drawing_TextBlobCreateFromString(str,
1078 nullptr, OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8));
1079 OH_Drawing_TextBlob *textBlob = OH_Drawing_TextBlobCreateFromString(str,
1080 font, OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8);
1081 EXPECT_NE(textBlob, nullptr);
1082 OH_Drawing_CanvasDrawTextBlob(nullptr, textBlob, 0, 0);
1083 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
1084 OH_Drawing_CanvasDrawTextBlob(canvas_, nullptr, 0, 0);
1085 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
1086 OH_Drawing_CanvasDrawTextBlob(canvas_, textBlob, 0, 0);
1087 OH_Drawing_TextBlobGetBounds(textBlob, nullptr);
1088 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
1089 OH_Drawing_TextBlobGetBounds(textBlob, rect);
1090 OH_Drawing_CanvasDrawRect(canvas_, rect);
1091 OH_Drawing_TextBlobDestroy(textBlob);
1092 OH_Drawing_FontDestroy(font);
1093 OH_Drawing_RectDestroy(rect);
1094 }
1095
1096 /*
1097 * @tc.name: NativeDrawingCanvasTest_DrawTextBlob035
1098 * @tc.desc: test for DrawTextBlob3
1099 * @tc.type: FUNC
1100 * @tc.require: SR000S9F0C
1101 */
1102 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_DrawTextBlob035, TestSize.Level1)
1103 {
1104 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0, 0, 0, 0);
1105 EXPECT_NE(rect, nullptr);
1106 OH_Drawing_Font *font = OH_Drawing_FontCreate();
1107 EXPECT_NE(font, nullptr);
1108 OH_Drawing_Typeface* typeface = OH_Drawing_TypefaceCreateFromFile(nullptr, 0);
1109 EXPECT_EQ(nullptr, typeface);
1110 // sub test 1, OH_Drawing_FontGetTypeface
1111 OH_Drawing_FontGetTypeface(nullptr);
1112 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
1113 EXPECT_EQ(nullptr, typeface);
1114 OH_Drawing_Typeface *typeSurface = OH_Drawing_TypefaceCreateDefault();
1115 OH_Drawing_FontSetTypeface(font, typeSurface);
1116 EXPECT_NE(nullptr, OH_Drawing_FontGetTypeface(font));
1117 // sub test 2, OH_Drawing_FontCountText
1118 const char* str = "123456";
1119 int count = 0;
1120 count = OH_Drawing_FontCountText(nullptr, str, strlen(str),
1121 OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8);
1122 EXPECT_EQ(0, count);
1123 count = OH_Drawing_FontCountText(font, nullptr, strlen(str),
1124 OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8);
1125 EXPECT_EQ(0, count);
1126 count = OH_Drawing_FontCountText(font, str, strlen(str),
1127 OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8);
1128 EXPECT_EQ(strlen(str), count);
1129 // sub test 3, OH_Drawing_TextBlobCreateFromText
1130 EXPECT_EQ(nullptr, OH_Drawing_TextBlobCreateFromText(nullptr, strlen(str),
1131 font, OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8));
1132 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
1133 EXPECT_EQ(nullptr, OH_Drawing_TextBlobCreateFromText(str, strlen(str),
1134 nullptr, OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8));
1135 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
1136 OH_Drawing_TextBlobCreateFromText(str, strlen(str), font, static_cast<OH_Drawing_TextEncoding>(NEGATIVE_ONE));
1137 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_PARAMETER_OUT_OF_RANGE);
1138 OH_Drawing_TextBlobCreateFromText(str, strlen(str), font, static_cast<OH_Drawing_TextEncoding>(INTNUM_TEN));
1139 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_PARAMETER_OUT_OF_RANGE);
1140 OH_Drawing_TextBlob *textBlob = OH_Drawing_TextBlobCreateFromText(str, strlen(str),
1141 font, OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8);
1142 EXPECT_NE(textBlob, nullptr);
1143 EXPECT_TRUE(OH_Drawing_TextBlobUniqueID(nullptr) == 0);
1144 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
1145 EXPECT_TRUE(OH_Drawing_TextBlobUniqueID(textBlob) > 0);
1146 // draw textblob
1147 OH_Drawing_CanvasDrawTextBlob(canvas_, textBlob, 0, 0);
1148
1149 OH_Drawing_TextBlobDestroy(textBlob);
1150 OH_Drawing_FontDestroy(font);
1151 OH_Drawing_TypefaceDestroy(typeSurface);
1152 }
1153
1154 /*
1155 * @tc.name: NativeDrawingCanvasTest_DrawTextBlob036
1156 * @tc.desc: test for DrawTextBlob4
1157 * @tc.type: FUNC
1158 * @tc.require: SR000S9F0C
1159 */
1160 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_DrawTextBlob036, TestSize.Level1)
1161 {
1162 size_t length = 1;
1163 OH_Drawing_Font *font = OH_Drawing_FontCreate();
1164 EXPECT_NE(font, nullptr);
1165 OH_Drawing_MemoryStream* memoryStream = OH_Drawing_MemoryStreamCreate(nullptr,
1166 length, false);
1167 OH_Drawing_MemoryStreamDestroy(memoryStream);
1168 EXPECT_EQ(nullptr, memoryStream);
1169 OH_Drawing_Typeface* typeface = OH_Drawing_TypefaceCreateFromStream(
1170 memoryStream, 0);
1171 EXPECT_EQ(nullptr, typeface);
1172 OH_Drawing_Typeface *typeSurface = OH_Drawing_TypefaceCreateDefault();
1173 OH_Drawing_FontSetTypeface(font, typeSurface);
1174 EXPECT_NE(nullptr, OH_Drawing_FontGetTypeface(font));
1175 const char* str = "123456";
1176 int count = strlen(str);
1177 OH_Drawing_Point2D pts[count];
1178 EXPECT_EQ(nullptr, OH_Drawing_TextBlobCreateFromPosText(nullptr, count, &pts[0],
1179 font, OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8));
1180 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
1181 EXPECT_EQ(nullptr, OH_Drawing_TextBlobCreateFromPosText(str, count, nullptr,
1182 font, OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8));
1183 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
1184 EXPECT_EQ(nullptr, OH_Drawing_TextBlobCreateFromPosText(str, count, &pts[0],
1185 nullptr, OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8));
1186 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
1187 OH_Drawing_TextBlobCreateFromPosText(str, count, &pts[0], font, static_cast<OH_Drawing_TextEncoding>(NEGATIVE_ONE));
1188 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_PARAMETER_OUT_OF_RANGE);
1189 OH_Drawing_TextBlobCreateFromPosText(str, count, &pts[0], font, static_cast<OH_Drawing_TextEncoding>(INTNUM_TEN));
1190 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_PARAMETER_OUT_OF_RANGE);
1191 OH_Drawing_TextBlob *textBlob = OH_Drawing_TextBlobCreateFromPosText(str, count, &pts[0],
1192 font, OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8);
1193 EXPECT_NE(textBlob, nullptr);
1194 OH_Drawing_CanvasDrawTextBlob(canvas_, textBlob, 0, 0);
1195
1196 OH_Drawing_TextBlobDestroy(textBlob);
1197 OH_Drawing_FontDestroy(font);
1198 OH_Drawing_TypefaceDestroy(typeSurface);
1199 }
1200
1201 /*
1202 * @tc.name: NativeDrawingCanvasTest_SaveLayer037
1203 * @tc.desc: test for SaveLayer
1204 * @tc.type: FUNC
1205 * @tc.require: SR000S9F0C
1206 */
1207 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_SaveLayer037, TestSize.Level1)
1208 {
1209 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(200, 500, 300, 600);
1210 EXPECT_NE(rect, nullptr);
1211 OH_Drawing_Brush* brush = OH_Drawing_BrushCreate();
1212 EXPECT_NE(brush, nullptr);
1213 // test exception
1214 OH_Drawing_CanvasSaveLayer(nullptr, rect, brush);
1215 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
1216 OH_Drawing_CanvasSaveLayer(canvas_, rect, brush);
1217 OH_Drawing_CanvasRestore(canvas_);
1218 OH_Drawing_RectDestroy(rect);
1219 }
1220
1221 /*
1222 * @tc.name: NativeDrawingCanvasTest_ClipRoundRect
1223 * @tc.desc: test for OH_Drawing_ClipRoundRect.
1224 * @tc.type: FUNC
1225 * @tc.require: AR000GTO5R
1226 */
1227 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_ClipRoundRect, TestSize.Level1)
1228 {
1229 OH_Drawing_Rect* rect = OH_Drawing_RectCreate(10, 100, 200, 300);
1230 OH_Drawing_RoundRect* roundRect = OH_Drawing_RoundRectCreate(rect, 10, 10);
1231 for (auto alias : {false, true}) {
1232 OH_Drawing_CanvasClipRoundRect(nullptr, roundRect, OH_Drawing_CanvasClipOp::INTERSECT, alias);
1233 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
1234 OH_Drawing_CanvasClipRoundRect(canvas_, nullptr, OH_Drawing_CanvasClipOp::INTERSECT, alias);
1235 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
1236 OH_Drawing_CanvasClipRoundRect(canvas_, roundRect, OH_Drawing_CanvasClipOp::INTERSECT, alias);
1237 }
1238 OH_Drawing_CanvasDrawRect(canvas_, rect);
1239 OH_Drawing_RectDestroy(rect);
1240 OH_Drawing_RoundRectDestroy(roundRect);
1241 }
1242
1243 /*
1244 * @tc.name: NativeDrawingCanvasTest_RoundRectGetCorner
1245 * @tc.desc: test for OH_Drawing_RoundRectGetCorner.
1246 * @tc.type: FUNC
1247 * @tc.require: AR000GTO5R
1248 */
1249 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_RoundRectGetCorner, TestSize.Level1)
1250 {
1251 OH_Drawing_Rect* rect = OH_Drawing_RectCreate(10, 100, 200, 300);
1252 OH_Drawing_RoundRect* roundRect = OH_Drawing_RoundRectCreate(rect, 0, 0);
1253 OH_Drawing_RoundRectSetCorner(nullptr, OH_Drawing_CornerPos::CORNER_POS_BOTTOM_LEFT, {10, 10});
1254 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
1255 OH_Drawing_RoundRectSetCorner(roundRect, OH_Drawing_CornerPos::CORNER_POS_BOTTOM_LEFT, {10, 10});
1256 OH_Drawing_RoundRectGetCorner(nullptr, OH_Drawing_CornerPos::CORNER_POS_BOTTOM_LEFT);
1257 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
1258 OH_Drawing_Corner_Radii radiusPoint =
1259 OH_Drawing_RoundRectGetCorner(roundRect, OH_Drawing_CornerPos::CORNER_POS_BOTTOM_LEFT);
1260 EXPECT_EQ(10.0f, radiusPoint.x);
1261 EXPECT_EQ(10.0f, radiusPoint.y);
1262 OH_Drawing_RectDestroy(rect);
1263 OH_Drawing_RoundRectDestroy(roundRect);
1264 }
1265
1266 /*
1267 * @tc.name: NativeDrawingCanvasTest_RoundRectSetCorner
1268 * @tc.desc: test for OH_Drawing_RoundRectSetCorner.
1269 * @tc.type: FUNC
1270 * @tc.require: AR000GTO5R
1271 */
1272 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_RoundRectSetCorner, TestSize.Level1)
1273 {
1274 OH_Drawing_Rect* rect = OH_Drawing_RectCreate(10, 100, 200, 300);
1275 OH_Drawing_RoundRect* roundRect = OH_Drawing_RoundRectCreate(rect, 0, 0);
1276 OH_Drawing_RoundRectSetCorner(nullptr, OH_Drawing_CornerPos::CORNER_POS_BOTTOM_LEFT, {10, 10});
1277 OH_Drawing_RoundRectSetCorner(roundRect, OH_Drawing_CornerPos::CORNER_POS_BOTTOM_LEFT, {10, 10});
1278 OH_Drawing_Corner_Radii radiusPoint =
1279 OH_Drawing_RoundRectGetCorner(roundRect, OH_Drawing_CornerPos::CORNER_POS_BOTTOM_LEFT);
1280 EXPECT_EQ(10.0f, radiusPoint.x);
1281 OH_Drawing_CanvasClipRoundRect(canvas_, roundRect, OH_Drawing_CanvasClipOp::INTERSECT, true);
1282 OH_Drawing_CanvasDrawRect(canvas_, rect);
1283 OH_Drawing_RectDestroy(rect);
1284 OH_Drawing_RoundRectDestroy(roundRect);
1285 }
1286
1287 /*
1288 * @tc.name: NativeDrawingCanvasTest_DrawRegion038
1289 * @tc.desc: test for DrawRegion
1290 * @tc.type: FUNC
1291 * @tc.require: AR000GTO5R
1292 */
1293 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_DrawRegion038, TestSize.Level1)
1294 {
1295 OH_Drawing_Region* region=OH_Drawing_RegionCreate();
1296 OH_Drawing_Rect* rect=OH_Drawing_RectCreate(0.0f, 0.0f, 256.0f, 256.0f);
1297 OH_Drawing_RegionSetRect(region, rect);
1298 OH_Drawing_CanvasDrawRegion(nullptr, region);
1299 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
1300 OH_Drawing_CanvasDrawRegion(canvas_, nullptr);
1301 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
1302 OH_Drawing_CanvasDrawRegion(canvas_, region);
1303 OH_Drawing_RegionDestroy(region);
1304 OH_Drawing_RectDestroy(rect);
1305 }
1306
1307 /*
1308 * @tc.name: NativeDrawingCanvasTest_DrawBackground039
1309 * @tc.desc: test for DrawBackground
1310 * @tc.type: FUNC
1311 * @tc.require: AR000GTO5R
1312 */
1313 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_DrawBackground039, TestSize.Level1)
1314 {
1315 OH_Drawing_Brush* brush = OH_Drawing_BrushCreate();
1316 OH_Drawing_BrushSetColor(brush, OH_Drawing_ColorSetArgb(0xFF, 0xFF, 0x00, 0x00));
1317 OH_Drawing_CanvasDrawBackground(nullptr, brush);
1318 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
1319 OH_Drawing_CanvasDrawBackground(canvas_, nullptr);
1320 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
1321 OH_Drawing_CanvasDrawBackground(canvas_, brush);
1322 OH_Drawing_BrushDestroy(brush);
1323 }
1324
1325 /*
1326 * @tc.name: NativeDrawingCanvasTest_DrawPixelMapRect040
1327 * @tc.desc: test for DrawPixelMapRect
1328 * @tc.type: FUNC
1329 * @tc.require: AR000GTO5R
1330 */
1331 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_DrawPixelMapRect040, TestSize.Level1)
1332 {
1333 OH_Pixelmap_InitializationOptions *options = nullptr;
1334 OH_PixelmapNative *pixelMap = nullptr;
1335 OH_PixelmapInitializationOptions_Create(&options);
1336 // 4 means width
1337 OH_PixelmapInitializationOptions_SetWidth(options, 4);
1338 // 4 means height
1339 OH_PixelmapInitializationOptions_SetHeight(options, 4);
1340 // 4 means RGBA format
1341 OH_PixelmapInitializationOptions_SetPixelFormat(options, 3);
1342 // 2 means ALPHA_FORMAT_PREMUL format
1343 OH_PixelmapInitializationOptions_SetAlphaType(options, 2);
1344 // 255 means rgba data
1345 uint8_t data[] = {
1346 255, 255, 0, 255,
1347 255, 255, 0, 255,
1348 255, 255, 0, 255,
1349 255, 255, 0, 255
1350 };
1351 // 16 means data length
1352 size_t dataLength = 16;
1353 OH_PixelmapNative_CreatePixelmap(data, dataLength, options, &pixelMap);
1354 EXPECT_NE(pixelMap, nullptr);
1355 OH_Drawing_PixelMap *drPixelMap = OH_Drawing_PixelMapGetFromOhPixelMapNative(pixelMap);
1356 EXPECT_NE(drPixelMap, nullptr);
1357 OH_Drawing_Rect* srcRect = OH_Drawing_RectCreate(0, 0, 4, 4);
1358 OH_Drawing_Rect* dstRect = OH_Drawing_RectCreate(0, 0, 4, 4);
1359 OH_Drawing_SamplingOptions* samplingOptions = OH_Drawing_SamplingOptionsCreate(
1360 OH_Drawing_FilterMode::FILTER_MODE_NEAREST, OH_Drawing_MipmapMode::MIPMAP_MODE_NEAREST);
1361 EXPECT_NE(samplingOptions, nullptr);
1362 OH_Drawing_CanvasDrawPixelMapRect(canvas_, drPixelMap, srcRect, dstRect, samplingOptions);
1363 OH_Drawing_CanvasDrawPixelMapRect(canvas_, drPixelMap, srcRect, dstRect, nullptr);
1364 OH_Drawing_CanvasDrawPixelMapRect(canvas_, drPixelMap, srcRect, nullptr, nullptr);
1365 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
1366 OH_Drawing_CanvasDrawPixelMapRect(canvas_, drPixelMap, nullptr, nullptr, nullptr);
1367 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
1368 OH_Drawing_CanvasDrawPixelMapRect(canvas_, nullptr, nullptr, nullptr, nullptr);
1369 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
1370 OH_Drawing_CanvasDrawPixelMapRect(nullptr, nullptr, nullptr, nullptr, nullptr);
1371 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
1372 OH_Drawing_PixelMapDissolve(drPixelMap);
1373 OH_PixelmapNative_Release(pixelMap);
1374 OH_PixelmapInitializationOptions_Release(options);
1375 OH_Drawing_RectDestroy(srcRect);
1376 OH_Drawing_RectDestroy(dstRect);
1377 OH_Drawing_SamplingOptionsDestroy(samplingOptions);
1378 }
1379
1380 /*
1381 * @tc.name: NativeDrawingCanvasTest_DrawPixelMapRect041
1382 * @tc.desc: test for DrawPixelMapRect
1383 * @tc.type: FUNC
1384 * @tc.require: AR000GTO5R
1385 */
1386 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_DrawPixelMapRect041, TestSize.Level1)
1387 {
1388 OH_Pixelmap_InitializationOptions *options = nullptr;
1389 OH_PixelmapNative *pixelMap = nullptr;
1390 OH_PixelmapInitializationOptions_Create(&options);
1391 // 4 means width
1392 OH_PixelmapInitializationOptions_SetWidth(options, 4);
1393 // 4 means height
1394 OH_PixelmapInitializationOptions_SetHeight(options, 4);
1395 // 4 means RGBA format
1396 OH_PixelmapInitializationOptions_SetPixelFormat(options, 3);
1397 // 2 means ALPHA_FORMAT_PREMUL format
1398 OH_PixelmapInitializationOptions_SetAlphaType(options, 2);
1399 // 255 means rgba data
1400 uint8_t data[] = {
1401 255, 255, 0, 255,
1402 255, 255, 0, 255,
1403 255, 255, 0, 255,
1404 255, 255, 0, 255
1405 };
1406 // 16 means data length
1407 size_t dataLength = 16;
1408 OH_PixelmapNative_CreatePixelmap(data, dataLength, options, &pixelMap);
1409 EXPECT_NE(pixelMap, nullptr);
1410 OH_Drawing_PixelMap *drPixelMap = OH_Drawing_PixelMapGetFromOhPixelMapNative(pixelMap);
1411 EXPECT_NE(drPixelMap, nullptr);
1412 auto recordingCanvas = new RecordingCanvas(100, 100);
1413 OH_Drawing_Canvas *cCanvas = reinterpret_cast<OH_Drawing_Canvas*>(recordingCanvas);
1414 EXPECT_NE(cCanvas, nullptr);
1415 OH_Drawing_Rect* srcRect = OH_Drawing_RectCreate(0, 0, 4, 4);
1416 OH_Drawing_Rect* dstRect = OH_Drawing_RectCreate(0, 0, 4, 4);
1417 OH_Drawing_SamplingOptions* samplingOptions = OH_Drawing_SamplingOptionsCreate(
1418 OH_Drawing_FilterMode::FILTER_MODE_NEAREST, OH_Drawing_MipmapMode::MIPMAP_MODE_NEAREST);
1419 EXPECT_NE(samplingOptions, nullptr);
1420 OH_Drawing_CanvasDrawPixelMapRect(cCanvas, drPixelMap, srcRect, dstRect, samplingOptions);
1421 OH_Drawing_CanvasDrawPixelMapRect(cCanvas, drPixelMap, srcRect, dstRect, nullptr);
1422 OH_Drawing_CanvasDrawPixelMapRect(cCanvas, drPixelMap, srcRect, nullptr, nullptr);
1423 OH_Drawing_CanvasDrawPixelMapRect(cCanvas, drPixelMap, nullptr, nullptr, nullptr);
1424 OH_Drawing_CanvasDrawPixelMapRect(cCanvas, nullptr, nullptr, nullptr, nullptr);
1425 OH_Drawing_CanvasDrawPixelMapRect(nullptr, nullptr, nullptr, nullptr, nullptr);
1426 auto drawCmdList = recordingCanvas->GetDrawCmdList();
1427 EXPECT_NE(drawCmdList, nullptr);
1428 Canvas canvas;
1429 drawCmdList->Playback(canvas);
1430 OH_Drawing_PixelMapDissolve(drPixelMap);
1431 OH_PixelmapNative_Release(pixelMap);
1432 OH_PixelmapInitializationOptions_Release(options);
1433 OH_Drawing_RectDestroy(srcRect);
1434 OH_Drawing_RectDestroy(dstRect);
1435 OH_Drawing_SamplingOptionsDestroy(samplingOptions);
1436 delete recordingCanvas;
1437 }
1438
1439 /*
1440 * @tc.name: NativeDrawingCanvasTest_IsClipEmpty042
1441 * @tc.desc: test for if clip is empty
1442 * @tc.type: FUNC
1443 * @tc.require: AR000GTO5R
1444 */
1445 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_IsClipEmpty042, TestSize.Level1)
1446 {
1447 OH_Drawing_Bitmap* bitmap = OH_Drawing_BitmapCreate();
1448 OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE};
1449 // 720: bitmap's width, 720: bitmap's height
1450 constexpr uint32_t width = 720;
1451 constexpr uint32_t height = 720;
1452 OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat);
1453 OH_Drawing_CanvasBind(canvas_, bitmap);
1454
1455 // 150.0f: rect's left, 100.0f: rect's top, 500.0f: rect's right, 500.0f: rect's bottom
1456 OH_Drawing_Rect* rect = OH_Drawing_RectCreate(150.0f, 100.0f, 500.f, 500.f);
1457
1458 OH_Drawing_CanvasClipRect(canvas_, rect, OH_Drawing_CanvasClipOp::INTERSECT, false);
1459
1460 bool isClipEmpty = false;
1461 EXPECT_EQ(OH_Drawing_CanvasIsClipEmpty(canvas_, &isClipEmpty), OH_DRAWING_SUCCESS);
1462 EXPECT_EQ(isClipEmpty, false);
1463
1464 OH_Drawing_RectDestroy(rect);
1465 OH_Drawing_BitmapDestroy(bitmap);
1466 }
1467
1468 /*
1469 * @tc.name: NativeDrawingCanvasTest_GetImageInfo043
1470 * @tc.desc: test for Gets ImageInfo of Canvas.
1471 * @tc.type: FUNC
1472 * @tc.require: AR000GTO5R
1473 */
1474 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_GetImageInfo043, TestSize.Level1)
1475 {
1476 OH_Drawing_Bitmap* bitmap = OH_Drawing_BitmapCreate();
1477 OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE};
1478 // 720: bitmap's width, 720: bitmap's height
1479 constexpr uint32_t width = 720;
1480 constexpr uint32_t height = 720;
1481 OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat);
1482 OH_Drawing_CanvasBind(canvas_, bitmap);
1483 OH_Drawing_Image_Info* imageInfo = new OH_Drawing_Image_Info();
1484 EXPECT_EQ(OH_Drawing_CanvasGetImageInfo(canvas_, imageInfo), OH_DRAWING_SUCCESS);
1485 EXPECT_EQ(720, imageInfo->width);
1486 EXPECT_EQ(720, imageInfo->height);
1487 EXPECT_EQ(1, imageInfo->alphaType);
1488 EXPECT_EQ(4, imageInfo->colorType);
1489 delete imageInfo;
1490 }
1491
1492 /*
1493 * @tc.name: NativeDrawingCanvasTest_ClipRegion044
1494 * @tc.desc: test for Drawing Canvas Clip Region.
1495 * @tc.type: FUNC
1496 * @tc.require: AR000GTO5R
1497 */
1498 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_ClipRegion044, TestSize.Level1)
1499 {
1500 OH_Drawing_Bitmap* bitmap = OH_Drawing_BitmapCreate();
1501 OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE};
1502 constexpr uint32_t width = 720; // 720: width of canvas
1503 constexpr uint32_t height = 720; // 720: height of canvas
1504 OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat);
1505 OH_Drawing_CanvasBind(canvas_, bitmap);
1506
1507 OH_Drawing_Region *region = OH_Drawing_RegionCreate();
1508 // 0.0f: rect's left, 0.0f: rect's top, 720.0f: rect's right, 720.0f: rect's bottom
1509 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0.0f, 0.0f, 720.f, 720.f);
1510 OH_Drawing_RegionSetRect(region, rect);
1511 EXPECT_EQ(OH_Drawing_CanvasClipRegion(canvas_, region, OH_Drawing_CanvasClipOp::INTERSECT), OH_DRAWING_SUCCESS);
1512 EXPECT_EQ(OH_Drawing_CanvasClipRegion(nullptr, region, OH_Drawing_CanvasClipOp::INTERSECT),
1513 OH_DRAWING_ERROR_INVALID_PARAMETER);
1514
1515 EXPECT_EQ(720, OH_Drawing_CanvasGetWidth(canvas_));
1516 EXPECT_EQ(720, OH_Drawing_CanvasGetHeight(canvas_));
1517
1518 OH_Drawing_RegionDestroy(region);
1519 OH_Drawing_RectDestroy(rect);
1520 OH_Drawing_BitmapDestroy(bitmap);
1521 }
1522
1523 /*
1524 * @tc.name: NativeDrawingCanvasTest_DrawPoint_045
1525 * @tc.desc: test for OH_Drawing_CanvasDrawPoint.
1526 * @tc.type: FUNC
1527 * @tc.require: AR000GTO5R
1528 */
1529 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_DrawPoint_045, TestSize.Level1)
1530 {
1531 OH_Drawing_Point2D point_ = {25.0f, 36.0f}; // 25.0f: x, 36.0f: y
1532 EXPECT_EQ(OH_Drawing_CanvasDrawPoint(canvas_, nullptr), OH_DRAWING_ERROR_INVALID_PARAMETER);
1533 EXPECT_EQ(OH_Drawing_CanvasDrawPoint(nullptr, &point_), OH_DRAWING_ERROR_INVALID_PARAMETER);
1534 EXPECT_EQ(OH_Drawing_CanvasDrawPoint(canvas_, &point_), OH_DRAWING_SUCCESS);
1535 }
1536
1537 /*
1538 * @tc.name: NativeDrawingCanvasTest_DrawColor046
1539 * @tc.desc: test for DrawColor
1540 * @tc.type: FUNC
1541 * @tc.require: SR000S9F0C
1542 */
1543 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_DrawColor046, TestSize.Level1)
1544 {
1545 EXPECT_EQ(OH_Drawing_CanvasDrawColor(nullptr, 0xFFFF0000, OH_Drawing_BlendMode::BLEND_MODE_SRC),
1546 OH_DRAWING_ERROR_INVALID_PARAMETER);
1547 EXPECT_EQ(OH_Drawing_CanvasDrawColor(canvas_, 0xFFFF0000, OH_Drawing_BlendMode::BLEND_MODE_COLOR),
1548 OH_DRAWING_SUCCESS);
1549 }
1550
1551 /*
1552 * @tc.name: NativeDrawingCanvasTest_DrawTextBlob047
1553 * @tc.desc: test for DrawTextBlob
1554 * @tc.type: FUNC
1555 * @tc.require: AR000GTO5R
1556 */
1557 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_DrawTextBlob047, TestSize.Level1)
1558 {
1559 OH_Drawing_Font *font = OH_Drawing_FontCreate();
1560 auto *builder = OH_Drawing_TextBlobBuilderCreate();
1561 EXPECT_EQ(nullptr, OH_Drawing_TextBlobBuilderAllocRunPos(nullptr, nullptr, INT32_MAX, nullptr));
1562 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
1563 EXPECT_EQ(nullptr, OH_Drawing_TextBlobBuilderAllocRunPos(builder, nullptr, INT32_MAX, nullptr));
1564 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
1565 EXPECT_EQ(nullptr, OH_Drawing_TextBlobBuilderAllocRunPos(builder, font, 0, nullptr));
1566 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
1567 OH_Drawing_TextBlobBuilderDestroy(builder);
1568 OH_Drawing_FontDestroy(font);
1569 }
1570
1571 /*
1572 * @tc.name: NativeDrawingCanvasTest_ImageFilterCreateBlur041
1573 * @tc.desc: test for Creates an OH_Drawing_ImageFilter object that blurs its input by the separate x and y sigmas.
1574 * @tc.type: FUNC
1575 * @tc.require: AR000GTO5R
1576 */
1577 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_ImageFilterCreateBlur041, TestSize.Level1)
1578 {
1579 float sifmaX = 0.f;
1580 float sigmaY = 0.f;
1581 OH_Drawing_ImageFilter *imagefilter = nullptr;
1582 imagefilter = OH_Drawing_ImageFilterCreateBlur(sifmaX, sigmaY, CLAMP, nullptr);
1583 EXPECT_NE(imagefilter, nullptr);
1584 OH_Drawing_ImageFilterDestroy(imagefilter);
1585 }
1586
1587 /*
1588 * @tc.name: NativeDrawingCanvasTest_ImageFilterCreateFromColorFilter042
1589 * @tc.desc: test for Creates an OH_Drawing_ImageFilter object that applies the color filter to the input.
1590 * @tc.type: FUNC
1591 * @tc.require: AR000GTO5R
1592 */
1593 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_ImageFilterCreateFromColorFilter042, TestSize.Level1)
1594 {
1595 float sifmaX = 0.f;
1596 float sigmaY = 0.f;
1597 OH_Drawing_ImageFilter *imagefilter = nullptr;
1598 imagefilter = OH_Drawing_ImageFilterCreateBlur(sifmaX, sigmaY, CLAMP, nullptr);
1599 EXPECT_NE(imagefilter, nullptr);
1600 EXPECT_EQ(OH_Drawing_BrushGetColor(brush_), 0xFFFF0000);
1601 OH_Drawing_ColorFilter* colorFilter = OH_Drawing_ColorFilterCreateBlendMode(0xFF0000FF,
1602 OH_Drawing_BlendMode::BLEND_MODE_SRC);
1603 EXPECT_NE(colorFilter, nullptr);
1604 OH_Drawing_ColorFilter* colorFilterTmp = OH_Drawing_ColorFilterCreateLinearToSrgbGamma();
1605 EXPECT_NE(colorFilterTmp, nullptr);
1606 OH_Drawing_ImageFilter *imagefiltercreatefromc = nullptr;
1607 imagefiltercreatefromc = OH_Drawing_ImageFilterCreateFromColorFilter(nullptr, nullptr);
1608 EXPECT_EQ(imagefiltercreatefromc, nullptr);
1609 imagefiltercreatefromc = OH_Drawing_ImageFilterCreateFromColorFilter(colorFilterTmp, imagefilter);
1610 EXPECT_NE(imagefiltercreatefromc, nullptr);
1611 OH_Drawing_ColorFilterDestroy(colorFilter);
1612 OH_Drawing_ColorFilterDestroy(colorFilterTmp);
1613 OH_Drawing_ImageFilterDestroy(imagefiltercreatefromc);
1614 OH_Drawing_ImageFilterDestroy(imagefilter);
1615 }
1616
1617 /*
1618 * @tc.name: NativeDrawingCanvasTest_ImageFilterDestroy043
1619 * @tc.desc: test for Destroys an OH_Drawing_ImageFilter object and reclaims the memory occupied by the object.
1620 * @tc.type: FUNC
1621 * @tc.require: AR000GTO5R
1622 */
1623 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_ImageFilterDestroy043, TestSize.Level1)
1624 {
1625 float sifmaX = 0.f;
1626 float sigmaY = 0.f;
1627 OH_Drawing_ImageFilter *imagefilter = nullptr;
1628 imagefilter = OH_Drawing_ImageFilterCreateBlur(sifmaX, sigmaY, CLAMP, nullptr);
1629 EXPECT_NE(imagefilter, nullptr);
1630 OH_Drawing_ImageFilterDestroy(nullptr);
1631 OH_Drawing_ImageFilterDestroy(imagefilter);
1632 }
1633
1634 /*
1635 * @tc.name: NativeDrawingCanvasTest_FilterSetImageFilter044
1636 * @tc.desc: test for Sets an OH_Drawing_ImageFilter object for an OH_Drawing_Filter object.
1637 * @tc.type: FUNC
1638 * @tc.require: AR000GTO5R
1639 */
1640 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_FilterSetImageFilter044, TestSize.Level1)
1641 {
1642 float sifmaX = 0.f;
1643 float sigmaY = 0.f;
1644 OH_Drawing_ImageFilter *imagefilter = OH_Drawing_ImageFilterCreateBlur(sifmaX, sigmaY, CLAMP, nullptr);
1645 EXPECT_NE(imagefilter, nullptr);
1646 OH_Drawing_Filter* filter = OH_Drawing_FilterCreate();
1647 OH_Drawing_FilterSetImageFilter(nullptr, imagefilter);
1648 OH_Drawing_FilterSetImageFilter(filter, nullptr);
1649 OH_Drawing_FilterSetImageFilter(filter, imagefilter);
1650 OH_Drawing_FilterDestroy(filter);
1651 OH_Drawing_ImageFilterDestroy(imagefilter);
1652 }
1653
1654 /*
1655 * @tc.name: NativeDrawingCanvasTest_CanvasDrawSingleCharacter045
1656 * @tc.desc: test for OH_Drawing_CanvasDrawSingleCharacter.
1657 * @tc.type: FUNC
1658 * @tc.require: AR000GTO5R
1659 */
1660 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_CanvasDrawSingleCharacter045, TestSize.Level1)
1661 {
1662 const char* strOne = "a";
1663 const char* strTwo = "你好";
1664 OH_Drawing_Font *font = OH_Drawing_FontCreate();
1665 EXPECT_NE(font, nullptr);
1666 float x = 0.f;
1667 float y = 0.f;
1668 EXPECT_EQ(OH_Drawing_CanvasDrawSingleCharacter(canvas_, strOne, font, x, y), OH_DRAWING_SUCCESS);
1669 EXPECT_EQ(OH_Drawing_CanvasDrawSingleCharacter(canvas_, strTwo, font, x, y), OH_DRAWING_SUCCESS);
1670 EXPECT_EQ(OH_Drawing_CanvasDrawSingleCharacter(nullptr, strOne, font, x, y), OH_DRAWING_ERROR_INVALID_PARAMETER);
1671 EXPECT_EQ(OH_Drawing_CanvasDrawSingleCharacter(canvas_, nullptr, font, x, y), OH_DRAWING_ERROR_INVALID_PARAMETER);
1672 EXPECT_EQ(OH_Drawing_CanvasDrawSingleCharacter(canvas_, strOne, nullptr, x, y),
1673 OH_DRAWING_ERROR_INVALID_PARAMETER);
1674 const char* strThree = "";
1675 EXPECT_EQ(OH_Drawing_CanvasDrawSingleCharacter(canvas_, strThree, font, x, y), OH_DRAWING_ERROR_INVALID_PARAMETER);
1676 OH_Drawing_FontDestroy(font);
1677 }
1678
1679 /*
1680 * @tc.name: NativeDrawingCanvasTest_CanvasDrawRecordCmd001
1681 * @tc.desc: test for OH_Drawing_CanvasDrawRecordCmd.
1682 * @tc.type: FUNC
1683 * @tc.require: AR000GTO5R
1684 */
1685 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_CanvasDrawRecordCmd001, TestSize.Level1)
1686 {
1687 int32_t width = 10; // canvas width is 10
1688 int32_t height = 20; // canvas width is 20
1689 OH_Drawing_Canvas* canvas = nullptr;
1690 OH_Drawing_RecordCmdUtils* recordCmdUtils = OH_Drawing_RecordCmdUtilsCreate();
1691 EXPECT_TRUE(recordCmdUtils != nullptr);
1692 OH_Drawing_ErrorCode code = OH_Drawing_RecordCmdUtilsBeginRecording(recordCmdUtils, width, height, &canvas);
1693 EXPECT_TRUE(canvas != nullptr);
1694 EXPECT_EQ(code, OH_DRAWING_SUCCESS);
1695 int32_t width1 = OH_Drawing_CanvasGetWidth(canvas);
1696 int32_t height2 = OH_Drawing_CanvasGetHeight(canvas);
1697 EXPECT_TRUE(width1 == width);
1698 EXPECT_TRUE(height2 == height);
1699 OH_Drawing_RecordCmd* recordCmd = nullptr;
1700 code = OH_Drawing_RecordCmdUtilsFinishRecording(recordCmdUtils, &recordCmd);
1701 EXPECT_TRUE(recordCmd != nullptr);
1702 EXPECT_EQ(code, OH_DRAWING_SUCCESS);
1703 OH_Drawing_Canvas* recordCanvas = OH_Drawing_CanvasCreate();
1704 EXPECT_TRUE(recordCanvas != nullptr);
1705 code = OH_Drawing_CanvasDrawRecordCmd(recordCanvas, recordCmd);
1706 EXPECT_EQ(code, OH_DRAWING_SUCCESS);
1707 code = OH_Drawing_CanvasDrawRecordCmd(nullptr, recordCmd);
1708 EXPECT_EQ(code, OH_DRAWING_ERROR_INVALID_PARAMETER);
1709 code = OH_Drawing_CanvasDrawRecordCmd(recordCanvas, nullptr);
1710 EXPECT_EQ(code, OH_DRAWING_ERROR_INVALID_PARAMETER);
1711 code = OH_Drawing_CanvasDrawRecordCmd(nullptr, nullptr);
1712 EXPECT_EQ(code, OH_DRAWING_ERROR_INVALID_PARAMETER);
1713 code = OH_Drawing_RecordCmdDestroy(recordCmd);
1714 EXPECT_EQ(code, OH_DRAWING_SUCCESS);
1715 code = OH_Drawing_RecordCmdUtilsDestroy(recordCmdUtils);
1716 EXPECT_EQ(code, OH_DRAWING_SUCCESS);
1717 OH_Drawing_CanvasDestroy(recordCanvas);
1718 }
1719 } // namespace Drawing
1720 } // namespace Rosen
1721 } // namespace OHOS
1722