1 /*
2 * Copyright (c) 2022-2025 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_helper.h"
27 #include "drawing_image.h"
28 #include "drawing_image_filter.h"
29 #include "drawing_mask_filter.h"
30 #include "drawing_matrix.h"
31 #include "drawing_path.h"
32 #include "drawing_pen.h"
33 #include "drawing_pixel_map.h"
34 #include "drawing_point.h"
35 #include "drawing_record_cmd.h"
36 #include "drawing_rect.h"
37 #include "drawing_region.h"
38 #include "drawing_round_rect.h"
39 #include "drawing_sampling_options.h"
40 #include "drawing_shader_effect.h"
41 #include "drawing_text_blob.h"
42 #include "drawing_typeface.h"
43 #include "drawing_memory_stream.h"
44 #include "effect/color_filter.h"
45 #include "effect/filter.h"
46 #include "recording/recording_canvas.h"
47 #include "image/pixelmap_native.h"
48 #include "drawing_canvas_utils.h"
49 #include "pixelmap_native_impl.h"
50
51 #ifdef RS_ENABLE_VK
52 #include "platform/ohos/backend/rs_vulkan_context.h"
53 #endif
54
55 using namespace testing;
56 using namespace testing::ext;
57
58 namespace OHOS {
59 namespace Rosen {
60 namespace Drawing {
61 class NativeDrawingCanvasTest : public testing::Test {
62 public:
63 static void SetUpTestCase();
64 static void TearDownTestCase();
65 void SetUp() override;
66 void TearDown() override;
67 protected:
68 OH_Drawing_Canvas *canvas_ = nullptr;
69 OH_Drawing_Brush *brush_ = nullptr;
70 };
71
72 constexpr uint32_t POINT_PARAMETER = 3;
73 constexpr uint32_t COLOR_PARAMETER = 3;
74 constexpr uint32_t INTNUM_TEN = 10;
75 constexpr int32_t NEGATIVE_ONE = -1;
76
SetUpTestCase()77 void NativeDrawingCanvasTest::SetUpTestCase()
78 {
79 #ifdef RS_ENABLE_VK
80 RsVulkanContext::SetRecyclable(false);
81 #endif
82 }
TearDownTestCase()83 void NativeDrawingCanvasTest::TearDownTestCase() {}
SetUp()84 void NativeDrawingCanvasTest::SetUp()
85 {
86 canvas_ = OH_Drawing_CanvasCreate();
87 ASSERT_NE(nullptr, canvas_);
88 OH_Drawing_CanvasClear(canvas_, OH_Drawing_ColorSetArgb(0xFF, 0xFF, 0xFF, 0xFF));
89 brush_ = OH_Drawing_BrushCreate();
90 EXPECT_NE(brush_, nullptr);
91 OH_Drawing_BrushSetColor(brush_, 0xffff0000);
92 OH_Drawing_CanvasAttachBrush(canvas_, brush_);
93 }
94
TearDown()95 void NativeDrawingCanvasTest::TearDown()
96 {
97 if (canvas_ != nullptr) {
98 OH_Drawing_CanvasDetachBrush(canvas_);
99 OH_Drawing_BrushDestroy(brush_);
100 brush_ = nullptr;
101 OH_Drawing_CanvasDestroy(canvas_);
102 canvas_ = nullptr;
103 }
104 }
105
CreateOHDrawingPixelMap(OH_Pixelmap_InitializationOptions * options,OH_PixelmapNative * pixelMap)106 static OH_Drawing_PixelMap* CreateOHDrawingPixelMap(
107 OH_Pixelmap_InitializationOptions *options, OH_PixelmapNative *pixelMap)
108 {
109 OH_PixelmapInitializationOptions_Create(&options);
110 // 4 means width
111 OH_PixelmapInitializationOptions_SetWidth(options, 4);
112 // 4 means height
113 OH_PixelmapInitializationOptions_SetHeight(options, 4);
114 // 3 means RGBA format
115 OH_PixelmapInitializationOptions_SetPixelFormat(options, 3);
116 // 2 means ALPHA_FORMAT_PREMUL format
117 OH_PixelmapInitializationOptions_SetAlphaType(options, 2);
118 // 255 means rgba data
119 uint8_t data[] = {
120 255, 255, 0, 255,
121 255, 255, 0, 255,
122 255, 255, 0, 255,
123 255, 255, 0, 255
124 };
125 // 16 means data length
126 size_t dataLength = 16;
127 OH_PixelmapNative_CreatePixelmap(data, dataLength, options, &pixelMap);
128 return OH_Drawing_PixelMapGetFromOhPixelMapNative(pixelMap);
129 }
130
131 /*
132 * @tc.name: NativeDrawingCanvasTest_CanvasNULLPTR001
133 * @tc.desc: test for OH_Drawing_CanvasBind.
134 * @tc.type: FUNC
135 * @tc.require: AR000GTO5R
136 */
137 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_CanvasNULLPTR001, TestSize.Level1)
138 {
139 OH_Drawing_Bitmap* bitmap = OH_Drawing_BitmapCreate();
140 EXPECT_NE(bitmap, nullptr);
141 OH_Drawing_CanvasBind(nullptr, bitmap);
142 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
143 OH_Drawing_BitmapDestroy(bitmap);
144 OH_Drawing_CanvasAttachPen(canvas_, nullptr);
145 OH_Drawing_CanvasTranslate(canvas_, (float)INT32_MIN, (float)INT32_MIN);
146 OH_Drawing_CanvasTranslate(canvas_, (float)INT32_MAX, (float)INT32_MAX);
147 OH_Drawing_CanvasDrawLine(nullptr, 0, 0, 20, 20);
148 OH_Drawing_CanvasDrawLine(canvas_, 0, 0, (float)INT32_MAX, (float)INT32_MAX);
149 OH_Drawing_CanvasDrawLine(canvas_, 0, 0, (float)INT32_MIN, (float)INT32_MIN);
150 OH_Drawing_Path* path = OH_Drawing_PathCreate();
151 OH_Drawing_PathMoveTo(path, (float)INT32_MAX, (float)INT32_MIN);
152 OH_Drawing_PathMoveTo(nullptr, 9999, -1000);
153 OH_Drawing_PathClose(nullptr);
154 OH_Drawing_PathClose(path);
155 OH_Drawing_CanvasDrawPath(nullptr, path);
156 OH_Drawing_CanvasDrawPath(canvas_, nullptr);
157 OH_Drawing_PathDestroy(path);
158 }
159
160 /*
161 * @tc.name: NativeDrawingCanvasTest_CanvasBind002
162 * @tc.desc: test for OH_Drawing_CanvasBind.
163 * @tc.type: FUNC
164 * @tc.require: AR000GTO5R
165 */
166 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_CanvasBind002, TestSize.Level1)
167 {
168 OH_Drawing_Bitmap* bitmap = OH_Drawing_BitmapCreate();
169 EXPECT_NE(bitmap, nullptr);
170 OH_Drawing_CanvasBind(canvas_, bitmap);
171 OH_Drawing_CanvasBind(canvas_, nullptr);
172 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
173 OH_Drawing_BitmapDestroy(bitmap);
174 }
175
176 /*
177 * @tc.name: NativeDrawingCanvasTest_canvas003
178 * @tc.desc: test for OH_Drawing_CanvasAttachPen & OH_Drawing_CanvasDetachPen.
179 * @tc.type: FUNC
180 * @tc.require: AR000GTO5R
181 */
182 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_canvas003, TestSize.Level1)
183 {
184 OH_Drawing_Pen* pen = OH_Drawing_PenCreate();
185 EXPECT_NE(pen, nullptr);
186 OH_Drawing_CanvasAttachPen(nullptr, pen);
187 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
188 OH_Drawing_CanvasAttachPen(canvas_, nullptr);
189 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
190 OH_Drawing_CanvasAttachPen(canvas_, pen);
191 OH_Drawing_CanvasDetachPen(canvas_);
192 OH_Drawing_CanvasDetachPen(nullptr);
193 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
194 OH_Drawing_PenDestroy(pen);
195 }
196
197 /*
198 * @tc.name: NativeDrawingCanvasTest_DrawLine004
199 * @tc.desc: test for OH_Drawing_CanvasDrawLine.
200 * @tc.type: FUNC
201 * @tc.require: AR000GTO5R
202 */
203 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_DrawLine004, TestSize.Level1)
204 {
205 OH_Drawing_CanvasDrawLine(nullptr, 0, 0, 20, 20);
206 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
207 OH_Drawing_CanvasDrawLine(canvas_, 0, 0, 20, 20);
208 OH_Drawing_CanvasDrawLine(canvas_, -15.2f, -1, 0, 20);
209 }
210
211 /*
212 * @tc.name: NativeDrawingCanvasTest_DrawPath005
213 * @tc.desc: test for OH_Drawing_CanvasDrawPath.
214 * @tc.type: FUNC
215 * @tc.require: AR000GTO5R
216 */
217 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_DrawPath005, TestSize.Level1)
218 {
219 OH_Drawing_Path* path = OH_Drawing_PathCreate();
220 EXPECT_NE(path, nullptr);
221 constexpr int height = 300;
222 constexpr int width = 300;
223 constexpr float arc = 18.0f;
224 int len = height / 4;
225 float aX = width / 2;
226 float aY = height / 4;
227 float dX = aX - len * std::sin(arc);
228 float dY = aY + len * std::cos(arc);
229 float cX = aX + len * std::sin(arc);
230 float cY = dY;
231 float bX = aX + (len / 2.0);
232 float bY = aY + std::sqrt((cX - dX) * (cX - dX) + (len / 2.0) * (len / 2.0));
233 float eX = aX - (len / 2.0);
234 float eY = bY;
235 OH_Drawing_PathMoveTo(path, aX, aY);
236 OH_Drawing_PathLineTo(path, bX, bY);
237 OH_Drawing_PathLineTo(path, cX, cY);
238 OH_Drawing_PathLineTo(path, dX, dY);
239 OH_Drawing_PathLineTo(path, eX, eY);
240 OH_Drawing_PathClose(path);
241 OH_Drawing_CanvasDrawPath(canvas_, path);
242 OH_Drawing_CanvasDrawPath(nullptr, path);
243 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
244 OH_Drawing_CanvasDrawPath(canvas_, nullptr);
245 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
246 OH_Drawing_PathDestroy(path);
247 }
248
249 /*
250 * @tc.name: NativeDrawingCanvasTest_DrawPoints006
251 * @tc.desc: test for OH_Drawing_CanvasDrawPoints.
252 * @tc.type: FUNC
253 * @tc.require: AR000GTO5R
254 */
255 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_DrawPoints006, TestSize.Level1)
256 {
257 OH_Drawing_Point2D pointOne={250, 500};
258 OH_Drawing_Point2D pointTwo={200, 500};
259 OH_Drawing_Point2D pointThree={500, 700};
260 OH_Drawing_Point2D points[POINT_PARAMETER] = {pointOne, pointTwo, pointThree};
261 OH_Drawing_CanvasDrawPoints(canvas_, POINT_MODE_POINTS, POINT_PARAMETER, nullptr);
262 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
263 OH_Drawing_CanvasDrawPoints(nullptr, POINT_MODE_POINTS, POINT_PARAMETER, nullptr);
264 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
265 OH_Drawing_CanvasDrawPoints(canvas_, POINT_MODE_POINTS, 0, nullptr);
266 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
267 OH_Drawing_CanvasDrawPoints(canvas_, POINT_MODE_POINTS, POINT_PARAMETER, points);
268 }
269
270 /*
271 * @tc.name: NativeDrawingCanvasTest_DrawVertices007
272 * @tc.desc: test for OH_Drawing_CanvasDrawVertices.
273 * @tc.type: FUNC
274 * @tc.require: AR000GTO5R
275 */
276 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_DrawVertices007, TestSize.Level1)
277 {
278 OH_Drawing_Point2D point_one = {0, 0};
279 OH_Drawing_Point2D point_two = {100, 100};
280 OH_Drawing_Point2D point_three = {300, 100};
281 OH_Drawing_Point2D points_vertices[POINT_PARAMETER] = {point_one, point_two, point_three};
282
283 OH_Drawing_Point2D texs_one = {0, 0};
284 OH_Drawing_Point2D texs_two = {1, 1};
285 OH_Drawing_Point2D texs_three = {2, 0};
286 OH_Drawing_Point2D texs_vertices[POINT_PARAMETER] = {texs_one, texs_two, texs_three};
287 uint32_t colors[COLOR_PARAMETER] = {0xFFFF0000, 0xFFFF0000, 0xFFFF0000};
288
289 uint16_t indices[COLOR_PARAMETER] = {0, 1, 2};
290
291 // test canvas == nullptr
292 OH_Drawing_CanvasDrawVertices(nullptr, VERTEX_MODE_TRIANGLES, POINT_PARAMETER, points_vertices, texs_vertices,
293 colors, POINT_PARAMETER, indices, BLEND_MODE_COLOR);
294 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
295
296 // test vertexCount < 3
297 OH_Drawing_CanvasDrawVertices(canvas_, VERTEX_MODE_TRIANGLES, 1, points_vertices, texs_vertices,
298 colors, POINT_PARAMETER, indices, BLEND_MODE_COLOR);
299 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
300
301 // test position == nullptr
302 OH_Drawing_CanvasDrawVertices(canvas_, VERTEX_MODE_TRIANGLES, POINT_PARAMETER, nullptr, texs_vertices, colors,
303 POINT_PARAMETER, indices, BLEND_MODE_COLOR);
304 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
305
306 // test indexCount != 0 && indexCount < 3
307 OH_Drawing_CanvasDrawVertices(canvas_, VERTEX_MODE_TRIANGLES, POINT_PARAMETER, points_vertices, texs_vertices,
308 colors, 1, indices, BLEND_MODE_COLOR);
309 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
310 }
311
312 /*
313 * @tc.name: NativeDrawingCanvasTest_SaveAndRestore008
314 * @tc.desc: test for OH_Drawing_CanvasSave & OH_Drawing_CanvasRestore.
315 * @tc.type: FUNC
316 * @tc.require: AR000GTO5R
317 */
318 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_SaveAndRestore008, TestSize.Level1)
319 {
320 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(100, 200, 500, 300);
321 EXPECT_NE(nullptr, rect);
322 OH_Drawing_CanvasSave(nullptr);
323 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
324 OH_Drawing_CanvasSave(canvas_);
325 OH_Drawing_CanvasTranslate(nullptr, 100, 100);
326 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
327 OH_Drawing_CanvasTranslate(canvas_, 100, 100);
328 OH_Drawing_CanvasDrawArc(nullptr, rect, 10, 200);
329 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
330 OH_Drawing_CanvasDrawArc(canvas_, nullptr, 10, 200);
331 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
332 OH_Drawing_CanvasDrawArc(canvas_, rect, 10, 200);
333 OH_Drawing_CanvasRestore(nullptr);
334 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
335 OH_Drawing_CanvasRestore(canvas_);
336 OH_Drawing_CanvasTranslate(canvas_, 200, 200);
337 OH_Drawing_CanvasDrawOval(nullptr, rect);
338 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
339 OH_Drawing_CanvasDrawOval(canvas_, nullptr);
340 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
341 OH_Drawing_CanvasDrawOval(canvas_, rect);
342 OH_Drawing_RectDestroy(nullptr);
343 OH_Drawing_RectDestroy(rect);
344 }
345
346 /*
347 * @tc.name: NativeDrawingCanvasTest_Clear009
348 * @tc.desc: test for OH_Drawing_CanvasClear.
349 * @tc.type: FUNC
350 * @tc.require: AR000GTO5R
351 */
352 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_Clear009, TestSize.Level1)
353 {
354 OH_Drawing_CanvasClear(nullptr, OH_Drawing_ColorSetArgb(0xFF, 0xFF, 0x00, 0x00));
355 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
356 OH_Drawing_CanvasClear(canvas_, -100);
357 OH_Drawing_CanvasClear(canvas_, OH_Drawing_ColorSetArgb(INT32_MAX, INT32_MAX, INT32_MIN, INT32_MIN));
358 OH_Drawing_CanvasClear(canvas_, OH_Drawing_ColorSetArgb(0xFF, 0xFF, 0x00, 0x00));
359 }
360
361 /*
362 * @tc.name: NativeDrawingCanvasTest_RestoreToCount010
363 * @tc.desc: test for OH_Drawing_CanvasRestoreToCount.
364 * @tc.type: FUNC
365 * @tc.require: AR000GTO5R
366 */
367 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_RestoreToCount010, TestSize.Level1)
368 {
369 OH_Drawing_CanvasSave(canvas_);
370 OH_Drawing_CanvasTranslate(canvas_, 300, 300);
371 OH_Drawing_CanvasSave(canvas_);
372 OH_Drawing_CanvasTranslate(canvas_, 100, 100);
373 OH_Drawing_CanvasSave(canvas_);
374 OH_Drawing_CanvasTranslate(canvas_, 100, 100);
375 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0, 0, 100, 100);
376 OH_Drawing_CanvasDrawRect(canvas_, rect);
377 int count = OH_Drawing_CanvasGetSaveCount(canvas_);
378 EXPECT_EQ(count, 4);
379 OH_Drawing_CanvasRestoreToCount(nullptr, count - 2);
380 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
381 OH_Drawing_CanvasRestoreToCount(canvas_, count - 2);
382 EXPECT_EQ(2, OH_Drawing_CanvasGetSaveCount(canvas_));
383 OH_Drawing_RoundRect *roundRect = OH_Drawing_RoundRectCreate(nullptr, 20, 20);
384 EXPECT_EQ(roundRect, nullptr);
385 roundRect = OH_Drawing_RoundRectCreate(rect, 20, 20);
386 EXPECT_NE(roundRect, nullptr);
387 OH_Drawing_CanvasDrawRoundRect(nullptr, roundRect);
388 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
389 OH_Drawing_CanvasDrawRoundRect(canvas_, nullptr);
390 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
391 OH_Drawing_CanvasDrawRoundRect(canvas_, roundRect);
392 OH_Drawing_CanvasRestoreToCount(canvas_, 1);
393 OH_Drawing_CanvasDrawRect(canvas_, rect);
394 OH_Drawing_RoundRectDestroy(roundRect);
395 OH_Drawing_RectDestroy(rect);
396 OH_Drawing_RoundRectDestroy(nullptr);
397 OH_Drawing_RectDestroy(nullptr);
398 }
399
400 /*
401 * @tc.name: NativeDrawingCanvasTest_Scale011
402 * @tc.desc: test for OH_Drawing_CanvasScale.
403 * @tc.type: FUNC
404 * @tc.require: AR000GTO5R
405 */
406 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_Scale011, TestSize.Level1)
407 {
408 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(10, 20, 60, 120);
409 OH_Drawing_CanvasTranslate(canvas_, 20, 20);
410 OH_Drawing_CanvasDrawRect(canvas_, rect);
411 OH_Drawing_CanvasScale(nullptr, 2, .5f);
412 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
413 OH_Drawing_CanvasScale(canvas_, 2, .5f);
414 OH_Drawing_BrushSetColor(nullptr, 0xFF67C23A);
415 OH_Drawing_BrushSetColor(brush_, 0xFF67C23A);
416 OH_Drawing_CanvasDrawRect(canvas_, rect);
417 }
418
419 /*
420 * @tc.name: NativeDrawingCanvasTest_Skew012
421 * @tc.desc: test for OH_Drawing_CanvasSkew.
422 * @tc.type: FUNC
423 * @tc.require: AR000GTO5R
424 */
425 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_Skew012, TestSize.Level1)
426 {
427 /**
428 * @tc.steps: step1. test OH_Drawing_CanvasSkew with an nullptr.
429 * @tc.expected: function works well not crash.
430 */
431 OH_Drawing_CanvasSkew(nullptr, 0, 0.3f);
432 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
433 /**
434 * @tc.steps: step2. test OH_Drawing_CanvasSkew with canvas.
435 * @tc.expected: function works well.
436 */
437 OH_Drawing_CanvasSkew(canvas_, 0, 0.3f);
438
439 OH_Drawing_Matrix* matrixSkew= OH_Drawing_MatrixCreate();
440 Matrix* cMatrix = reinterpret_cast<Matrix*>(matrixSkew);
441 EXPECT_NE(cMatrix, nullptr);
442 cMatrix->SetSkew(0, 0.3f);
443
444 OH_Drawing_Matrix* matrixTotal = OH_Drawing_MatrixCreate();
445 OH_Drawing_CanvasGetTotalMatrix(canvas_, nullptr);
446 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
447 OH_Drawing_CanvasGetTotalMatrix(nullptr, matrixTotal);
448 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
449 float valueMatrixSkew;
450 float valueCanvasSkew;
451 valueMatrixSkew = OH_Drawing_MatrixGetValue(matrixSkew, 0);
452 valueCanvasSkew = OH_Drawing_MatrixGetValue(matrixTotal, 0);
453 EXPECT_TRUE(IsScalarAlmostEqual(valueMatrixSkew, valueCanvasSkew));
454
455 OH_Drawing_CanvasGetTotalMatrix(canvas_, matrixTotal);
456 EXPECT_NE(matrixTotal, nullptr);
457
458 valueMatrixSkew = OH_Drawing_MatrixGetValue(matrixSkew, 0);
459 valueCanvasSkew = OH_Drawing_MatrixGetValue(matrixTotal, 0);
460 EXPECT_TRUE(IsScalarAlmostEqual(valueMatrixSkew, valueCanvasSkew));
461
462 valueMatrixSkew = OH_Drawing_MatrixGetValue(matrixSkew, 1);
463 valueCanvasSkew = OH_Drawing_MatrixGetValue(matrixTotal, 1);
464 EXPECT_TRUE(IsScalarAlmostEqual(valueMatrixSkew, valueCanvasSkew));
465
466 valueMatrixSkew = OH_Drawing_MatrixGetValue(matrixSkew, 2);
467 valueCanvasSkew = OH_Drawing_MatrixGetValue(matrixTotal, 2);
468 EXPECT_TRUE(IsScalarAlmostEqual(valueMatrixSkew, valueCanvasSkew));
469
470 valueMatrixSkew = OH_Drawing_MatrixGetValue(matrixSkew, 3);
471 valueCanvasSkew = OH_Drawing_MatrixGetValue(matrixTotal, 3);
472 EXPECT_TRUE(IsScalarAlmostEqual(valueMatrixSkew, valueCanvasSkew));
473
474 valueMatrixSkew = OH_Drawing_MatrixGetValue(matrixSkew, 4);
475 valueCanvasSkew = OH_Drawing_MatrixGetValue(matrixTotal, 4);
476 EXPECT_TRUE(IsScalarAlmostEqual(valueMatrixSkew, valueCanvasSkew));
477
478 valueMatrixSkew = OH_Drawing_MatrixGetValue(matrixSkew, 5);
479 valueCanvasSkew = OH_Drawing_MatrixGetValue(matrixTotal, 5);
480 EXPECT_TRUE(IsScalarAlmostEqual(valueMatrixSkew, valueCanvasSkew));
481
482 valueMatrixSkew = OH_Drawing_MatrixGetValue(matrixSkew, 6);
483 valueCanvasSkew = OH_Drawing_MatrixGetValue(matrixTotal, 6);
484 EXPECT_TRUE(IsScalarAlmostEqual(valueMatrixSkew, valueCanvasSkew));
485
486 valueMatrixSkew = OH_Drawing_MatrixGetValue(matrixSkew, 7);
487 valueCanvasSkew = OH_Drawing_MatrixGetValue(matrixTotal, 7);
488 EXPECT_TRUE(IsScalarAlmostEqual(valueMatrixSkew, valueCanvasSkew));
489
490 valueMatrixSkew = OH_Drawing_MatrixGetValue(matrixSkew, 8);
491 valueCanvasSkew = OH_Drawing_MatrixGetValue(matrixTotal, 8);
492 EXPECT_TRUE(IsScalarAlmostEqual(valueMatrixSkew, valueCanvasSkew));
493
494 OH_Drawing_MatrixDestroy(matrixSkew);
495 OH_Drawing_MatrixDestroy(matrixTotal);
496 }
497
498 /*
499 * @tc.name: NativeDrawingCanvasTest_ClipRect013
500 * @tc.desc: test for OH_Drawing_CanvasClipRect.
501 * @tc.type: FUNC
502 * @tc.require: AR000GTO5R
503 */
504 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_ClipRect013, TestSize.Level1)
505 {
506 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0, 0, 90, 90);
507 OH_Drawing_CanvasRotate(nullptr, 10, 0, 0);
508 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
509 OH_Drawing_CanvasRotate(canvas_, 10, 0, 0);
510 OH_Drawing_Point *point = OH_Drawing_PointCreate(100, 60);
511 OH_Drawing_BrushSetAntiAlias(nullptr, true);
512 OH_Drawing_BrushSetAntiAlias(brush_, true);
513 for (auto alias : {false, true}) {
514 OH_Drawing_CanvasSave(canvas_);
515 OH_Drawing_CanvasClipRect(nullptr, rect, OH_Drawing_CanvasClipOp::INTERSECT, alias);
516 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
517 OH_Drawing_CanvasClipRect(canvas_, nullptr, OH_Drawing_CanvasClipOp::INTERSECT, alias);
518 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
519 OH_Drawing_CanvasClipRect(canvas_, rect, OH_Drawing_CanvasClipOp::INTERSECT, alias);
520 OH_Drawing_CanvasDrawCircle(canvas_, nullptr, 60);
521 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
522 OH_Drawing_CanvasDrawCircle(nullptr, point, 60);
523 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
524 OH_Drawing_CanvasDrawCircle(canvas_, point, 0);
525 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_PARAMETER_OUT_OF_RANGE);
526 OH_Drawing_CanvasDrawCircle(canvas_, point, 60);
527 OH_Drawing_CanvasRestore(canvas_);
528 OH_Drawing_CanvasTranslate(canvas_, 80, 0);
529 }
530 OH_Drawing_RectDestroy(rect);
531 OH_Drawing_PointDestroy(point);
532 }
533
534 /*
535 * @tc.name: NativeDrawingCanvasTest_ClipPath014
536 * @tc.desc: test for OH_Drawing_CanvasClipPath.
537 * @tc.type: FUNC
538 * @tc.require: AR000GTO5R
539 */
540 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_ClipPath014, TestSize.Level1)
541 {
542 OH_Drawing_Path *path = OH_Drawing_PathCreate();
543 OH_Drawing_PathMoveTo(path, 100, 300);
544 OH_Drawing_PathLineTo(path, 200, 300);
545 OH_Drawing_PathLineTo(path, 200, 400);
546 OH_Drawing_PathLineTo(path, 100, 350);
547 OH_Drawing_PathClose(nullptr);
548 OH_Drawing_PathClose(path);
549 OH_Drawing_CanvasClipPath(nullptr, path, OH_Drawing_CanvasClipOp::DIFFERENCE, true);
550 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
551 OH_Drawing_CanvasClipPath(canvas_, nullptr, OH_Drawing_CanvasClipOp::DIFFERENCE, true);
552 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
553 OH_Drawing_CanvasClipPath(canvas_, path, OH_Drawing_CanvasClipOp::DIFFERENCE, true);
554 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(100, 300, 200, 400);
555 OH_Drawing_CanvasDrawRect(nullptr, rect);
556 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
557 OH_Drawing_CanvasDrawRect(canvas_, nullptr);
558 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
559 OH_Drawing_CanvasDrawRect(canvas_, rect);
560 OH_Drawing_RectDestroy(rect);
561 OH_Drawing_PathDestroy(path);
562 }
563
564 /*
565 * @tc.name: NativeDrawingCanvasTest_LinearGradient015
566 * @tc.desc: test for LinearGradient
567 * @tc.type: FUNC
568 * @tc.require: AR000GTO5R
569 */
570 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_LinearGradient015, TestSize.Level1)
571 {
572 OH_Drawing_Point* startPt = OH_Drawing_PointCreate(100, 400);
573 OH_Drawing_Point* endPt = OH_Drawing_PointCreate(200, 500);
574 uint32_t color[] = {0xffff0000, 0xff00ff00};
575 float pos[] = {0., 1.0};
576 OH_Drawing_ShaderEffect* linearGradient = OH_Drawing_ShaderEffectCreateLinearGradient(startPt, endPt,
577 color, pos, 2, OH_Drawing_TileMode::CLAMP);
578 OH_Drawing_BrushSetShaderEffect(nullptr, linearGradient);
579 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
580 OH_Drawing_BrushSetShaderEffect(brush_, nullptr);
581 OH_Drawing_BrushSetShaderEffect(brush_, linearGradient);
582 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(200, 500, 300, 600);
583 OH_Drawing_CanvasDrawRect(canvas_, rect);
584 OH_Drawing_RectDestroy(rect);
585 OH_Drawing_ShaderEffectDestroy(nullptr);
586 OH_Drawing_ShaderEffectDestroy(linearGradient);
587 OH_Drawing_PointDestroy(startPt);
588 OH_Drawing_PointDestroy(endPt);
589 }
590
591 /*
592 * @tc.name: NativeDrawingCanvasTest_SweepGradient016
593 * @tc.desc: test for sweep gradient shader effect
594 * @tc.type: FUNC
595 * @tc.require: AR000GTO5R
596 */
597 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_SweepGradient016, TestSize.Level1)
598 {
599 OH_Drawing_Point* centerPt = OH_Drawing_PointCreate(350, 450);
600 uint32_t colors[] = {0xffff00ff, 0xff00ff00};
601 float pos[] = {0., 1.0};
602 OH_Drawing_ShaderEffect* sweepGradient = OH_Drawing_ShaderEffectCreateSweepGradient(nullptr, nullptr,
603 nullptr, -2, OH_Drawing_TileMode::MIRROR);
604 EXPECT_EQ(sweepGradient, nullptr);
605 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
606 sweepGradient = OH_Drawing_ShaderEffectCreateSweepGradient(centerPt, colors,
607 pos, 2, OH_Drawing_TileMode::MIRROR);
608 EXPECT_NE(sweepGradient, nullptr);
609 OH_Drawing_BrushSetShaderEffect(brush_, sweepGradient);
610 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(300, 400, 500, 500);
611 OH_Drawing_CanvasDrawRect(canvas_, rect);
612 OH_Drawing_RectDestroy(rect);
613 OH_Drawing_ShaderEffectDestroy(sweepGradient);
614 OH_Drawing_PointDestroy(centerPt);
615 }
616
617 /*
618 * @tc.name: NativeDrawingCanvasTest_ImageShader017
619 * @tc.desc: test for image shader effect
620 * @tc.type: FUNC
621 * @tc.require: AR000GTO5R
622 */
623 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_ImageShader017, TestSize.Level1)
624 {
625 OH_Drawing_Image *image = OH_Drawing_ImageCreate();
626 OH_Drawing_Brush *brush = OH_Drawing_BrushCreate();
627 OH_Drawing_BrushSetColor(brush, OH_Drawing_ColorSetArgb(0xFF, 0xFF, 0xFF, 0x00));
628 OH_Drawing_SamplingOptions *options = OH_Drawing_SamplingOptionsCreate(FILTER_MODE_LINEAR, MIPMAP_MODE_LINEAR);
629 OH_Drawing_Matrix *matrix = OH_Drawing_MatrixCreate();
630 OH_Drawing_ShaderEffect *effect = nullptr;
631 effect = OH_Drawing_ShaderEffectCreateImageShader(nullptr, CLAMP, CLAMP, nullptr, nullptr);
632 EXPECT_EQ(effect, nullptr);
633 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
634 effect = OH_Drawing_ShaderEffectCreateImageShader(image, CLAMP, CLAMP, options, matrix);
635 OH_Drawing_BrushSetShaderEffect(brush, effect);
636 OH_Drawing_CanvasAttachBrush(nullptr, brush);
637 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
638 OH_Drawing_CanvasAttachBrush(canvas_, nullptr);
639 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
640 OH_Drawing_CanvasAttachBrush(canvas_, brush);
641 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(300, 400, 500, 500);
642 OH_Drawing_CanvasDrawRect(canvas_, rect);
643 OH_Drawing_RectDestroy(rect);
644 OH_Drawing_ShaderEffectDestroy(effect);
645 OH_Drawing_MatrixDestroy(matrix);
646 OH_Drawing_SamplingOptionsDestroy(options);
647 OH_Drawing_BrushDestroy(brush);
648 OH_Drawing_ImageDestroy(image);
649 }
650
651 /*
652 * @tc.name: NativeDrawingCanvasTest_MaskFilter018
653 * @tc.desc: test for maskfilter
654 * @tc.type: FUNC
655 * @tc.require: AR000GTO5R
656 */
657 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_MaskFilter018, TestSize.Level1)
658 {
659 EXPECT_EQ(OH_Drawing_BrushGetColor(brush_), 0xFFFF0000);
660 OH_Drawing_MaskFilter* maskFilter = OH_Drawing_MaskFilterCreateBlur(OH_Drawing_BlurType::NORMAL, 10, true);
661 OH_Drawing_Filter* filter = OH_Drawing_FilterCreate();
662 OH_Drawing_FilterSetMaskFilter(nullptr, maskFilter);
663 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
664 OH_Drawing_FilterSetMaskFilter(filter, nullptr);
665 OH_Drawing_FilterSetMaskFilter(filter, maskFilter);
666 OH_Drawing_BrushSetFilter(brush_, filter);
667 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(200, 500, 300, 600);
668 OH_Drawing_CanvasDrawRect(canvas_, rect);
669 OH_Drawing_RectDestroy(rect);
670 OH_Drawing_MaskFilterDestroy(maskFilter);
671 OH_Drawing_FilterDestroy(filter);
672 }
673
674 /*
675 * @tc.name: NativeDrawingCanvasTest_ColorFilter019
676 * @tc.desc: test for colorfilter create blend mode, linear to srgb gamma, luma, matrix
677 * @tc.type: FUNC
678 * @tc.require: AR000GTO5R
679 */
680 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_ColorFilterCreateBlendMode019, TestSize.Level1)
681 {
682 EXPECT_EQ(OH_Drawing_BrushGetColor(brush_), 0xFFFF0000);
683 OH_Drawing_ColorFilter* colorFilter = OH_Drawing_ColorFilterCreateBlendMode(0xff0000ff,
684 OH_Drawing_BlendMode::BLEND_MODE_SRC);
685 EXPECT_NE(colorFilter, nullptr);
686 OH_Drawing_ColorFilter* colorFilterTmp = OH_Drawing_ColorFilterCreateLinearToSrgbGamma();
687 EXPECT_NE(colorFilterTmp, nullptr);
688 OH_Drawing_Filter* filter = OH_Drawing_FilterCreate();
689 EXPECT_NE(filter, nullptr);
690
691 OH_Drawing_FilterSetColorFilter(nullptr, colorFilter);
692 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
693 OH_Drawing_FilterSetColorFilter(filter, nullptr);
694 OH_Drawing_FilterGetColorFilter(filter, colorFilterTmp);
695 NativeHandle<ColorFilter>* colorFilterHandle = Helper::CastTo<OH_Drawing_ColorFilter*,
696 NativeHandle<ColorFilter>*>(colorFilterTmp);
697 EXPECT_NE(colorFilterHandle, nullptr);
698 EXPECT_NE(colorFilterHandle->value, nullptr);
699 EXPECT_EQ(colorFilterHandle->value->GetType(), ColorFilter::FilterType::NO_TYPE);
700
701 OH_Drawing_FilterSetColorFilter(filter, colorFilter);
702 OH_Drawing_FilterGetColorFilter(filter, colorFilterTmp);
703 NativeHandle<ColorFilter>* colorFilterHandleT = Helper::CastTo<OH_Drawing_ColorFilter*,
704 NativeHandle<ColorFilter>*>(colorFilterTmp);
705 EXPECT_NE(colorFilterHandleT, nullptr);
706 EXPECT_NE(colorFilterHandleT->value, nullptr);
707 EXPECT_EQ(colorFilterHandleT->value->GetType(), ColorFilter::FilterType::BLEND_MODE);
708
709 OH_Drawing_BrushSetFilter(brush_, nullptr);
710 OH_Drawing_BrushSetFilter(brush_, filter);
711 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0, 0, 100, 100);
712 OH_Drawing_CanvasDrawRect(canvas_, rect);
713 OH_Drawing_ColorFilter* linear = OH_Drawing_ColorFilterCreateLinearToSrgbGamma();
714 OH_Drawing_FilterSetColorFilter(filter, linear);
715 OH_Drawing_CanvasTranslate(canvas_, 100, 100);
716 OH_Drawing_CanvasDrawRect(canvas_, rect);
717 OH_Drawing_ColorFilter* luma = OH_Drawing_ColorFilterCreateLuma();
718 OH_Drawing_FilterSetColorFilter(filter, luma);
719 OH_Drawing_CanvasTranslate(canvas_, 200, 200);
720 OH_Drawing_CanvasDrawRect(canvas_, rect);
721 const float matrix[20] = {
722 1, 0, 0, 0, 0,
723 0, 1, 0, 0, 0,
724 0, 0, 1, 0, 0,
725 0, 0, 0, 0.5f, 0
726 };
727 OH_Drawing_ColorFilter* matrixFilter = OH_Drawing_ColorFilterCreateMatrix(nullptr);
728 EXPECT_EQ(matrixFilter, nullptr);
729 matrixFilter = OH_Drawing_ColorFilterCreateMatrix(matrix);
730 EXPECT_NE(matrixFilter, nullptr);
731 OH_Drawing_FilterSetColorFilter(filter, matrixFilter);
732 OH_Drawing_CanvasTranslate(canvas_, 300, 300);
733 OH_Drawing_CanvasDrawRect(canvas_, rect);
734 OH_Drawing_RectDestroy(rect);
735 OH_Drawing_ColorFilterDestroy(colorFilter);
736 OH_Drawing_ColorFilterDestroy(luma);
737 OH_Drawing_ColorFilterDestroy(matrixFilter);
738 OH_Drawing_ColorFilterDestroy(linear);
739 OH_Drawing_ColorFilterDestroy(colorFilterTmp);
740 OH_Drawing_FilterDestroy(filter);
741 OH_Drawing_FilterDestroy(nullptr);
742 }
743
744 /*
745 * @tc.name: NativeDrawingCanvasTest_ColorFilterCreateCompose020
746 * @tc.desc: test for create compose color filter
747 * @tc.type: FUNC
748 * @tc.require: AR000GTO5R
749 */
750 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_ColorFilterCreateCompose020, TestSize.Level1)
751 {
752 EXPECT_EQ(OH_Drawing_BrushGetColor(brush_), 0xFFFF0000);
753 OH_Drawing_ColorFilter* outerFilter = OH_Drawing_ColorFilterCreateLuma();
754 OH_Drawing_ColorFilter* innerFilter = OH_Drawing_ColorFilterCreateSrgbGammaToLinear();
755 OH_Drawing_ColorFilter* compose = OH_Drawing_ColorFilterCreateCompose(nullptr, nullptr);
756 EXPECT_EQ(compose, nullptr);
757 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
758 compose = OH_Drawing_ColorFilterCreateCompose(outerFilter, innerFilter);
759 EXPECT_NE(compose, nullptr);
760 OH_Drawing_Filter* filter = OH_Drawing_FilterCreate();
761 OH_Drawing_FilterSetColorFilter(filter, compose);
762 OH_Drawing_BrushSetFilter(brush_, filter);
763 OH_Drawing_Canvas* canvas_ = OH_Drawing_CanvasCreate();
764 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(200, 500, 300, 600);
765 OH_Drawing_CanvasDrawRect(canvas_, rect);
766 OH_Drawing_RectDestroy(rect);
767 OH_Drawing_ColorFilterDestroy(outerFilter);
768 OH_Drawing_ColorFilterDestroy(innerFilter);
769 OH_Drawing_ColorFilterDestroy(compose);
770 OH_Drawing_FilterDestroy(filter);
771 }
772
773 /*
774 * @tc.name: NativeDrawingCanvasTest_DrawBitmap021
775 * @tc.desc: test for DrawBitmap
776 * @tc.type: FUNC
777 * @tc.require: AR000GTO5R
778 */
779 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_DrawBitmap021, TestSize.Level1)
780 {
781 OH_Drawing_Bitmap* bitmap = OH_Drawing_BitmapCreate();
782 OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE};
783 constexpr uint32_t width = 200;
784 constexpr uint32_t height = 200;
785 OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat);
786 OH_Drawing_CanvasBind(canvas_, bitmap);
787 OH_Drawing_CanvasDrawBitmap(nullptr, bitmap, 0, 0);
788 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
789 OH_Drawing_CanvasDrawBitmap(canvas_, nullptr, 0, 0);
790 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
791 OH_Drawing_CanvasDrawBitmap(canvas_, bitmap, 0, 0);
792 OH_Drawing_CanvasClear(canvas_, OH_Drawing_ColorSetArgb(0xFF, 0xFF, 0xFF, 0xFF));
793 OH_Drawing_BitmapDestroy(bitmap);
794 }
795
796 /*
797 * @tc.name: NativeDrawingCanvasTest_DrawBitmapRect022
798 * @tc.desc: test for DrawBitmapRect
799 * @tc.type: FUNC
800 * @tc.require: AR000GTO5R
801 */
802 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_DrawBitmapRect022, TestSize.Level1)
803 {
804 OH_Drawing_Bitmap* bitmap = OH_Drawing_BitmapCreate();
805 EXPECT_NE(bitmap, nullptr);
806 OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE};
807 constexpr uint32_t width = 200;
808 constexpr uint32_t height = 200;
809 OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat);
810 OH_Drawing_Rect* src = OH_Drawing_RectCreate(0, 0, 200, 200);
811 EXPECT_NE(src, nullptr);
812 OH_Drawing_Rect* dst = OH_Drawing_RectCreate(0, 0, 200, 200);
813 EXPECT_NE(dst, nullptr);
814 OH_Drawing_SamplingOptions* options = OH_Drawing_SamplingOptionsCreate(
815 OH_Drawing_FilterMode::FILTER_MODE_NEAREST, OH_Drawing_MipmapMode::MIPMAP_MODE_NEAREST);
816 EXPECT_NE(options, nullptr);
817 OH_Drawing_CanvasDrawBitmapRect(canvas_, bitmap, src, dst, options);
818 OH_Drawing_CanvasDrawBitmapRect(canvas_, bitmap, src, dst, nullptr);
819 OH_Drawing_CanvasDrawBitmapRect(canvas_, bitmap, src, nullptr, nullptr);
820 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
821 OH_Drawing_CanvasDrawBitmapRect(canvas_, bitmap, nullptr, nullptr, nullptr);
822 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
823 OH_Drawing_CanvasDrawBitmapRect(canvas_, nullptr, nullptr, nullptr, nullptr);
824 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
825 OH_Drawing_CanvasDrawBitmapRect(nullptr, nullptr, nullptr, nullptr, nullptr);
826 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
827 OH_Drawing_BitmapDestroy(bitmap);
828 }
829
830 /*
831 * @tc.name: NativeDrawingCanvasTest_SetMatrix023
832 * @tc.desc: test for SetMatrix
833 * @tc.type: FUNC
834 * @tc.require: AR000GTO5R
835 */
836 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_SetMatrix023, TestSize.Level1)
837 {
838 OH_Drawing_Matrix* matrix = OH_Drawing_MatrixCreate();
839 EXPECT_NE(matrix, nullptr);
840 OH_Drawing_MatrixSetMatrix(
841 matrix,
842 1, 0, 0,
843 0, -1, 0,
844 0, 0, 1);
845 OH_Drawing_CanvasSetMatrix(canvas_, matrix);
846 OH_Drawing_CanvasSetMatrix(canvas_, nullptr);
847 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
848 OH_Drawing_CanvasSetMatrix(nullptr, nullptr);
849 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
850 OH_Drawing_MatrixDestroy(matrix);
851 }
852
853 /*
854 * @tc.name: NativeDrawingCanvasTest_ResetMatrix024
855 * @tc.desc: test for ResetMatrix
856 * @tc.type: FUNC
857 * @tc.require: AR000GTO5R
858 */
859 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_ResetMatrix024, TestSize.Level1)
860 {
861 OH_Drawing_CanvasResetMatrix(nullptr);
862 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
863 OH_Drawing_CanvasResetMatrix(canvas_);
864 }
865
866 /*
867 * @tc.name: NativeDrawingCanvasTest_DrawImageRect025
868 * @tc.desc: test for DrawImageRect
869 * @tc.type: FUNC
870 * @tc.require: AR000GTO5R
871 */
872 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_DrawImageRect025, TestSize.Level1)
873 {
874 OH_Drawing_Rect* rect = OH_Drawing_RectCreate(0, 0, 200, 200);
875 EXPECT_NE(rect, nullptr);
876 OH_Drawing_Image* image = OH_Drawing_ImageCreate();
877 EXPECT_NE(image, nullptr);
878 OH_Drawing_Bitmap* bitmap = OH_Drawing_BitmapCreate();
879 EXPECT_NE(bitmap, nullptr);
880 OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE};
881 constexpr uint32_t width = 200;
882 constexpr uint32_t height = 200;
883 OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat);
884 OH_Drawing_ImageBuildFromBitmap(image, bitmap);
885 OH_Drawing_SamplingOptions* options = OH_Drawing_SamplingOptionsCreate(
886 OH_Drawing_FilterMode::FILTER_MODE_NEAREST, OH_Drawing_MipmapMode::MIPMAP_MODE_NEAREST);
887 EXPECT_NE(options, nullptr);
888 OH_Drawing_CanvasDrawImageRect(canvas_, image, rect, options);
889 OH_Drawing_CanvasDrawImageRect(canvas_, image, rect, nullptr);
890 OH_Drawing_CanvasDrawImageRect(canvas_, image, nullptr, nullptr);
891 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
892 OH_Drawing_CanvasDrawImageRect(canvas_, nullptr, nullptr, nullptr);
893 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
894 OH_Drawing_CanvasDrawImageRect(nullptr, nullptr, nullptr, nullptr);
895 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
896 OH_Drawing_CanvasDrawImageRectWithSrc(canvas_, image, rect, rect, options, STRICT_SRC_RECT_CONSTRAINT);
897 OH_Drawing_CanvasDrawImageRectWithSrc(nullptr, image, rect, rect, options, STRICT_SRC_RECT_CONSTRAINT);
898 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
899 OH_Drawing_CanvasDrawImageRectWithSrc(canvas_, nullptr, rect, rect, options, STRICT_SRC_RECT_CONSTRAINT);
900 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
901 OH_Drawing_CanvasDrawImageRectWithSrc(canvas_, image, nullptr, rect, options, STRICT_SRC_RECT_CONSTRAINT);
902 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
903 OH_Drawing_CanvasDrawImageRectWithSrc(nullptr, nullptr, nullptr, nullptr, nullptr, STRICT_SRC_RECT_CONSTRAINT);
904 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
905 OH_Drawing_SamplingOptionsDestroy(options);
906 OH_Drawing_BitmapDestroy(bitmap);
907 OH_Drawing_ImageDestroy(image);
908 }
909
910 /*
911 * @tc.name: NativeDrawingCanvasTest_ReadPixelsToBitmap026
912 * @tc.desc: test for ReadPixelsToBitmap
913 * @tc.type: FUNC
914 * @tc.require: AR000GTO5R
915 */
916 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_ReadPixelsToBitmap026, TestSize.Level1)
917 {
918 OH_Drawing_Bitmap* bitmap = OH_Drawing_BitmapCreate();
919 EXPECT_NE(bitmap, nullptr);
920 EXPECT_TRUE(!OH_Drawing_CanvasReadPixelsToBitmap(canvas_, bitmap, 100, 100));
921 EXPECT_TRUE(!OH_Drawing_CanvasReadPixelsToBitmap(canvas_, nullptr, 100, 100));
922 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
923 EXPECT_TRUE(!OH_Drawing_CanvasReadPixelsToBitmap(nullptr, nullptr, 100, 100));
924 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
925 OH_Drawing_BitmapDestroy(bitmap);
926 }
927
928 /*
929 * @tc.name: NativeDrawingCanvasTest_ReadPixels027
930 * @tc.desc: test for ReadPixels
931 * @tc.type: FUNC
932 * @tc.require: AR000GTO5R
933 */
934 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_ReadPixels027, TestSize.Level1)
935 {
936 OH_Drawing_Image_Info imageInfo;
937 OH_Drawing_Bitmap* bitmap = OH_Drawing_BitmapCreate();
938 EXPECT_NE(bitmap, nullptr);
939 OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE};
940 constexpr uint32_t width = 200;
941 constexpr uint32_t height = 200;
942 OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat);
943 void* pixels = OH_Drawing_BitmapGetPixels(bitmap);
944 EXPECT_TRUE(!OH_Drawing_CanvasReadPixels(canvas_, &imageInfo, pixels, 0, 0, 0));
945 EXPECT_TRUE(!OH_Drawing_CanvasReadPixels(canvas_, &imageInfo, nullptr, 0, 0, 0));
946 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
947 EXPECT_TRUE(!OH_Drawing_CanvasReadPixels(canvas_, nullptr, nullptr, 0, 0, 0));
948 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
949 EXPECT_TRUE(!OH_Drawing_CanvasReadPixels(nullptr, nullptr, nullptr, 0, 0, 0));
950 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
951 OH_Drawing_BitmapDestroy(bitmap);
952 }
953
954 /*
955 * @tc.name: NativeDrawingCanvasTest_GetWidth028
956 * @tc.desc: test for GetWidth
957 * @tc.type: FUNC
958 * @tc.require: AR000GTO5R
959 */
960 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_GetWidth028, TestSize.Level1)
961 {
962 EXPECT_TRUE(OH_Drawing_CanvasGetWidth(nullptr) == 0);
963 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
964 EXPECT_TRUE(OH_Drawing_CanvasGetWidth(canvas_) >= 0);
965 }
966
967 /*
968 * @tc.name: NativeDrawingCanvasTest_GetHeight029
969 * @tc.desc: test for GetHeight
970 * @tc.type: FUNC
971 * @tc.require: AR000GTO5R
972 */
973 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_GetHeight029, TestSize.Level1)
974 {
975 EXPECT_TRUE(OH_Drawing_CanvasGetHeight(nullptr) == 0);
976 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
977 EXPECT_TRUE(OH_Drawing_CanvasGetHeight(canvas_) >= 0);
978 }
979
980 /*
981 * @tc.name: NativeDrawingCanvasTest_GetLocalClipBounds030
982 * @tc.desc: test for GetLocalClipBounds
983 * @tc.type: FUNC
984 * @tc.require: AR000GTO5R
985 */
986 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_GetLocalClipBounds030, TestSize.Level1)
987 {
988 OH_Drawing_CanvasGetLocalClipBounds(nullptr, nullptr);
989 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
990 OH_Drawing_Rect* rect = OH_Drawing_RectCreate(0, 0, 1, 1);
991 EXPECT_NE(rect, nullptr);
992 OH_Drawing_CanvasGetLocalClipBounds(nullptr, rect);
993 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
994 OH_Drawing_CanvasGetLocalClipBounds(canvas_, rect);
995 OH_Drawing_RectDestroy(rect);
996 }
997
998 /*
999 * @tc.name: NativeDrawingCanvasTest_ConcatMatrix031
1000 * @tc.desc: test for ConcatMatrix
1001 * @tc.type: FUNC
1002 * @tc.require: AR000GTO5R
1003 */
1004 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_ConcatMatrix031, TestSize.Level1)
1005 {
1006 OH_Drawing_Matrix* matrix = OH_Drawing_MatrixCreate();
1007 EXPECT_NE(matrix, nullptr);
1008 OH_Drawing_MatrixSetMatrix(
1009 matrix,
1010 1, 0, 0,
1011 0, -1, 0,
1012 0, 0, 1);
1013 OH_Drawing_CanvasConcatMatrix(canvas_, matrix);
1014 OH_Drawing_CanvasConcatMatrix(canvas_, nullptr);
1015 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
1016 OH_Drawing_CanvasConcatMatrix(nullptr, nullptr);
1017 OH_Drawing_MatrixDestroy(matrix);
1018 }
1019
1020 /*
1021 * @tc.name: NativeDrawingCanvasTest_DrawShadow032
1022 * @tc.desc: test for DrawShadow
1023 * @tc.type: FUNC
1024 * @tc.require: AR000GTO5R
1025 */
1026 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_DrawShadow032, TestSize.Level1)
1027 {
1028 OH_Drawing_Point3D p1{0.0, 0.0, 0.0};
1029 OH_Drawing_Point3D p2{10.0, 10.0, 10.0};
1030 OH_Drawing_CanvasDrawShadow(nullptr, nullptr, p1, p2, 0, 0xFF000000,
1031 0xFF000000, OH_Drawing_CanvasShadowFlags::SHADOW_FLAGS_ALL);
1032 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
1033 OH_Drawing_CanvasDrawShadow(canvas_, nullptr, p1, p2, 0, 0xFF000000,
1034 0xFF000000, OH_Drawing_CanvasShadowFlags::SHADOW_FLAGS_ALL);
1035 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
1036
1037 OH_Drawing_Path* path = OH_Drawing_PathCreate();
1038 EXPECT_NE(path, nullptr);
1039 OH_Drawing_CanvasDrawShadow(canvas_, path, p1, p2, 10, 0xFF000000, 0xFF000000,
1040 OH_Drawing_CanvasShadowFlags::SHADOW_FLAGS_ALL);
1041 OH_Drawing_CanvasDrawShadow(canvas_, path, p1, p2, 10, 0xFF000000, 0xFF000000,
1042 static_cast<OH_Drawing_CanvasShadowFlags>(NEGATIVE_ONE));
1043 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_PARAMETER_OUT_OF_RANGE);
1044 OH_Drawing_CanvasDrawShadow(canvas_, path, p1, p2, 10, 0xFF000000, 0xFF000000,
1045 static_cast<OH_Drawing_CanvasShadowFlags>(INTNUM_TEN));
1046 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_PARAMETER_OUT_OF_RANGE);
1047 }
1048
1049 /*
1050 * @tc.name: NativeDrawingCanvasTest_DrawTextBlob033
1051 * @tc.desc: test for DrawTextBlob
1052 * @tc.type: FUNC
1053 * @tc.require: AR000GTO5R
1054 */
1055 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_DrawTextBlob033, TestSize.Level1)
1056 {
1057 OH_Drawing_Font *font = OH_Drawing_FontCreate();
1058 OH_Drawing_FontSetFakeBoldText(font, true);
1059 OH_Drawing_FontSetTextSize(font, 20);
1060 OH_Drawing_FontSetTextSkewX(font, 0.25);
1061 OH_Drawing_Typeface *typeSurface = OH_Drawing_TypefaceCreateDefault();
1062 OH_Drawing_FontSetTypeface(font, typeSurface);
1063 auto *builder = OH_Drawing_TextBlobBuilderCreate();
1064 EXPECT_EQ(nullptr, OH_Drawing_TextBlobBuilderAllocRunPos(nullptr, nullptr, INT32_MAX, nullptr));
1065 EXPECT_EQ(nullptr, OH_Drawing_TextBlobBuilderAllocRunPos(builder, font, INT32_MIN, nullptr));
1066 const OH_Drawing_RunBuffer* runBuffer = OH_Drawing_TextBlobBuilderAllocRunPos(builder, font, 9, nullptr);
1067 ASSERT_NE(runBuffer, nullptr);
1068 runBuffer->glyphs[0] = 65;
1069 runBuffer->pos[0] = 0;
1070 runBuffer->pos[1] = 0;
1071 runBuffer->glyphs[1] = 227;
1072 runBuffer->pos[2] = 14.9;
1073 runBuffer->pos[3] = 0;
1074 runBuffer->glyphs[2] = 283;
1075 runBuffer->pos[4] = 25.84;
1076 runBuffer->pos[5] = 0;
1077 runBuffer->glyphs[3] = 283;
1078 runBuffer->pos[6] = 30.62;
1079 runBuffer->pos[7] = 0;
1080 runBuffer->glyphs[4] = 299;
1081 runBuffer->pos[8] = 35.4;
1082 runBuffer->pos[9] = 0;
1083 runBuffer->glyphs[5] = 2;
1084 runBuffer->pos[10] = 47.22;
1085 runBuffer->pos[11] = 0;
1086 runBuffer->glyphs[6]= 94;
1087 runBuffer->pos[12] = 52.62;
1088 runBuffer->pos[13] = 0;
1089 runBuffer->glyphs[7] = 37;
1090 runBuffer->pos[14] = 67.42;
1091 runBuffer->pos[15] = 0;
1092 runBuffer->glyphs[8] = 84;
1093 runBuffer->pos[16] = 81.7;
1094 runBuffer->pos[17] = 0;
1095 OH_Drawing_TextBlob *textBlob = OH_Drawing_TextBlobBuilderMake(builder);
1096 OH_Drawing_CanvasDrawTextBlob(canvas_, textBlob, 100, 700);
1097 OH_Drawing_TextBlobDestroy(textBlob);
1098 OH_Drawing_TextBlobBuilderDestroy(builder);
1099 OH_Drawing_FontDestroy(font);
1100 OH_Drawing_TypefaceDestroy(typeSurface);
1101 OH_Drawing_TextBlobDestroy(nullptr);
1102 OH_Drawing_TextBlobBuilderDestroy(nullptr);
1103 OH_Drawing_FontDestroy(nullptr);
1104 OH_Drawing_TypefaceDestroy(nullptr);
1105 }
1106
1107 /*
1108 * @tc.name: NativeDrawingCanvasTest_DrawTextBlob034
1109 * @tc.desc: test for DrawTextBlob2
1110 * @tc.type: FUNC
1111 * @tc.require: SR000S9F0C
1112 */
1113 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_DrawTextBlob034, TestSize.Level1)
1114 {
1115 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0, 0, 0, 0);
1116 EXPECT_NE(rect, nullptr);
1117 OH_Drawing_Font *font = OH_Drawing_FontCreate();
1118 EXPECT_NE(font, nullptr);
1119 const char* str = "123456";
1120 EXPECT_EQ(nullptr, OH_Drawing_TextBlobCreateFromString(nullptr,
1121 font, OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8));
1122 EXPECT_EQ(nullptr, OH_Drawing_TextBlobCreateFromString(str,
1123 nullptr, OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8));
1124 OH_Drawing_TextBlob *textBlob = OH_Drawing_TextBlobCreateFromString(str,
1125 font, OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8);
1126 EXPECT_NE(textBlob, nullptr);
1127 OH_Drawing_CanvasDrawTextBlob(nullptr, textBlob, 0, 0);
1128 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
1129 OH_Drawing_CanvasDrawTextBlob(canvas_, nullptr, 0, 0);
1130 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
1131 OH_Drawing_CanvasDrawTextBlob(canvas_, textBlob, 0, 0);
1132 OH_Drawing_TextBlobGetBounds(textBlob, nullptr);
1133 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
1134 OH_Drawing_TextBlobGetBounds(textBlob, rect);
1135 OH_Drawing_CanvasDrawRect(canvas_, rect);
1136 OH_Drawing_TextBlobDestroy(textBlob);
1137 OH_Drawing_FontDestroy(font);
1138 OH_Drawing_RectDestroy(rect);
1139 }
1140
1141 /*
1142 * @tc.name: NativeDrawingCanvasTest_DrawTextBlob035
1143 * @tc.desc: test for DrawTextBlob3
1144 * @tc.type: FUNC
1145 * @tc.require: SR000S9F0C
1146 */
1147 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_DrawTextBlob035, TestSize.Level1)
1148 {
1149 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0, 0, 0, 0);
1150 EXPECT_NE(rect, nullptr);
1151 OH_Drawing_Font *font = OH_Drawing_FontCreate();
1152 EXPECT_NE(font, nullptr);
1153 OH_Drawing_Typeface* typeface = OH_Drawing_TypefaceCreateFromFile(nullptr, 0);
1154 EXPECT_EQ(nullptr, typeface);
1155 // sub test 1, OH_Drawing_FontGetTypeface
1156 OH_Drawing_FontGetTypeface(nullptr);
1157 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
1158 EXPECT_EQ(nullptr, typeface);
1159 OH_Drawing_Typeface *typeSurface = OH_Drawing_TypefaceCreateDefault();
1160 OH_Drawing_FontSetTypeface(font, typeSurface);
1161 EXPECT_NE(nullptr, OH_Drawing_FontGetTypeface(font));
1162 // sub test 2, OH_Drawing_FontCountText
1163 const char* str = "123456";
1164 int count = 0;
1165 count = OH_Drawing_FontCountText(nullptr, str, strlen(str),
1166 OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8);
1167 EXPECT_EQ(0, count);
1168 count = OH_Drawing_FontCountText(font, nullptr, strlen(str),
1169 OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8);
1170 EXPECT_EQ(0, count);
1171 count = OH_Drawing_FontCountText(font, str, strlen(str),
1172 OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8);
1173 EXPECT_EQ(strlen(str), count);
1174 // sub test 3, OH_Drawing_TextBlobCreateFromText
1175 EXPECT_EQ(nullptr, OH_Drawing_TextBlobCreateFromText(nullptr, strlen(str),
1176 font, OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8));
1177 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
1178 EXPECT_EQ(nullptr, OH_Drawing_TextBlobCreateFromText(str, strlen(str),
1179 nullptr, OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8));
1180 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
1181 OH_Drawing_TextBlobCreateFromText(str, strlen(str), font, static_cast<OH_Drawing_TextEncoding>(NEGATIVE_ONE));
1182 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_PARAMETER_OUT_OF_RANGE);
1183 OH_Drawing_TextBlobCreateFromText(str, strlen(str), font, static_cast<OH_Drawing_TextEncoding>(INTNUM_TEN));
1184 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_PARAMETER_OUT_OF_RANGE);
1185 OH_Drawing_TextBlob *textBlob = OH_Drawing_TextBlobCreateFromText(str, strlen(str),
1186 font, OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8);
1187 EXPECT_NE(textBlob, nullptr);
1188 EXPECT_TRUE(OH_Drawing_TextBlobUniqueID(nullptr) == 0);
1189 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
1190 EXPECT_TRUE(OH_Drawing_TextBlobUniqueID(textBlob) > 0);
1191 // draw textblob
1192 OH_Drawing_CanvasDrawTextBlob(canvas_, textBlob, 0, 0);
1193
1194 OH_Drawing_TextBlobDestroy(textBlob);
1195 OH_Drawing_FontDestroy(font);
1196 OH_Drawing_TypefaceDestroy(typeSurface);
1197 }
1198
1199 /*
1200 * @tc.name: NativeDrawingCanvasTest_DrawTextBlob036
1201 * @tc.desc: test for DrawTextBlob4
1202 * @tc.type: FUNC
1203 * @tc.require: SR000S9F0C
1204 */
1205 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_DrawTextBlob036, TestSize.Level1)
1206 {
1207 size_t length = 1;
1208 OH_Drawing_Font *font = OH_Drawing_FontCreate();
1209 EXPECT_NE(font, nullptr);
1210 OH_Drawing_MemoryStream* memoryStream = OH_Drawing_MemoryStreamCreate(nullptr,
1211 length, false);
1212 OH_Drawing_MemoryStreamDestroy(memoryStream);
1213 EXPECT_EQ(nullptr, memoryStream);
1214 OH_Drawing_Typeface* typeface = OH_Drawing_TypefaceCreateFromStream(
1215 memoryStream, 0);
1216 EXPECT_EQ(nullptr, typeface);
1217 OH_Drawing_Typeface *typeSurface = OH_Drawing_TypefaceCreateDefault();
1218 OH_Drawing_FontSetTypeface(font, typeSurface);
1219 EXPECT_NE(nullptr, OH_Drawing_FontGetTypeface(font));
1220 const char* str = "123456";
1221 int count = strlen(str);
1222 OH_Drawing_Point2D pts[count];
1223 EXPECT_EQ(nullptr, OH_Drawing_TextBlobCreateFromPosText(nullptr, count, &pts[0],
1224 font, OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8));
1225 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
1226 EXPECT_EQ(nullptr, OH_Drawing_TextBlobCreateFromPosText(str, count, nullptr,
1227 font, OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8));
1228 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
1229 EXPECT_EQ(nullptr, OH_Drawing_TextBlobCreateFromPosText(str, count, &pts[0],
1230 nullptr, OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8));
1231 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
1232 OH_Drawing_TextBlobCreateFromPosText(str, count, &pts[0], font, static_cast<OH_Drawing_TextEncoding>(NEGATIVE_ONE));
1233 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_PARAMETER_OUT_OF_RANGE);
1234 OH_Drawing_TextBlobCreateFromPosText(str, count, &pts[0], font, static_cast<OH_Drawing_TextEncoding>(INTNUM_TEN));
1235 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_PARAMETER_OUT_OF_RANGE);
1236 OH_Drawing_TextBlob *textBlob = OH_Drawing_TextBlobCreateFromPosText(str, count, &pts[0],
1237 font, OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8);
1238 EXPECT_NE(textBlob, nullptr);
1239 OH_Drawing_CanvasDrawTextBlob(canvas_, textBlob, 0, 0);
1240
1241 OH_Drawing_TextBlobDestroy(textBlob);
1242 OH_Drawing_FontDestroy(font);
1243 OH_Drawing_TypefaceDestroy(typeSurface);
1244 }
1245
1246 /*
1247 * @tc.name: NativeDrawingCanvasTest_SaveLayer037
1248 * @tc.desc: test for SaveLayer
1249 * @tc.type: FUNC
1250 * @tc.require: SR000S9F0C
1251 */
1252 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_SaveLayer037, TestSize.Level1)
1253 {
1254 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(200, 500, 300, 600);
1255 EXPECT_NE(rect, nullptr);
1256 OH_Drawing_Brush* brush = OH_Drawing_BrushCreate();
1257 EXPECT_NE(brush, nullptr);
1258 // test exception
1259 OH_Drawing_CanvasSaveLayer(nullptr, rect, brush);
1260 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
1261 OH_Drawing_CanvasSaveLayer(canvas_, rect, brush);
1262 OH_Drawing_CanvasRestore(canvas_);
1263 OH_Drawing_RectDestroy(rect);
1264 }
1265
1266 /*
1267 * @tc.name: NativeDrawingCanvasTest_ClipRoundRect
1268 * @tc.desc: test for OH_Drawing_ClipRoundRect.
1269 * @tc.type: FUNC
1270 * @tc.require: AR000GTO5R
1271 */
1272 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_ClipRoundRect, TestSize.Level1)
1273 {
1274 OH_Drawing_Rect* rect = OH_Drawing_RectCreate(10, 100, 200, 300);
1275 OH_Drawing_RoundRect* roundRect = OH_Drawing_RoundRectCreate(rect, 10, 10);
1276 for (auto alias : {false, true}) {
1277 OH_Drawing_CanvasClipRoundRect(nullptr, roundRect, OH_Drawing_CanvasClipOp::INTERSECT, alias);
1278 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
1279 OH_Drawing_CanvasClipRoundRect(canvas_, nullptr, OH_Drawing_CanvasClipOp::INTERSECT, alias);
1280 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
1281 OH_Drawing_CanvasClipRoundRect(canvas_, roundRect, OH_Drawing_CanvasClipOp::INTERSECT, alias);
1282 }
1283 OH_Drawing_CanvasDrawRect(canvas_, rect);
1284 OH_Drawing_RectDestroy(rect);
1285 OH_Drawing_RoundRectDestroy(roundRect);
1286 }
1287
1288 /*
1289 * @tc.name: NativeDrawingCanvasTest_RoundRectGetCorner
1290 * @tc.desc: test for OH_Drawing_RoundRectGetCorner.
1291 * @tc.type: FUNC
1292 * @tc.require: AR000GTO5R
1293 */
1294 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_RoundRectGetCorner, TestSize.Level1)
1295 {
1296 OH_Drawing_Rect* rect = OH_Drawing_RectCreate(10, 100, 200, 300);
1297 OH_Drawing_RoundRect* roundRect = OH_Drawing_RoundRectCreate(rect, 0, 0);
1298 OH_Drawing_RoundRectSetCorner(nullptr, OH_Drawing_CornerPos::CORNER_POS_BOTTOM_LEFT, {10, 10});
1299 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
1300 OH_Drawing_RoundRectSetCorner(roundRect, OH_Drawing_CornerPos::CORNER_POS_BOTTOM_LEFT, {10, 10});
1301 OH_Drawing_RoundRectGetCorner(nullptr, OH_Drawing_CornerPos::CORNER_POS_BOTTOM_LEFT);
1302 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
1303 OH_Drawing_Corner_Radii radiusPoint =
1304 OH_Drawing_RoundRectGetCorner(roundRect, OH_Drawing_CornerPos::CORNER_POS_BOTTOM_LEFT);
1305 EXPECT_EQ(10.0f, radiusPoint.x);
1306 EXPECT_EQ(10.0f, radiusPoint.y);
1307 OH_Drawing_RectDestroy(rect);
1308 OH_Drawing_RoundRectDestroy(roundRect);
1309 }
1310
1311 /*
1312 * @tc.name: NativeDrawingCanvasTest_RoundRectSetCorner
1313 * @tc.desc: test for OH_Drawing_RoundRectSetCorner.
1314 * @tc.type: FUNC
1315 * @tc.require: AR000GTO5R
1316 */
1317 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_RoundRectSetCorner, TestSize.Level1)
1318 {
1319 OH_Drawing_Rect* rect = OH_Drawing_RectCreate(10, 100, 200, 300);
1320 OH_Drawing_RoundRect* roundRect = OH_Drawing_RoundRectCreate(rect, 0, 0);
1321 OH_Drawing_RoundRectSetCorner(nullptr, OH_Drawing_CornerPos::CORNER_POS_BOTTOM_LEFT, {10, 10});
1322 OH_Drawing_RoundRectSetCorner(roundRect, OH_Drawing_CornerPos::CORNER_POS_BOTTOM_LEFT, {10, 10});
1323 OH_Drawing_Corner_Radii corner = OH_Drawing_RoundRectGetCorner(roundRect,
1324 OH_Drawing_CornerPos::CORNER_POS_BOTTOM_LEFT);
1325 EXPECT_EQ(corner.x, 10);
1326 OH_Drawing_CanvasClipRoundRect(canvas_, roundRect, OH_Drawing_CanvasClipOp::INTERSECT, true);
1327 OH_Drawing_CanvasDrawRect(canvas_, rect);
1328 OH_Drawing_RectDestroy(rect);
1329 OH_Drawing_RoundRectDestroy(roundRect);
1330 }
1331
1332 /*
1333 * @tc.name: NativeDrawingCanvasTest_DrawRegion038
1334 * @tc.desc: test for DrawRegion
1335 * @tc.type: FUNC
1336 * @tc.require: AR000GTO5R
1337 */
1338 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_DrawRegion038, TestSize.Level1)
1339 {
1340 OH_Drawing_Region* region=OH_Drawing_RegionCreate();
1341 OH_Drawing_Rect* rect=OH_Drawing_RectCreate(0.0f, 0.0f, 256.0f, 256.0f);
1342 OH_Drawing_RegionSetRect(region, rect);
1343 OH_Drawing_CanvasDrawRegion(nullptr, region);
1344 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
1345 OH_Drawing_CanvasDrawRegion(canvas_, nullptr);
1346 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
1347 OH_Drawing_CanvasDrawRegion(canvas_, region);
1348 OH_Drawing_RegionDestroy(region);
1349 OH_Drawing_RectDestroy(rect);
1350 }
1351
1352 /*
1353 * @tc.name: NativeDrawingCanvasTest_DrawBackground039
1354 * @tc.desc: test for DrawBackground
1355 * @tc.type: FUNC
1356 * @tc.require: AR000GTO5R
1357 */
1358 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_DrawBackground039, TestSize.Level1)
1359 {
1360 OH_Drawing_Brush* brush = OH_Drawing_BrushCreate();
1361 OH_Drawing_BrushSetColor(brush, OH_Drawing_ColorSetArgb(0xFF, 0xFF, 0x00, 0x00));
1362 OH_Drawing_CanvasDrawBackground(nullptr, brush);
1363 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
1364 OH_Drawing_CanvasDrawBackground(canvas_, nullptr);
1365 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
1366 OH_Drawing_CanvasDrawBackground(canvas_, brush);
1367 OH_Drawing_BrushDestroy(brush);
1368 }
1369
1370 /*
1371 * @tc.name: NativeDrawingCanvasTest_DrawPixelMapRect040
1372 * @tc.desc: test for DrawPixelMapRect
1373 * @tc.type: FUNC
1374 * @tc.require: AR000GTO5R
1375 */
1376 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_DrawPixelMapRect040, TestSize.Level1)
1377 {
1378 OH_Pixelmap_InitializationOptions *options = nullptr;
1379 OH_PixelmapNative *pixelMap = nullptr;
1380 OH_PixelmapInitializationOptions_Create(&options);
1381 // 4 means width
1382 OH_PixelmapInitializationOptions_SetWidth(options, 4);
1383 // 4 means height
1384 OH_PixelmapInitializationOptions_SetHeight(options, 4);
1385 // 4 means RGBA format
1386 OH_PixelmapInitializationOptions_SetPixelFormat(options, 3);
1387 // 2 means ALPHA_FORMAT_PREMUL format
1388 OH_PixelmapInitializationOptions_SetAlphaType(options, 2);
1389 // 255 means rgba data
1390 uint8_t data[] = {
1391 255, 255, 0, 255,
1392 255, 255, 0, 255,
1393 255, 255, 0, 255,
1394 255, 255, 0, 255
1395 };
1396 // 16 means data length
1397 size_t dataLength = 16;
1398 OH_PixelmapNative_CreatePixelmap(data, dataLength, options, &pixelMap);
1399 EXPECT_NE(pixelMap, nullptr);
1400 OH_Drawing_PixelMap *drPixelMap = OH_Drawing_PixelMapGetFromOhPixelMapNative(pixelMap);
1401 EXPECT_NE(drPixelMap, nullptr);
1402 OH_Drawing_Rect* srcRect = OH_Drawing_RectCreate(0, 0, 4, 4);
1403 OH_Drawing_Rect* dstRect = OH_Drawing_RectCreate(0, 0, 4, 4);
1404 OH_Drawing_SamplingOptions* samplingOptions = OH_Drawing_SamplingOptionsCreate(
1405 OH_Drawing_FilterMode::FILTER_MODE_NEAREST, OH_Drawing_MipmapMode::MIPMAP_MODE_NEAREST);
1406 EXPECT_NE(samplingOptions, nullptr);
1407 OH_Drawing_CanvasDrawPixelMapRect(canvas_, drPixelMap, srcRect, dstRect, samplingOptions);
1408 OH_Drawing_CanvasDrawPixelMapRect(canvas_, drPixelMap, srcRect, dstRect, nullptr);
1409 OH_Drawing_CanvasDrawPixelMapRect(canvas_, drPixelMap, srcRect, nullptr, nullptr);
1410 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
1411 OH_Drawing_CanvasDrawPixelMapRect(canvas_, drPixelMap, nullptr, nullptr, nullptr);
1412 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
1413 OH_Drawing_CanvasDrawPixelMapRect(canvas_, nullptr, nullptr, nullptr, nullptr);
1414 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
1415 OH_Drawing_CanvasDrawPixelMapRect(nullptr, nullptr, nullptr, nullptr, nullptr);
1416 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
1417 OH_Drawing_PixelMapDissolve(drPixelMap);
1418 OH_PixelmapNative_Release(pixelMap);
1419 OH_PixelmapInitializationOptions_Release(options);
1420 OH_Drawing_RectDestroy(srcRect);
1421 OH_Drawing_RectDestroy(dstRect);
1422 OH_Drawing_SamplingOptionsDestroy(samplingOptions);
1423 }
1424
1425 /*
1426 * @tc.name: NativeDrawingCanvasTest_DrawPixelMapRect041
1427 * @tc.desc: test for DrawPixelMapRect
1428 * @tc.type: FUNC
1429 * @tc.require: AR000GTO5R
1430 */
1431 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_DrawPixelMapRect041, TestSize.Level1)
1432 {
1433 OH_Pixelmap_InitializationOptions *options = nullptr;
1434 OH_PixelmapNative *pixelMap = nullptr;
1435 OH_PixelmapInitializationOptions_Create(&options);
1436 // 4 means width
1437 OH_PixelmapInitializationOptions_SetWidth(options, 4);
1438 // 4 means height
1439 OH_PixelmapInitializationOptions_SetHeight(options, 4);
1440 // 4 means RGBA format
1441 OH_PixelmapInitializationOptions_SetPixelFormat(options, 3);
1442 // 2 means ALPHA_FORMAT_PREMUL format
1443 OH_PixelmapInitializationOptions_SetAlphaType(options, 2);
1444 // 255 means rgba data
1445 uint8_t data[] = {
1446 255, 255, 0, 255,
1447 255, 255, 0, 255,
1448 255, 255, 0, 255,
1449 255, 255, 0, 255
1450 };
1451 // 16 means data length
1452 size_t dataLength = 16;
1453 OH_PixelmapNative_CreatePixelmap(data, dataLength, options, &pixelMap);
1454 EXPECT_NE(pixelMap, nullptr);
1455 OH_Drawing_PixelMap *drPixelMap = OH_Drawing_PixelMapGetFromOhPixelMapNative(pixelMap);
1456 EXPECT_NE(drPixelMap, nullptr);
1457 auto recordingCanvas = new RecordingCanvas(100, 100);
1458 OH_Drawing_Canvas *cCanvas = reinterpret_cast<OH_Drawing_Canvas*>(recordingCanvas);
1459 EXPECT_NE(cCanvas, nullptr);
1460 OH_Drawing_Rect* srcRect = OH_Drawing_RectCreate(0, 0, 4, 4);
1461 OH_Drawing_Rect* dstRect = OH_Drawing_RectCreate(0, 0, 4, 4);
1462 OH_Drawing_SamplingOptions* samplingOptions = OH_Drawing_SamplingOptionsCreate(
1463 OH_Drawing_FilterMode::FILTER_MODE_NEAREST, OH_Drawing_MipmapMode::MIPMAP_MODE_NEAREST);
1464 EXPECT_NE(samplingOptions, nullptr);
1465 OH_Drawing_CanvasDrawPixelMapRect(cCanvas, drPixelMap, srcRect, dstRect, samplingOptions);
1466 OH_Drawing_CanvasDrawPixelMapRect(cCanvas, drPixelMap, srcRect, dstRect, nullptr);
1467 OH_Drawing_CanvasDrawPixelMapRect(cCanvas, drPixelMap, srcRect, nullptr, nullptr);
1468 OH_Drawing_CanvasDrawPixelMapRect(cCanvas, drPixelMap, nullptr, nullptr, nullptr);
1469 OH_Drawing_CanvasDrawPixelMapRect(cCanvas, nullptr, nullptr, nullptr, nullptr);
1470 OH_Drawing_CanvasDrawPixelMapRect(nullptr, nullptr, nullptr, nullptr, nullptr);
1471 auto drawCmdList = recordingCanvas->GetDrawCmdList();
1472 EXPECT_NE(drawCmdList, nullptr);
1473 Canvas canvas;
1474 drawCmdList->Playback(canvas);
1475 OH_Drawing_PixelMapDissolve(drPixelMap);
1476 OH_PixelmapNative_Release(pixelMap);
1477 OH_PixelmapInitializationOptions_Release(options);
1478 OH_Drawing_RectDestroy(srcRect);
1479 OH_Drawing_RectDestroy(dstRect);
1480 OH_Drawing_SamplingOptionsDestroy(samplingOptions);
1481 delete recordingCanvas;
1482 }
1483
1484 /*
1485 * @tc.name: NativeDrawingCanvasTest_IsClipEmpty042
1486 * @tc.desc: test for if clip is empty
1487 * @tc.type: FUNC
1488 * @tc.require: AR000GTO5R
1489 */
1490 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_IsClipEmpty042, TestSize.Level1)
1491 {
1492 OH_Drawing_Bitmap* bitmap = OH_Drawing_BitmapCreate();
1493 OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE};
1494 // 720: bitmap's width, 720: bitmap's height
1495 constexpr uint32_t width = 720;
1496 constexpr uint32_t height = 720;
1497 OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat);
1498 OH_Drawing_CanvasBind(canvas_, bitmap);
1499
1500 // 150.0f: rect's left, 100.0f: rect's top, 500.0f: rect's right, 500.0f: rect's bottom
1501 OH_Drawing_Rect* rect = OH_Drawing_RectCreate(150.0f, 100.0f, 500.f, 500.f);
1502
1503 OH_Drawing_CanvasClipRect(canvas_, rect, OH_Drawing_CanvasClipOp::INTERSECT, false);
1504
1505 bool isClipEmpty = false;
1506 EXPECT_EQ(OH_Drawing_CanvasIsClipEmpty(canvas_, &isClipEmpty), OH_DRAWING_SUCCESS);
1507 EXPECT_EQ(isClipEmpty, false);
1508
1509 OH_Drawing_RectDestroy(rect);
1510 OH_Drawing_BitmapDestroy(bitmap);
1511 }
1512
1513 /*
1514 * @tc.name: NativeDrawingCanvasTest_GetImageInfo043
1515 * @tc.desc: test for Gets ImageInfo of Canvas.
1516 * @tc.type: FUNC
1517 * @tc.require: AR000GTO5R
1518 */
1519 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_GetImageInfo043, TestSize.Level1)
1520 {
1521 OH_Drawing_Bitmap* bitmap = OH_Drawing_BitmapCreate();
1522 OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE};
1523 // 720: bitmap's width, 720: bitmap's height
1524 constexpr uint32_t width = 720;
1525 constexpr uint32_t height = 720;
1526 OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat);
1527 OH_Drawing_CanvasBind(canvas_, bitmap);
1528 OH_Drawing_Image_Info* imageInfo = new OH_Drawing_Image_Info();
1529 EXPECT_EQ(OH_Drawing_CanvasGetImageInfo(canvas_, imageInfo), OH_DRAWING_SUCCESS);
1530 EXPECT_EQ(720, imageInfo->width);
1531 EXPECT_EQ(720, imageInfo->height);
1532 EXPECT_EQ(1, imageInfo->alphaType);
1533 EXPECT_EQ(4, imageInfo->colorType);
1534 delete imageInfo;
1535 }
1536
1537 /*
1538 * @tc.name: NativeDrawingCanvasTest_ClipRegion044
1539 * @tc.desc: test for Drawing Canvas Clip Region.
1540 * @tc.type: FUNC
1541 * @tc.require: AR000GTO5R
1542 */
1543 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_ClipRegion044, TestSize.Level1)
1544 {
1545 OH_Drawing_Bitmap* bitmap = OH_Drawing_BitmapCreate();
1546 OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE};
1547 constexpr uint32_t width = 720; // 720: width of canvas
1548 constexpr uint32_t height = 720; // 720: height of canvas
1549 OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat);
1550 OH_Drawing_CanvasBind(canvas_, bitmap);
1551
1552 OH_Drawing_Region *region = OH_Drawing_RegionCreate();
1553 // 0.0f: rect's left, 0.0f: rect's top, 720.0f: rect's right, 720.0f: rect's bottom
1554 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0.0f, 0.0f, 720.f, 720.f);
1555 OH_Drawing_RegionSetRect(region, rect);
1556 EXPECT_EQ(OH_Drawing_CanvasClipRegion(canvas_, region, OH_Drawing_CanvasClipOp::INTERSECT), OH_DRAWING_SUCCESS);
1557 EXPECT_EQ(OH_Drawing_CanvasClipRegion(nullptr, region, OH_Drawing_CanvasClipOp::INTERSECT),
1558 OH_DRAWING_ERROR_INVALID_PARAMETER);
1559
1560 EXPECT_EQ(720, OH_Drawing_CanvasGetWidth(canvas_));
1561 EXPECT_EQ(720, OH_Drawing_CanvasGetHeight(canvas_));
1562
1563 OH_Drawing_RegionDestroy(region);
1564 OH_Drawing_RectDestroy(rect);
1565 OH_Drawing_BitmapDestroy(bitmap);
1566 }
1567
1568 /*
1569 * @tc.name: NativeDrawingCanvasTest_DrawPoint_045
1570 * @tc.desc: test for OH_Drawing_CanvasDrawPoint.
1571 * @tc.type: FUNC
1572 * @tc.require: AR000GTO5R
1573 */
1574 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_DrawPoint_045, TestSize.Level1)
1575 {
1576 OH_Drawing_Point2D point_ = {25.0f, 36.0f}; // 25.0f: x, 36.0f: y
1577 EXPECT_EQ(OH_Drawing_CanvasDrawPoint(canvas_, nullptr), OH_DRAWING_ERROR_INVALID_PARAMETER);
1578 EXPECT_EQ(OH_Drawing_CanvasDrawPoint(nullptr, &point_), OH_DRAWING_ERROR_INVALID_PARAMETER);
1579 EXPECT_EQ(OH_Drawing_CanvasDrawPoint(canvas_, &point_), OH_DRAWING_SUCCESS);
1580 }
1581
1582 /*
1583 * @tc.name: NativeDrawingCanvasTest_DrawColor046
1584 * @tc.desc: test for DrawColor
1585 * @tc.type: FUNC
1586 * @tc.require: SR000S9F0C
1587 */
1588 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_DrawColor046, TestSize.Level1)
1589 {
1590 EXPECT_EQ(OH_Drawing_CanvasDrawColor(nullptr, 0xFFFF0000, OH_Drawing_BlendMode::BLEND_MODE_SRC),
1591 OH_DRAWING_ERROR_INVALID_PARAMETER);
1592 EXPECT_EQ(OH_Drawing_CanvasDrawColor(canvas_, 0xFFFF0000, OH_Drawing_BlendMode::BLEND_MODE_COLOR),
1593 OH_DRAWING_SUCCESS);
1594 }
1595
1596 /*
1597 * @tc.name: NativeDrawingCanvasTest_DrawTextBlob047
1598 * @tc.desc: test for DrawTextBlob
1599 * @tc.type: FUNC
1600 * @tc.require: AR000GTO5R
1601 */
1602 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_DrawTextBlob047, TestSize.Level1)
1603 {
1604 OH_Drawing_Font *font = OH_Drawing_FontCreate();
1605 auto *builder = OH_Drawing_TextBlobBuilderCreate();
1606 EXPECT_EQ(nullptr, OH_Drawing_TextBlobBuilderAllocRunPos(nullptr, nullptr, INT32_MAX, nullptr));
1607 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
1608 EXPECT_EQ(nullptr, OH_Drawing_TextBlobBuilderAllocRunPos(builder, nullptr, INT32_MAX, nullptr));
1609 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
1610 EXPECT_EQ(nullptr, OH_Drawing_TextBlobBuilderAllocRunPos(builder, font, 0, nullptr));
1611 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
1612 OH_Drawing_TextBlobBuilderDestroy(builder);
1613 OH_Drawing_FontDestroy(font);
1614 }
1615
1616 /*
1617 * @tc.name: NativeDrawingCanvasTest_DrawPixelMapRectConstraint048
1618 * @tc.desc: test for OH_Drawing_CanvasDrawPixelMapRectConstraint in FAST_SRC_RECT_CONSTRAINT mode.
1619 * @tc.type: FUNC
1620 * @tc.require: ICBC29
1621 */
1622 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_DrawPixelMapRectConstraint048, TestSize.Level1)
1623 {
1624 OH_Pixelmap_InitializationOptions *options = nullptr;
1625 OH_PixelmapNative *pixelMap = nullptr;
1626 OH_Drawing_PixelMap *drPixelMap = CreateOHDrawingPixelMap(options, pixelMap);
1627 EXPECT_NE(drPixelMap, nullptr);
1628 OH_Drawing_Rect* srcRect = OH_Drawing_RectCreate(0, 0, 4, 4);
1629 OH_Drawing_Rect* dstRect = OH_Drawing_RectCreate(0, 0, 4, 4);
1630 OH_Drawing_SamplingOptions* samplingOptions = OH_Drawing_SamplingOptionsCreate(
1631 OH_Drawing_FilterMode::FILTER_MODE_NEAREST, OH_Drawing_MipmapMode::MIPMAP_MODE_NEAREST);
1632 EXPECT_NE(samplingOptions, nullptr);
1633 OH_Drawing_ErrorCode code = OH_Drawing_CanvasDrawPixelMapRectConstraint(canvas_, drPixelMap, srcRect, dstRect,
1634 samplingOptions, OH_Drawing_SrcRectConstraint::FAST_SRC_RECT_CONSTRAINT);
1635 EXPECT_EQ(code, OH_DRAWING_SUCCESS);
1636 code = OH_Drawing_CanvasDrawPixelMapRectConstraint(canvas_, drPixelMap, srcRect, dstRect, nullptr,
1637 OH_Drawing_SrcRectConstraint::FAST_SRC_RECT_CONSTRAINT);
1638 EXPECT_EQ(code, OH_DRAWING_SUCCESS);
1639 code = OH_Drawing_CanvasDrawPixelMapRectConstraint(canvas_, drPixelMap, srcRect, nullptr, nullptr,
1640 OH_Drawing_SrcRectConstraint::FAST_SRC_RECT_CONSTRAINT);
1641 EXPECT_EQ(code, OH_DRAWING_ERROR_INVALID_PARAMETER);
1642 code = OH_Drawing_CanvasDrawPixelMapRectConstraint(canvas_, drPixelMap, nullptr, nullptr, nullptr,
1643 OH_Drawing_SrcRectConstraint::FAST_SRC_RECT_CONSTRAINT);
1644 EXPECT_EQ(code, OH_DRAWING_ERROR_INVALID_PARAMETER);
1645 code = OH_Drawing_CanvasDrawPixelMapRectConstraint(canvas_, nullptr, nullptr, nullptr, nullptr,
1646 OH_Drawing_SrcRectConstraint::FAST_SRC_RECT_CONSTRAINT);
1647 EXPECT_EQ(code, OH_DRAWING_ERROR_INVALID_PARAMETER);
1648 code = OH_Drawing_CanvasDrawPixelMapRectConstraint(nullptr, nullptr, nullptr, nullptr, nullptr,
1649 OH_Drawing_SrcRectConstraint::FAST_SRC_RECT_CONSTRAINT);
1650 EXPECT_EQ(code, OH_DRAWING_ERROR_INVALID_PARAMETER);
1651 OH_Drawing_PixelMapDissolve(drPixelMap);
1652 OH_PixelmapNative_Release(pixelMap);
1653 OH_PixelmapInitializationOptions_Release(options);
1654 OH_Drawing_RectDestroy(srcRect);
1655 OH_Drawing_RectDestroy(dstRect);
1656 OH_Drawing_SamplingOptionsDestroy(samplingOptions);
1657 }
1658
1659 /*
1660 * @tc.name: NativeDrawingCanvasTest_DrawPixelMapRectConstraint049
1661 * @tc.desc: test for OH_Drawing_CanvasDrawPixelMapRectConstraint in FAST_SRC_RECT_CONSTRAINT mode
1662 * using RecordingCanvas.
1663 * @tc.type: FUNC
1664 * @tc.require: ICBC29
1665 */
1666 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_DrawPixelMapRectConstraint049, TestSize.Level1)
1667 {
1668 OH_Pixelmap_InitializationOptions *options = nullptr;
1669 OH_PixelmapNative *pixelMap = nullptr;
1670 OH_Drawing_PixelMap *drPixelMap = CreateOHDrawingPixelMap(options, pixelMap);
1671 EXPECT_NE(drPixelMap, nullptr);
1672
1673 auto recordingCanvas = new RecordingCanvas(100, 100);
1674 OH_Drawing_Canvas *cCanvas = reinterpret_cast<OH_Drawing_Canvas*>(recordingCanvas);
1675 EXPECT_NE(cCanvas, nullptr);
1676 OH_Drawing_Rect* srcRect = OH_Drawing_RectCreate(0, 0, 4, 4);
1677 OH_Drawing_Rect* dstRect = OH_Drawing_RectCreate(0, 0, 4, 4);
1678 OH_Drawing_SamplingOptions* samplingOptions = OH_Drawing_SamplingOptionsCreate(
1679 OH_Drawing_FilterMode::FILTER_MODE_NEAREST, OH_Drawing_MipmapMode::MIPMAP_MODE_NEAREST);
1680 EXPECT_NE(samplingOptions, nullptr);
1681 OH_Drawing_ErrorCode code = OH_Drawing_CanvasDrawPixelMapRectConstraint(cCanvas, drPixelMap, srcRect, dstRect,
1682 samplingOptions, OH_Drawing_SrcRectConstraint::FAST_SRC_RECT_CONSTRAINT);
1683 EXPECT_EQ(code, OH_DRAWING_SUCCESS);
1684 code = OH_Drawing_CanvasDrawPixelMapRectConstraint(cCanvas, drPixelMap, srcRect, dstRect, nullptr,
1685 OH_Drawing_SrcRectConstraint::FAST_SRC_RECT_CONSTRAINT);
1686 EXPECT_EQ(code, OH_DRAWING_SUCCESS);
1687 code = OH_Drawing_CanvasDrawPixelMapRectConstraint(cCanvas, drPixelMap, srcRect, nullptr, nullptr,
1688 OH_Drawing_SrcRectConstraint::FAST_SRC_RECT_CONSTRAINT);
1689 EXPECT_EQ(code, OH_DRAWING_ERROR_INVALID_PARAMETER);
1690 code = OH_Drawing_CanvasDrawPixelMapRectConstraint(cCanvas, drPixelMap, nullptr, nullptr, nullptr,
1691 OH_Drawing_SrcRectConstraint::FAST_SRC_RECT_CONSTRAINT);
1692 EXPECT_EQ(code, OH_DRAWING_ERROR_INVALID_PARAMETER);
1693 code = OH_Drawing_CanvasDrawPixelMapRectConstraint(cCanvas, nullptr, nullptr, nullptr, nullptr,
1694 OH_Drawing_SrcRectConstraint::FAST_SRC_RECT_CONSTRAINT);
1695 EXPECT_EQ(code, OH_DRAWING_ERROR_INVALID_PARAMETER);
1696 code = OH_Drawing_CanvasDrawPixelMapRectConstraint(nullptr, nullptr, nullptr, nullptr, nullptr,
1697 OH_Drawing_SrcRectConstraint::FAST_SRC_RECT_CONSTRAINT);
1698 EXPECT_EQ(code, OH_DRAWING_ERROR_INVALID_PARAMETER);
1699 auto drawCmdList = recordingCanvas->GetDrawCmdList();
1700 EXPECT_NE(drawCmdList, nullptr);
1701 Canvas canvas;
1702 drawCmdList->Playback(canvas);
1703 OH_Drawing_PixelMapDissolve(drPixelMap);
1704 OH_PixelmapNative_Release(pixelMap);
1705 OH_PixelmapInitializationOptions_Release(options);
1706 OH_Drawing_RectDestroy(srcRect);
1707 OH_Drawing_RectDestroy(dstRect);
1708 OH_Drawing_SamplingOptionsDestroy(samplingOptions);
1709 delete recordingCanvas;
1710 }
1711
1712 /*
1713 * @tc.name: NativeDrawingCanvasTest_DrawPixelMapRectConstraint050
1714 * @tc.desc: test for OH_Drawing_CanvasDrawPixelMapRectConstraint in STRICT_SRC_RECT_CONSTRAINT mode.
1715 * @tc.type: FUNC
1716 * @tc.require: ICBC29
1717 */
1718 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_DrawPixelMapRectConstraint050, TestSize.Level1)
1719 {
1720 OH_Pixelmap_InitializationOptions *options = nullptr;
1721 OH_PixelmapNative *pixelMap = nullptr;
1722 OH_Drawing_PixelMap *drPixelMap = CreateOHDrawingPixelMap(options, pixelMap);
1723 EXPECT_NE(drPixelMap, nullptr);
1724 OH_Drawing_Rect* srcRect = OH_Drawing_RectCreate(0, 0, 4, 4);
1725 OH_Drawing_Rect* dstRect = OH_Drawing_RectCreate(0, 0, 4, 4);
1726 OH_Drawing_SamplingOptions* samplingOptions = OH_Drawing_SamplingOptionsCreate(
1727 OH_Drawing_FilterMode::FILTER_MODE_NEAREST, OH_Drawing_MipmapMode::MIPMAP_MODE_NEAREST);
1728 EXPECT_NE(samplingOptions, nullptr);
1729 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreateWithPixelMap(drPixelMap);
1730 EXPECT_NE(canvas, nullptr);
1731 OH_Drawing_ErrorCode code = OH_Drawing_CanvasDrawPixelMapRectConstraint(canvas, drPixelMap, srcRect, dstRect,
1732 samplingOptions, OH_Drawing_SrcRectConstraint::STRICT_SRC_RECT_CONSTRAINT);
1733 EXPECT_EQ(code, OH_DRAWING_SUCCESS);
1734 code = OH_Drawing_CanvasDrawPixelMapRectConstraint(canvas, drPixelMap, srcRect, dstRect, nullptr,
1735 OH_Drawing_SrcRectConstraint::STRICT_SRC_RECT_CONSTRAINT);
1736 EXPECT_EQ(code, OH_DRAWING_SUCCESS);
1737 code = OH_Drawing_CanvasDrawPixelMapRectConstraint(canvas, drPixelMap, srcRect, nullptr, nullptr,
1738 OH_Drawing_SrcRectConstraint::STRICT_SRC_RECT_CONSTRAINT);
1739 EXPECT_EQ(code, OH_DRAWING_ERROR_INVALID_PARAMETER);
1740 code = OH_Drawing_CanvasDrawPixelMapRectConstraint(canvas, drPixelMap, nullptr, nullptr, nullptr,
1741 OH_Drawing_SrcRectConstraint::STRICT_SRC_RECT_CONSTRAINT);
1742 EXPECT_EQ(code, OH_DRAWING_ERROR_INVALID_PARAMETER);
1743 code = OH_Drawing_CanvasDrawPixelMapRectConstraint(canvas, nullptr, nullptr, nullptr, nullptr,
1744 OH_Drawing_SrcRectConstraint::STRICT_SRC_RECT_CONSTRAINT);
1745 EXPECT_EQ(code, OH_DRAWING_ERROR_INVALID_PARAMETER);
1746 code = OH_Drawing_CanvasDrawPixelMapRectConstraint(nullptr, nullptr, nullptr, nullptr, nullptr,
1747 OH_Drawing_SrcRectConstraint::STRICT_SRC_RECT_CONSTRAINT);
1748 EXPECT_EQ(code, OH_DRAWING_ERROR_INVALID_PARAMETER);
1749 OH_Drawing_PixelMapDissolve(drPixelMap);
1750 OH_PixelmapNative_Release(pixelMap);
1751 OH_PixelmapInitializationOptions_Release(options);
1752 OH_Drawing_RectDestroy(srcRect);
1753 OH_Drawing_RectDestroy(dstRect);
1754 OH_Drawing_SamplingOptionsDestroy(samplingOptions);
1755 OH_Drawing_CanvasDestroy(canvas);
1756 }
1757
1758 /*
1759 * @tc.name: NativeDrawingCanvasTest_DrawPixelMapRectConstraint051
1760 * @tc.desc: test for OH_Drawing_CanvasDrawPixelMapRectConstraint in STRICT_SRC_RECT_CONSTRAINT mode
1761 * using RecordingCanvas.
1762 * @tc.type: FUNC
1763 * @tc.require: ICBC29
1764 */
1765 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_OH_Drawing_DrawPixelMapRectConstraint051, TestSize.Level1)
1766 {
1767 OH_Pixelmap_InitializationOptions *options = nullptr;
1768 OH_PixelmapNative *pixelMap = nullptr;
1769 OH_Drawing_PixelMap *drPixelMap = CreateOHDrawingPixelMap(options, pixelMap);
1770 EXPECT_NE(drPixelMap, nullptr);
1771 auto recordingCanvas = new RecordingCanvas(100, 100);
1772 OH_Drawing_Canvas *cCanvas = reinterpret_cast<OH_Drawing_Canvas*>(recordingCanvas);
1773 EXPECT_NE(cCanvas, nullptr);
1774 OH_Drawing_Rect* srcRect = OH_Drawing_RectCreate(0, 0, 4, 4);
1775 OH_Drawing_Rect* dstRect = OH_Drawing_RectCreate(0, 0, 4, 4);
1776 OH_Drawing_SamplingOptions* samplingOptions = OH_Drawing_SamplingOptionsCreate(
1777 OH_Drawing_FilterMode::FILTER_MODE_NEAREST, OH_Drawing_MipmapMode::MIPMAP_MODE_NEAREST);
1778 EXPECT_NE(samplingOptions, nullptr);
1779 OH_Drawing_ErrorCode code = OH_Drawing_CanvasDrawPixelMapRectConstraint(cCanvas, drPixelMap, srcRect, dstRect,
1780 samplingOptions, OH_Drawing_SrcRectConstraint::STRICT_SRC_RECT_CONSTRAINT);
1781 EXPECT_EQ(code, OH_DRAWING_SUCCESS);
1782 code = OH_Drawing_CanvasDrawPixelMapRectConstraint(cCanvas, drPixelMap, srcRect, dstRect, nullptr,
1783 OH_Drawing_SrcRectConstraint::STRICT_SRC_RECT_CONSTRAINT);
1784 EXPECT_EQ(code, OH_DRAWING_SUCCESS);
1785 code = OH_Drawing_CanvasDrawPixelMapRectConstraint(cCanvas, drPixelMap, srcRect, nullptr, nullptr,
1786 OH_Drawing_SrcRectConstraint::STRICT_SRC_RECT_CONSTRAINT);
1787 EXPECT_EQ(code, OH_DRAWING_ERROR_INVALID_PARAMETER);
1788 code = OH_Drawing_CanvasDrawPixelMapRectConstraint(cCanvas, drPixelMap, nullptr, nullptr, nullptr,
1789 OH_Drawing_SrcRectConstraint::STRICT_SRC_RECT_CONSTRAINT);
1790 EXPECT_EQ(code, OH_DRAWING_ERROR_INVALID_PARAMETER);
1791 code = OH_Drawing_CanvasDrawPixelMapRectConstraint(cCanvas, nullptr, nullptr, nullptr, nullptr,
1792 OH_Drawing_SrcRectConstraint::STRICT_SRC_RECT_CONSTRAINT);
1793 EXPECT_EQ(code, OH_DRAWING_ERROR_INVALID_PARAMETER);
1794 code = OH_Drawing_CanvasDrawPixelMapRectConstraint(nullptr, nullptr, nullptr, nullptr, nullptr,
1795 OH_Drawing_SrcRectConstraint::STRICT_SRC_RECT_CONSTRAINT);
1796 EXPECT_EQ(code, OH_DRAWING_ERROR_INVALID_PARAMETER);
1797 auto drawCmdList = recordingCanvas->GetDrawCmdList();
1798 EXPECT_NE(drawCmdList, nullptr);
1799 Canvas canvas;
1800 drawCmdList->Playback(canvas);
1801 OH_Drawing_PixelMapDissolve(drPixelMap);
1802 OH_PixelmapNative_Release(pixelMap);
1803 OH_PixelmapInitializationOptions_Release(options);
1804 OH_Drawing_RectDestroy(srcRect);
1805 OH_Drawing_RectDestroy(dstRect);
1806 OH_Drawing_SamplingOptionsDestroy(samplingOptions);
1807 delete recordingCanvas;
1808 }
1809
1810 /*
1811 * @tc.name: NativeDrawingCanvasTest_DrawPixelMapRectConstraint052
1812 * @tc.desc: test for DrawingCanvasUtils::DrawPixelMapRectConstraint with invalid parameters and validate error codes.
1813 * @tc.type: FUNC
1814 * @tc.require: ICBC29
1815 */
1816 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_DrawPixelMapRectConstraint052, TestSize.Level1)
1817 {
1818 OH_Pixelmap_InitializationOptions *options = nullptr;
1819 OH_PixelmapNative *pixelMap = nullptr;
1820 OH_Drawing_PixelMap *drPixelMap = CreateOHDrawingPixelMap(options, pixelMap);
1821 EXPECT_NE(drPixelMap, nullptr);
1822
1823 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreateWithPixelMap(nullptr);
1824 EXPECT_EQ(canvas, nullptr);
1825 canvas = OH_Drawing_CanvasCreateWithPixelMap(drPixelMap);
1826 EXPECT_NE(canvas, nullptr);
1827
1828 std::shared_ptr<Media::PixelMap> p = reinterpret_cast<OH_PixelmapNative*>(drPixelMap)->GetInnerPixelmap();
1829 const Drawing::Rect srcRect = Drawing::Rect(0, 0, 4, 4);
1830 const Drawing::Rect dstRect = Drawing::Rect(0, 0, 4, 4);
1831
1832 OH_Drawing_ErrorCode code = DrawingCanvasUtils::DrawPixelMapRectConstraint(nullptr, p, &srcRect, &dstRect,
1833 nullptr, Drawing::SrcRectConstraint::STRICT_SRC_RECT_CONSTRAINT);
1834 EXPECT_EQ(code, OH_DRAWING_ERROR_INVALID_PARAMETER);
1835 code = DrawingCanvasUtils::DrawPixelMapRectConstraint(reinterpret_cast<Canvas*>(canvas), nullptr, &srcRect,
1836 &dstRect, nullptr, Drawing::SrcRectConstraint::STRICT_SRC_RECT_CONSTRAINT);
1837 EXPECT_EQ(code, OH_DRAWING_ERROR_INVALID_PARAMETER);
1838 code = DrawingCanvasUtils::DrawPixelMapRectConstraint(reinterpret_cast<Canvas*>(canvas), p, &srcRect, nullptr,
1839 nullptr, Drawing::SrcRectConstraint::STRICT_SRC_RECT_CONSTRAINT);
1840 EXPECT_EQ(code, OH_DRAWING_ERROR_INVALID_PARAMETER);
1841 code = DrawingCanvasUtils::DrawPixelMapRectConstraint(reinterpret_cast<Canvas*>(canvas), p, &srcRect,
1842 &dstRect, nullptr, Drawing::SrcRectConstraint::STRICT_SRC_RECT_CONSTRAINT);
1843 EXPECT_EQ(code, OH_DRAWING_SUCCESS);
1844 OH_Drawing_PixelMapDissolve(drPixelMap);
1845 OH_PixelmapNative_Release(pixelMap);
1846 OH_Drawing_CanvasDestroy(canvas);
1847 OH_PixelmapInitializationOptions_Release(options);
1848 }
1849
1850 /*
1851 * @tc.name: NativeDrawingCanvasTest_ImageFilterCreateBlur041
1852 * @tc.desc: test for Creates an OH_Drawing_ImageFilter object that blurs its input by the separate x and y sigmas.
1853 * @tc.type: FUNC
1854 * @tc.require: AR000GTO5R
1855 */
1856 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_ImageFilterCreateBlur041, TestSize.Level1)
1857 {
1858 float sifmaX = 0.f;
1859 float sigmaY = 0.f;
1860 OH_Drawing_ImageFilter *imagefilter = nullptr;
1861 imagefilter = OH_Drawing_ImageFilterCreateBlur(sifmaX, sigmaY, CLAMP, nullptr);
1862 EXPECT_NE(imagefilter, nullptr);
1863 OH_Drawing_ImageFilterDestroy(imagefilter);
1864 }
1865
1866 /*
1867 * @tc.name: NativeDrawingCanvasTest_ImageFilterCreateFromColorFilter042
1868 * @tc.desc: test for Creates an OH_Drawing_ImageFilter object that applies the color filter to the input.
1869 * @tc.type: FUNC
1870 * @tc.require: AR000GTO5R
1871 */
1872 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_ImageFilterCreateFromColorFilter042, TestSize.Level1)
1873 {
1874 float sifmaX = 0.f;
1875 float sigmaY = 0.f;
1876 OH_Drawing_ImageFilter *imagefilter = nullptr;
1877 imagefilter = OH_Drawing_ImageFilterCreateBlur(sifmaX, sigmaY, CLAMP, nullptr);
1878 EXPECT_NE(imagefilter, nullptr);
1879 EXPECT_EQ(OH_Drawing_BrushGetColor(brush_), 0xFFFF0000);
1880 OH_Drawing_ColorFilter* colorFilter = OH_Drawing_ColorFilterCreateBlendMode(0xFF0000FF,
1881 OH_Drawing_BlendMode::BLEND_MODE_SRC);
1882 EXPECT_NE(colorFilter, nullptr);
1883 OH_Drawing_ColorFilter* colorFilterTmp = OH_Drawing_ColorFilterCreateLinearToSrgbGamma();
1884 EXPECT_NE(colorFilterTmp, nullptr);
1885 OH_Drawing_ImageFilter *imagefiltercreatefromc = nullptr;
1886 imagefiltercreatefromc = OH_Drawing_ImageFilterCreateFromColorFilter(nullptr, nullptr);
1887 EXPECT_EQ(imagefiltercreatefromc, nullptr);
1888 imagefiltercreatefromc = OH_Drawing_ImageFilterCreateFromColorFilter(colorFilterTmp, imagefilter);
1889 EXPECT_NE(imagefiltercreatefromc, nullptr);
1890 OH_Drawing_ColorFilterDestroy(colorFilter);
1891 OH_Drawing_ColorFilterDestroy(colorFilterTmp);
1892 OH_Drawing_ImageFilterDestroy(imagefiltercreatefromc);
1893 OH_Drawing_ImageFilterDestroy(imagefilter);
1894 }
1895
1896 /*
1897 * @tc.name: NativeDrawingCanvasTest_ImageFilterDestroy043
1898 * @tc.desc: test for Destroys an OH_Drawing_ImageFilter object and reclaims the memory occupied by the object.
1899 * @tc.type: FUNC
1900 * @tc.require: AR000GTO5R
1901 */
1902 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_ImageFilterDestroy043, TestSize.Level1)
1903 {
1904 float sifmaX = 0.f;
1905 float sigmaY = 0.f;
1906 OH_Drawing_ImageFilter *imagefilter = nullptr;
1907 imagefilter = OH_Drawing_ImageFilterCreateBlur(sifmaX, sigmaY, CLAMP, nullptr);
1908 EXPECT_NE(imagefilter, nullptr);
1909 OH_Drawing_ImageFilterDestroy(nullptr);
1910 OH_Drawing_ImageFilterDestroy(imagefilter);
1911 }
1912
1913 /*
1914 * @tc.name: NativeDrawingCanvasTest_FilterSetImageFilter044
1915 * @tc.desc: test for Sets an OH_Drawing_ImageFilter object for an OH_Drawing_Filter object.
1916 * @tc.type: FUNC
1917 * @tc.require: AR000GTO5R
1918 */
1919 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_FilterSetImageFilter044, TestSize.Level1)
1920 {
1921 float sifmaX = 0.f;
1922 float sigmaY = 0.f;
1923 OH_Drawing_ImageFilter *imagefilter = OH_Drawing_ImageFilterCreateBlur(sifmaX, sigmaY, CLAMP, nullptr);
1924 EXPECT_NE(imagefilter, nullptr);
1925 OH_Drawing_Filter* filter = OH_Drawing_FilterCreate();
1926 OH_Drawing_FilterSetImageFilter(nullptr, imagefilter);
1927 OH_Drawing_FilterSetImageFilter(filter, nullptr);
1928 OH_Drawing_FilterSetImageFilter(filter, imagefilter);
1929 OH_Drawing_FilterDestroy(filter);
1930 OH_Drawing_ImageFilterDestroy(imagefilter);
1931 }
1932
1933 /*
1934 * @tc.name: NativeDrawingCanvasTest_CanvasDrawSingleCharacter045
1935 * @tc.desc: test for OH_Drawing_CanvasDrawSingleCharacter.
1936 * @tc.type: FUNC
1937 * @tc.require: AR000GTO5R
1938 */
1939 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_CanvasDrawSingleCharacter045, TestSize.Level1)
1940 {
1941 const char* strOne = "a";
1942 const char* strTwo = "你好";
1943 OH_Drawing_Font *font = OH_Drawing_FontCreate();
1944 EXPECT_NE(font, nullptr);
1945 float x = 0.f;
1946 float y = 0.f;
1947 EXPECT_EQ(OH_Drawing_CanvasDrawSingleCharacter(canvas_, strOne, font, x, y), OH_DRAWING_SUCCESS);
1948 EXPECT_EQ(OH_Drawing_CanvasDrawSingleCharacter(canvas_, strTwo, font, x, y), OH_DRAWING_SUCCESS);
1949 EXPECT_EQ(OH_Drawing_CanvasDrawSingleCharacter(nullptr, strOne, font, x, y), OH_DRAWING_ERROR_INVALID_PARAMETER);
1950 EXPECT_EQ(OH_Drawing_CanvasDrawSingleCharacter(canvas_, nullptr, font, x, y), OH_DRAWING_ERROR_INVALID_PARAMETER);
1951 EXPECT_EQ(OH_Drawing_CanvasDrawSingleCharacter(canvas_, strOne, nullptr, x, y),
1952 OH_DRAWING_ERROR_INVALID_PARAMETER);
1953 const char* strThree = "";
1954 EXPECT_EQ(OH_Drawing_CanvasDrawSingleCharacter(canvas_, strThree, font, x, y), OH_DRAWING_ERROR_INVALID_PARAMETER);
1955 OH_Drawing_FontDestroy(font);
1956 }
1957
1958 /*
1959 * @tc.name: NativeDrawingCanvasTest_ImageFilterCreateBlurWithCrop046
1960 * @tc.desc: test for OH_Drawing_ImageFilterCreateBlurWithCrop.
1961 * @tc.type: FUNC
1962 * @tc.require: ICBC29
1963 */
1964 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_ImageFilterCreateBlurWithCrop046, TestSize.Level1)
1965 {
1966 float sifmaX = 0.f;
1967 float sigmaY = 0.f;
1968 OH_Drawing_ImageFilter* imagefilterWithCrop1 =
1969 OH_Drawing_ImageFilterCreateBlurWithCrop(sifmaX, sigmaY, CLAMP, nullptr, nullptr);
1970 EXPECT_NE(imagefilterWithCrop1, nullptr);
1971 OH_Drawing_ImageFilter* imagefilter = nullptr;
1972 imagefilter = OH_Drawing_ImageFilterCreateBlur(sifmaX, sigmaY, CLAMP, nullptr);
1973 EXPECT_NE(imagefilter, nullptr);
1974 OH_Drawing_Rect* rect = OH_Drawing_RectCreate(100, 200, 500, 300);
1975 EXPECT_NE(rect, nullptr);
1976 OH_Drawing_ImageFilter* imagefilterWithCrop2 =
1977 OH_Drawing_ImageFilterCreateBlurWithCrop(sifmaX, sigmaY, CLAMP, imagefilter, rect);
1978 EXPECT_NE(imagefilterWithCrop2, nullptr);
1979 OH_Drawing_ImageFilterDestroy(imagefilter);
1980 OH_Drawing_ImageFilterDestroy(imagefilterWithCrop1);
1981 OH_Drawing_ImageFilterDestroy(imagefilterWithCrop2);
1982 OH_Drawing_RectDestroy(rect);
1983 }
1984
1985 /*
1986 * @tc.name: NativeDrawingCanvasTest_CanvasDrawRecordCmd001
1987 * @tc.desc: test for OH_Drawing_CanvasDrawRecordCmd.
1988 * @tc.type: FUNC
1989 * @tc.require: AR000GTO5R
1990 */
1991 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_CanvasDrawRecordCmd001, TestSize.Level1)
1992 {
1993 int32_t width = 10; // canvas width is 10
1994 int32_t height = 20; // canvas width is 20
1995 OH_Drawing_Canvas* canvas = nullptr;
1996 OH_Drawing_RecordCmdUtils* recordCmdUtils = OH_Drawing_RecordCmdUtilsCreate();
1997 EXPECT_TRUE(recordCmdUtils != nullptr);
1998 OH_Drawing_ErrorCode code = OH_Drawing_RecordCmdUtilsBeginRecording(recordCmdUtils, width, height, &canvas);
1999 EXPECT_TRUE(canvas != nullptr);
2000 EXPECT_EQ(code, OH_DRAWING_SUCCESS);
2001 int32_t width1 = OH_Drawing_CanvasGetWidth(canvas);
2002 int32_t height2 = OH_Drawing_CanvasGetHeight(canvas);
2003 EXPECT_TRUE(width1 == width);
2004 EXPECT_TRUE(height2 == height);
2005 OH_Drawing_RecordCmd* recordCmd = nullptr;
2006 code = OH_Drawing_RecordCmdUtilsFinishRecording(recordCmdUtils, &recordCmd);
2007 EXPECT_TRUE(recordCmd != nullptr);
2008 EXPECT_EQ(code, OH_DRAWING_SUCCESS);
2009 OH_Drawing_Canvas* recordCanvas = OH_Drawing_CanvasCreate();
2010 EXPECT_TRUE(recordCanvas != nullptr);
2011 code = OH_Drawing_CanvasDrawRecordCmd(recordCanvas, recordCmd);
2012 EXPECT_EQ(code, OH_DRAWING_SUCCESS);
2013 code = OH_Drawing_CanvasDrawRecordCmd(nullptr, recordCmd);
2014 EXPECT_EQ(code, OH_DRAWING_ERROR_INVALID_PARAMETER);
2015 code = OH_Drawing_CanvasDrawRecordCmd(recordCanvas, nullptr);
2016 EXPECT_EQ(code, OH_DRAWING_ERROR_INVALID_PARAMETER);
2017 code = OH_Drawing_CanvasDrawRecordCmd(nullptr, nullptr);
2018 EXPECT_EQ(code, OH_DRAWING_ERROR_INVALID_PARAMETER);
2019 code = OH_Drawing_RecordCmdDestroy(recordCmd);
2020 EXPECT_EQ(code, OH_DRAWING_SUCCESS);
2021 code = OH_Drawing_RecordCmdUtilsDestroy(recordCmdUtils);
2022 EXPECT_EQ(code, OH_DRAWING_SUCCESS);
2023 OH_Drawing_CanvasDestroy(recordCanvas);
2024 }
2025
2026 /*
2027 * @tc.name: NativeDrawingCanvasTest_CanvasDrawRecordCmdNesting001
2028 * @tc.desc: test for OH_Drawing_CanvasDrawRecordCmdNesting.
2029 * @tc.type: FUNC
2030 * @tc.require: AR000GTO5R
2031 */
2032 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_CanvasDrawRecordCmdNesting001, TestSize.Level1)
2033 {
2034 int32_t width = 10; // canvas width is 10
2035 int32_t height = 20; // canvas width is 20
2036 OH_Drawing_Canvas* recordCanvas1 = nullptr;
2037 OH_Drawing_RecordCmdUtils* recordCmdUtils1 = OH_Drawing_RecordCmdUtilsCreate();
2038 EXPECT_TRUE(recordCmdUtils1 != nullptr);
2039 OH_Drawing_ErrorCode code = OH_Drawing_RecordCmdUtilsBeginRecording(recordCmdUtils1, width, height, &recordCanvas1);
2040 EXPECT_TRUE(recordCanvas1 != nullptr);
2041 EXPECT_EQ(code, OH_DRAWING_SUCCESS);
2042 OH_Drawing_CanvasDrawLine(recordCanvas1, 0, 0, static_cast<float>(width), static_cast<float>(height));
2043 OH_Drawing_RecordCmd* recordCmd1 = nullptr;
2044 code = OH_Drawing_RecordCmdUtilsFinishRecording(recordCmdUtils1, &recordCmd1);
2045 EXPECT_TRUE(recordCmd1 != nullptr);
2046 EXPECT_EQ(code, OH_DRAWING_SUCCESS);
2047 OH_Drawing_RecordCmdUtilsDestroy(recordCmdUtils1);
2048
2049 OH_Drawing_Canvas* recordCanvas2 = nullptr;
2050 OH_Drawing_RecordCmdUtils* recordCmdUtils2 = OH_Drawing_RecordCmdUtilsCreate();
2051 EXPECT_TRUE(recordCmdUtils2 != nullptr);
2052 code = OH_Drawing_RecordCmdUtilsBeginRecording(recordCmdUtils2, width, height, &recordCanvas2);
2053 EXPECT_TRUE(recordCanvas2 != nullptr);
2054 EXPECT_EQ(code, OH_DRAWING_SUCCESS);
2055 OH_Drawing_CanvasDrawLine(recordCanvas2, static_cast<float>(width), 0, 0, static_cast<float>(height));
2056 code = OH_Drawing_CanvasDrawRecordCmdNesting(recordCanvas2, recordCmd1);
2057 EXPECT_EQ(code, OH_DRAWING_SUCCESS);
2058 OH_Drawing_RecordCmd* recordCmd2 = nullptr;
2059 code = OH_Drawing_RecordCmdUtilsFinishRecording(recordCmdUtils2, &recordCmd2);
2060 EXPECT_TRUE(recordCmd2 != nullptr);
2061 EXPECT_EQ(code, OH_DRAWING_SUCCESS);
2062 OH_Drawing_RecordCmdUtilsDestroy(recordCmdUtils2);
2063 // test exception
2064 OH_Drawing_Canvas* recordCanvas = OH_Drawing_CanvasCreate();
2065 EXPECT_TRUE(recordCanvas != nullptr);
2066 code = OH_Drawing_CanvasDrawRecordCmdNesting(recordCanvas, recordCmd1);
2067 EXPECT_EQ(code, OH_DRAWING_SUCCESS);
2068 code = OH_Drawing_CanvasDrawRecordCmdNesting(nullptr, recordCmd1);
2069 EXPECT_EQ(code, OH_DRAWING_ERROR_INVALID_PARAMETER);
2070 code = OH_Drawing_CanvasDrawRecordCmdNesting(recordCanvas, nullptr);
2071 EXPECT_EQ(code, OH_DRAWING_ERROR_INVALID_PARAMETER);
2072 code = OH_Drawing_CanvasDrawRecordCmdNesting(nullptr, nullptr);
2073 EXPECT_EQ(code, OH_DRAWING_ERROR_INVALID_PARAMETER);
2074
2075 OH_Drawing_CanvasDestroy(recordCanvas);
2076 OH_Drawing_RecordCmdDestroy(recordCmd1);
2077 OH_Drawing_RecordCmdDestroy(recordCmd2);
2078 }
2079
2080 /*
2081 * @tc.name: NativeDrawingCanvasTest_CanvasDrawRecordCmdNesting002
2082 * @tc.desc: test for OH_Drawing_CanvasDrawRecordCmdNesting.
2083 * @tc.type: FUNC
2084 * @tc.require: AR000GTO5R
2085 */
2086 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_CanvasDrawRecordCmdNesting002, TestSize.Level1)
2087 {
2088 int32_t width = 10; // canvas width is 10
2089 int32_t height = 20; // canvas width is 20
2090 OH_Drawing_Canvas* recordCanvas1 = nullptr;
2091 OH_Drawing_RecordCmdUtils* recordCmdUtils1 = OH_Drawing_RecordCmdUtilsCreate();
2092 EXPECT_TRUE(recordCmdUtils1 != nullptr);
2093 OH_Drawing_ErrorCode code = OH_Drawing_RecordCmdUtilsBeginRecording(recordCmdUtils1, width, height, &recordCanvas1);
2094 EXPECT_TRUE(recordCanvas1 != nullptr);
2095 EXPECT_EQ(code, OH_DRAWING_SUCCESS);
2096 OH_Drawing_CanvasDrawLine(recordCanvas1, 0, 0, static_cast<float>(width), static_cast<float>(height));
2097 OH_Drawing_RecordCmd* recordCmd1 = nullptr;
2098 code = OH_Drawing_RecordCmdUtilsFinishRecording(recordCmdUtils1, &recordCmd1);
2099 EXPECT_TRUE(recordCmd1 != nullptr);
2100 EXPECT_EQ(code, OH_DRAWING_SUCCESS);
2101 OH_Drawing_RecordCmdUtilsDestroy(recordCmdUtils1);
2102
2103 OH_Drawing_Canvas* recordCanvas2 = nullptr;
2104 OH_Drawing_RecordCmdUtils* recordCmdUtils2 = OH_Drawing_RecordCmdUtilsCreate();
2105 EXPECT_TRUE(recordCmdUtils2 != nullptr);
2106 code = OH_Drawing_RecordCmdUtilsBeginRecording(recordCmdUtils2, width, height, &recordCanvas2);
2107 EXPECT_TRUE(recordCanvas2 != nullptr);
2108 EXPECT_EQ(code, OH_DRAWING_SUCCESS);
2109 OH_Drawing_CanvasDrawLine(recordCanvas2, static_cast<float>(width), 0, 0, static_cast<float>(height));
2110 code = OH_Drawing_CanvasDrawRecordCmdNesting(recordCanvas2, recordCmd1);
2111 EXPECT_EQ(code, OH_DRAWING_SUCCESS);
2112 OH_Drawing_RecordCmd* recordCmd2 = nullptr;
2113 // test beginRecording repeatedly
2114 code = OH_Drawing_RecordCmdUtilsBeginRecording(recordCmdUtils2, width, height, &recordCanvas2);
2115 EXPECT_EQ(code, OH_DRAWING_SUCCESS);
2116 code = OH_Drawing_CanvasDrawRecordCmdNesting(recordCanvas2, recordCmd1);
2117 EXPECT_EQ(code, OH_DRAWING_SUCCESS);
2118 // test DrawRecordCmdNesting repeatedly
2119 code = OH_Drawing_CanvasDrawRecordCmdNesting(recordCanvas2, recordCmd1);
2120 EXPECT_EQ(code, OH_DRAWING_SUCCESS);
2121 // test DrawRecordCmdNesting and DrawRecordCmdNest
2122 code = OH_Drawing_CanvasDrawRecordCmd(recordCanvas2, recordCmd1);
2123 EXPECT_EQ(code, OH_DRAWING_SUCCESS);
2124 OH_Drawing_RecordCmdDestroy(recordCmd1);
2125 code = OH_Drawing_RecordCmdUtilsFinishRecording(recordCmdUtils2, &recordCmd2);
2126 EXPECT_TRUE(recordCmd2 != nullptr);
2127 EXPECT_EQ(code, OH_DRAWING_SUCCESS);
2128 OH_Drawing_RecordCmdUtilsDestroy(recordCmdUtils2);
2129 OH_Drawing_RecordCmdDestroy(recordCmd2);
2130 }
2131
2132 /*
2133 * @tc.name: NativeDrawingCanvasTest_ImageFilterCreateOffsetImageFilter001
2134 * @tc.desc: test for creates an OH_Drawing_ImageFilter object that instance with the provided x and y offset.
2135 * @tc.type: FUNC
2136 * @tc.require: IAYWTV
2137 */
2138 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_ImageFilterCreateOffset001, TestSize.Level1)
2139 {
2140 OH_Drawing_ImageFilter* cInput = nullptr;
2141 float dx = 0.f;
2142 float dy = 0.f;
2143
2144 OH_Drawing_ImageFilter* imagefilterTest1 =
2145 OH_Drawing_ImageFilterCreateOffset(dx, dy, cInput);
2146 EXPECT_TRUE(imagefilterTest1 != nullptr);
2147
2148 float sifmaX = 10.0f;
2149 float sigmaY = 10.0f;
2150 cInput = OH_Drawing_ImageFilterCreateBlur(sifmaX, sigmaY, CLAMP, nullptr);
2151 EXPECT_TRUE(cInput != nullptr);
2152 OH_Drawing_ImageFilter* imagefilterTest2 =
2153 OH_Drawing_ImageFilterCreateOffset(dx, dy, cInput);
2154 EXPECT_TRUE(imagefilterTest2 != nullptr);
2155
2156 OH_Drawing_ImageFilterDestroy(cInput);
2157 OH_Drawing_ImageFilterDestroy(imagefilterTest1);
2158 OH_Drawing_ImageFilterDestroy(imagefilterTest2);
2159 }
2160
2161 /*
2162 * @tc.name: NativeDrawingCanvasTest_ImageFilterCreateShaderImageFilter001
2163 * @tc.desc: test for creates an OH_Drawing_ImageFilter object that renders the contents of the input Shader.
2164 * @tc.type: FUNC
2165 * @tc.require: IAYWTV
2166 */
2167 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_ImageFilterCreateShaderImageFilter001, TestSize.Level1)
2168 {
2169 OH_Drawing_ShaderEffect* cShader = nullptr;
2170 OH_Drawing_ImageFilter* imagefilterTest1 = OH_Drawing_ImageFilterCreateFromShaderEffect(cShader);
2171 EXPECT_TRUE(imagefilterTest1 == nullptr);
2172 uint32_t color = 1;
2173 cShader = OH_Drawing_ShaderEffectCreateColorShader(color);
2174 EXPECT_TRUE(cShader != nullptr);
2175 OH_Drawing_ImageFilter* imagefilterTest2 = OH_Drawing_ImageFilterCreateFromShaderEffect(cShader);
2176 EXPECT_TRUE(imagefilterTest2 != nullptr);
2177
2178 OH_Drawing_ShaderEffectDestroy(cShader);
2179 OH_Drawing_ImageFilterDestroy(imagefilterTest1);
2180 OH_Drawing_ImageFilterDestroy(imagefilterTest2);
2181 }
2182
2183 /*
2184 * @tc.name: NativeDrawingCanvasTest_ColorFilterCreateLighting001
2185 * @tc.desc: test for colorfilter create lighting.
2186 * @tc.type: FUNC
2187 * @tc.require: IAYWTV
2188 */
2189 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_ColorFilterCreateLighting001, TestSize.Level1)
2190 {
2191 OH_Drawing_ColorFilter* colorFilter = OH_Drawing_ColorFilterCreateLighting(0xff0000ff, 0xff000001);
2192 EXPECT_NE(colorFilter, nullptr);
2193 OH_Drawing_ColorFilter* colorFilterTmp = OH_Drawing_ColorFilterCreateLinearToSrgbGamma();
2194 EXPECT_NE(colorFilterTmp, nullptr);
2195 OH_Drawing_Filter* filter = OH_Drawing_FilterCreate();
2196 EXPECT_NE(filter, nullptr);
2197
2198 OH_Drawing_FilterSetColorFilter(nullptr, colorFilter);
2199 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER);
2200 OH_Drawing_FilterSetColorFilter(filter, nullptr);
2201 OH_Drawing_FilterGetColorFilter(filter, colorFilterTmp);
2202 NativeHandle<ColorFilter>* colorFilterHandle = Helper::CastTo<OH_Drawing_ColorFilter*,
2203 NativeHandle<ColorFilter>*>(colorFilterTmp);
2204 EXPECT_NE(colorFilterHandle, nullptr);
2205 EXPECT_NE(colorFilterHandle->value, nullptr);
2206 EXPECT_EQ(colorFilterHandle->value->GetType(), ColorFilter::FilterType::NO_TYPE);
2207
2208 OH_Drawing_FilterSetColorFilter(filter, colorFilter);
2209 OH_Drawing_FilterGetColorFilter(filter, colorFilterTmp);
2210 NativeHandle<ColorFilter>* colorFilterHandleT = Helper::CastTo<OH_Drawing_ColorFilter*,
2211 NativeHandle<ColorFilter>*>(colorFilterTmp);
2212 EXPECT_NE(colorFilterHandleT, nullptr);
2213 EXPECT_NE(colorFilterHandleT->value, nullptr);
2214 EXPECT_EQ(colorFilterHandleT->value->GetType(), ColorFilter::FilterType::LIGHTING);
2215
2216 OH_Drawing_BrushSetFilter(brush_, nullptr);
2217 OH_Drawing_BrushSetFilter(brush_, filter);
2218 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0, 0, 100, 100);
2219 OH_Drawing_CanvasDrawRect(canvas_, rect);
2220 }
2221
2222 /*
2223 * @tc.name: NativeDrawingCanvasTest_CanvasCreateWithPixelMap001
2224 * @tc.desc: test for OH_Drawing_CanvasCreateWithPixelMap.
2225 * @tc.type: FUNC
2226 * @tc.require: IBHFF5
2227 */
2228 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_CanvasCreateWithPixelMap001, TestSize.Level1)
2229 {
2230 OH_Pixelmap_InitializationOptions *options = nullptr;
2231 OH_PixelmapInitializationOptions_Create(&options);
2232 EXPECT_NE(options, nullptr);
2233
2234 // 1 means width
2235 OH_PixelmapInitializationOptions_SetWidth(options, 1);
2236 // 1 means height
2237 OH_PixelmapInitializationOptions_SetHeight(options, 1);
2238 // 3 means RGBA format
2239 OH_PixelmapInitializationOptions_SetPixelFormat(options, 3);
2240 // 2 means ALPHA_FORMAT_PREMUL format
2241 OH_PixelmapInitializationOptions_SetAlphaType(options, 2);
2242 // 4 means data length
2243 size_t bufferSize = 4;
2244 void *buffer = malloc(bufferSize);
2245 EXPECT_NE(buffer, nullptr);
2246
2247 OH_PixelmapNative *pixelMap = nullptr;
2248 OH_PixelmapNative_CreatePixelmap(static_cast<uint8_t *>(buffer), bufferSize, options, &pixelMap);
2249 EXPECT_NE(pixelMap, nullptr);
2250 OH_Drawing_PixelMap *drPixelMap = OH_Drawing_PixelMapGetFromOhPixelMapNative(pixelMap);
2251 EXPECT_NE(drPixelMap, nullptr);
2252
2253 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreateWithPixelMap(nullptr);
2254 EXPECT_EQ(canvas, nullptr);
2255 canvas = OH_Drawing_CanvasCreateWithPixelMap(drPixelMap);
2256 EXPECT_NE(canvas, nullptr);
2257
2258 OH_Drawing_CanvasDestroy(canvas);
2259 OH_Drawing_PixelMapDissolve(drPixelMap);
2260 OH_PixelmapNative_Release(pixelMap);
2261 OH_PixelmapInitializationOptions_Release(options);
2262 free(buffer);
2263 }
2264
2265 /*
2266 * @tc.name: NativeDrawingCanvasTest_DrawSingleCharacterWithFeatures001
2267 * @tc.desc: test for draw single character with Features
2268 * @tc.type: FUNC
2269 * @tc.require: ICG6L3
2270 */
2271 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_DrawSingleCharacterWithFeatures001, TestSize.Level1)
2272 {
2273 const char* strOne = "a";
2274 const char* strTwo = "你好";
2275 const char* strThree = "";
2276 float x = 0.f;
2277 float y = 0.f;
2278 OH_Drawing_FontFeatures* featuresEmpty = OH_Drawing_FontFeaturesCreate();
2279 EXPECT_NE(featuresEmpty, nullptr);
2280 OH_Drawing_FontFeatures* featuresOne = OH_Drawing_FontFeaturesCreate();
2281 EXPECT_NE(featuresOne, nullptr);
2282 OH_Drawing_ErrorCode ret = OH_Drawing_FontFeaturesAddFeature(featuresOne, "ccmp", 0);
2283 EXPECT_EQ(ret, OH_DRAWING_SUCCESS);
2284 OH_Drawing_FontFeatures* featuresTwo = OH_Drawing_FontFeaturesCreate();
2285 EXPECT_NE(featuresTwo, nullptr);
2286 ret = OH_Drawing_FontFeaturesAddFeature(featuresTwo, "cc", 0);
2287 OH_Drawing_Font *font = OH_Drawing_FontCreate();
2288 EXPECT_NE(font, nullptr);
2289 OH_Drawing_Font *fontWithTypeface = OH_Drawing_FontCreate();
2290 EXPECT_NE(fontWithTypeface, nullptr);
2291 OH_Drawing_Typeface* typeface = OH_Drawing_TypefaceCreateFromFile("/system/fonts/HarmonyOS_Sans.ttf", 0);
2292 EXPECT_NE(typeface, nullptr);
2293 OH_Drawing_FontSetTypeface(fontWithTypeface, typeface);
2294
2295 EXPECT_EQ(OH_Drawing_CanvasDrawSingleCharacterWithFeatures(canvas_, strOne, font, x, y, featuresEmpty),
2296 OH_DRAWING_SUCCESS);
2297 OH_Drawing_FontSetSubpixel(font, true);
2298 EXPECT_EQ(OH_Drawing_CanvasDrawSingleCharacterWithFeatures(canvas_, strTwo, font, x, y, featuresEmpty),
2299 OH_DRAWING_SUCCESS);
2300 EXPECT_EQ(OH_Drawing_CanvasDrawSingleCharacterWithFeatures(canvas_, strTwo, font, x, y, featuresOne),
2301 OH_DRAWING_SUCCESS);
2302 EXPECT_EQ(OH_Drawing_CanvasDrawSingleCharacterWithFeatures(canvas_, strTwo, font, x, y, featuresTwo),
2303 OH_DRAWING_SUCCESS);
2304 EXPECT_EQ(OH_Drawing_CanvasDrawSingleCharacterWithFeatures(canvas_, strTwo, fontWithTypeface, x, y,
2305 featuresEmpty), OH_DRAWING_SUCCESS);
2306 EXPECT_EQ(OH_Drawing_CanvasDrawSingleCharacterWithFeatures(nullptr, strOne, font, x, y, featuresEmpty),
2307 OH_DRAWING_ERROR_INVALID_PARAMETER);
2308 EXPECT_EQ(OH_Drawing_CanvasDrawSingleCharacterWithFeatures(canvas_, nullptr, font, x, y, featuresEmpty),
2309 OH_DRAWING_ERROR_INVALID_PARAMETER);
2310 EXPECT_EQ(OH_Drawing_CanvasDrawSingleCharacterWithFeatures(canvas_, strOne, nullptr, x, y, featuresEmpty),
2311 OH_DRAWING_ERROR_INVALID_PARAMETER);
2312 EXPECT_EQ(OH_Drawing_CanvasDrawSingleCharacterWithFeatures(canvas_, strOne, font, x, y, nullptr),
2313 OH_DRAWING_ERROR_INVALID_PARAMETER);
2314 EXPECT_EQ(OH_Drawing_CanvasDrawSingleCharacterWithFeatures(canvas_, strThree, font, x, y, featuresEmpty),
2315 OH_DRAWING_ERROR_INVALID_PARAMETER);
2316
2317 OH_Drawing_FontDestroy(font);
2318 OH_Drawing_FontFeaturesDestroy(featuresOne);
2319 OH_Drawing_FontFeaturesDestroy(featuresTwo);
2320 OH_Drawing_FontFeaturesDestroy(featuresEmpty);
2321 }
2322
2323 /*
2324 * @tc.name: NativeDrawingCanvasTest_DrawSingleCharacterWithFeatures001
2325 * @tc.desc: test for draw single character with Features with canvas pixelmap
2326 * @tc.type: FUNC
2327 * @tc.require: ICG6L3
2328 */
2329 HWTEST_F(NativeDrawingCanvasTest, NativeDrawingCanvasTest_DrawSingleCharacterWithFeatures002, TestSize.Level1)
2330 {
2331 OH_Pixelmap_InitializationOptions *options = nullptr;
2332 OH_PixelmapInitializationOptions_Create(&options);
2333 EXPECT_NE(options, nullptr);
2334 OH_PixelmapInitializationOptions_SetWidth(options, 1);
2335 OH_PixelmapInitializationOptions_SetHeight(options, 1);
2336 size_t bufferSize = 4;
2337 void *buffer = malloc(bufferSize);
2338 EXPECT_NE(buffer, nullptr);
2339 OH_PixelmapNative *pixelMap = nullptr;
2340 OH_PixelmapNative_CreatePixelmap(static_cast<uint8_t *>(buffer), bufferSize, options, &pixelMap);
2341 EXPECT_NE(pixelMap, nullptr);
2342 OH_Drawing_PixelMap *drPixelMap = OH_Drawing_PixelMapGetFromOhPixelMapNative(pixelMap);
2343 EXPECT_NE(drPixelMap, nullptr);
2344 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreateWithPixelMap(drPixelMap);
2345 EXPECT_NE(canvas, nullptr);
2346 OH_Drawing_Font *font = OH_Drawing_FontCreate();
2347 EXPECT_NE(font, nullptr);
2348 OH_Drawing_FontFeatures* featuresEmpty = OH_Drawing_FontFeaturesCreate();
2349 EXPECT_NE(featuresEmpty, nullptr);
2350
2351 EXPECT_EQ(OH_Drawing_CanvasDrawSingleCharacterWithFeatures(canvas, "\uE000", font, 0.f, 0.f, featuresEmpty),
2352 OH_DRAWING_SUCCESS);
2353
2354 OH_Drawing_FontFeaturesDestroy(featuresEmpty);
2355 OH_Drawing_FontDestroy(font);
2356 OH_Drawing_CanvasDestroy(canvas);
2357 OH_Drawing_PixelMapDissolve(drPixelMap);
2358 OH_PixelmapNative_Release(pixelMap);
2359 free(buffer);
2360 OH_PixelmapInitializationOptions_Release(options);
2361 }
2362 } // namespace Drawing
2363 } // namespace Rosen
2364 } // namespace OHOS
2365