1 /*
2 * Copyright (c) 2024 Shenzhen Kaihong Digital Industry Development Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "DrawingNativeCanvasCommon.h"
17 #include "drawing_bitmap.h"
18 #include "drawing_brush.h"
19 #include "drawing_canvas.h"
20 #include "drawing_color.h"
21 #include "drawing_color_filter.h"
22 #include "drawing_error_code.h"
23 #include "drawing_filter.h"
24 #include "drawing_font.h"
25 #include "drawing_image.h"
26 #include "drawing_mask_filter.h"
27 #include "drawing_matrix.h"
28 #include "drawing_memory_stream.h"
29 #include "drawing_path.h"
30 #include "drawing_pen.h"
31 #include "drawing_pixel_map.h"
32 #include "drawing_point.h"
33 #include "drawing_rect.h"
34 #include "drawing_region.h"
35 #include "drawing_round_rect.h"
36 #include "drawing_sampling_options.h"
37 #include "drawing_shader_effect.h"
38 #include "drawing_text_blob.h"
39 #include "drawing_typeface.h"
40 #include "image/pixelmap_native.h"
41 #include "gtest/gtest.h"
42
43 using namespace testing;
44 using namespace testing::ext;
45
46 namespace OHOS {
47 namespace Rosen {
48 namespace Drawing {
49 /*
50 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_1100
51 * @tc.name: testCanvasDrawPixelMapRectNormal
52 * @tc.desc: test for testCanvasDrawPixelMapRectNormal.
53 * @tc.size : SmallTest
54 * @tc.type : Function
55 * @tc.level : Level 0
56 */
HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawPixelMapRectNormal, TestSize.Level0)57 HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawPixelMapRectNormal, TestSize.Level0)
58 {
59 // 1. OH_Drawing_CanvasCreate
60 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate();
61 EXPECT_NE(canvas, nullptr);
62
63 // 2. Obtain OH_Drawing_PixelMap from OH_Drawing_PixelMapGetFromNativePixelMap()
64
65 // 3. Create src and dst using OH_Drawing_RectCreate
66 OH_Drawing_Rect *src = OH_Drawing_RectCreate(0, 0, 100, 100);
67 EXPECT_NE(src, nullptr);
68 OH_Drawing_Rect *dst = OH_Drawing_RectCreate(0, 0, 100, 100);
69 EXPECT_NE(dst, nullptr);
70
71 // 4. Obtain OH_Drawing_PixelMap from OH_Drawing_PixelMapGetFromOhPixelMapNative
72 OH_PixelmapNative *pixelMap = GET_OH_PixelmapNative();
73 OH_Drawing_PixelMap *drPixelMap = OH_Drawing_PixelMapGetFromOhPixelMapNative(pixelMap);
74 EXPECT_NE(drPixelMap, nullptr);
75
76 // 5. Iterate through OH_Drawing_FilterMode and OH_Drawing_MipmapMode to construct OH_Drawing_SamplingOptions for
77 OH_Drawing_FilterMode filterMode[] = {FILTER_MODE_NEAREST, FILTER_MODE_LINEAR};
78 OH_Drawing_MipmapMode mode[] = {MIPMAP_MODE_NEAREST, MIPMAP_MODE_LINEAR, MIPMAP_MODE_NONE};
79 for (int i = 0; i < 2; i++) {
80 for (int j = 0; j < 3; j++) {
81 OH_Drawing_SamplingOptions *options = OH_Drawing_SamplingOptionsCreate(filterMode[i], mode[j]);
82 OH_Drawing_CanvasDrawPixelMapRect(canvas, drPixelMap, src, dst, options);
83 }
84 }
85
86 // 6. Free the memory.
87 OH_Drawing_PixelMapDissolve(drPixelMap);
88 OH_Drawing_RectDestroy(src);
89 OH_Drawing_RectDestroy(dst);
90 OH_Drawing_CanvasDestroy(canvas);
91 }
92
93 /*
94 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_1101
95 * @tc.name: testCanvasDrawPixelMapRectNull
96 * @tc.desc: test for testCanvasDrawPixelMapRectNull.
97 * @tc.size : SmallTest
98 * @tc.type : Function
99 * @tc.level : Level 3
100 */
HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawPixelMapRectNull, TestSize.Level3)101 HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawPixelMapRectNull, TestSize.Level3)
102 {
103 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate();
104 EXPECT_NE(canvas, nullptr);
105 OH_PixelmapNative *pixelMap = GET_OH_PixelmapNative();
106 OH_Drawing_PixelMap *drPixelMap = OH_Drawing_PixelMapGetFromOhPixelMapNative(pixelMap);
107 EXPECT_NE(drPixelMap, nullptr);
108 OH_Drawing_Rect *src = OH_Drawing_RectCreate(0, 0, 100, 100);
109 EXPECT_NE(src, nullptr);
110 OH_Drawing_Rect *dst = OH_Drawing_RectCreate(0, 0, 100, 100);
111 EXPECT_NE(dst, nullptr);
112 OH_Drawing_SamplingOptions *sampleOptions =
113 OH_Drawing_SamplingOptionsCreate(FILTER_MODE_NEAREST, MIPMAP_MODE_NEAREST);
114
115 OH_Drawing_CanvasDrawPixelMapRect(nullptr, drPixelMap, src, dst, sampleOptions);
116 OH_Drawing_CanvasDrawPixelMapRect(canvas, nullptr, src, dst, sampleOptions);
117 OH_Drawing_CanvasDrawPixelMapRect(canvas, drPixelMap, nullptr, dst, sampleOptions);
118 OH_Drawing_CanvasDrawPixelMapRect(canvas, drPixelMap, src, nullptr, sampleOptions);
119 OH_Drawing_CanvasDrawPixelMapRect(canvas, drPixelMap, src, dst, nullptr);
120 OH_Drawing_PixelMapGetFromNativePixelMap(nullptr);
121
122 float rectParams[][4] = {
123 {0, 1, 1, 1}, {1, 0, 1, 1}, {1, 1, 0, 1}, {1, 1, 1, 0}, {0, 0, 0, 0},
124 };
125 for (int i = 0; i < sizeof(rectParams) / sizeof(rectParams[0]); ++i) {
126 OH_Drawing_Rect *src =
127 OH_Drawing_RectCreate(rectParams[i][0], rectParams[i][1], rectParams[i][2], rectParams[i][3]);
128 OH_Drawing_CanvasDrawPixelMapRect(canvas, drPixelMap, src, dst, sampleOptions);
129
130 OH_Drawing_Rect *dst =
131 OH_Drawing_RectCreate(rectParams[i][0], rectParams[i][1], rectParams[i][2], rectParams[i][3]);
132 OH_Drawing_CanvasDrawPixelMapRect(canvas, drPixelMap, src, dst, sampleOptions);
133
134 OH_Drawing_RectDestroy(src);
135 OH_Drawing_RectDestroy(dst);
136 }
137
138 OH_Drawing_RectDestroy(src);
139 OH_Drawing_RectDestroy(dst);
140 OH_Drawing_SamplingOptionsDestroy(sampleOptions);
141 OH_Drawing_PixelMapDissolve(drPixelMap);
142 OH_Drawing_CanvasDestroy(canvas);
143 }
144
145 /*
146 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_1102
147 * @tc.name: testCanvasDrawPixelMapRectAbnormal
148 * @tc.desc: test for testCanvasDrawPixelMapRectAbnormal.
149 * @tc.size : SmallTest
150 * @tc.type : Function
151 * @tc.level : Level 3
152 */
HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawPixelMapRectAbnormal, TestSize.Level3)153 HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawPixelMapRectAbnormal, TestSize.Level3)
154 {
155 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate();
156 OH_PixelmapNative *pixelMap = GET_OH_PixelmapNative();
157 OH_Drawing_PixelMap *drPixelMap = OH_Drawing_PixelMapGetFromOhPixelMapNative(pixelMap);
158 EXPECT_NE(drPixelMap, nullptr);
159 OH_Drawing_Rect *src = OH_Drawing_RectCreate(0, 0, 100, 100);
160 EXPECT_NE(src, nullptr);
161 OH_Drawing_Rect *dst = OH_Drawing_RectCreate(0, 0, 100, 100);
162 EXPECT_NE(dst, nullptr);
163 OH_Drawing_SamplingOptions *sampleOptions =
164 OH_Drawing_SamplingOptionsCreate(FILTER_MODE_NEAREST, MIPMAP_MODE_NEAREST);
165 OH_Drawing_CanvasDrawPixelMapRect(nullptr, drPixelMap, src, dst, sampleOptions);
166 OH_Drawing_CanvasDrawPixelMapRect(canvas, nullptr, src, dst, sampleOptions);
167 OH_Drawing_CanvasDrawPixelMapRect(canvas, drPixelMap, nullptr, dst, sampleOptions);
168 OH_Drawing_CanvasDrawPixelMapRect(canvas, drPixelMap, src, nullptr, sampleOptions);
169 OH_Drawing_CanvasDrawPixelMapRect(canvas, drPixelMap, src, dst, nullptr);
170 OH_Drawing_PixelMapGetFromNativePixelMap(nullptr);
171 OH_Drawing_RectDestroy(src);
172 OH_Drawing_RectDestroy(dst);
173 // Define parameter arrays for source and destination rectangles
174 int srcRects[][4] = {
175 {-1, 1, 1, 1}, {1, -1, 1, 1}, {1, 1, -1, 1}, {1, 1, 1, -1}, {100, 100, 100, 200},
176 {100, 200, 200, 200}, {100, 100, 100, 100}, {200, 200, 100, 100}, {0, 0, 100, 100},
177 };
178 // Loop to draw the first 7 src rectangles
179 for (int i = 0; i < 8; i++) {
180 src = OH_Drawing_RectCreate(srcRects[i][0], srcRects[i][1], srcRects[i][2], srcRects[i][3]);
181 OH_Drawing_CanvasDrawPixelMapRect(canvas, drPixelMap, src, dst, sampleOptions);
182 OH_Drawing_RectDestroy(src);
183 }
184 src = OH_Drawing_RectCreate(0, 0, 100, 100);
185 int dstRects[][4] = {
186 {100, 100, 100, 200},
187 {100, 200, 200, 200},
188 {100, 100, 100, 100},
189 {200, 200, 100, 100},
190 };
191 // Loop to draw all dst rectangles using the last src rectangle
192 for (int i = 0; i < 4; i++) {
193 dst = OH_Drawing_RectCreate(dstRects[i][0], dstRects[i][1], dstRects[i][2], dstRects[i][3]);
194 OH_Drawing_CanvasDrawPixelMapRect(canvas, drPixelMap, src, dst, sampleOptions);
195 OH_Drawing_RectDestroy(dst);
196 }
197 OH_Drawing_RectDestroy(src);
198 OH_Drawing_SamplingOptionsDestroy(sampleOptions);
199 OH_Drawing_PixelMapDissolve(drPixelMap);
200 OH_Drawing_CanvasDestroy(canvas);
201 }
202
203 /*
204 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_1103
205 * @tc.name: testCanvasDrawPixelMapRectMaximum
206 * @tc.desc: test for testCanvasDrawPixelMapRectMaximum.
207 * @tc.size : SmallTest
208 * @tc.type : Function
209 * @tc.level : Level 3
210 */
HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawPixelMapRectMaximum, TestSize.Level3)211 HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawPixelMapRectMaximum, TestSize.Level3)
212 {
213 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate();
214 EXPECT_NE(canvas, nullptr);
215
216 OH_PixelmapNative *pixelMap = GET_OH_PixelmapNative();
217 OH_Drawing_PixelMap *drPixelMap = OH_Drawing_PixelMapGetFromOhPixelMapNative(pixelMap);
218 EXPECT_NE(drPixelMap, nullptr);
219
220 OH_Drawing_Rect *src = OH_Drawing_RectCreate(0, 0, 100, 100);
221 EXPECT_NE(src, nullptr);
222 OH_Drawing_Rect *dst = OH_Drawing_RectCreate(0, 0, 100, 100);
223 EXPECT_NE(dst, nullptr);
224
225 OH_Drawing_SamplingOptions *sampleOptions =
226 OH_Drawing_SamplingOptionsCreate(FILTER_MODE_NEAREST, MIPMAP_MODE_NEAREST);
227 // 2
228 OH_Drawing_Rect *src1 = OH_Drawing_RectCreate(FLT_MAX, FLT_MAX, 100, 100);
229 OH_Drawing_CanvasDrawPixelMapRect(canvas, drPixelMap, src1, dst, sampleOptions);
230 // 3
231 OH_Drawing_Rect *src2 = OH_Drawing_RectCreate(0, 0, FLT_MAX, FLT_MAX);
232 OH_Drawing_CanvasDrawPixelMapRect(canvas, drPixelMap, src2, dst, sampleOptions);
233 // 4
234 OH_Drawing_Rect *dst1 = OH_Drawing_RectCreate(FLT_MAX, FLT_MAX, 100, 100);
235 OH_Drawing_CanvasDrawPixelMapRect(canvas, drPixelMap, src, dst1, sampleOptions);
236 // 5
237 OH_Drawing_Rect *dst2 = OH_Drawing_RectCreate(0, 0, FLT_MAX, FLT_MAX);
238 OH_Drawing_CanvasDrawPixelMapRect(canvas, drPixelMap, src, dst2, sampleOptions);
239 // 6
240 OH_Drawing_RectDestroy(src1);
241 OH_Drawing_RectDestroy(src2);
242 OH_Drawing_RectDestroy(dst1);
243 OH_Drawing_RectDestroy(dst2);
244 OH_Drawing_RectDestroy(src);
245 OH_Drawing_RectDestroy(dst);
246 OH_Drawing_SamplingOptionsDestroy(sampleOptions);
247 OH_Drawing_PixelMapDissolve(drPixelMap);
248 OH_Drawing_CanvasDestroy(canvas);
249 }
250
251 /*
252 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_1103
253 * @tc.name: testCanvasDrawPixelMapRect4KBoundary
254 * @tc.desc: test for testCanvasDrawPixelMapRect4KBoundary.
255 * @tc.size : SmallTest
256 * @tc.type : Function
257 * @tc.level : Level 3
258 */
HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawPixelMapRect4KBoundary, TestSize.Level3)259 HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawPixelMapRect4KBoundary, TestSize.Level3)
260 {
261 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate();
262 EXPECT_NE(canvas, nullptr);
263
264 OH_PixelmapNative *pixelMap = GET_OH_PixelmapNative4KBoundary();
265 OH_Drawing_PixelMap *drPixelMap = OH_Drawing_PixelMapGetFromOhPixelMapNative(pixelMap);
266 EXPECT_NE(drPixelMap, nullptr);
267
268 OH_Drawing_Rect *src = OH_Drawing_RectCreate(0, 0, 100, 100);
269 EXPECT_NE(src, nullptr);
270 OH_Drawing_Rect *dst = OH_Drawing_RectCreate(0, 0, 100, 100);
271 EXPECT_NE(dst, nullptr);
272
273 OH_Drawing_SamplingOptions *sampleOptions =
274 OH_Drawing_SamplingOptionsCreate(FILTER_MODE_NEAREST, MIPMAP_MODE_NEAREST);
275 // 2
276 OH_Drawing_Rect *src1 = OH_Drawing_RectCreate(FLT_MAX, FLT_MAX, 100, 100);
277 OH_Drawing_CanvasDrawPixelMapRect(canvas, drPixelMap, src1, dst, sampleOptions);
278 // 3
279 OH_Drawing_Rect *src2 = OH_Drawing_RectCreate(0, 0, FLT_MAX, FLT_MAX);
280 OH_Drawing_CanvasDrawPixelMapRect(canvas, drPixelMap, src2, dst, sampleOptions);
281 // 4
282 OH_Drawing_Rect *dst1 = OH_Drawing_RectCreate(FLT_MAX, FLT_MAX, 100, 100);
283 OH_Drawing_CanvasDrawPixelMapRect(canvas, drPixelMap, src, dst1, sampleOptions);
284 // 5
285 OH_Drawing_Rect *dst2 = OH_Drawing_RectCreate(0, 0, FLT_MAX, FLT_MAX);
286 OH_Drawing_CanvasDrawPixelMapRect(canvas, drPixelMap, src, dst2, sampleOptions);
287 // 6
288 OH_Drawing_RectDestroy(src1);
289 OH_Drawing_RectDestroy(src2);
290 OH_Drawing_RectDestroy(dst1);
291 OH_Drawing_RectDestroy(dst2);
292 OH_Drawing_RectDestroy(src);
293 OH_Drawing_RectDestroy(dst);
294 OH_Drawing_SamplingOptionsDestroy(sampleOptions);
295 OH_Drawing_PixelMapDissolve(drPixelMap);
296 OH_Drawing_CanvasDestroy(canvas);
297 }
298
299 /*
300 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_1104
301 * @tc.name: testCanvasDrawPixelMapRectInputDestroyed
302 * @tc.desc: test for testCanvasDrawPixelMapRectInputDestroyed.
303 * @tc.size : SmallTest
304 * @tc.type : Function
305 * @tc.level : Level 3
306 */
HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawPixelMapRectInputDestroyed, TestSize.Level3)307 HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawPixelMapRectInputDestroyed, TestSize.Level3)
308 {
309 // Deprecated
310 }
311
312 /*
313 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_1200
314 * @tc.name: testCanvasDrawBackgroundNormal
315 * @tc.desc: test for testCanvasDrawBackgroundNormal.
316 * @tc.size : SmallTest
317 * @tc.type : Function
318 * @tc.level : Level 0
319 */
HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawBackgroundNormal, TestSize.Level0)320 HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawBackgroundNormal, TestSize.Level0)
321 {
322 // 1. OH_Drawing_CanvasCreate
323 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate();
324 EXPECT_NE(canvas, nullptr);
325
326 // 2. OH_Drawing_BrushCreate
327 OH_Drawing_Brush *brush = OH_Drawing_BrushCreate();
328 EXPECT_NE(brush, nullptr);
329
330 // 3. OH_Drawing_CanvasDrawBackground
331 OH_Drawing_CanvasDrawBackground(canvas, brush);
332
333 // 4. Free the memory.
334 OH_Drawing_BrushDestroy(brush);
335 OH_Drawing_CanvasDestroy(canvas);
336 }
337
338 /*
339 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_1201
340 * @tc.name: testCanvasDrawBackgroundNull
341 * @tc.desc: test for testCanvasDrawBackgroundNull.
342 * @tc.size : SmallTest
343 * @tc.type : Function
344 * @tc.level : Level 3
345 */
HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawBackgroundNull, TestSize.Level3)346 HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawBackgroundNull, TestSize.Level3)
347 {
348 // 1. OH_Drawing_CanvasCreate
349 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate();
350 EXPECT_NE(canvas, nullptr);
351
352 // 2. OH_Drawing_BrushCreate
353 OH_Drawing_Brush *brush = OH_Drawing_BrushCreate();
354 EXPECT_NE(brush, nullptr);
355
356 // 3. Pass an empty value as the first argument for OH_Drawing_CanvasDrawBackground.
357 OH_Drawing_CanvasDrawBackground(nullptr, brush);
358
359 // 4. Pass an empty value as the second argument for OH_Drawing_CanvasDrawBackground.
360 OH_Drawing_CanvasDrawBackground(canvas, nullptr);
361
362 // 5. Free the memory.
363 OH_Drawing_BrushDestroy(brush);
364 OH_Drawing_CanvasDestroy(canvas);
365 }
366
367 /*
368 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_1202
369 * @tc.name: testCanvasDrawBackgroundInputDestroyed
370 * @tc.desc: test for testCanvasDrawBackgroundInputDestroyed.
371 * @tc.size : SmallTest
372 * @tc.type : Function
373 * @tc.level : Level 3
374 */
HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawBackgroundInputDestroyed, TestSize.Level3)375 HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawBackgroundInputDestroyed, TestSize.Level3)
376 {
377 // Deprecated
378 }
379
380 /*
381 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_1203
382 * @tc.name: testCanvasDrawBackgroundMultipleCalls
383 * @tc.desc: test for testCanvasDrawBackgroundMultipleCalls.
384 * @tc.size : SmallTest
385 * @tc.type : Function
386 * @tc.level : Level 3
387 */
HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawBackgroundMultipleCalls, TestSize.Level3)388 HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawBackgroundMultipleCalls, TestSize.Level3)
389 {
390 // 1. OH_Drawing_CanvasCreate
391 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate();
392 EXPECT_NE(canvas, nullptr);
393
394 // 2. OH_Drawing_BrushCreate
395 OH_Drawing_Brush *brush = OH_Drawing_BrushCreate();
396 EXPECT_NE(brush, nullptr);
397
398 // 3. OH_Drawing_CanvasDrawBackground, 10 times.
399 for (int i = 0; i < 10; i++) {
400 OH_Drawing_CanvasDrawBackground(canvas, brush);
401 }
402
403 // 4. Free the memory.
404 OH_Drawing_BrushDestroy(brush);
405 OH_Drawing_CanvasDestroy(canvas);
406 }
407
408 /*
409 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_1300
410 * @tc.name: testCanvasDrawRegionNormal
411 * @tc.desc: test for testCanvasDrawRegionNormal.
412 * @tc.size : SmallTest
413 * @tc.type : Function
414 * @tc.level : Level 0
415 */
HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawRegionNormal, TestSize.Level0)416 HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawRegionNormal, TestSize.Level0)
417 {
418 // 1. OH_Drawing_CanvasCreate
419 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate();
420 EXPECT_NE(canvas, nullptr);
421
422 // 2. OH_Drawing_RegionCreate
423 OH_Drawing_Region *region = OH_Drawing_RegionCreate();
424 EXPECT_NE(region, nullptr);
425
426 // 3. OH_Drawing_RegionSetRect
427 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0.0f, 0.0f, 256.0f, 256.0f);
428 OH_Drawing_RegionSetRect(region, rect);
429
430 // 4. OH_Drawing_CanvasDrawRegion
431 OH_Drawing_CanvasDrawRegion(canvas, region);
432
433 // 5. Free the memory.
434 OH_Drawing_RectDestroy(rect);
435 OH_Drawing_RegionDestroy(region);
436 OH_Drawing_CanvasDestroy(canvas);
437 }
438
439 /*
440 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_1301
441 * @tc.name: testCanvasDrawRegionNull
442 * @tc.desc: test for testCanvasDrawRegionNull.
443 * @tc.size : SmallTest
444 * @tc.type : Function
445 * @tc.level : Level 3
446 */
HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawRegionNull, TestSize.Level3)447 HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawRegionNull, TestSize.Level3)
448 {
449 // 1. OH_Drawing_CanvasCreate
450 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate();
451 EXPECT_NE(canvas, nullptr);
452
453 // 2. OH_Drawing_RegionCreate
454 OH_Drawing_Region *region = OH_Drawing_RegionCreate();
455 EXPECT_NE(region, nullptr);
456
457 // 3. OH_Drawing_CanvasDrawRegion, first parameter is nullptr
458 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0.0f, 0.0f, 256.0f, 256.0f);
459 OH_Drawing_RegionSetRect(region, rect);
460 OH_Drawing_CanvasDrawRegion(nullptr, region);
461
462 // 4. OH_Drawing_CanvasDrawRegion, second parameter is nullptr
463 OH_Drawing_CanvasDrawRegion(canvas, nullptr);
464
465 // 5. OH_Drawing_CanvasDrawRegion, region is empty
466 OH_Drawing_Region *region2 = OH_Drawing_RegionCreate();
467 OH_Drawing_CanvasDrawRegion(canvas, region2);
468
469 // 6. Free the memory.
470 OH_Drawing_RectDestroy(rect);
471 OH_Drawing_RegionDestroy(region);
472 OH_Drawing_RegionDestroy(region2);
473 OH_Drawing_CanvasDestroy(canvas);
474 }
475
476 /*
477 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_1302
478 * @tc.name: testCanvasDrawRegionInputDestroyed
479 * @tc.desc: test for testCanvasDrawRegionInputDestroyed.
480 * @tc.size : SmallTest
481 * @tc.type : Function
482 * @tc.level : Level 3
483 */
HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawRegionInputDestroyed, TestSize.Level3)484 HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawRegionInputDestroyed, TestSize.Level3)
485 {
486 // Deprecated
487 }
488
489 /*
490 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_1400
491 * @tc.name: testCanvasDrawPointsNormal
492 * @tc.desc: test for testCanvasDrawPointsNormal.
493 * @tc.size : SmallTest
494 * @tc.type : Function
495 * @tc.level : Level 0
496 */
HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawPointsNormal, TestSize.Level0)497 HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawPointsNormal, TestSize.Level0)
498 {
499 // 1. OH_Drawing_CanvasCreate
500 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate();
501 EXPECT_NE(canvas, nullptr);
502
503 // 2. OH_Drawing_Point2D creates an array of points.
504 OH_Drawing_Point2D point = {250, 500};
505 OH_Drawing_Point2D points1[1] = {point};
506
507 // 3. OH_Drawing_CanvasDrawPoints iterates through the enum values OH_Drawing_PointMode, with count set to the
508 // length of the corresponding value.
509 OH_Drawing_PointMode modeArray[3] = {POINT_MODE_POINTS, POINT_MODE_LINES, POINT_MODE_POLYGON};
510 for (int i = 0; i < 3; i++) {
511 OH_Drawing_CanvasDrawPoints(canvas, modeArray[i], 1, points1);
512 }
513
514 // 4. OH_Drawing_Point2D creates an array of multiple points.
515 OH_Drawing_Point2D pointOne = {250, 500};
516 OH_Drawing_Point2D pointTwo = {200, 500};
517 OH_Drawing_Point2D pointThree = {500, 700};
518 OH_Drawing_Point2D points2[3] = {pointOne, pointTwo, pointThree};
519
520 // 5. OH_Drawing_CanvasDrawPoints iterates through the enum values OH_Drawing_PointMode, with count set to the
521 // length of the corresponding value.
522 for (int i = 0; i < 3; i++) {
523 OH_Drawing_CanvasDrawPoints(canvas, modeArray[i], 3, points2);
524 }
525
526 // 6. Free the memory.
527 OH_Drawing_CanvasDestroy(canvas);
528 }
529
530 /*
531 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_1401
532 * @tc.name: testCanvasDrawPointsNull
533 * @tc.desc: test for testCanvasDrawPointsNull.
534 * @tc.size : SmallTest
535 * @tc.type : Function
536 * @tc.level : Level 3
537 */
HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawPointsNull, TestSize.Level3)538 HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawPointsNull, TestSize.Level3)
539 {
540 // 1. OH_Drawing_CanvasCreate
541 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate();
542 EXPECT_NE(canvas, nullptr);
543
544 OH_Drawing_Point2D pointOne = {250, 500};
545 OH_Drawing_Point2D pointTwo = {200, 500};
546 OH_Drawing_Point2D pointThree = {500, 700};
547 OH_Drawing_Point2D points[3] = {pointOne, pointTwo, pointThree};
548 OH_Drawing_Point2D pointsEmpty[0] = {};
549
550 // 2. Pass an empty value as the first argument for OH_Drawing_CanvasDrawPoints.
551 OH_Drawing_CanvasDrawPoints(nullptr, POINT_MODE_LINES, 3, points);
552
553 // 3. Set the third argument of OH_Drawing_CanvasDrawPoints to 0.
554 OH_Drawing_CanvasDrawPoints(canvas, POINT_MODE_LINES, 0, points);
555
556 // 4. Pass an empty array as the fourth argument for OH_Drawing_CanvasDrawPoints.
557 OH_Drawing_CanvasDrawPoints(canvas, POINT_MODE_LINES, 3, pointsEmpty);
558
559 // 5. Free the memory.
560 OH_Drawing_CanvasDestroy(canvas);
561 }
562
563 /*
564 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_1402
565 * @tc.name: testCanvasDrawPointsAbnormal
566 * @tc.desc: test for testCanvasDrawPointsAbnormal.
567 * @tc.size : SmallTest
568 * @tc.type : Function
569 * @tc.level : Level 3
570 */
HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawPointsAbnormal, TestSize.Level3)571 HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawPointsAbnormal, TestSize.Level3)
572 {
573 // 1. OH_Drawing_CanvasCreate
574 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate();
575 EXPECT_NE(canvas, nullptr);
576
577 // 2. Pass a negative value for the count parameter in OH_Drawing_CanvasDrawPoints.
578 OH_Drawing_Point2D pointOne = {250, 500};
579 OH_Drawing_Point2D pointTwo = {200, 500};
580 OH_Drawing_Point2D pointThree = {500, 700};
581 OH_Drawing_Point2D points[3] = {pointOne, pointTwo, pointThree};
582
583 if (0) {
584 // todo cpp crash
585 // libc++abi: terminating due to uncaught exception of type std::bad_alloc: std::bad_alloc
586 OH_Drawing_CanvasDrawPoints(canvas, POINT_MODE_LINES, -1, points);
587 }
588
589 // 3. Pass a floating-point value for the count parameter in OH_Drawing_CanvasDrawPoints.
590 OH_Drawing_CanvasDrawPoints(canvas, POINT_MODE_LINES, 1.0f, points);
591
592 // 4. Set the x-coordinate of the point in OH_Drawing_Point2D parameter to a negative number in
593 // OH_Drawing_CanvasDrawPoints.
594 OH_Drawing_Point2D point1 = {-250, 500};
595 OH_Drawing_Point2D points1[1] = {point1};
596 OH_Drawing_CanvasDrawPoints(canvas, POINT_MODE_LINES, 1, points1);
597
598 // 5. Set the y-coordinate of the point in OH_Drawing_Point2D parameter to a negative number in
599 // OH_Drawing_CanvasDrawPoints.
600 OH_Drawing_Point2D point2 = {250, -500};
601 OH_Drawing_Point2D points2[1] = {point2};
602 OH_Drawing_CanvasDrawPoints(canvas, POINT_MODE_LINES, 1, points2);
603
604 // 6. Set both the x and y coordinates of the point in OH_Drawing_Point2D parameter to negative numbers in
605 // OH_Drawing_CanvasDrawPoints.
606 OH_Drawing_Point2D point3 = {-250, -500};
607 OH_Drawing_Point2D points3[1] = {point3};
608 OH_Drawing_CanvasDrawPoints(canvas, POINT_MODE_LINES, 1, points3);
609
610 // 7. Free the memory.
611 OH_Drawing_CanvasDestroy(canvas);
612 }
613
614 /*
615 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_1403
616 * @tc.name: testCanvasDrawPointsMismatch
617 * @tc.desc: test for testCanvasDrawPointsMismatch.
618 * @tc.size : SmallTest
619 * @tc.type : Function
620 * @tc.level : Level 3
621 */
HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawPointsMismatch, TestSize.Level3)622 HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawPointsMismatch, TestSize.Level3)
623 {
624 // 1. OH_Drawing_CanvasCreate
625 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate();
626 EXPECT_NE(canvas, nullptr);
627
628 // 2. Pass an array of OH_Drawing_Point2D with a length of 1 and pass 2 as the count parameter in
629 // OH_Drawing_CanvasDrawPoints.
630 OH_Drawing_Point2D pointOne = {250, 500};
631 OH_Drawing_Point2D points1[1] = {pointOne};
632 OH_Drawing_CanvasDrawPoints(canvas, POINT_MODE_LINES, 2, points1);
633
634 // 3. Pass an array of OH_Drawing_Point2D with a length of 3 and pass 1 as the count parameter in
635 // OH_Drawing_CanvasDrawPoints.
636 OH_Drawing_Point2D pointOne1 = {250, 500};
637 OH_Drawing_Point2D pointTwo1 = {200, 500};
638 OH_Drawing_Point2D pointThree1 = {500, 700};
639 OH_Drawing_Point2D points2[3] = {pointOne1, pointTwo1, pointThree1};
640 OH_Drawing_CanvasDrawPoints(canvas, POINT_MODE_LINES, 1, points2);
641
642 // 4. Free the memory.
643 OH_Drawing_CanvasDestroy(canvas);
644 }
645
646 /*
647 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_1404
648 * @tc.name: testCanvasDrawPointsMaximum
649 * @tc.desc: test for testCanvasDrawPointsMaximum.
650 * @tc.size : SmallTest
651 * @tc.type : Function
652 * @tc.level : Level 3
653 */
HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawPointsMaximum, TestSize.Level3)654 HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawPointsMaximum, TestSize.Level3)
655 {
656 // 1. OH_Drawing_CanvasCreate
657 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate();
658 EXPECT_NE(canvas, nullptr);
659
660 // 2. Pass an extremely large value for the count parameter in OH_Drawing_CanvasDrawPoints.
661 OH_Drawing_Point2D pointOne = {250, 500};
662 OH_Drawing_Point2D pointTwo = {200, 500};
663 OH_Drawing_Point2D pointThree = {500, 700};
664 OH_Drawing_Point2D points[3] = {pointOne, pointTwo, pointThree};
665 if (0) {
666 // todo cpp crash
667 // libc++abi: terminating due to uncaught exception of type std::bad_alloc: std::bad_alloc
668 OH_Drawing_CanvasDrawPoints(canvas, POINT_MODE_LINES, INT32_MAX, points);
669 }
670
671 // 3. Set the x-coordinate of the point in OH_Drawing_Point2D parameter to an extremely large value in
672 // OH_Drawing_CanvasDrawPoints.
673 OH_Drawing_Point2D point1 = {INT32_MAX, 500};
674 OH_Drawing_Point2D points1[1] = {point1};
675 OH_Drawing_CanvasDrawPoints(canvas, POINT_MODE_LINES, 1, points1);
676
677 // 4. Set the y-coordinate of the point in OH_Drawing_Point2D parameter to an extremely large value in
678 // OH_Drawing_CanvasDrawPoints.
679 OH_Drawing_Point2D point2 = {250, INT32_MAX};
680 OH_Drawing_Point2D points2[1] = {point2};
681 OH_Drawing_CanvasDrawPoints(canvas, POINT_MODE_LINES, 1, points2);
682
683 // 5. Free the memory.
684 OH_Drawing_CanvasDestroy(canvas);
685 }
686
687 /*
688 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_1405
689 * @tc.name: testCanvasDrawPointsInputDestroyed
690 * @tc.desc: test for testCanvasDrawPointsInputDestroyed.
691 * @tc.size : SmallTest
692 * @tc.type : Function
693 * @tc.level : Level 3
694 */
HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawPointsInputDestroyed, TestSize.Level3)695 HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawPointsInputDestroyed, TestSize.Level3)
696 {
697 // Deprecated
698 }
699
700 /*
701 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_1500
702 * @tc.name: testCanvasDrawBitmapNormal
703 * @tc.desc: test for testCanvasDrawBitmapNormal.
704 * @tc.size : SmallTest
705 * @tc.type : Function
706 * @tc.level : Level 0
707 */
HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawBitmapNormal, TestSize.Level0)708 HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawBitmapNormal, TestSize.Level0)
709 {
710 // 1. OH_Drawing_CanvasCreate
711 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate();
712 EXPECT_NE(canvas, nullptr);
713
714 // 2. OH_Drawing_BitmapCreate
715 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate();
716 EXPECT_NE(bitmap, nullptr);
717
718 // 3. OH_Drawing_CanvasDrawBitmap
719 OH_Drawing_CanvasDrawBitmap(canvas, bitmap, 0, 0);
720
721 // 4. OH_Drawing_BitmapCreateFromPixels, iterate through OH_Drawing_ColorFormat and OH_Drawing_AlphaFormat to
722 // construct OH_Drawing_Image_Info.
723 OH_Drawing_ColorFormat formats[] = {
724 COLOR_FORMAT_UNKNOWN, COLOR_FORMAT_ALPHA_8, COLOR_FORMAT_RGB_565,
725 COLOR_FORMAT_ARGB_4444, COLOR_FORMAT_RGBA_8888, COLOR_FORMAT_BGRA_8888,
726 };
727
728 OH_Drawing_AlphaFormat alphaFormats[] = {
729 ALPHA_FORMAT_UNKNOWN,
730 ALPHA_FORMAT_OPAQUE,
731 ALPHA_FORMAT_PREMUL,
732 ALPHA_FORMAT_UNPREMUL,
733 };
734
735 for (int i = 0; i < 6; i++) {
736 for (int j = 0; j < 4; j++) {
737 int width = 500;
738 int height = 500;
739 int rowBytes = width * height * 4;
740 OH_Drawing_Image_Info imageInfo = {width, height, formats[i], alphaFormats[j]};
741 OH_Drawing_BitmapFormat cFormat{formats[i], alphaFormats[j]};
742 OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat);
743 void *pixels = OH_Drawing_BitmapGetPixels(bitmap);
744 bitmap = OH_Drawing_BitmapCreateFromPixels(&imageInfo, pixels, rowBytes);
745 // 5. OH_Drawing_CanvasDrawBitmap
746 OH_Drawing_CanvasDrawBitmap(canvas, bitmap, 0, 0);
747 OH_Drawing_BitmapDestroy(bitmap);
748 }
749 }
750
751 // 6. OH_Drawing_BitmapCreateFromPixels, initialize the Bitmap with rowBytes greater than the image.
752 int width = 500;
753 int height = 500;
754 OH_Drawing_Image_Info imageInfo = {width, height, COLOR_FORMAT_UNKNOWN, ALPHA_FORMAT_UNKNOWN};
755 int rowBytes = 600 * 600 * 4;
756 void *pixels = new int[width * height];
757 bitmap = OH_Drawing_BitmapCreateFromPixels(&imageInfo, pixels, rowBytes);
758
759 // 7. OH_Drawing_CanvasDrawBitmap
760 OH_Drawing_CanvasDrawBitmap(canvas, bitmap, 0, 0);
761
762 // 8. Free the memory.
763 OH_Drawing_BitmapDestroy(bitmap);
764 OH_Drawing_CanvasDestroy(canvas);
765 }
766
767 /*
768 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_1501
769 * @tc.name: testCanvasDrawBitmapNull
770 * @tc.desc: test for testCanvasDrawBitmapNull.
771 * @tc.size : SmallTest
772 * @tc.type : Function
773 * @tc.level : Level 3
774 */
HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawBitmapNull, TestSize.Level3)775 HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawBitmapNull, TestSize.Level3)
776 {
777 // 1. OH_Drawing_CanvasCreate
778 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate();
779 EXPECT_NE(canvas, nullptr);
780
781 // 2. OH_Drawing_BitmapCreate
782 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate();
783 EXPECT_NE(bitmap, nullptr);
784
785 // 3. The first parameter in OH_Drawing_CanvasDrawBitmap is empty.
786 OH_Drawing_CanvasDrawBitmap(nullptr, bitmap, 0, 0);
787
788 // 4. The second parameter in OH_Drawing_CanvasDrawBitmap is empty.
789 OH_Drawing_CanvasDrawBitmap(canvas, nullptr, 0, 0);
790
791 // 5. OH_Drawing_BitmapCreateFromPixels, initialize the image with a size of 48*48, and allocate memory for pixels
792 // as 47*48.
793 int width = 48;
794 int height = 48;
795 OH_Drawing_Image_Info imageInfo = {width, height, COLOR_FORMAT_UNKNOWN, ALPHA_FORMAT_UNKNOWN};
796 int rowBytes = width * height * 4;
797 void *pixels = new int[47 * 48];
798 bitmap = OH_Drawing_BitmapCreateFromPixels(&imageInfo, pixels, rowBytes);
799
800 // 6. OH_Drawing_CanvasDrawBitmap
801 OH_Drawing_CanvasDrawBitmap(canvas, bitmap, 0, 0);
802 OH_Drawing_BitmapDestroy(bitmap);
803
804 // 7. OH_Drawing_BitmapCreateFromPixels, initialize the image with a size of 48*48, and allocate memory for pixels
805 // as 48*47.
806 width = 48;
807 height = 48;
808 imageInfo = {width, height, COLOR_FORMAT_UNKNOWN, ALPHA_FORMAT_UNKNOWN};
809 rowBytes = width * height * 4;
810 pixels = new int[48 * 47];
811 bitmap = OH_Drawing_BitmapCreateFromPixels(&imageInfo, pixels, rowBytes);
812
813 // 8. OH_Drawing_CanvasDrawBitmap
814 OH_Drawing_CanvasDrawBitmap(canvas, bitmap, 0, 0);
815 OH_Drawing_BitmapDestroy(bitmap);
816
817 // 9. OH_Drawing_BitmapCreateFromPixels, initialize the image with a size of 48*48, allocate memory for pixels as
818 // 48*48, and set rowBytes as 47.
819 width = 48;
820 height = 48;
821 imageInfo = {width, height, COLOR_FORMAT_UNKNOWN, ALPHA_FORMAT_UNKNOWN};
822 rowBytes = 47;
823 pixels = new int[48 * 48];
824 bitmap = OH_Drawing_BitmapCreateFromPixels(&imageInfo, pixels, rowBytes);
825
826 // 10. OH_Drawing_CanvasDrawBitmap
827 OH_Drawing_CanvasDrawBitmap(canvas, bitmap, 0, 0);
828
829 // 11. The third parameter in OH_Drawing_CanvasDrawBitmap is 0.
830 OH_Drawing_CanvasDrawBitmap(canvas, bitmap, 0, 0);
831
832 // 12. The fourth parameter in OH_Drawing_CanvasDrawBitmap is 0.
833 OH_Drawing_CanvasDrawBitmap(canvas, bitmap, 0, 0);
834
835 // 13. Free the memory.
836 OH_Drawing_BitmapDestroy(bitmap);
837 OH_Drawing_CanvasDestroy(canvas);
838 }
839
840 /*
841 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_1502
842 * @tc.name: testCanvasDrawBitmapAbnormal
843 * @tc.desc: test for testCanvasDrawBitmapAbnormal.
844 * @tc.size : SmallTest
845 * @tc.type : Function
846 * @tc.level : Level 3
847 */
HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawBitmapAbnormal, TestSize.Level3)848 HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawBitmapAbnormal, TestSize.Level3)
849 {
850 // 1. OH_Drawing_CanvasCreate
851 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate();
852 EXPECT_NE(canvas, nullptr);
853
854 // 2. OH_Drawing_BitmapCreate
855 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate();
856 EXPECT_NE(bitmap, nullptr);
857
858 // 3. The x-coordinate of the top-left corner of the bitmap object in OH_Drawing_CanvasDrawBitmap is negative.
859 OH_Drawing_CanvasDrawBitmap(canvas, bitmap, -1, 0);
860
861 // 4. The y-coordinate of the top-left corner of the bitmap object in OH_Drawing_CanvasDrawBitmap is negative.
862 OH_Drawing_CanvasDrawBitmap(canvas, bitmap, 0, -1);
863
864 // 5. Free the memory.
865 OH_Drawing_BitmapDestroy(bitmap);
866 OH_Drawing_CanvasDestroy(canvas);
867 }
868
869 /*
870 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_1503
871 * @tc.name: testCanvasDrawBitmapMaximum
872 * @tc.desc: test for testCanvasDrawBitmapMaximum.
873 * @tc.size : SmallTest
874 * @tc.type : Function
875 * @tc.level : Level 3
876 */
HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawBitmapMaximum, TestSize.Level3)877 HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawBitmapMaximum, TestSize.Level3)
878 {
879 // 1. OH_Drawing_CanvasCreate
880 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate();
881 EXPECT_NE(canvas, nullptr);
882
883 // 2. OH_Drawing_BitmapCreate
884 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate();
885 EXPECT_NE(bitmap, nullptr);
886
887 // 3. The x-coordinate of the top-left corner of the bitmap object in OH_Drawing_CanvasDrawBitmap is set to a very
888 // large value.
889 OH_Drawing_CanvasDrawBitmap(canvas, bitmap, FLT_MAX, 0);
890
891 // 4. The y-coordinate of the top-left corner of the bitmap object in OH_Drawing_CanvasDrawBitmap is set to a very
892 // large value.
893 OH_Drawing_CanvasDrawBitmap(canvas, bitmap, 0, FLT_MAX);
894
895 // 5. Free the memory.
896 OH_Drawing_BitmapDestroy(bitmap);
897 OH_Drawing_CanvasDestroy(canvas);
898 }
899
900 /*
901 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_1504
902 * @tc.name: testCanvasDrawBitmapInputDestroyed
903 * @tc.desc: test for testCanvasDrawBitmapInputDestroyed.
904 * @tc.size : SmallTest
905 * @tc.type : Function
906 * @tc.level : Level 3
907 */
HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawBitmapInputDestroyed, TestSize.Level3)908 HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawBitmapInputDestroyed, TestSize.Level3)
909 {
910 // Deprecated
911 }
912
913 /*
914 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_1505
915 * @tc.name: testCanvasDrawBitmapBoundary
916 * @tc.desc: test for testCanvasDrawBitmapBoundary.
917 * @tc.size : SmallTest
918 * @tc.type : Function
919 * @tc.level : Level 0
920 */
HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawBitmapBoundary, TestSize.Level0)921 HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawBitmapBoundary, TestSize.Level0)
922 {
923 // 1. OH_Drawing_CanvasCreate
924 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate();
925 EXPECT_NE(canvas, nullptr);
926
927 // 2. OH_Drawing_BitmapCreate
928 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate();
929 EXPECT_NE(bitmap, nullptr);
930
931 // 3. OH_Drawing_CanvasDrawBitmap
932 OH_Drawing_CanvasDrawBitmap(canvas, bitmap, 0, 0);
933
934 // 4. OH_Drawing_BitmapCreateFromPixels, iterate through OH_Drawing_ColorFormat and OH_Drawing_AlphaFormat to
935 // construct OH_Drawing_Image_Info.
936 OH_Drawing_ColorFormat formats[] = {
937 COLOR_FORMAT_UNKNOWN, COLOR_FORMAT_ALPHA_8, COLOR_FORMAT_RGB_565,
938 COLOR_FORMAT_ARGB_4444, COLOR_FORMAT_RGBA_8888, COLOR_FORMAT_BGRA_8888,
939 };
940
941 OH_Drawing_AlphaFormat alphaFormats[] = {
942 ALPHA_FORMAT_UNKNOWN,
943 ALPHA_FORMAT_OPAQUE,
944 ALPHA_FORMAT_PREMUL,
945 ALPHA_FORMAT_UNPREMUL,
946 };
947
948 int width = 4096;
949 int height = 2160;
950 for (int i = 0; i < 6; i++) {
951 for (int j = 0; j < 4; j++) {
952 int rowBytes = width * height * 4;
953 OH_Drawing_Image_Info imageInfo = {width, height, formats[i], alphaFormats[j]};
954 OH_Drawing_BitmapFormat cFormat{formats[i], alphaFormats[j]};
955 OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat);
956 void *pixels = OH_Drawing_BitmapGetPixels(bitmap);
957 bitmap = OH_Drawing_BitmapCreateFromPixels(&imageInfo, pixels, rowBytes);
958 // 5. OH_Drawing_CanvasDrawBitmap
959 OH_Drawing_CanvasDrawBitmap(canvas, bitmap, 0, 0);
960 OH_Drawing_BitmapDestroy(bitmap);
961 }
962 }
963
964 // 6. OH_Drawing_BitmapCreateFromPixels, initialize the Bitmap with rowBytes greater than the image.
965 OH_Drawing_Image_Info imageInfo = {width, height, COLOR_FORMAT_UNKNOWN, ALPHA_FORMAT_UNKNOWN};
966 int rowBytes = 600 * 600 * 4;
967 void *pixels = new int[width * height];
968 bitmap = OH_Drawing_BitmapCreateFromPixels(&imageInfo, pixels, rowBytes);
969
970 // 7. OH_Drawing_CanvasDrawBitmap
971 OH_Drawing_CanvasDrawBitmap(canvas, bitmap, 0, 0);
972
973 // 8. Free the memory.
974 OH_Drawing_BitmapDestroy(bitmap);
975 OH_Drawing_CanvasDestroy(canvas);
976 }
977
978 /*
979 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_1600
980 * @tc.name: testCanvasDrawBitmapRectNormal
981 * @tc.desc: test for testCanvasDrawBitmapRectNormal.
982 * @tc.size : SmallTest
983 * @tc.type : Function
984 * @tc.level : Level 0
985 */
HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawBitmapRectNormal, TestSize.Level0)986 HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawBitmapRectNormal, TestSize.Level0)
987 {
988 // 1. OH_Drawing_CanvasCreate
989 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate();
990 EXPECT_NE(canvas, nullptr);
991 // 2. OH_Drawing_BitmapCreate
992 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate();
993 EXPECT_NE(bitmap, nullptr);
994 // 3. OH_Drawing_RectCreate src and dst
995 OH_Drawing_Rect *src = OH_Drawing_RectCreate(0, 0, 100, 100);
996 OH_Drawing_Rect *dst = OH_Drawing_RectCreate(0, 0, 100, 100);
997 // 4. OH_Drawing_CanvasDrawBitmap
998 OH_Drawing_CanvasDrawBitmap(canvas, bitmap, 0, 0);
999 // 5. OH_Drawing_CanvasDrawBitmapRect, iterate through OH_Drawing_FilterMode and OH_Drawing_MipmapMode to construct
1000 // OH_Drawing_SamplingOptions
1001 OH_Drawing_FilterMode filterMode[] = {FILTER_MODE_NEAREST, FILTER_MODE_LINEAR};
1002 OH_Drawing_MipmapMode mode[] = {MIPMAP_MODE_NEAREST, MIPMAP_MODE_LINEAR, MIPMAP_MODE_NONE};
1003 for (int i = 0; i < 2; i++) {
1004 for (int j = 0; j < 3; j++) {
1005 OH_Drawing_SamplingOptions *options = OH_Drawing_SamplingOptionsCreate(filterMode[i], mode[j]);
1006 OH_Drawing_CanvasDrawBitmapRect(canvas, bitmap, src, dst, options);
1007 OH_Drawing_SamplingOptionsDestroy(options);
1008 }
1009 }
1010 // 6. OH_Drawing_CanvasDrawBitmap
1011 OH_Drawing_CanvasDrawBitmap(canvas, bitmap, 0, 0);
1012 OH_Drawing_BitmapDestroy(bitmap);
1013 // 7. OH_Drawing_BitmapCreateFromPixels, initialize Bitmap with a rowBytes larger than the image
1014 int width = 500;
1015 int height = 500;
1016 OH_Drawing_Image_Info imageInfo = {width, height, COLOR_FORMAT_UNKNOWN, ALPHA_FORMAT_UNKNOWN};
1017 int rowBytes = 600 * 600 * 4;
1018 void *pixels = new int[width * height];
1019 bitmap = OH_Drawing_BitmapCreateFromPixels(&imageInfo, pixels, rowBytes);
1020 // 8. OH_Drawing_CanvasDrawBitmapRect, iterate through OH_Drawing_FilterMode and OH_Drawing_MipmapMode to construct
1021 // OH_Drawing_SamplingOptions
1022 for (int i = 0; i < 2; i++) {
1023 for (int j = 0; j < 3; j++) {
1024 OH_Drawing_SamplingOptions *options = OH_Drawing_SamplingOptionsCreate(filterMode[i], mode[j]);
1025 OH_Drawing_CanvasDrawBitmapRect(canvas, bitmap, src, dst, options);
1026 OH_Drawing_SamplingOptionsDestroy(options);
1027 }
1028 }
1029 // 9. CanvasDrawBitmapRect with src parameter set to nullptr
1030 OH_Drawing_SamplingOptions *options = OH_Drawing_SamplingOptionsCreate(FILTER_MODE_NEAREST, MIPMAP_MODE_LINEAR);
1031 OH_Drawing_CanvasDrawBitmapRect(canvas, bitmap, nullptr, dst, options);
1032 // 10. Free memory
1033 OH_Drawing_RectDestroy(src);
1034 OH_Drawing_RectDestroy(dst);
1035 OH_Drawing_BitmapDestroy(bitmap);
1036 OH_Drawing_CanvasDestroy(canvas);
1037 OH_Drawing_SamplingOptionsDestroy(options);
1038 }
1039
1040 /*
1041 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_1601
1042 * @tc.name: testCanvasDrawBitmapRectNull
1043 * @tc.desc: test for testCanvasDrawBitmapRectNull.
1044 * @tc.size : SmallTest
1045 * @tc.type : Function
1046 * @tc.level : Level 3
1047 */
HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawBitmapRectNull, TestSize.Level3)1048 HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawBitmapRectNull, TestSize.Level3)
1049 {
1050 // 1. OH_Drawing_CanvasCreate
1051 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate();
1052 EXPECT_NE(canvas, nullptr);
1053
1054 // 2. OH_Drawing_BitmapCreate, OH_Drawing_SamplingOptionsCreate
1055 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate();
1056 EXPECT_NE(bitmap, nullptr);
1057 OH_Drawing_SamplingOptions *options = OH_Drawing_SamplingOptionsCreate(FILTER_MODE_NEAREST, MIPMAP_MODE_LINEAR);
1058
1059 // 3. OH_Drawing_CanvasDrawBitmapRect with the first parameter set to nullptr
1060 OH_Drawing_Rect *src = OH_Drawing_RectCreate(0, 0, 200, 200);
1061 EXPECT_NE(src, nullptr);
1062 OH_Drawing_Rect *dst = OH_Drawing_RectCreate(0, 0, 200, 200);
1063 EXPECT_NE(dst, nullptr);
1064 OH_Drawing_CanvasDrawBitmapRect(nullptr, bitmap, src, dst, options);
1065
1066 // 4. OH_Drawing_CanvasDrawBitmapRect with the second parameter set to nullptr
1067 OH_Drawing_CanvasDrawBitmapRect(canvas, nullptr, src, dst, options);
1068
1069 // 5. OH_Drawing_BitmapCreateFromPixels, initialize the image with a size of 48*48, and allocate memory for pixels
1070 // as 47*48.
1071 int width = 48;
1072 int height = 48;
1073 OH_Drawing_Image_Info imageInfo = {width, height, COLOR_FORMAT_UNKNOWN, ALPHA_FORMAT_UNKNOWN};
1074 int rowBytes = width * height * 4;
1075 void *pixels = new int[47 * 48];
1076 OH_Drawing_BitmapDestroy(bitmap);
1077 bitmap = OH_Drawing_BitmapCreateFromPixels(&imageInfo, pixels, rowBytes);
1078
1079 // 6. OH_Drawing_CanvasDrawBitmapRect
1080 OH_Drawing_CanvasDrawBitmapRect(canvas, bitmap, src, dst, options);
1081
1082 // 7. OH_Drawing_BitmapCreateFromPixels, initialize the image with a size of 48*48, and allocate memory for pixels
1083 // as 48*47.
1084 width = 48;
1085 height = 48;
1086 imageInfo = {width, height, COLOR_FORMAT_UNKNOWN, ALPHA_FORMAT_UNKNOWN};
1087 rowBytes = width * height * 4;
1088 pixels = new int[48 * 47];
1089 OH_Drawing_BitmapDestroy(bitmap);
1090 bitmap = OH_Drawing_BitmapCreateFromPixels(&imageInfo, pixels, rowBytes);
1091
1092 // 8. OH_Drawing_CanvasDrawBitmapRect
1093 OH_Drawing_CanvasDrawBitmapRect(canvas, bitmap, src, dst, options);
1094
1095 // 9. OH_Drawing_BitmapCreateFromPixels, initialize the image with a size of 48*48, allocate memory for pixels as
1096 // 48*48, and set rowBytes as 47.
1097 width = 48;
1098 height = 48;
1099 imageInfo = {width, height, COLOR_FORMAT_UNKNOWN, ALPHA_FORMAT_UNKNOWN};
1100 rowBytes = 47;
1101 pixels = new int[48 * 48];
1102 OH_Drawing_BitmapDestroy(bitmap);
1103 bitmap = OH_Drawing_BitmapCreateFromPixels(&imageInfo, pixels, rowBytes);
1104
1105 // 10. OH_Drawing_CanvasDrawBitmapRect
1106 OH_Drawing_CanvasDrawBitmapRect(canvas, bitmap, src, dst, options);
1107
1108 // 11. OH_Drawing_CanvasDrawBitmapRect with the fourth parameter set to nullptr
1109 OH_Drawing_CanvasDrawBitmapRect(canvas, bitmap, src, dst, nullptr);
1110
1111 // 12. OH_Drawing_CanvasDrawBitmapRect with the fifth parameter set to nullptr
1112 // error: no matching function for call to 'OH_Drawing_CanvasDrawBitmapRect'
1113
1114 // 13. Free memory
1115 OH_Drawing_CanvasDestroy(canvas);
1116 OH_Drawing_BitmapDestroy(bitmap);
1117 OH_Drawing_RectDestroy(src);
1118 OH_Drawing_RectDestroy(dst);
1119 OH_Drawing_SamplingOptionsDestroy(options);
1120 }
1121
1122 /*
1123 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_1602
1124 * @tc.name: testCanvasDrawBitmapRectAbnormal
1125 * @tc.desc: test for testCanvasDrawBitmapRectAbnormal.
1126 * @tc.size : SmallTest
1127 * @tc.type : Function
1128 * @tc.level : Level 3
1129 */
HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawBitmapRectAbnormal, TestSize.Level3)1130 HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawBitmapRectAbnormal, TestSize.Level3)
1131 {
1132 // 1. OH_Drawing_CanvasCreate
1133 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate();
1134 EXPECT_NE(canvas, nullptr);
1135 // 2. OH_Drawing_BitmapCreate, OH_Drawing_SamplingOptionsCreate
1136 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate();
1137 EXPECT_NE(bitmap, nullptr);
1138 OH_Drawing_SamplingOptions *options = OH_Drawing_SamplingOptionsCreate(FILTER_MODE_NEAREST, MIPMAP_MODE_LINEAR);
1139 // 3. OH_Drawing_CanvasDrawBitmapRect with OH_Drawing_Rect created with negative values for left, top, right, bottom
1140 OH_Drawing_Rect *src = OH_Drawing_RectCreate(-100, -100, -50, -50);
1141 EXPECT_NE(src, nullptr);
1142 OH_Drawing_Rect *dst = OH_Drawing_RectCreate(-100, -100, -50, -50);
1143 EXPECT_NE(dst, nullptr);
1144 OH_Drawing_CanvasDrawBitmapRect(canvas, bitmap, src, dst, options);
1145 // 4. OH_Drawing_CanvasDrawBitmapRect with OH_Drawing_Rect src created with the top-left coordinate equal to the
1146 // bottom-right coordinate
1147 src = OH_Drawing_RectCreate(100, 100, 100, 100);
1148 EXPECT_NE(src, nullptr);
1149 OH_Drawing_CanvasDrawBitmapRect(canvas, bitmap, src, dst, options);
1150 // 5. OH_Drawing_CanvasDrawBitmapRect with OH_Drawing_Rect src created with the top-left coordinate greater than the
1151 // bottom-right coordinate
1152 src = OH_Drawing_RectCreate(200, 200, 100, 100);
1153 EXPECT_NE(src, nullptr);
1154 OH_Drawing_CanvasDrawBitmapRect(canvas, bitmap, src, dst, options);
1155 // 6. OH_Drawing_CanvasDrawBitmapRect with OH_Drawing_Rect dst created with the top-left coordinate equal to the
1156 // bottom-right coordinate
1157 dst = OH_Drawing_RectCreate(100, 100, 100, 100);
1158 EXPECT_NE(dst, nullptr);
1159 OH_Drawing_CanvasDrawBitmapRect(canvas, bitmap, src, dst, options);
1160 // 7. OH_Drawing_CanvasDrawBitmapRect with OH_Drawing_Rect dst created with the top-left coordinate greater than the
1161 // bottom-right coordinate
1162 dst = OH_Drawing_RectCreate(200, 200, 100, 100);
1163 EXPECT_NE(dst, nullptr);
1164 OH_Drawing_CanvasDrawBitmapRect(canvas, bitmap, src, dst, options);
1165 // 8. OH_Drawing_CanvasDrawBitmapRect with OH_Drawing_Rect dst created with the top-left coordinate equal to the
1166 // bottom-right coordinate
1167 dst = OH_Drawing_RectCreate(100, 100, 100, 100);
1168 EXPECT_NE(dst, nullptr);
1169 OH_Drawing_CanvasDrawBitmapRect(canvas, bitmap, src, dst, options);
1170 // 9. OH_Drawing_CanvasDrawBitmapRect with OH_Drawing_Rect dst created with the top-left coordinate greater than the
1171 // bottom-right coordinate
1172 dst = OH_Drawing_RectCreate(200, 200, 100, 100);
1173 EXPECT_NE(dst, nullptr);
1174 OH_Drawing_CanvasDrawBitmapRect(canvas, bitmap, src, dst, options);
1175 // 10. Free memory
1176 OH_Drawing_CanvasDestroy(canvas);
1177 OH_Drawing_BitmapDestroy(bitmap);
1178 OH_Drawing_RectDestroy(src);
1179 OH_Drawing_RectDestroy(dst);
1180 OH_Drawing_SamplingOptionsDestroy(options);
1181 }
1182
1183 /*
1184 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_1603
1185 * @tc.name: testCanvasDrawBitmapRectMaximum
1186 * @tc.desc: test for testCanvasDrawBitmapRectMaximum.
1187 * @tc.size : SmallTest
1188 * @tc.type : Function
1189 * @tc.level : Level 3
1190 */
HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawBitmapRectMaximum, TestSize.Level3)1191 HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawBitmapRectMaximum, TestSize.Level3)
1192 {
1193 // 1. OH_Drawing_CanvasCreate
1194 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate();
1195 EXPECT_NE(canvas, nullptr);
1196 // 2. OH_Drawing_BitmapCreate, OH_Drawing_SamplingOptionsCreate
1197 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate();
1198 EXPECT_NE(bitmap, nullptr);
1199 OH_Drawing_SamplingOptions *options = OH_Drawing_SamplingOptionsCreate(FILTER_MODE_NEAREST, MIPMAP_MODE_LINEAR);
1200 // 3. OH_Drawing_CanvasDrawBitmapRect with OH_Drawing_Rect src created with maximum values for the top-left
1201 // coordinate
1202 OH_Drawing_Rect *src = OH_Drawing_RectCreate(FLT_MAX, FLT_MAX, 200, 200);
1203 EXPECT_NE(src, nullptr);
1204 OH_Drawing_Rect *dst = OH_Drawing_RectCreate(0, 0, 200, 200);
1205 EXPECT_NE(dst, nullptr);
1206 OH_Drawing_CanvasDrawBitmapRect(canvas, bitmap, src, dst, options);
1207 // 4. OH_Drawing_CanvasDrawBitmapRect with OH_Drawing_Rect src created with maximum values for the top-right
1208 // coordinate
1209 src = OH_Drawing_RectCreate(0, 0, FLT_MAX, FLT_MAX);
1210 EXPECT_NE(src, nullptr);
1211 OH_Drawing_CanvasDrawBitmapRect(canvas, bitmap, src, dst, options);
1212 // 5. OH_Drawing_CanvasDrawBitmapRect with OH_Drawing_Rect dst created with maximum values for the top-left
1213 // coordinate
1214 dst = OH_Drawing_RectCreate(FLT_MAX, FLT_MAX, 200, 200);
1215 EXPECT_NE(dst, nullptr);
1216 OH_Drawing_CanvasDrawBitmapRect(canvas, bitmap, src, dst, options);
1217 // 6. OH_Drawing_CanvasDrawBitmapRect with OH_Drawing_Rect dst created with maximum values for the top-right
1218 // coordinate
1219 dst = OH_Drawing_RectCreate(0, 0, FLT_MAX, FLT_MAX);
1220 EXPECT_NE(dst, nullptr);
1221 OH_Drawing_CanvasDrawBitmapRect(canvas, bitmap, src, dst, options);
1222 // 7. Free memory
1223 OH_Drawing_CanvasDestroy(canvas);
1224 OH_Drawing_BitmapDestroy(bitmap);
1225 OH_Drawing_RectDestroy(src);
1226 OH_Drawing_RectDestroy(dst);
1227 OH_Drawing_SamplingOptionsDestroy(options);
1228 }
1229
1230 /*
1231 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_1604
1232 * @tc.name: testCanvasDrawBitmapRectInputDestroyed
1233 * @tc.desc: test for testCanvasDrawBitmapRectInputDestroyed.
1234 * @tc.size : SmallTest
1235 * @tc.type : Function
1236 * @tc.level : Level 3
1237 */
HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawBitmapRectInputDestroyed, TestSize.Level3)1238 HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawBitmapRectInputDestroyed, TestSize.Level3)
1239 {
1240 // Deprecated
1241 }
1242
1243 /*
1244 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_1605
1245 * @tc.name: testCanvasDrawBitmapRectBoundary
1246 * @tc.desc: test for testCanvasDrawBitmapRectBoundary.
1247 * @tc.size : SmallTest
1248 * @tc.type : Function
1249 * @tc.level : Level 0
1250 */
HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawBitmapRectBoundary, TestSize.Level0)1251 HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawBitmapRectBoundary, TestSize.Level0)
1252 {
1253 // 1. OH_Drawing_CanvasCreate
1254 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate();
1255 EXPECT_NE(canvas, nullptr);
1256 // 2. OH_Drawing_BitmapCreate
1257 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate();
1258 EXPECT_NE(bitmap, nullptr);
1259 // 3. OH_Drawing_RectCreate src and dst
1260 OH_Drawing_Rect *src = OH_Drawing_RectCreate(0, 0, 100, 100);
1261 OH_Drawing_Rect *dst = OH_Drawing_RectCreate(0, 0, 100, 100);
1262 // 4. OH_Drawing_CanvasDrawBitmap
1263 OH_Drawing_CanvasDrawBitmap(canvas, bitmap, 0, 0);
1264 // 5. OH_Drawing_CanvasDrawBitmapRect, iterate through OH_Drawing_FilterMode and OH_Drawing_MipmapMode to construct
1265 // OH_Drawing_SamplingOptions
1266 OH_Drawing_FilterMode filterMode[] = {FILTER_MODE_NEAREST, FILTER_MODE_LINEAR};
1267 OH_Drawing_MipmapMode mode[] = {MIPMAP_MODE_NEAREST, MIPMAP_MODE_LINEAR, MIPMAP_MODE_NONE};
1268 for (int i = 0; i < 2; i++) {
1269 for (int j = 0; j < 3; j++) {
1270 OH_Drawing_SamplingOptions *options = OH_Drawing_SamplingOptionsCreate(filterMode[i], mode[j]);
1271 OH_Drawing_CanvasDrawBitmapRect(canvas, bitmap, src, dst, options);
1272 OH_Drawing_SamplingOptionsDestroy(options);
1273 }
1274 }
1275 // 6. OH_Drawing_CanvasDrawBitmap
1276 OH_Drawing_CanvasDrawBitmap(canvas, bitmap, 0, 0);
1277 OH_Drawing_BitmapDestroy(bitmap);
1278 // 7. OH_Drawing_BitmapCreateFromPixels, initialize Bitmap with a rowBytes larger than the image
1279 int width = 4096;
1280 int height = 2160;
1281 OH_Drawing_Image_Info imageInfo = {width, height, COLOR_FORMAT_UNKNOWN, ALPHA_FORMAT_UNKNOWN};
1282 int rowBytes = 600 * 600 * 4;
1283 void *pixels = new int[width * height];
1284 bitmap = OH_Drawing_BitmapCreateFromPixels(&imageInfo, pixels, rowBytes);
1285 // 8. OH_Drawing_CanvasDrawBitmapRect, iterate through OH_Drawing_FilterMode and OH_Drawing_MipmapMode to construct
1286 // OH_Drawing_SamplingOptions
1287 for (int i = 0; i < 2; i++) {
1288 for (int j = 0; j < 3; j++) {
1289 OH_Drawing_SamplingOptions *options = OH_Drawing_SamplingOptionsCreate(filterMode[i], mode[j]);
1290 OH_Drawing_CanvasDrawBitmapRect(canvas, bitmap, src, dst, options);
1291 OH_Drawing_SamplingOptionsDestroy(options);
1292 }
1293 }
1294 // 9. CanvasDrawBitmapRect with src parameter set to nullptr
1295 OH_Drawing_SamplingOptions *options = OH_Drawing_SamplingOptionsCreate(FILTER_MODE_NEAREST, MIPMAP_MODE_LINEAR);
1296 OH_Drawing_CanvasDrawBitmapRect(canvas, bitmap, nullptr, dst, options);
1297 // 10. Free memory
1298 OH_Drawing_RectDestroy(src);
1299 OH_Drawing_RectDestroy(dst);
1300 OH_Drawing_BitmapDestroy(bitmap);
1301 OH_Drawing_CanvasDestroy(canvas);
1302 OH_Drawing_SamplingOptionsDestroy(options);
1303 }
1304
1305 /*
1306 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_1700
1307 * @tc.name: testCanvasDrawRectNormal
1308 * @tc.desc: test for testCanvasDrawRectNormal.
1309 * @tc.size : SmallTest
1310 * @tc.type : Function
1311 * @tc.level : Level 0
1312 */
HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawRectNormal, TestSize.Level0)1313 HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawRectNormal, TestSize.Level0)
1314 {
1315 // 1. OH_Drawing_CanvasCreate
1316 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate();
1317 EXPECT_NE(canvas, nullptr);
1318 // 2. OH_Drawing_RectCreate
1319 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0, 0, 200, 200);
1320 EXPECT_NE(rect, nullptr);
1321 // 3. OH_Drawing_CanvasDrawRect
1322 OH_Drawing_CanvasDrawRect(canvas, rect);
1323 // 4. Free memory
1324 OH_Drawing_CanvasDestroy(canvas);
1325 OH_Drawing_RectDestroy(rect);
1326 }
1327
1328 /*
1329 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_1701
1330 * @tc.name: testCanvasDrawRectNull
1331 * @tc.desc: test for testCanvasDrawRectNull.
1332 * @tc.size : SmallTest
1333 * @tc.type : Function
1334 * @tc.level : Level 3
1335 */
HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawRectNull, TestSize.Level3)1336 HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawRectNull, TestSize.Level3)
1337 {
1338 // 1. OH_Drawing_CanvasCreate
1339 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate();
1340 EXPECT_NE(canvas, nullptr);
1341 // 2. OH_Drawing_RectCreate
1342 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0, 0, 200, 200);
1343 EXPECT_NE(rect, nullptr);
1344 // 3. OH_Drawing_CanvasDrawRect with the first parameter being null
1345 OH_Drawing_CanvasDrawRect(canvas, nullptr);
1346 // 4. OH_Drawing_CanvasDrawRect with the second parameter being null
1347 OH_Drawing_CanvasDrawRect(nullptr, rect);
1348 // 5. OH_Drawing_CanvasDrawRect with the second parameter OH_Drawing_Rect created with left, top, right, bottom
1349 // respectively set to 0
1350 rect = OH_Drawing_RectCreate(0, 200, 200, 200);
1351 OH_Drawing_CanvasDrawRect(canvas, rect);
1352 rect = OH_Drawing_RectCreate(200, 0, 200, 200);
1353 OH_Drawing_CanvasDrawRect(canvas, rect);
1354 rect = OH_Drawing_RectCreate(200, 200, 0, 200);
1355 OH_Drawing_CanvasDrawRect(canvas, rect);
1356 rect = OH_Drawing_RectCreate(200, 200, 200, 0);
1357 OH_Drawing_CanvasDrawRect(canvas, rect);
1358 // 6. OH_Drawing_CanvasDrawRect with the second parameter OH_Drawing_Rect created with all values set to 0
1359 rect = OH_Drawing_RectCreate(0, 0, 0, 0);
1360 EXPECT_NE(rect, nullptr);
1361 OH_Drawing_CanvasDrawRect(canvas, rect);
1362 // 7. Free memory
1363 OH_Drawing_CanvasDestroy(canvas);
1364 OH_Drawing_RectDestroy(rect);
1365 }
1366
1367 /*
1368 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_1702
1369 * @tc.name: testCanvasDrawRectAbnormal
1370 * @tc.desc: test for testCanvasDrawRectAbnormal.
1371 * @tc.size : SmallTest
1372 * @tc.type : Function
1373 * @tc.level : Level 3
1374 */
HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawRectAbnormal, TestSize.Level3)1375 HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawRectAbnormal, TestSize.Level3)
1376 {
1377 // 1. OH_Drawing_CanvasCreate
1378 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate();
1379 EXPECT_NE(canvas, nullptr);
1380
1381 // 2. OH_Drawing_CanvasDrawRect with OH_Drawing_Rect created with left, top, right, bottom being negative numbers
1382 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(-100, 100, 50, 50);
1383 OH_Drawing_CanvasDrawRect(canvas, rect);
1384 rect = OH_Drawing_RectCreate(100, -100, 50, 50);
1385 OH_Drawing_CanvasDrawRect(canvas, rect);
1386 rect = OH_Drawing_RectCreate(100, 100, -50, 50);
1387 OH_Drawing_CanvasDrawRect(canvas, rect);
1388 rect = OH_Drawing_RectCreate(100, 100, 50, -50);
1389 OH_Drawing_CanvasDrawRect(canvas, rect);
1390
1391 // 3. OH_Drawing_CanvasDrawRect with OH_Drawing_Rect created with the top-left coordinate equal to the bottom-right
1392 // coordinate
1393 rect = OH_Drawing_RectCreate(100, 100, 100, 100);
1394 OH_Drawing_CanvasDrawRect(canvas, rect);
1395
1396 rect = OH_Drawing_RectCreate(200, 200, 200, 200);
1397 OH_Drawing_CanvasDrawRect(canvas, rect);
1398
1399 // 4. OH_Drawing_CanvasDrawRect with OH_Drawing_Rect created with the top-left coordinate equal to the bottom-right
1400 // coordinate
1401 rect = OH_Drawing_RectCreate(200, 200, 200, 200);
1402 OH_Drawing_CanvasDrawRect(canvas, rect);
1403
1404 // 5. OH_Drawing_CanvasDrawRect with OH_Drawing_Rect created with the top-left coordinate greater than the
1405 // bottom-right coordinate
1406 rect = OH_Drawing_RectCreate(200, 200, 100, 100);
1407 OH_Drawing_CanvasDrawRect(canvas, rect);
1408
1409 // 6. Free memory
1410 OH_Drawing_CanvasDestroy(canvas);
1411 OH_Drawing_RectDestroy(rect);
1412 }
1413
1414 /*
1415 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_1703
1416 * @tc.name: testCanvasDrawRectMaximum
1417 * @tc.desc: test for testCanvasDrawRectMaximum.
1418 * @tc.size : SmallTest
1419 * @tc.type : Function
1420 * @tc.level : Level 3
1421 */
HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawRectMaximum, TestSize.Level3)1422 HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawRectMaximum, TestSize.Level3)
1423 {
1424 // 1. OH_Drawing_CanvasCreate
1425 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate();
1426 EXPECT_NE(canvas, nullptr);
1427
1428 // 2. OH_Drawing_CanvasDrawRect with OH_Drawing_Rect created with left, top, right, bottom set to maximum values
1429 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(FLT_MAX, 200, 200, 200);
1430 OH_Drawing_CanvasDrawRect(canvas, rect);
1431 rect = OH_Drawing_RectCreate(200, FLT_MAX, 200, 200);
1432 OH_Drawing_CanvasDrawRect(canvas, rect);
1433 rect = OH_Drawing_RectCreate(200, 200, FLT_MAX, 200);
1434 OH_Drawing_CanvasDrawRect(canvas, rect);
1435 rect = OH_Drawing_RectCreate(200, 200, 200, FLT_MAX);
1436 OH_Drawing_CanvasDrawRect(canvas, rect);
1437
1438 // 3. Free memory
1439 OH_Drawing_CanvasDestroy(canvas);
1440 }
1441
1442 /*
1443 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_1704
1444 * @tc.name: testCanvasDrawRectInputDestroyed
1445 * @tc.desc: test for testCanvasDrawRectInputDestroyed.
1446 * @tc.size : SmallTest
1447 * @tc.type : Function
1448 * @tc.level : Level 3
1449 */
HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawRectInputDestroyed, TestSize.Level3)1450 HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawRectInputDestroyed, TestSize.Level3)
1451 {
1452 // Deprecated
1453 }
1454
1455 /*
1456 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_1800
1457 * @tc.name: testCanvasDrawCircleNormal
1458 * @tc.desc: test for testCanvasDrawCircleNormal.
1459 * @tc.size : SmallTest
1460 * @tc.type : Function
1461 * @tc.level : Level 0
1462 */
HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawCircleNormal, TestSize.Level0)1463 HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawCircleNormal, TestSize.Level0)
1464 {
1465 // 1. OH_Drawing_CanvasCreate
1466 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate();
1467 EXPECT_NE(canvas, nullptr);
1468 // 2. OH_Drawing_PointCreate
1469 OH_Drawing_Point *center = OH_Drawing_PointCreate(100, 100);
1470 EXPECT_NE(center, nullptr);
1471 // 3. OH_Drawing_CanvasDrawCircle
1472 OH_Drawing_CanvasDrawCircle(canvas, center, 50);
1473 // 4. Free memory
1474 OH_Drawing_CanvasDestroy(canvas);
1475 OH_Drawing_PointDestroy(center);
1476 }
1477
1478 /*
1479 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_1801
1480 * @tc.name: testCanvasDrawCircleNull
1481 * @tc.desc: test for testCanvasDrawCircleNull.
1482 * @tc.size : SmallTest
1483 * @tc.type : Function
1484 * @tc.level : Level 3
1485 */
HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawCircleNull, TestSize.Level3)1486 HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawCircleNull, TestSize.Level3)
1487 {
1488 // 1. OH_Drawing_CanvasCreate
1489 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate();
1490 EXPECT_NE(canvas, nullptr);
1491 // 2. OH_Drawing_PointCreate
1492 OH_Drawing_Point *center = OH_Drawing_PointCreate(100, 100);
1493 EXPECT_NE(center, nullptr);
1494 // 3. OH_Drawing_CanvasDrawCircle with the first parameter being null
1495 OH_Drawing_CanvasDrawCircle(nullptr, center, 50);
1496 // 4. OH_Drawing_CanvasDrawCircle with the second parameter being null
1497 OH_Drawing_CanvasDrawCircle(canvas, nullptr, 50);
1498 // 5. OH_Drawing_CanvasDrawCircle with the third parameter being 0
1499 OH_Drawing_CanvasDrawCircle(canvas, center, 0);
1500 // 6. Free memory
1501 OH_Drawing_CanvasDestroy(canvas);
1502 OH_Drawing_PointDestroy(center);
1503 }
1504
1505 /*
1506 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_1802
1507 * @tc.name: testCanvasDrawCircleAbnormal
1508 * @tc.desc: test for testCanvasDrawCircleAbnormal.
1509 * @tc.size : SmallTest
1510 * @tc.type : Function
1511 * @tc.level : Level 3
1512 */
HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawCircleAbnormal, TestSize.Level3)1513 HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawCircleAbnormal, TestSize.Level3)
1514 {
1515 // 1. OH_Drawing_CanvasCreate
1516 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate();
1517 EXPECT_NE(canvas, nullptr);
1518 // 2. OH_Drawing_PointCreate with x parameter being negative
1519 OH_Drawing_Point *center = OH_Drawing_PointCreate(-100, 100);
1520 // 3. OH_Drawing_CanvasDrawCircle
1521 OH_Drawing_CanvasDrawCircle(canvas, center, 50);
1522 // 4. OH_Drawing_PointCreate with y parameter being negative
1523 center = OH_Drawing_PointCreate(100, -100);
1524 OH_Drawing_CanvasDrawCircle(canvas, center, 50);
1525 // 5. OH_Drawing_CanvasDrawCircle with radius parameter being negative
1526 OH_Drawing_CanvasDrawCircle(canvas, center, -50);
1527 // 6. Free memory
1528 OH_Drawing_CanvasDestroy(canvas);
1529 OH_Drawing_PointDestroy(center);
1530 }
1531
1532 /*
1533 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_1803
1534 * @tc.name: testCanvasDrawCircleMaximum
1535 * @tc.desc: test for testCanvasDrawCircleMaximum.
1536 * @tc.size : SmallTest
1537 * @tc.type : Function
1538 * @tc.level : Level 3
1539 */
HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawCircleMaximum, TestSize.Level3)1540 HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawCircleMaximum, TestSize.Level3)
1541 {
1542 // 1. OH_Drawing_CanvasCreate
1543 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate();
1544 EXPECT_NE(canvas, nullptr);
1545 // 2. OH_Drawing_PointCreate with x parameter set to the maximum value
1546 OH_Drawing_Point *center = OH_Drawing_PointCreate(FLT_MAX, 100);
1547 EXPECT_NE(center, nullptr);
1548 // 3. OH_Drawing_CanvasDrawCircle
1549 OH_Drawing_CanvasDrawCircle(canvas, center, 50);
1550 // 4. OH_Drawing_PointCreate with y parameter set to the maximum value
1551 center = OH_Drawing_PointCreate(100, FLT_MAX);
1552 EXPECT_NE(center, nullptr);
1553 // 5. OH_Drawing_CanvasDrawCircle
1554 OH_Drawing_CanvasDrawCircle(canvas, center, 50);
1555 // 6. OH_Drawing_CanvasDrawCircle with radius parameter set to the maximum value
1556 OH_Drawing_CanvasDrawCircle(canvas, center, FLT_MAX);
1557 // 7. Free memory
1558 OH_Drawing_CanvasDestroy(canvas);
1559 OH_Drawing_PointDestroy(center);
1560 }
1561
1562 /*
1563 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_1804
1564 * @tc.name: testCanvasDrawCircleInputDestroyed
1565 * @tc.desc: test for testCanvasDrawCircleInputDestroyed.
1566 * @tc.size : SmallTest
1567 * @tc.type : Function
1568 * @tc.level : Level 3
1569 */
HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawCircleInputDestroyed, TestSize.Level3)1570 HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawCircleInputDestroyed, TestSize.Level3)
1571 {
1572 // Deprecated
1573 }
1574
1575 } // namespace Drawing
1576 } // namespace Rosen
1577 } // namespace OHOS