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 43using namespace testing; 44using namespace testing::ext; 45 46namespace OHOS { 47namespace Rosen { 48namespace 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 */ 57HWTEST_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 */ 101HWTEST_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 */ 153HWTEST_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 */ 211HWTEST_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 */ 259HWTEST_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 */ 307HWTEST_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 */ 320HWTEST_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 */ 346HWTEST_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 */ 375HWTEST_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 */ 388HWTEST_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 */ 416HWTEST_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 */ 447HWTEST_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 */ 484HWTEST_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 */ 497HWTEST_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 */ 538HWTEST_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 */ 571HWTEST_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 */ 622HWTEST_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 */ 654HWTEST_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 */ 695HWTEST_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 */ 708HWTEST_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 */ 775HWTEST_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 */ 848HWTEST_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 */ 877HWTEST_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 */ 908HWTEST_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 */ 921HWTEST_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 */ 986HWTEST_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 */ 1048HWTEST_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 */ 1130HWTEST_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 */ 1191HWTEST_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 */ 1238HWTEST_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 */ 1251HWTEST_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 */ 1313HWTEST_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 */ 1336HWTEST_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 */ 1375HWTEST_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 */ 1422HWTEST_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 */ 1450HWTEST_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 */ 1463HWTEST_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 */ 1486HWTEST_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 */ 1513HWTEST_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 */ 1540HWTEST_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 */ 1570HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawCircleInputDestroyed, TestSize.Level3) 1571{ 1572 // Deprecated 1573} 1574 1575} // namespace Drawing 1576} // namespace Rosen 1577} // namespace OHOS