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 "gtest/gtest.h" 17 18#include "DrawingNativeCanvasCommon.h" 19#include "drawing_bitmap.h" 20#include "drawing_brush.h" 21#include "drawing_canvas.h" 22#include "drawing_color.h" 23#include "drawing_color_filter.h" 24#include "drawing_filter.h" 25#include "drawing_font.h" 26#include "drawing_image.h" 27#include "drawing_mask_filter.h" 28#include "drawing_matrix.h" 29#include "drawing_memory_stream.h" 30#include "drawing_path.h" 31#include "drawing_pen.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 41using namespace testing; 42using namespace testing::ext; 43 44namespace OHOS { 45namespace Rosen { 46namespace Drawing { 47 48/* 49 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_2900 50 * @tc.name: testCanvasSkewNormal 51 * @tc.desc: test for testCanvasSkewNormal. 52 * @tc.size : SmallTest 53 * @tc.type : Function 54 * @tc.level : Level 0 55 */ 56HWTEST_F(DrawingNativeCanvasTest, testCanvasSkewNormal, TestSize.Level0) { 57 // 1. OH_Drawing_CanvasCreate 58 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 59 // 2. OH_Drawing_CanvasSkew with positive skew values on the x and y axes 60 OH_Drawing_CanvasSkew(canvas, 1.0, 1.0); 61 // 3. Call drawing class interface 62 OH_Drawing_Rect *rect1 = OH_Drawing_RectCreate(0, 0, 100, 100); 63 OH_Drawing_CanvasDrawRect(canvas, rect1); 64 // 4. OH_Drawing_CanvasSkew with negative skew values on the x and y axes 65 OH_Drawing_CanvasSkew(canvas, -1.0, -1.0); 66 // 5. Call drawing class interface 67 OH_Drawing_Rect *rect2 = OH_Drawing_RectCreate(0, 0, 100, 100); 68 OH_Drawing_CanvasDrawRect(canvas, rect2); 69 // 6. OH_Drawing_CanvasSkew with positive skew value on the x-axis and negative skew value on the y-axis 70 OH_Drawing_CanvasSkew(canvas, 1.0, -1.0); 71 // 7. Call drawing class interface 72 OH_Drawing_Rect *rect3 = OH_Drawing_RectCreate(0, 0, 100, 100); 73 OH_Drawing_CanvasDrawRect(canvas, rect3); 74 // 8. Free memory 75 OH_Drawing_RectDestroy(rect1); 76 OH_Drawing_RectDestroy(rect2); 77 OH_Drawing_RectDestroy(rect3); 78 OH_Drawing_CanvasDestroy(canvas); 79} 80 81/* 82 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_2901 83 * @tc.name: testCanvasSkewNull 84 * @tc.desc: test for testCanvasSkewNull. 85 * @tc.size : SmallTest 86 * @tc.type : Function 87 * @tc.level : Level 3 88 */ 89HWTEST_F(DrawingNativeCanvasTest, testCanvasSkewNull, TestSize.Level3) { 90 // 1. OH_Drawing_CanvasCreate 91 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 92 // 2. OH_Drawing_CanvasSkew with the first parameter as null 93 OH_Drawing_CanvasSkew(nullptr, 2, 2); 94 // 3. OH_Drawing_CanvasSkew with the second parameter as 0 95 OH_Drawing_CanvasSkew(canvas, 0, 2); 96 // 4. OH_Drawing_CanvasSkew with the third parameter as 0 97 OH_Drawing_CanvasSkew(canvas, 2, 0); 98 // 5. Free memory 99 OH_Drawing_CanvasDestroy(canvas); 100} 101 102/* 103 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_2903 104 * @tc.name: testCanvasSkewMaximum 105 * @tc.desc: test for testCanvasSkewMaximum. 106 * @tc.size : SmallTest 107 * @tc.type : Function 108 * @tc.level : Level 3 109 */ 110HWTEST_F(DrawingNativeCanvasTest, testCanvasSkewMaximum, TestSize.Level3) { 111 // 1. OH_Drawing_CanvasCreate 112 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 113 // 2. OH_Drawing_CanvasSkew with the skew amount sx on the x-axis as the maximum value 114 OH_Drawing_CanvasSkew(canvas, FLT_MAX, 1); 115 // 3. OH_Drawing_CanvasSkew with the skew amount sy on the y-axis as the maximum value 116 OH_Drawing_CanvasSkew(canvas, 1, FLT_MAX); 117 // 4. Free memory 118 OH_Drawing_CanvasDestroy(canvas); 119} 120 121/* 122 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_2904 123 * @tc.name: testCanvasSkewInputDestroyed 124 * @tc.desc: test for testCanvasSkewInputDestroyed. 125 * @tc.size : SmallTest 126 * @tc.type : Function 127 * @tc.level : Level 3 128 */ 129HWTEST_F(DrawingNativeCanvasTest, testCanvasSkewInputDestroyed, TestSize.Level3) { 130 // Deprecated 131} 132 133/* 134 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_2905 135 * @tc.name: testCanvasSkewMultipleCalls 136 * @tc.desc: test for testCanvasSkewMultipleCalls. 137 * @tc.size : SmallTest 138 * @tc.type : Function 139 * @tc.level : Level 3 140 */ 141HWTEST_F(DrawingNativeCanvasTest, testCanvasSkewMultipleCalls, TestSize.Level3) { 142 // 1. OH_Drawing_CanvasCreate 143 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 144 // 2. Call OH_Drawing_CanvasSkew 10 times, each time with a different skew value 145 for (int i = 0; i < 10; i++) { 146 float skew = i * 0.1; 147 OH_Drawing_CanvasSkew(canvas, skew, skew); 148 } 149 // 3. Call drawing class interface 150 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0, 0, 100, 100); 151 OH_Drawing_CanvasDrawRect(canvas, rect); 152 // 4. Free memory 153 OH_Drawing_RectDestroy(rect); 154 OH_Drawing_CanvasDestroy(canvas); 155} 156 157/* 158 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_3000 159 * @tc.name: testCanvasGetWidthtestCanvasGetHeightNormal 160 * @tc.desc: test for testCanvasGetWidthtestCanvasGetHeightNormal. 161 * @tc.size : SmallTest 162 * @tc.type : Function 163 * @tc.level : Level 0 164 */ 165HWTEST_F(DrawingNativeCanvasTest, testCanvasGetWidthtestCanvasGetHeightNormal, TestSize.Level0) { 166 // 1. OH_Drawing_CanvasCreate 167 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 168 // 2. Switch the binding to a bitmap canvas using OH_Drawing_CanvasBind, and verify the canvas information by 169 // calling OH_Drawing_CanvasGetHeight and OH_Drawing_CanvasGetWidth 170 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate(); 171 OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE}; 172 constexpr uint32_t width = 200; 173 constexpr uint32_t height = 200; 174 OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat); 175 OH_Drawing_CanvasBind(canvas, bitmap); 176 int32_t canvasWidth = OH_Drawing_CanvasGetWidth(canvas); 177 int32_t canvasHeight = OH_Drawing_CanvasGetHeight(canvas); 178 EXPECT_EQ(canvasWidth, width); 179 EXPECT_EQ(canvasHeight, height); 180 // 3. Free memory 181 OH_Drawing_BitmapDestroy(bitmap); 182 OH_Drawing_CanvasDestroy(canvas); 183} 184 185/* 186 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_3001 187 * @tc.name: testCanvasGetWidthtestCanvasGetHeightNull 188 * @tc.desc: test for testCanvasGetWidthtestCanvasGetHeightNull. 189 * @tc.size : SmallTest 190 * @tc.type : Function 191 * @tc.level : Level 3 192 */ 193HWTEST_F(DrawingNativeCanvasTest, testCanvasGetWidthtestCanvasGetHeightNull, TestSize.Level3) { 194 // 1. OH_Drawing_CanvasCreate 195 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 196 // 2. OH_Drawing_CanvasGetHeight with null input 197 int32_t canvasHeight = OH_Drawing_CanvasGetHeight(nullptr); 198 EXPECT_EQ(canvasHeight, 0); 199 // 3. OH_Drawing_CanvasGetWidth with null input 200 int32_t canvasWidth = OH_Drawing_CanvasGetWidth(nullptr); 201 EXPECT_EQ(canvasWidth, 0); 202 // 4. Free memory 203 OH_Drawing_CanvasDestroy(canvas); 204} 205 206/* 207 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_3002 208 * @tc.name: testCanvasGetWidthtestCanvasGetHeightMultipleCalls 209 * @tc.desc: test for testCanvasGetWidthtestCanvasGetHeightMultipleCalls. 210 * @tc.size : SmallTest 211 * @tc.type : Function 212 * @tc.level : Level 3 213 */ 214HWTEST_F(DrawingNativeCanvasTest, testCanvasGetWidthtestCanvasGetHeightMultipleCalls, TestSize.Level3) { 215 // 1. OH_Drawing_CanvasCreate 216 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 217 // 2. Switch the binding to a bitmap canvas with different widths and heights 10 times, and verify the canvas 218 // information by calling OH_Drawing_CanvasGetHeight and OH_Drawing_CanvasGetWidth after each switch 219 for (int i = 0; i < 10; i++) { 220 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate(); 221 OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE}; 222 uint32_t width = 200 + i * 10; 223 uint32_t height = 200 + i * 10; 224 OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat); 225 OH_Drawing_CanvasBind(canvas, bitmap); 226 int32_t canvasWidth = OH_Drawing_CanvasGetWidth(canvas); 227 int32_t canvasHeight = OH_Drawing_CanvasGetHeight(canvas); 228 EXPECT_EQ(canvasWidth, width); 229 EXPECT_EQ(canvasHeight, height); 230 OH_Drawing_BitmapDestroy(bitmap); 231 } 232 // 3. Switch the binding to different widths and heights of bitmap canvas 10 times 233 for (int i = 0; i < 10; i++) { 234 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate(); 235 OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE}; 236 uint32_t width = 200 + i * 10; 237 uint32_t height = 200 + i * 10; 238 OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat); 239 OH_Drawing_CanvasBind(canvas, bitmap); 240 OH_Drawing_BitmapDestroy(bitmap); 241 } 242 243 // 4. Call OH_Drawing_CanvasGetHeight and OH_Drawing_CanvasGetWidth 10 times to verify the canvas 244 for (int i = 0; i < 10; i++) { 245 int32_t canvasWidth = OH_Drawing_CanvasGetWidth(canvas); 246 int32_t canvasHeight = OH_Drawing_CanvasGetHeight(canvas); 247 EXPECT_EQ(canvasWidth, 200 + 90); 248 EXPECT_EQ(canvasHeight, 200 + 90); 249 } 250 251 // 5. Free memory 252 OH_Drawing_CanvasDestroy(canvas); 253} 254 255/* 256 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_3003 257 * @tc.name: testCanvasGetWidthtestCanvasGetHeightInputDestroyed 258 * @tc.desc: test for testCanvasGetWidthtestCanvasGetHeightInputDestroyed. 259 * @tc.size : SmallTest 260 * @tc.type : Function 261 * @tc.level : Level 3 262 */ 263HWTEST_F(DrawingNativeCanvasTest, testCanvasGetWidthtestCanvasGetHeightInputDestroyed, TestSize.Level3) { 264 // Deprecated 265} 266 267/* 268 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_3004 269 * @tc.name: testCanvasGetWidthtestCanvasGetHeightMultipleCallsBoudary 270 * @tc.desc: test for testCanvasGetWidthtestCanvasGetHeightMultipleCallsBoudary. 271 * @tc.size : SmallTest 272 * @tc.type : Function 273 * @tc.level : Level 3 274 */ 275HWTEST_F(DrawingNativeCanvasTest, testCanvasGetWidthtestCanvasGetHeightMultipleCallsBoudary, TestSize.Level3) { 276 // 1. OH_Drawing_CanvasCreate 277 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 278 // 2. Switch the binding to a bitmap canvas with different widths and heights 10 times, and verify the canvas 279 // information by calling OH_Drawing_CanvasGetHeight and OH_Drawing_CanvasGetWidth after each switch 280 constexpr uint32_t width = 4096; 281 constexpr uint32_t height = 2160; 282 for (int i = 0; i < 10; i++) { 283 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate(); 284 OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE}; 285 OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat); 286 OH_Drawing_CanvasBind(canvas, bitmap); 287 int32_t canvasWidth = OH_Drawing_CanvasGetWidth(canvas); 288 int32_t canvasHeight = OH_Drawing_CanvasGetHeight(canvas); 289 EXPECT_EQ(canvasWidth, width); 290 EXPECT_EQ(canvasHeight, height); 291 OH_Drawing_BitmapDestroy(bitmap); 292 } 293 // 3. Switch the binding to different widths and heights of bitmap canvas 10 times 294 for (int i = 0; i < 10; i++) { 295 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate(); 296 OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE}; 297 OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat); 298 OH_Drawing_CanvasBind(canvas, bitmap); 299 OH_Drawing_BitmapDestroy(bitmap); 300 } 301 302 // 4. Call OH_Drawing_CanvasGetHeight and OH_Drawing_CanvasGetWidth 10 times to verify the canvas 303 for (int i = 0; i < 10; i++) { 304 int32_t canvasWidth = OH_Drawing_CanvasGetWidth(canvas); 305 int32_t canvasHeight = OH_Drawing_CanvasGetHeight(canvas); 306 EXPECT_EQ(canvasWidth, width); 307 EXPECT_EQ(canvasHeight, height); 308 } 309 310 // 5. Free memory 311 OH_Drawing_CanvasDestroy(canvas); 312} 313 314/* 315 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_3100 316 * @tc.name: testCanvasGetLocalClipBoundsNormal 317 * @tc.desc: test for testCanvasGetLocalClipBoundsNormal. 318 * @tc.size : SmallTest 319 * @tc.type : Function 320 * @tc.level : Level 0 321 */ 322HWTEST_F(DrawingNativeCanvasTest, testCanvasGetLocalClipBoundsNormal, TestSize.Level0) { 323 // 1. OH_Drawing_CanvasCreate 324 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 325 // 2. OH_Drawing_RectCreate 326 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0, 0, 100, 100); 327 // 3. OH_Drawing_CanvasGetLocalClipBounds 328 OH_Drawing_CanvasGetLocalClipBounds(canvas, rect); 329 // 4. OH_Drawing_CanvasDrawRect 330 OH_Drawing_CanvasDrawRect(canvas, rect); 331 // 5. Free memory 332 OH_Drawing_RectDestroy(rect); 333 OH_Drawing_CanvasDestroy(canvas); 334} 335 336/* 337 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_3101 338 * @tc.name: testCanvasGetLocalClipBoundsNull 339 * @tc.desc: test for testCanvasGetLocalClipBoundsNull. 340 * @tc.size : SmallTest 341 * @tc.type : Function 342 * @tc.level : Level 3 343 */ 344HWTEST_F(DrawingNativeCanvasTest, testCanvasGetLocalClipBoundsNull, TestSize.Level3) { 345 // 1. OH_Drawing_CanvasCreate 346 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 347 // 2. OH_Drawing_RectCreate 348 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0, 0, 100, 100); 349 // 3. OH_Drawing_CanvasGetLocalClipBounds with the first parameter as null 350 OH_Drawing_CanvasGetLocalClipBounds(nullptr, rect); 351 // 4. OH_Drawing_CanvasGetLocalClipBounds with the second parameter as null 352 OH_Drawing_CanvasGetLocalClipBounds(canvas, nullptr); 353 // 5. OH_Drawing_CanvasGetLocalClipBounds with OH_Drawing_Rect created with left, top, right, bottom as 0 354 rect = OH_Drawing_RectCreate(0, 100, 100, 100); 355 OH_Drawing_CanvasGetLocalClipBounds(canvas, rect); 356 rect = OH_Drawing_RectCreate(100, 0, 100, 100); 357 OH_Drawing_CanvasGetLocalClipBounds(canvas, rect); 358 rect = OH_Drawing_RectCreate(100, 100, 0, 100); 359 OH_Drawing_CanvasGetLocalClipBounds(canvas, rect); 360 rect = OH_Drawing_RectCreate(100, 100, 100, 0); 361 OH_Drawing_CanvasGetLocalClipBounds(canvas, rect); 362 // 6. OH_Drawing_CanvasGetLocalClipBounds with OH_Drawing_Rect created with all values as 0 363 rect = OH_Drawing_RectCreate(0, 0, 0, 0); 364 OH_Drawing_CanvasGetLocalClipBounds(canvas, rect); 365 // 7. Free memory 366 OH_Drawing_RectDestroy(rect); 367} 368 369/* 370 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_3102 371 * @tc.name: testCanvasGetLocalClipBoundsAbnormal 372 * @tc.desc: test for testCanvasGetLocalClipBoundsAbnormal. 373 * @tc.size : SmallTest 374 * @tc.type : Function 375 * @tc.level : Level 3 376 */ 377HWTEST_F(DrawingNativeCanvasTest, testCanvasGetLocalClipBoundsAbnormal, TestSize.Level3) { 378 // 1. OH_Drawing_CanvasCreate 379 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 380 // 2. OH_Drawing_CanvasGetLocalClipBounds with OH_Drawing_Rect created with negative values for left, top, right, 381 // and bottom 382 OH_Drawing_Rect *rect1 = OH_Drawing_RectCreate(-100, 100, 100, 100); 383 OH_Drawing_CanvasGetLocalClipBounds(canvas, rect1); 384 OH_Drawing_Rect *rect2 = OH_Drawing_RectCreate(100, -100, 100, 100); 385 OH_Drawing_CanvasGetLocalClipBounds(canvas, rect2); 386 OH_Drawing_Rect *rect3 = OH_Drawing_RectCreate(100, 100, -100, 100); 387 OH_Drawing_CanvasGetLocalClipBounds(canvas, rect3); 388 OH_Drawing_Rect *rect4 = OH_Drawing_RectCreate(100, 100, 100, -100); 389 OH_Drawing_CanvasGetLocalClipBounds(canvas, rect4); 390 // 3. OH_Drawing_CanvasGetLocalClipBounds with OH_Drawing_Rect src created with the top-left coordinate equal to the 391 // bottom-right coordinate or the top-left coordinate equal to the bottom-right coordinate 392 OH_Drawing_Rect *rect5 = OH_Drawing_RectCreate(100, 200, 200, 200); 393 OH_Drawing_CanvasGetLocalClipBounds(canvas, rect5); 394 OH_Drawing_Rect *rect6 = OH_Drawing_RectCreate(200, 100, 200, 200); 395 OH_Drawing_CanvasGetLocalClipBounds(canvas, rect6); 396 // 4. OH_Drawing_CanvasGetLocalClipBounds with OH_Drawing_Rect src created with the top-left coordinate equal to the 397 // bottom-right coordinate 398 OH_Drawing_Rect *rect7 = OH_Drawing_RectCreate(100, 100, 100, 100); 399 OH_Drawing_CanvasGetLocalClipBounds(canvas, rect7); 400 // 5. OH_Drawing_CanvasGetLocalClipBounds with OH_Drawing_Rect src created with the top-left coordinate greater than 401 // the bottom-right coordinate 402 OH_Drawing_Rect *rect8 = OH_Drawing_RectCreate(200, 200, 100, 100); 403 OH_Drawing_CanvasGetLocalClipBounds(canvas, rect8); 404 // 6. Free memory 405 OH_Drawing_RectDestroy(rect1); 406 OH_Drawing_RectDestroy(rect2); 407 OH_Drawing_RectDestroy(rect3); 408 OH_Drawing_RectDestroy(rect4); 409 OH_Drawing_RectDestroy(rect5); 410 OH_Drawing_RectDestroy(rect6); 411 OH_Drawing_RectDestroy(rect7); 412 OH_Drawing_RectDestroy(rect8); 413 OH_Drawing_CanvasDestroy(canvas); 414} 415 416/* 417 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_3103 418 * @tc.name: testCanvasGetLocalClipBoundsMultipleCalls 419 * @tc.desc: test for testCanvasGetLocalClipBoundsMultipleCalls. 420 * @tc.size : SmallTest 421 * @tc.type : Function 422 * @tc.level : Level 3 423 */ 424HWTEST_F(DrawingNativeCanvasTest, testCanvasGetLocalClipBoundsMultipleCalls, TestSize.Level3) { 425 // 1. OH_Drawing_CanvasCreate 426 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 427 // 2. Switch the binding to a bitmap canvas with different widths and heights 10 times, and verify the canvas 428 // information by calling OH_Drawing_CanvasGetLocalClipBounds after each switch 429 for (int i = 0; i < 10; i++) { 430 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate(); 431 OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE}; 432 uint32_t width = 200; 433 uint32_t height = 200; 434 OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat); 435 OH_Drawing_CanvasBind(canvas, bitmap); 436 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0, 0, width, height); 437 OH_Drawing_CanvasGetLocalClipBounds(canvas, rect); 438 OH_Drawing_RectDestroy(rect); 439 OH_Drawing_BitmapDestroy(bitmap); 440 } 441 // 3. Switch the binding to different widths and heights of bitmap canvas 10 times 442 for (int i = 0; i < 10; i++) { 443 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate(); 444 OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE}; 445 uint32_t width = 200 + i * 10; 446 uint32_t height = 200 + i * 10; 447 OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat); 448 OH_Drawing_CanvasBind(canvas, bitmap); 449 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0, 0, width, height); 450 OH_Drawing_CanvasGetLocalClipBounds(canvas, rect); 451 OH_Drawing_RectDestroy(rect); 452 OH_Drawing_BitmapDestroy(bitmap); 453 } 454 // 4. Call OH_Drawing_CanvasGetLocalClipBounds 10 times to verify the canvas 455 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0, 0, 200, 200); 456 for (int i = 0; i < 10; i++) { 457 OH_Drawing_CanvasGetLocalClipBounds(canvas, rect); 458 } 459 // 5. Free memory 460 OH_Drawing_RectDestroy(rect); 461 OH_Drawing_CanvasDestroy(canvas); 462} 463 464/* 465 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_3104 466 * @tc.name: testCanvasGetLocalClipBoundsInputDestroyed 467 * @tc.desc: test for testCanvasGetLocalClipBoundsInputDestroyed. 468 * @tc.size : SmallTest 469 * @tc.type : Function 470 * @tc.level : Level 3 471 */ 472HWTEST_F(DrawingNativeCanvasTest, testCanvasGetLocalClipBoundsInputDestroyed, TestSize.Level3) { 473 // Deprecated 474} 475 476/* 477 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_3105 478 * @tc.name: testCanvasGetLocalClipBoundsMultipleCallsBoundary 479 * @tc.desc: test for testCanvasGetLocalClipBoundsMultipleCallsBoundary. 480 * @tc.size : SmallTest 481 * @tc.type : Function 482 * @tc.level : Level 3 483 */ 484HWTEST_F(DrawingNativeCanvasTest, testCanvasGetLocalClipBoundsMultipleCallsBoundary, TestSize.Level3) { 485 // 1. OH_Drawing_CanvasCreate 486 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 487 // 2. Switch the binding to a bitmap canvas with different widths and heights 10 times, and verify the canvas 488 // information by calling OH_Drawing_CanvasGetLocalClipBounds after each switch 489 uint32_t width = 4096; 490 uint32_t height = 2160; 491 for (int i = 0; i < 10; i++) { 492 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate(); 493 OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE}; 494 OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat); 495 OH_Drawing_CanvasBind(canvas, bitmap); 496 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0, 0, width, height); 497 OH_Drawing_CanvasGetLocalClipBounds(canvas, rect); 498 OH_Drawing_RectDestroy(rect); 499 OH_Drawing_BitmapDestroy(bitmap); 500 } 501 // 3. Switch the binding to different widths and heights of bitmap canvas 10 times 502 for (int i = 0; i < 10; i++) { 503 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate(); 504 OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE}; 505 OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat); 506 OH_Drawing_CanvasBind(canvas, bitmap); 507 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0, 0, width, height); 508 OH_Drawing_CanvasGetLocalClipBounds(canvas, rect); 509 OH_Drawing_RectDestroy(rect); 510 OH_Drawing_BitmapDestroy(bitmap); 511 } 512 // 4. Call OH_Drawing_CanvasGetLocalClipBounds 10 times to verify the canvas 513 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0, 0, 200, 200); 514 for (int i = 0; i < 10; i++) { 515 OH_Drawing_CanvasGetLocalClipBounds(canvas, rect); 516 } 517 // 5. Free memory 518 OH_Drawing_RectDestroy(rect); 519 OH_Drawing_CanvasDestroy(canvas); 520} 521 522/* 523 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_3200 524 * @tc.name: testCanvasConcatMatrixtestCanvasGetTotalMatrixNormal 525 * @tc.desc: test for testCanvasConcatMatrixtestCanvasGetTotalMatrixNormal. 526 * @tc.size : SmallTest 527 * @tc.type : Function 528 * @tc.level : Level 0 529 */ 530HWTEST_F(DrawingNativeCanvasTest, testCanvasConcatMatrixtestCanvasGetTotalMatrixNormal, TestSize.Level0) { 531 // 1. OH_Drawing_CanvasCreate 532 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 533 // 2. OH_Drawing_MatrixCreate 534 OH_Drawing_Matrix *matrix = OH_Drawing_MatrixCreate(); 535 OH_Drawing_MatrixSetMatrix(matrix, 1, 0, 0, 0, -1, 0, 0, 0, 1); 536 // 3. Call OH_Drawing_CanvasConcatMatrix to get the 3x3 matrix of the canvas by calling 537 // OH_Drawing_CanvasGetTotalMatrix 538 OH_Drawing_CanvasConcatMatrix(canvas, matrix); 539 OH_Drawing_Matrix *totalMatrix = OH_Drawing_MatrixCreate(); 540 OH_Drawing_CanvasGetTotalMatrix(canvas, totalMatrix); 541 EXPECT_NE(totalMatrix, nullptr); 542 // 4. Free memory 543 OH_Drawing_MatrixDestroy(matrix); 544 OH_Drawing_MatrixDestroy(totalMatrix); 545 OH_Drawing_CanvasDestroy(canvas); 546} 547 548/* 549 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_3201 550 * @tc.name: testCanvasConcatMatrixNull 551 * @tc.desc: test for testCanvasConcatMatrixNull. 552 * @tc.size : SmallTest 553 * @tc.type : Function 554 * @tc.level : Level 3 555 */ 556HWTEST_F(DrawingNativeCanvasTest, testCanvasConcatMatrixNull, TestSize.Level3) { 557 // 1. OH_Drawing_CanvasCreate 558 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 559 // 2. OH_Drawing_MatrixCreate 560 OH_Drawing_Matrix *matrix = OH_Drawing_MatrixCreate(); 561 OH_Drawing_MatrixSetMatrix(matrix, 1, 0, 0, 0, -1, 0, 0, 0, 1); 562 // 3. OH_Drawing_CanvasConcatMatrix with the first parameter as null 563 OH_Drawing_CanvasConcatMatrix(nullptr, matrix); 564 // 4. OH_Drawing_CanvasConcatMatrix with the second parameter as null 565 OH_Drawing_CanvasConcatMatrix(canvas, nullptr); 566 // 5. Free memory 567 OH_Drawing_MatrixDestroy(matrix); 568 OH_Drawing_CanvasDestroy(canvas); 569} 570 571/* 572 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_3202 573 * @tc.name: testCanvasGetTotalMatrixNull 574 * @tc.desc: test for testCanvasGetTotalMatrixNull. 575 * @tc.size : SmallTest 576 * @tc.type : Function 577 * @tc.level : Level 3 578 */ 579HWTEST_F(DrawingNativeCanvasTest, testCanvasGetTotalMatrixNull, TestSize.Level3) { 580 // 1. OH_Drawing_CanvasCreate 581 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 582 // 2. OH_Drawing_MatrixCreate 583 OH_Drawing_Matrix *matrix = OH_Drawing_MatrixCreate(); 584 // 3. OH_Drawing_CanvasGetTotalMatrix with the first parameter as null 585 OH_Drawing_CanvasGetTotalMatrix(nullptr, matrix); 586 // 4. OH_Drawing_CanvasGetTotalMatrix with the second parameter as null 587 OH_Drawing_CanvasGetTotalMatrix(canvas, nullptr); 588 // 5. Free memory 589 OH_Drawing_MatrixDestroy(matrix); 590} 591 592/* 593 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_3203 594 * @tc.name: testCanvasConcatMatrixtestCanvasGetTotalMatrixMultipleCalls 595 * @tc.desc: test for testCanvasConcatMatrixtestCanvasGetTotalMatrixMultipleCalls. 596 * @tc.size : SmallTest 597 * @tc.type : Function 598 * @tc.level : Level 3 599 */ 600HWTEST_F(DrawingNativeCanvasTest, testCanvasConcatMatrixtestCanvasGetTotalMatrixMultipleCalls, TestSize.Level3) { 601 // 1. OH_Drawing_CanvasCreate 602 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 603 // 2. OH_Drawing_MatrixCreateScale 604 OH_Drawing_Matrix *matrix = OH_Drawing_MatrixCreateScale(10, 10, 10, 10); 605 // 3. Call OH_Drawing_CanvasConcatMatrix to get the 3x3 matrix of the canvas by calling 606 // OH_Drawing_CanvasGetTotalMatrix 607 OH_Drawing_CanvasConcatMatrix(canvas, matrix); 608 OH_Drawing_Matrix *totalMatrix = OH_Drawing_MatrixCreate(); 609 OH_Drawing_CanvasGetTotalMatrix(canvas, totalMatrix); 610 // 4. OH_Drawing_MatrixCreateRotation 611 OH_Drawing_Matrix *matrix2 = OH_Drawing_MatrixCreateRotation(180, 1, 1); 612 // 5. Call OH_Drawing_CanvasConcatMatrix to get the 3x3 matrix of the canvas by calling 613 // OH_Drawing_CanvasGetTotalMatrix 614 OH_Drawing_CanvasConcatMatrix(canvas, matrix2); 615 OH_Drawing_Matrix *totalMatrix2 = OH_Drawing_MatrixCreate(); 616 OH_Drawing_CanvasGetTotalMatrix(canvas, totalMatrix2); 617 // 6. OH_Drawing_MatrixCreateTranslation 618 OH_Drawing_Matrix *matrix3 = OH_Drawing_MatrixCreateTranslation(10, 10); 619 // 7. Call OH_Drawing_CanvasConcatMatrix to get the 3x3 matrix of the canvas by calling 620 // OH_Drawing_CanvasGetTotalMatrix 621 OH_Drawing_CanvasConcatMatrix(canvas, matrix3); 622 OH_Drawing_Matrix *totalMatrix3 = OH_Drawing_MatrixCreate(); 623 OH_Drawing_CanvasGetTotalMatrix(canvas, totalMatrix3); 624 // 8. Repeat steps 2-7 10 times 625 for (int i = 0; i < 10; i++) { 626 OH_Drawing_Matrix *matrix = OH_Drawing_MatrixCreateScale(10, 10, 10, 10); 627 OH_Drawing_CanvasConcatMatrix(canvas, matrix); 628 OH_Drawing_Matrix *totalMatrix = OH_Drawing_MatrixCreate(); 629 OH_Drawing_CanvasGetTotalMatrix(canvas, totalMatrix); 630 631 OH_Drawing_Matrix *matrix2 = OH_Drawing_MatrixCreateRotation(180, 1, 1); 632 OH_Drawing_CanvasConcatMatrix(canvas, matrix2); 633 OH_Drawing_Matrix *totalMatrix2 = OH_Drawing_MatrixCreate(); 634 OH_Drawing_CanvasGetTotalMatrix(canvas, totalMatrix2); 635 636 OH_Drawing_Matrix *matrix3 = OH_Drawing_MatrixCreateTranslation(10, 10); 637 OH_Drawing_CanvasConcatMatrix(canvas, matrix3); 638 OH_Drawing_Matrix *totalMatrix3 = OH_Drawing_MatrixCreate(); 639 OH_Drawing_CanvasGetTotalMatrix(canvas, totalMatrix3); 640 641 OH_Drawing_MatrixDestroy(matrix); 642 OH_Drawing_MatrixDestroy(matrix2); 643 OH_Drawing_MatrixDestroy(matrix3); 644 OH_Drawing_MatrixDestroy(totalMatrix); 645 OH_Drawing_MatrixDestroy(totalMatrix2); 646 OH_Drawing_MatrixDestroy(totalMatrix3); 647 } 648 // 9. Call OH_Drawing_CanvasConcatMatrix 10 times 649 for (int i = 0; i < 10; i++) { 650 OH_Drawing_CanvasConcatMatrix(canvas, matrix); 651 } 652 653 // 10. Free memory 654 OH_Drawing_MatrixDestroy(matrix); 655 OH_Drawing_MatrixDestroy(matrix2); 656 OH_Drawing_MatrixDestroy(matrix3); 657 OH_Drawing_MatrixDestroy(totalMatrix); 658} 659 660/* 661 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_3204 662 * @tc.name: testCanvasConcatMatrixtestCanvasGetTotalMatrixInputDestroyed 663 * @tc.desc: test for testCanvasConcatMatrixtestCanvasGetTotalMatrixInputDestroyed. 664 * @tc.size : SmallTest 665 * @tc.type : Function 666 * @tc.level : Level 3 667 */ 668HWTEST_F(DrawingNativeCanvasTest, testCanvasConcatMatrixtestCanvasGetTotalMatrixInputDestroyed, TestSize.Level3) { 669 // Deprecated 670} 671 672/* 673 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_3300 674 * @tc.name: testCanvasDrawShadowNormal 675 * @tc.desc: test for testCanvasDrawShadowNormal. 676 * @tc.size : SmallTest 677 * @tc.type : Function 678 * @tc.level : Level 0 679 */ 680HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawShadowNormal, TestSize.Level0) { 681 // 1. OH_Drawing_CanvasCreate 682 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 683 EXPECT_NE(canvas, nullptr); 684 // 2. OH_Drawing_PathCreate 685 OH_Drawing_Path *path = OH_Drawing_PathCreate(); 686 EXPECT_NE(path, nullptr); 687 // 3. OH_Drawing_CanvasDrawShadow, iterate through the OH_Drawing_CanvasShadowFlags enumeration values 688 OH_Drawing_CanvasShadowFlags flags[] = { 689 SHADOW_FLAGS_NONE, 690 SHADOW_FLAGS_TRANSPARENT_OCCLUDER, 691 SHADOW_FLAGS_GEOMETRIC_ONLY, 692 SHADOW_FLAGS_ALL, 693 }; 694 OH_Drawing_Point3D p1{0.0, 0.0, 0.0}; 695 OH_Drawing_Point3D p2{10.0, 10.0, 10.0}; 696 for (int i = 0; i < 4; i++) { 697 OH_Drawing_CanvasDrawShadow(canvas, path, p1, p2, 10, 0xFF000000, 0xFF000000, flags[i]); 698 } 699 // 4. Free memory 700 OH_Drawing_PathDestroy(path); 701 OH_Drawing_CanvasDestroy(canvas); 702} 703 704/* 705 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_3301 706 * @tc.name: testCanvasDrawShadowNull 707 * @tc.desc: test for testCanvasDrawShadowNull. 708 * @tc.size : SmallTest 709 * @tc.type : Function 710 * @tc.level : Level 3 711 */ 712HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawShadowNull, TestSize.Level3) { 713 // 1. OH_Drawing_CanvasCreate 714 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 715 // 2. OH_Drawing_PathCreate 716 OH_Drawing_Path *path = OH_Drawing_PathCreate(); 717 // 3. OH_Drawing_CanvasDrawShadow with the first parameter as null 718 OH_Drawing_Point3D p1{0.0, 0.0, 0.0}; 719 OH_Drawing_Point3D p2{10.0, 10.0, 10.0}; 720 OH_Drawing_CanvasDrawShadow(nullptr, path, p1, p2, 10, 0xFF000000, 0xFF000000, SHADOW_FLAGS_ALL); 721 // 4. OH_Drawing_CanvasDrawShadow with the second parameter as null 722 OH_Drawing_CanvasDrawShadow(canvas, nullptr, p1, p2, 10, 0xFF000000, 0xFF000000, SHADOW_FLAGS_ALL); 723 // 5. OH_Drawing_CanvasDrawShadow with the third parameter as null 724 // Unable to test, compilation error 725 // 6. OH_Drawing_CanvasDrawShadow with the fourth parameter as null 726 // Unable to test, compilation error 727 // 7. OH_Drawing_CanvasDrawShadow with the fifth parameter as 0 728 OH_Drawing_CanvasDrawShadow(canvas, path, p1, p2, 0, 0xFF000000, 0xFF000000, SHADOW_FLAGS_ALL); 729 // 8. OH_Drawing_CanvasDrawShadow with the sixth parameter as 0 730 OH_Drawing_CanvasDrawShadow(canvas, path, p1, p2, 10, 0, 0xFF000000, SHADOW_FLAGS_ALL); 731 // 9. OH_Drawing_CanvasDrawShadow with the seventh parameter as 0 732 OH_Drawing_CanvasDrawShadow(canvas, path, p1, p2, 10, 0xFF000000, 0, SHADOW_FLAGS_ALL); 733 // 10. Free memory 734 OH_Drawing_PathDestroy(path); 735 OH_Drawing_CanvasDestroy(canvas); 736} 737 738/* 739 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_3302 740 * @tc.name: testCanvasDrawShadowAbnormal 741 * @tc.desc: test for testCanvasDrawShadowAbnormal. 742 * @tc.size : SmallTest 743 * @tc.type : Function 744 * @tc.level : Level 3 745 */ 746HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawShadowAbnormal, TestSize.Level3) { 747 // 1. OH_Drawing_CanvasCreate 748 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 749 // 2. OH_Drawing_PathCreate 750 OH_Drawing_Path *path = OH_Drawing_PathCreate(); 751 // 3. OH_Drawing_CanvasDrawShadow, the third parameter planeParams x, y, z are set to negative values 752 OH_Drawing_Point3D p1{-1.0, -1.0, -1.0}; 753 OH_Drawing_Point3D p2{10.0, 10.0, 10.0}; 754 OH_Drawing_CanvasDrawShadow(canvas, path, p1, p2, 10, 0xFF000000, 0xFF000000, SHADOW_FLAGS_ALL); 755 // 4. OH_Drawing_CanvasDrawShadow, the fourth parameter devLightPos x, y, z are set to negative values 756 OH_Drawing_Point3D p3{0.0, 0.0, 0.0}; 757 OH_Drawing_Point3D p4{-10.0, -10.0, -10.0}; 758 OH_Drawing_CanvasDrawShadow(canvas, path, p3, p4, 10, 0xFF000000, 0xFF000000, SHADOW_FLAGS_ALL); 759 // 5. OH_Drawing_CanvasDrawShadow, the fifth parameter lightRadius is set to a negative value 760 OH_Drawing_CanvasDrawShadow(canvas, path, p3, p4, -10, 0xFF000000, 0xFF000000, SHADOW_FLAGS_ALL); 761 // 6. OH_Drawing_CanvasDrawShadow, the sixth parameter ambientColor is set to a negative value 762 OH_Drawing_CanvasDrawShadow(canvas, path, p3, p4, 10, -0xFF000000, 0xFF000000, SHADOW_FLAGS_ALL); 763 // 7. OH_Drawing_CanvasDrawShadow, the seventh parameter spotColor is set to a negative value 764 OH_Drawing_CanvasDrawShadow(canvas, path, p3, p4, 10, 0xFF000000, -0xFF000000, SHADOW_FLAGS_ALL); 765 // 8. Free memory 766 OH_Drawing_PathDestroy(path); 767 OH_Drawing_CanvasDestroy(canvas); 768} 769 770/* 771 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_3303 772 * @tc.name: testCanvasDrawShadowMaximum 773 * @tc.desc: test for testCanvasDrawShadowMaximum. 774 * @tc.size : SmallTest 775 * @tc.type : Function 776 * @tc.level : Level 3 777 */ 778HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawShadowMaximum, TestSize.Level3) { 779 // 1. OH_Drawing_CanvasCreate 780 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 781 // 2. OH_Drawing_PathCreate 782 OH_Drawing_Path *path = OH_Drawing_PathCreate(); 783 OH_Drawing_Point3D p1{1.0, 1.0, 1.0}; 784 OH_Drawing_Point3D p2{10.0, 10.0, 10.0}; 785 // 3. OH_Drawing_CanvasDrawShadow, set the x, y, z values in the planeParams parameter to maximum values 786 p1 = {FLT_MAX, FLT_MAX, FLT_MAX}; 787 OH_Drawing_CanvasDrawShadow(canvas, path, p1, p2, 10, 0xFFFFFFFF, 0xFFFFFFFF, SHADOW_FLAGS_ALL); 788 // 4. OH_Drawing_CanvasDrawShadow, set the x, y, z values in the devLightPos parameter to maximum values 789 p1 = {1.0, 1.0, 1.0}; 790 p2 = {FLT_MAX, FLT_MAX, FLT_MAX}; 791 OH_Drawing_CanvasDrawShadow(canvas, path, p1, p2, 10, 0xFFFFFFFF, 0xFFFFFFFF, SHADOW_FLAGS_ALL); 792 // 5. OH_Drawing_CanvasDrawShadow, set the lightRadius parameter to maximum value 793 OH_Drawing_CanvasDrawShadow(canvas, path, p1, p2, FLT_MAX, 0xFFFFFFFF, 0xFFFFFFFF, SHADOW_FLAGS_ALL); 794 // 6. OH_Drawing_CanvasDrawShadow, set the ambientColor parameter to maximum value 795 OH_Drawing_CanvasDrawShadow(canvas, path, p1, p2, 10, 0xFFFFFFFF, 0xFFFFFFFF, SHADOW_FLAGS_ALL); 796 // 7. OH_Drawing_CanvasDrawShadow, set the spotColor parameter to maximum value 797 OH_Drawing_CanvasDrawShadow(canvas, path, p1, p2, 10, 0xFFFFFFFF, 0xFFFFFFFF, SHADOW_FLAGS_ALL); 798 // 8. Free memory 799 OH_Drawing_PathDestroy(path); 800 OH_Drawing_CanvasDestroy(canvas); 801} 802 803/* 804 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_3304 805 * @tc.name: testCanvasDrawShadowInputDestroyed 806 * @tc.desc: test for testCanvasDrawShadowInputDestroyed. 807 * @tc.size : SmallTest 808 * @tc.type : Function 809 * @tc.level : Level 3 810 */ 811HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawShadowInputDestroyed, TestSize.Level3) { 812 // Deprecated 813} 814 815/* 816 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_3400 817 * @tc.name: testCanvasClearNormal 818 * @tc.desc: test for testCanvasClearNormal. 819 * @tc.size : SmallTest 820 * @tc.type : Function 821 * @tc.level : Level 0 822 */ 823HWTEST_F(DrawingNativeCanvasTest, testCanvasClearNormal, TestSize.Level0) { 824 // 1. OH_Drawing_CanvasCreate 825 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 826 // 2. OH_Drawing_CanvasClear, covering the minimum value 0x00000000 and the maximum value 0xFFFFFFFF for color 827 OH_Drawing_CanvasClear(canvas, 0x00000000); 828 OH_Drawing_CanvasClear(canvas, 0xFFFFFFFF); 829 // 3. Free memory 830 OH_Drawing_CanvasDestroy(canvas); 831} 832 833/* 834 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_3401 835 * @tc.name: testCanvasClearNull 836 * @tc.desc: test for testCanvasClearNull. 837 * @tc.size : SmallTest 838 * @tc.type : Function 839 * @tc.level : Level 3 840 */ 841HWTEST_F(DrawingNativeCanvasTest, testCanvasClearNull, TestSize.Level3) { 842 // 1. OH_Drawing_CanvasCreate 843 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 844 // 2. OH_Drawing_CanvasClear with the first parameter as null 845 OH_Drawing_CanvasClear(nullptr, 0x00000000); 846 // 3. Free memory 847 OH_Drawing_CanvasDestroy(canvas); 848} 849 850/* 851 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_3402 852 * @tc.name: testCanvasClearAbnormal 853 * @tc.desc: test for testCanvasClearAbnormal. 854 * @tc.size : SmallTest 855 * @tc.type : Function 856 * @tc.level : Level 3 857 */ 858HWTEST_F(DrawingNativeCanvasTest, testCanvasClearAbnormal, TestSize.Level3) { 859 // 1. OH_Drawing_CanvasCreate 860 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 861 // 2. OH_Drawing_CanvasClear with the parameter color set to a negative value 862 OH_Drawing_CanvasClear(canvas, -1); 863 // 3. OH_Drawing_CanvasClear with the parameter color set to a floating-point value 864 // compile error, ignore 865 // 4. Free memory 866 OH_Drawing_CanvasDestroy(canvas); 867} 868 869/* 870 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_3403 871 * @tc.name: testCanvasClearMultipleCalls 872 * @tc.desc: test for testCanvasClearMultipleCalls. 873 * @tc.size : SmallTest 874 * @tc.type : Function 875 * @tc.level : Level 3 876 */ 877HWTEST_F(DrawingNativeCanvasTest, testCanvasClearMultipleCalls, TestSize.Level3) { 878 // 1. OH_Drawing_CanvasCreate 879 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 880 // 2. Call OH_Drawing_CanvasClear 10 times, each time with a different color 881 for (int i = 0; i < 10; i++) { 882 OH_Drawing_CanvasClear(canvas, 0x11111111 + i * 10); 883 } 884 // 3. Free memory 885 OH_Drawing_CanvasDestroy(canvas); 886} 887 888/* 889 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_3404 890 * @tc.name: testCanvasClearInputDestroyed 891 * @tc.desc: test for testCanvasClearInputDestroyed. 892 * @tc.size : SmallTest 893 * @tc.type : Function 894 * @tc.level : Level 3 895 */ 896HWTEST_F(DrawingNativeCanvasTest, testCanvasClearInputDestroyed, TestSize.Level3) { 897 // Deprecated 898} 899 900/* 901 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_3405 902 * @tc.name: testCanvasClearMaximum 903 * @tc.desc: test for testCanvasClearMaximum. 904 * @tc.size : SmallTest 905 * @tc.type : Function 906 * @tc.level : Level 3 907 */ 908HWTEST_F(DrawingNativeCanvasTest, testCanvasClearMaximum, TestSize.Level3) { 909 // 1. OH_Drawing_CanvasCreate 910 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 911 // 2. OH_Drawing_CanvasClear with the parameter color set to the maximum value 912 OH_Drawing_CanvasClear(canvas, 0xFFFFFFFF); 913 // 3. Free memory 914 OH_Drawing_CanvasDestroy(canvas); 915} 916 917/* 918 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_3500 919 * @tc.name: testCanvasSetMatrixNormal 920 * @tc.desc: test for testCanvasSetMatrixNormal. 921 * @tc.size : SmallTest 922 * @tc.type : Function 923 * @tc.level : Level 0 924 */ 925HWTEST_F(DrawingNativeCanvasTest, testCanvasSetMatrixNormal, TestSize.Level0) { 926 // 1. OH_Drawing_CanvasCreate 927 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 928 // 2. OH_Drawing_MatrixCreate 929 OH_Drawing_Matrix *matrix = OH_Drawing_MatrixCreate(); 930 OH_Drawing_MatrixSetMatrix(matrix, 1, 0, 0, 0, -1, 0, 0, 0, 1); 931 // 3. Call OH_Drawing_CanvasSetMatrix and use OH_Drawing_MatrixGetValue to get the matrix information 932 OH_Drawing_CanvasSetMatrix(canvas, matrix); 933 float val = OH_Drawing_MatrixGetValue(matrix, 0); 934 EXPECT_EQ(val, 1); 935 936 // 4. Free memory 937 OH_Drawing_MatrixDestroy(matrix); 938 OH_Drawing_CanvasDestroy(canvas); 939} 940 941/* 942 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_3501 943 * @tc.name: testCanvasSetMatrixNull 944 * @tc.desc: test for testCanvasSetMatrixNull. 945 * @tc.size : SmallTest 946 * @tc.type : Function 947 * @tc.level : Level 3 948 */ 949HWTEST_F(DrawingNativeCanvasTest, testCanvasSetMatrixNull, TestSize.Level3) { 950 // 1. OH_Drawing_CanvasCreate 951 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 952 // 2. OH_Drawing_MatrixCreate 953 OH_Drawing_Matrix *matrix = OH_Drawing_MatrixCreate(); 954 OH_Drawing_MatrixSetMatrix(matrix, 1, 0, 0, 0, -1, 0, 0, 0, 1); 955 // 3. OH_Drawing_CanvasSetMatrix with the first parameter as null 956 OH_Drawing_CanvasSetMatrix(nullptr, matrix); 957 // 4. OH_Drawing_CanvasSetMatrix with the second parameter as null 958 OH_Drawing_CanvasSetMatrix(canvas, nullptr); 959 // 5. Free memory 960 OH_Drawing_MatrixDestroy(matrix); 961 OH_Drawing_CanvasDestroy(canvas); 962} 963 964/* 965 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_3502 966 * @tc.name: testCanvasSetMatrixMultipleCalls 967 * @tc.desc: test for testCanvasSetMatrixMultipleCalls. 968 * @tc.size : SmallTest 969 * @tc.type : Function 970 * @tc.level : Level 3 971 */ 972HWTEST_F(DrawingNativeCanvasTest, testCanvasSetMatrixMultipleCalls, TestSize.Level3) { 973 // 1. OH_Drawing_CanvasCreate 974 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 975 // 2. OH_Drawing_MatrixCreate 976 OH_Drawing_Matrix *matrix = OH_Drawing_MatrixCreate(); 977 OH_Drawing_MatrixSetMatrix(matrix, 1, 0, 0, 0, -1, 0, 0, 0, 1); 978 // 3. Call OH_Drawing_CanvasSetMatrix 10 times, and after each call, call OH_Drawing_MatrixGetValue to get the 979 // matrix information 980 for (int i = 0; i < 10; i++) { 981 OH_Drawing_CanvasSetMatrix(canvas, matrix); 982 float val = OH_Drawing_MatrixGetValue(matrix, 0); 983 EXPECT_EQ(val, 1); 984 } 985 // 4. Free memory 986 OH_Drawing_MatrixDestroy(matrix); 987 OH_Drawing_CanvasDestroy(canvas); 988} 989 990/* 991 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_3503 992 * @tc.name: testCanvasSetMatrixInputDestroyed 993 * @tc.desc: test for testCanvasSetMatrixInputDestroyed. 994 * @tc.size : SmallTest 995 * @tc.type : Function 996 * @tc.level : Level 3 997 */ 998HWTEST_F(DrawingNativeCanvasTest, testCanvasSetMatrixInputDestroyed, TestSize.Level3) { 999 // Deprecated 1000} 1001 1002/* 1003 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_3600 1004 * @tc.name: testCanvasResetMatrixNormal 1005 * @tc.desc: test for testCanvasResetMatrixNormal. 1006 * @tc.size : SmallTest 1007 * @tc.type : Function 1008 * @tc.level : Level 0 1009 */ 1010HWTEST_F(DrawingNativeCanvasTest, testCanvasResetMatrixNormal, TestSize.Level0) { 1011 // 1. Call OH_Drawing_CanvasCreate to create a canvas object 1012 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1013 // 2. Call OH_Drawing_CanvasResetMatrix 1014 OH_Drawing_CanvasResetMatrix(canvas); 1015 // 3. Free memory 1016 OH_Drawing_CanvasDestroy(canvas); 1017} 1018 1019/* 1020 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_3601 1021 * @tc.name: testCanvasResetMatrixNull 1022 * @tc.desc: test for testCanvasResetMatrixNull. 1023 * @tc.size : SmallTest 1024 * @tc.type : Function 1025 * @tc.level : Level 3 1026 */ 1027HWTEST_F(DrawingNativeCanvasTest, testCanvasResetMatrixNull, TestSize.Level3) { 1028 // 1. Call OH_Drawing_CanvasResetMatrix with a null parameter 1029 OH_Drawing_CanvasResetMatrix(nullptr); 1030} 1031 1032/* 1033 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_3603 1034 * @tc.name: testCanvasResetMatrixMultipleCalls 1035 * @tc.desc: test for testCanvasResetMatrixMultipleCalls. 1036 * @tc.size : SmallTest 1037 * @tc.type : Function 1038 * @tc.level : Level 3 1039 */ 1040HWTEST_F(DrawingNativeCanvasTest, testCanvasResetMatrixMultipleCalls, TestSize.Level3) { 1041 // 1. Call OH_Drawing_CanvasCreate to create a canvas object 1042 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1043 // 2. Call OH_Drawing_MatrixCreate 1044 OH_Drawing_Matrix *matrix = OH_Drawing_MatrixCreate(); 1045 OH_Drawing_MatrixSetMatrix(matrix, 1, 0, 0, 0, -1, 0, 0, 0, 1); 1046 // 3. Call OH_Drawing_CanvasSetMatrix 10 times, call OH_Drawing_CanvasResetMatrix 10 times, and get matrix 1047 // information using OH_Drawing_MatrixGetValue 1048 for (int i = 0; i < 10; i++) { 1049 OH_Drawing_CanvasSetMatrix(canvas, matrix); 1050 } 1051 for (int i = 0; i < 10; i++) { 1052 OH_Drawing_CanvasResetMatrix(canvas); 1053 } 1054 // 4. Call OH_Drawing_CanvasSetMatrix, OH_Drawing_CanvasResetMatrix, and get matrix information using 1055 // OH_Drawing_MatrixGetValue 1056 OH_Drawing_CanvasSetMatrix(canvas, matrix); 1057 OH_Drawing_CanvasResetMatrix(canvas); 1058 float val = OH_Drawing_MatrixGetValue(matrix, 0); 1059 EXPECT_EQ(val, 1); 1060 // 5. Repeat steps 4 for 10 times 1061 for (int i = 0; i < 10; i++) { 1062 OH_Drawing_CanvasSetMatrix(canvas, matrix); 1063 OH_Drawing_CanvasResetMatrix(canvas); 1064 EXPECT_EQ(OH_Drawing_MatrixGetValue(matrix, 0), 1); 1065 } 1066 // 6. Free memory 1067 OH_Drawing_MatrixDestroy(matrix); 1068 OH_Drawing_CanvasDestroy(canvas); 1069} 1070 1071/* 1072 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_3700 1073 * @tc.name: testCanvasDrawImageRectWithSrcNormal 1074 * @tc.desc: test for testCanvasDrawImageRectWithSrcNormal. 1075 * @tc.size : SmallTest 1076 * @tc.type : Function 1077 * @tc.level : Level 0 1078 */ 1079HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawImageRectWithSrcNormal, TestSize.Level0) { 1080 // 1. Call OH_Drawing_CanvasCreate to create a canvas object 1081 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1082 EXPECT_NE(canvas, nullptr); 1083 // 2. Call OH_Drawing_ImageCreate to create an image object 1084 OH_Drawing_Image *image = OH_Drawing_ImageCreate(); 1085 EXPECT_NE(image, nullptr); 1086 // 3. Call OH_Drawing_RectCreate to create a rectangle object 1087 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0, 0, 100, 100); 1088 // 4. Call OH_Drawing_RectCreate to create a rectangle object 1089 OH_Drawing_Rect *rect2 = OH_Drawing_RectCreate(0, 0, 100, 100); 1090 // 5. Call OH_Drawing_SamplingOptionsCreate to create a sampling options object 1091 OH_Drawing_SamplingOptions *options = OH_Drawing_SamplingOptionsCreate(OH_Drawing_FilterMode::FILTER_MODE_NEAREST, 1092 OH_Drawing_MipmapMode::MIPMAP_MODE_NEAREST); 1093 EXPECT_NE(options, nullptr); 1094 // 6. Call OH_Drawing_CanvasDrawImageRectWithSrc with the sixth parameter iterating through the enumeration 1095 OH_Drawing_CanvasDrawImageRectWithSrc(canvas, image, rect, rect2, options, STRICT_SRC_RECT_CONSTRAINT); 1096 OH_Drawing_CanvasDrawImageRectWithSrc(canvas, image, rect, rect2, options, FAST_SRC_RECT_CONSTRAINT); 1097 // 7. Free memory 1098 OH_Drawing_RectDestroy(rect); 1099 OH_Drawing_RectDestroy(rect2); 1100 OH_Drawing_SamplingOptionsDestroy(options); 1101 OH_Drawing_ImageDestroy(image); 1102 OH_Drawing_CanvasDestroy(canvas); 1103} 1104 1105/* 1106 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_3701 1107 * @tc.name: testCanvasDrawImageRectWithSrcNull 1108 * @tc.desc: test for testCanvasDrawImageRectWithSrcNull. 1109 * @tc.size : SmallTest 1110 * @tc.type : Function 1111 * @tc.level : Level 3 1112 */ 1113HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawImageRectWithSrcNull, TestSize.Level3) { 1114 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1115 EXPECT_NE(canvas, nullptr); 1116 OH_Drawing_Image *image = OH_Drawing_ImageCreate(); 1117 EXPECT_NE(image, nullptr); 1118 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0, 0, 100, 100); 1119 OH_Drawing_Rect *rect2 = OH_Drawing_RectCreate(0, 0, 100, 100); 1120 OH_Drawing_SamplingOptions *options = OH_Drawing_SamplingOptionsCreate(OH_Drawing_FilterMode::FILTER_MODE_NEAREST, 1121 OH_Drawing_MipmapMode::MIPMAP_MODE_NEAREST); 1122 // 1. Call OH_Drawing_CanvasDrawImageRectWithSrc with the first parameter being nullptr 1123 OH_Drawing_CanvasDrawImageRectWithSrc(nullptr, image, rect, rect2, options, STRICT_SRC_RECT_CONSTRAINT); 1124 // 2. Call OH_Drawing_CanvasDrawImageRectWithSrc with the second parameter being nullptr 1125 OH_Drawing_CanvasDrawImageRectWithSrc(canvas, nullptr, rect, rect2, options, STRICT_SRC_RECT_CONSTRAINT); 1126 // 3. Call OH_Drawing_CanvasDrawImageRectWithSrc with the third parameter being nullptr 1127 OH_Drawing_CanvasDrawImageRectWithSrc(canvas, image, nullptr, rect2, options, STRICT_SRC_RECT_CONSTRAINT); 1128 // 4. Call OH_Drawing_CanvasDrawImageRectWithSrc with the fourth parameter being nullptr 1129 OH_Drawing_CanvasDrawImageRectWithSrc(canvas, image, rect, nullptr, options, STRICT_SRC_RECT_CONSTRAINT); 1130 // 5. Call OH_Drawing_CanvasDrawImageRectWithSrc with the fifth parameter being nullptr 1131 OH_Drawing_CanvasDrawImageRectWithSrc(canvas, image, rect, rect2, nullptr, STRICT_SRC_RECT_CONSTRAINT); 1132 // 6. Free memory 1133 OH_Drawing_RectDestroy(rect); 1134 OH_Drawing_RectDestroy(rect2); 1135 OH_Drawing_SamplingOptionsDestroy(options); 1136 OH_Drawing_ImageDestroy(image); 1137 OH_Drawing_CanvasDestroy(canvas); 1138} 1139 1140/* 1141 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_3800 1142 * @tc.name: testCanvasDrawImageRectNormal 1143 * @tc.desc: test for testCanvasDrawImageRectNormal. 1144 * @tc.size : SmallTest 1145 * @tc.type : Function 1146 * @tc.level : Level 0 1147 */ 1148HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawImageRectNormal, TestSize.Level0) { 1149 // 1. Create a canvas object using OH_Drawing_CanvasCreate 1150 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1151 // 2. Create an image object using OH_Drawing_ImageCreate 1152 OH_Drawing_Image *image = OH_Drawing_ImageCreate(); 1153 // 3. Create a rectangle object using OH_Drawing_RectCreate 1154 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0, 0, 100, 100); 1155 // 4. Create a sampling options object using OH_Drawing_SamplingOptionsCreate 1156 OH_Drawing_SamplingOptions *options = OH_Drawing_SamplingOptionsCreate(OH_Drawing_FilterMode::FILTER_MODE_NEAREST, 1157 OH_Drawing_MipmapMode::MIPMAP_MODE_NEAREST); 1158 // 5. Call OH_Drawing_CanvasDrawImageRect 1159 OH_Drawing_CanvasDrawImageRect(canvas, image, rect, options); 1160 // 6. Free memory 1161 OH_Drawing_RectDestroy(rect); 1162 OH_Drawing_SamplingOptionsDestroy(options); 1163 OH_Drawing_ImageDestroy(image); 1164 OH_Drawing_CanvasDestroy(canvas); 1165} 1166 1167/* 1168 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_3801 1169 * @tc.name: testCanvasDrawImageRectNull 1170 * @tc.desc: test for testCanvasDrawImageRectNull. 1171 * @tc.size : SmallTest 1172 * @tc.type : Function 1173 * @tc.level : Level 3 1174 */ 1175HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawImageRectNull, TestSize.Level3) { 1176 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1177 OH_Drawing_Image *image = OH_Drawing_ImageCreate(); 1178 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0, 0, 100, 100); 1179 OH_Drawing_SamplingOptions *options = OH_Drawing_SamplingOptionsCreate(OH_Drawing_FilterMode::FILTER_MODE_NEAREST, 1180 OH_Drawing_MipmapMode::MIPMAP_MODE_NEAREST); 1181 // 1. Call OH_Drawing_CanvasDrawImageRect with the first parameter as null 1182 OH_Drawing_CanvasDrawImageRect(nullptr, image, rect, options); 1183 // 2. Call OH_Drawing_CanvasDrawImageRect with the second parameter as null 1184 OH_Drawing_CanvasDrawImageRect(canvas, nullptr, rect, options); 1185 // 3. Call OH_Drawing_CanvasDrawImageRect with the third parameter as null 1186 OH_Drawing_CanvasDrawImageRect(canvas, image, nullptr, options); 1187 // 4. Call OH_Drawing_CanvasDrawImageRect with the fourth parameter as null 1188 OH_Drawing_CanvasDrawImageRect(canvas, image, rect, nullptr); 1189 // 5. Free memory 1190 OH_Drawing_RectDestroy(rect); 1191 OH_Drawing_SamplingOptionsDestroy(options); 1192 OH_Drawing_ImageDestroy(image); 1193 OH_Drawing_CanvasDestroy(canvas); 1194} 1195 1196/* 1197 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_3900 1198 * @tc.name: testCanvasDrawVerticesNormal 1199 * @tc.desc: test for testCanvasDrawVerticesNormal. 1200 * @tc.size : SmallTest 1201 * @tc.type : Function 1202 * @tc.level : Level 0 1203 */ 1204HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawVerticesNormal, TestSize.Level0) { 1205 OH_Drawing_Point2D point_one = {0, 0}; 1206 OH_Drawing_Point2D point_two = {100, 100}; 1207 OH_Drawing_Point2D point_three = {300, 100}; 1208 OH_Drawing_Point2D points_vertices[3] = {point_one, point_two, point_three}; 1209 1210 OH_Drawing_Point2D texs_one = {0, 0}; 1211 OH_Drawing_Point2D texs_two = {1, 1}; 1212 OH_Drawing_Point2D texs_three = {2, 0}; 1213 OH_Drawing_Point2D texs_vertices[3] = {texs_one, texs_two, texs_three}; 1214 uint32_t colors[3] = {0xFFFF0000, 0xFFFF0000, 0xFFFF0000}; 1215 uint16_t indices[3] = {0, 1, 2}; 1216 // 1. Call OH_Drawing_CanvasCreate to create a canvas object 1217 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1218 // 2. Call OH_Drawing_CanvasDrawVertices with the second parameter iterating through the enum 1219 OH_Drawing_VertexMode mode[] = {VERTEX_MODE_TRIANGLES, VERTEX_MODE_TRIANGLES_STRIP, VERTEX_MODE_TRIANGLE_FAN}; 1220 for (int i = 0; i < 3; i++) { 1221 OH_Drawing_CanvasDrawVertices(canvas, mode[i], 3, points_vertices, texs_vertices, colors, 3, indices, 1222 BLEND_MODE_COLOR); 1223 } 1224 // 3. Call OH_Drawing_CanvasDrawVertices with the ninth parameter iterating through the enum 1225 OH_Drawing_BlendMode blendMode[] = { 1226 BLEND_MODE_CLEAR, BLEND_MODE_SRC, BLEND_MODE_DST, BLEND_MODE_SRC_OVER, 1227 BLEND_MODE_DST_OVER, BLEND_MODE_SRC_IN, BLEND_MODE_DST_IN, BLEND_MODE_SRC_OUT, 1228 BLEND_MODE_DST_OUT, BLEND_MODE_SRC_ATOP, BLEND_MODE_DST_ATOP, BLEND_MODE_XOR, 1229 BLEND_MODE_PLUS, BLEND_MODE_MODULATE, BLEND_MODE_SCREEN, BLEND_MODE_OVERLAY, 1230 BLEND_MODE_DARKEN, BLEND_MODE_LIGHTEN, BLEND_MODE_COLOR_DODGE, BLEND_MODE_COLOR_BURN, 1231 BLEND_MODE_HARD_LIGHT, BLEND_MODE_SOFT_LIGHT, BLEND_MODE_DIFFERENCE, BLEND_MODE_EXCLUSION, 1232 BLEND_MODE_MULTIPLY, BLEND_MODE_HUE, BLEND_MODE_SATURATION, BLEND_MODE_COLOR, 1233 BLEND_MODE_LUMINOSITY, 1234 }; 1235 for (int i = 0; i < 30; i++) { 1236 OH_Drawing_CanvasDrawVertices(canvas, VERTEX_MODE_TRIANGLES, 3, points_vertices, texs_vertices, colors, 3, 1237 indices, blendMode[i]); 1238 } 1239 // 4. Free memory 1240 OH_Drawing_CanvasDestroy(canvas); 1241} 1242 1243/* 1244 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_3901 1245 * @tc.name: testCanvasDrawVerticesNull 1246 * @tc.desc: test for testCanvasDrawVerticesNull. 1247 * @tc.size : SmallTest 1248 * @tc.type : Function 1249 * @tc.level : Level 3 1250 */ 1251HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawVerticesNull, TestSize.Level3) { 1252 OH_Drawing_Point2D point_one = {0, 0}; 1253 OH_Drawing_Point2D point_two = {100, 100}; 1254 OH_Drawing_Point2D point_three = {300, 100}; 1255 OH_Drawing_Point2D points_vertices[3] = {point_one, point_two, point_three}; 1256 1257 OH_Drawing_Point2D texs_one = {0, 0}; 1258 OH_Drawing_Point2D texs_two = {1, 1}; 1259 OH_Drawing_Point2D texs_three = {2, 0}; 1260 OH_Drawing_Point2D texs_vertices[3] = {texs_one, texs_two, texs_three}; 1261 uint32_t colors[3] = {0xFFFF0000, 0xFFFF0000, 0xFFFF0000}; 1262 uint16_t indices[3] = {0, 1, 2}; 1263 1264 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1265 1266 // 1. Call OH_Drawing_CanvasDrawVertices with the first parameter as nullptr 1267 OH_Drawing_CanvasDrawVertices(nullptr, VERTEX_MODE_TRIANGLES, 3, points_vertices, texs_vertices, colors, 3, indices, 1268 BLEND_MODE_COLOR); 1269 // 2. Call OH_Drawing_CanvasDrawVertices with the third parameter as 0 1270 OH_Drawing_CanvasDrawVertices(canvas, VERTEX_MODE_TRIANGLES, 0, points_vertices, texs_vertices, colors, 3, indices, 1271 BLEND_MODE_COLOR); 1272 // 3. Call OH_Drawing_CanvasDrawVertices with the fourth parameter as nullptr 1273 OH_Drawing_CanvasDrawVertices(canvas, VERTEX_MODE_TRIANGLES, 3, nullptr, texs_vertices, colors, 3, indices, 1274 BLEND_MODE_COLOR); 1275 // 4. Call OH_Drawing_CanvasDrawVertices with the fifth parameter as nullptr 1276 OH_Drawing_CanvasDrawVertices(canvas, VERTEX_MODE_TRIANGLES, 3, points_vertices, nullptr, colors, 3, indices, 1277 BLEND_MODE_COLOR); 1278 // 5. Call OH_Drawing_CanvasDrawVertices with the sixth parameter as nullptr 1279 OH_Drawing_CanvasDrawVertices(canvas, VERTEX_MODE_TRIANGLES, 3, points_vertices, texs_vertices, nullptr, 3, indices, 1280 BLEND_MODE_COLOR); 1281 // 6. Call OH_Drawing_CanvasDrawVertices with the seventh parameter as 0 1282 OH_Drawing_CanvasDrawVertices(canvas, VERTEX_MODE_TRIANGLES, 3, points_vertices, texs_vertices, colors, 0, indices, 1283 BLEND_MODE_COLOR); 1284 // 7. Call OH_Drawing_CanvasDrawVertices with the eighth parameter as nullptr 1285 OH_Drawing_CanvasDrawVertices(canvas, VERTEX_MODE_TRIANGLES, 3, points_vertices, texs_vertices, colors, 3, nullptr, 1286 BLEND_MODE_COLOR); 1287 // 8. Free memory 1288 OH_Drawing_CanvasDestroy(canvas); 1289} 1290 1291/* 1292 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_3902 1293 * @tc.name: testCanvasDrawVerticesAbnormal 1294 * @tc.desc: test for testCanvasDrawVerticesAbnormal. 1295 * @tc.size : SmallTest 1296 * @tc.type : Function 1297 * @tc.level : Level 3 1298 */ 1299HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawVerticesAbnormal, TestSize.Level3) { 1300 // 1. Create a canvas object by calling OH_Drawing_CanvasCreate 1301 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1302 1303 // 2. Call OH_Drawing_CanvasDrawVertices with a floating-point number as the third parameter 1304 // Compilation error, cannot pass a floating-point number 1305 1306 // 3. Call OH_Drawing_CanvasDrawVertices with a floating-point number as the seventh parameter 1307 // Compilation error, cannot pass a floating-point number 1308 1309 // 4. Free memory 1310 OH_Drawing_CanvasDestroy(canvas); 1311} 1312 1313/* 1314 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_3903 1315 * @tc.name: testCanvasDrawVerticesMaximum 1316 * @tc.desc: test for testCanvasDrawVerticesMaximum. 1317 * @tc.size : SmallTest 1318 * @tc.type : Function 1319 * @tc.level : Level 3 1320 */ 1321HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawVerticesMaximum, TestSize.Level3) { 1322 // 1. Create a canvas object by calling OH_Drawing_CanvasCreate 1323 OH_Drawing_Point2D point_one = {0, 0}; 1324 OH_Drawing_Point2D point_two = {100, 100}; 1325 OH_Drawing_Point2D point_three = {300, 100}; 1326 OH_Drawing_Point2D points_vertices[3] = {point_one, point_two, point_three}; 1327 1328 OH_Drawing_Point2D texs_one = {0, 0}; 1329 OH_Drawing_Point2D texs_two = {1, 1}; 1330 OH_Drawing_Point2D texs_three = {2, 0}; 1331 OH_Drawing_Point2D texs_vertices[3] = {texs_one, texs_two, texs_three}; 1332 uint32_t colors[3] = {0xFFFF0000, 0xFFFF0000, 0xFFFF0000}; 1333 uint16_t indices[3] = {0, 1, 2}; 1334 1335 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1336 1337 if (0) { 1338 // todo cpp crash 1339 // 2. Call OH_Drawing_CanvasDrawVertices with the third parameter as the maximum value 0x7FFFFFFF 1340 OH_Drawing_CanvasDrawVertices(canvas, VERTEX_MODE_TRIANGLES, 0x7FFFFFFF, points_vertices, texs_vertices, colors, 1341 3, indices, BLEND_MODE_COLOR); 1342 // 3. Call OH_Drawing_CanvasDrawVertices with the seventh parameter as the maximum value 0x7FFFFFFF 1343 OH_Drawing_CanvasDrawVertices(canvas, VERTEX_MODE_TRIANGLES, 3, points_vertices, texs_vertices, colors, 1344 0x7FFFFFFF, indices, BLEND_MODE_COLOR); 1345 } 1346 1347 // 4. Free memory 1348 OH_Drawing_CanvasDestroy(canvas); 1349} 1350 1351/* 1352 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_4000 1353 * @tc.name: testCanvasReadPixelsNormal 1354 * @tc.desc: test for testCanvasReadPixelsNormal. 1355 * @tc.size : SmallTest 1356 * @tc.type : Function 1357 * @tc.level : Level 0 1358 */ 1359HWTEST_F(DrawingNativeCanvasTest, testCanvasReadPixelsNormal, TestSize.Level0) { 1360 // 1. Create a canvas object by calling OH_Drawing_CanvasCreate 1361 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1362 // 2. Call OH_Drawing_CanvasReadPixels 1363 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate(); 1364 OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE}; 1365 constexpr uint32_t width = 200; 1366 constexpr uint32_t height = 200; 1367 OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat); 1368 void *pixels = OH_Drawing_BitmapGetPixels(bitmap); 1369 OH_Drawing_Image_Info imageInfo; 1370 OH_Drawing_CanvasReadPixels(canvas, &imageInfo, pixels, 0, 0, 0); 1371 // 3. Free memory 1372 OH_Drawing_BitmapDestroy(bitmap); 1373 OH_Drawing_CanvasDestroy(canvas); 1374} 1375 1376/* 1377 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_4001 1378 * @tc.name: testCanvasReadPixelsNull 1379 * @tc.desc: test for testCanvasReadPixelsNull. 1380 * @tc.size : SmallTest 1381 * @tc.type : Function 1382 * @tc.level : Level 3 1383 */ 1384HWTEST_F(DrawingNativeCanvasTest, testCanvasReadPixelsNull, TestSize.Level3) { 1385 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1386 // 1. Call OH_Drawing_CanvasReadPixels with the first parameter as nullptr 1387 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate(); 1388 OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE}; 1389 constexpr uint32_t width = 200; 1390 constexpr uint32_t height = 200; 1391 OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat); 1392 void *pixels = OH_Drawing_BitmapGetPixels(bitmap); 1393 OH_Drawing_Image_Info imageInfo; 1394 OH_Drawing_CanvasReadPixels(nullptr, &imageInfo, pixels, 0, 0, 0); 1395 // 2. Call OH_Drawing_CanvasReadPixels with the second parameter as nullptr 1396 OH_Drawing_CanvasReadPixels(canvas, nullptr, pixels, 0, 0, 0); 1397 // 3. Call OH_Drawing_CanvasReadPixels with the third parameter as nullptr 1398 OH_Drawing_CanvasReadPixels(canvas, &imageInfo, nullptr, 0, 0, 0); 1399 // 4. Free memory 1400 OH_Drawing_BitmapDestroy(bitmap); 1401 OH_Drawing_CanvasDestroy(canvas); 1402} 1403 1404/* 1405 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_4002 1406 * @tc.name: testCanvasReadPixelsMismatch 1407 * @tc.desc: test for testCanvasReadPixelsMismatch. 1408 * @tc.size : SmallTest 1409 * @tc.type : Function 1410 * @tc.level : Level 3 1411 */ 1412HWTEST_F(DrawingNativeCanvasTest, testCanvasReadPixelsMismatch, TestSize.Level3) { 1413 // Deprecated 1414} 1415 1416/* 1417 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_4003 1418 * @tc.name: testCanvasReadPixelsAbnormal 1419 * @tc.desc: test for testCanvasReadPixelsAbnormal. 1420 * @tc.size : SmallTest 1421 * @tc.type : Function 1422 * @tc.level : Level 3 1423 */ 1424HWTEST_F(DrawingNativeCanvasTest, testCanvasReadPixelsAbnormal, TestSize.Level3) { 1425 // 1. Create a canvas object by calling OH_Drawing_CanvasCreate 1426 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1427 // 2. Call OH_Drawing_CanvasReadPixels with the fourth parameter as a negative number or a floating-point number 1428 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate(); 1429 OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE}; 1430 constexpr uint32_t width = 200; 1431 constexpr uint32_t height = 200; 1432 OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat); 1433 void *pixels = OH_Drawing_BitmapGetPixels(bitmap); 1434 OH_Drawing_Image_Info imageInfo; 1435 OH_Drawing_CanvasReadPixels(canvas, &imageInfo, pixels, -1, 0, 0); 1436 OH_Drawing_CanvasReadPixels(canvas, &imageInfo, pixels, 1.0f, 0, 0); 1437 // 3. Call OH_Drawing_CanvasReadPixels with the fifth parameter as a floating-point number 1438 OH_Drawing_CanvasReadPixels(canvas, &imageInfo, pixels, 0, 1.0f, 0); 1439 // 4. Call OH_Drawing_CanvasReadPixels with the sixth parameter as a floating-point number 1440 OH_Drawing_CanvasReadPixels(canvas, &imageInfo, pixels, 0, 0, 1.0f); 1441 // 5. Free memory 1442 OH_Drawing_BitmapDestroy(bitmap); 1443 OH_Drawing_CanvasDestroy(canvas); 1444} 1445 1446/* 1447 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_4004 1448 * @tc.name: testCanvasReadPixelsMaximum 1449 * @tc.desc: test for testCanvasReadPixelsMaximum. 1450 * @tc.size : SmallTest 1451 * @tc.type : Function 1452 * @tc.level : Level 3 1453 */ 1454HWTEST_F(DrawingNativeCanvasTest, testCanvasReadPixelsMaximum, TestSize.Level3) { 1455 // 1. Create a canvas object by calling OH_Drawing_CanvasCreate 1456 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1457 // 2. Call OH_Drawing_CanvasReadPixels with the fourth parameter as the maximum value 0xFFFFFFFF 1458 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate(); 1459 OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE}; 1460 constexpr uint32_t width = 200; 1461 constexpr uint32_t height = 200; 1462 OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat); 1463 void *pixels = OH_Drawing_BitmapGetPixels(bitmap); 1464 OH_Drawing_Image_Info imageInfo; 1465 OH_Drawing_CanvasReadPixels(canvas, &imageInfo, pixels, 0xFFFFFFFF, 0, 0); 1466 // 3. Call OH_Drawing_CanvasReadPixels with the fifth parameter as the maximum value 0x7FFFFFFF 1467 OH_Drawing_CanvasReadPixels(canvas, &imageInfo, pixels, 0, 0x7FFFFFFF, 0); 1468 // 4. Call OH_Drawing_CanvasReadPixels with the sixth parameter as the maximum value 0x7FFFFFFF 1469 OH_Drawing_CanvasReadPixels(canvas, &imageInfo, pixels, 0, 0, 0x7FFFFFFF); 1470 // 5. Free memory 1471 OH_Drawing_BitmapDestroy(bitmap); 1472 OH_Drawing_CanvasDestroy(canvas); 1473} 1474 1475/* 1476 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_4005 1477 * @tc.name: testCanvasReadPixelsBoundary 1478 * @tc.desc: test for testCanvasReadPixelsBoundary. 1479 * @tc.size : SmallTest 1480 * @tc.type : Function 1481 * @tc.level : Level 0 1482 */ 1483HWTEST_F(DrawingNativeCanvasTest, testCanvasReadPixelsBoundary, TestSize.Level0) { 1484 // 1. Create a canvas object by calling OH_Drawing_CanvasCreate 1485 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1486 // 2. Call OH_Drawing_CanvasReadPixels 1487 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate(); 1488 OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE}; 1489 constexpr uint32_t width = 4096; 1490 constexpr uint32_t height = 2160; 1491 OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat); 1492 void *pixels = OH_Drawing_BitmapGetPixels(bitmap); 1493 OH_Drawing_Image_Info imageInfo; 1494 OH_Drawing_CanvasReadPixels(canvas, &imageInfo, pixels, 0, 0, 0); 1495 // 3. Free memory 1496 OH_Drawing_BitmapDestroy(bitmap); 1497 OH_Drawing_CanvasDestroy(canvas); 1498} 1499 1500/* 1501 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_4100 1502 * @tc.name: testCanvasReadPixelsToBitmapNormal 1503 * @tc.desc: test for testCanvasReadPixelsToBitmapNormal. 1504 * @tc.size : SmallTest 1505 * @tc.type : Function 1506 * @tc.level : Level 0 1507 */ 1508HWTEST_F(DrawingNativeCanvasTest, testCanvasReadPixelsToBitmapNormal, TestSize.Level0) { 1509 // 1. Create a canvas object by calling OH_Drawing_CanvasCreate 1510 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1511 // 2. Create a bitmap object by calling OH_Drawing_BitmapCreate 1512 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate(); 1513 // 3. Call OH_Drawing_CanvasReadPixelsToBitmap 1514 OH_Drawing_CanvasReadPixelsToBitmap(canvas, bitmap, 1, 1); 1515 // 4. Free memory 1516 OH_Drawing_BitmapDestroy(bitmap); 1517 OH_Drawing_CanvasDestroy(canvas); 1518} 1519 1520/* 1521 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_4101 1522 * @tc.name: testCanvasReadPixelsToBitmapNull 1523 * @tc.desc: test for testCanvasReadPixelsToBitmapNull. 1524 * @tc.size : SmallTest 1525 * @tc.type : Function 1526 * @tc.level : Level 3 1527 */ 1528HWTEST_F(DrawingNativeCanvasTest, testCanvasReadPixelsToBitmapNull, TestSize.Level3) { 1529 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1530 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate(); 1531 // 1. Call OH_Drawing_CanvasReadPixelsToBitmap with the first parameter as null 1532 OH_Drawing_CanvasReadPixelsToBitmap(nullptr, bitmap, 1, 1); 1533 // 2. Call OH_Drawing_CanvasReadPixelsToBitmap with the second parameter as null 1534 OH_Drawing_CanvasReadPixelsToBitmap(canvas, nullptr, 1, 1); 1535 // 3. Call OH_Drawing_CanvasReadPixelsToBitmap with the third parameter as 0 1536 OH_Drawing_CanvasReadPixelsToBitmap(canvas, bitmap, 0, 1); 1537 // 4. Call OH_Drawing_CanvasReadPixelsToBitmap with the fourth parameter as 0 1538 OH_Drawing_CanvasReadPixelsToBitmap(canvas, bitmap, 1, 0); 1539 // 5. Free memory 1540 OH_Drawing_BitmapDestroy(bitmap); 1541 OH_Drawing_CanvasDestroy(canvas); 1542} 1543 1544/* 1545 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_4102 1546 * @tc.name: testCanvasReadPixelsToBitmapAbnormal 1547 * @tc.desc: test for testCanvasReadPixelsToBitmapAbnormal. 1548 * @tc.size : SmallTest 1549 * @tc.type : Function 1550 * @tc.level : Level 3 1551 */ 1552HWTEST_F(DrawingNativeCanvasTest, testCanvasReadPixelsToBitmapAbnormal, TestSize.Level3) { 1553 // 1. Create a canvas object by calling OH_Drawing_CanvasCreate 1554 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1555 // 2. Create a bitmap object by calling OH_Drawing_BitmapCreate 1556 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate(); 1557 // 3. Call OH_Drawing_CanvasReadPixelsToBitmap with the third parameter as a floating-point number 1558 OH_Drawing_CanvasReadPixelsToBitmap(canvas, bitmap, 1.0f, 0); 1559 // 4. Call OH_Drawing_CanvasReadPixelsToBitmap with the fourth parameter as a floating-point number 1560 OH_Drawing_CanvasReadPixelsToBitmap(canvas, bitmap, 1, 1.0f); 1561 // 5. Free memory 1562 OH_Drawing_BitmapDestroy(bitmap); 1563 OH_Drawing_CanvasDestroy(canvas); 1564} 1565 1566/* 1567 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_4103 1568 * @tc.name: testCanvasReadPixelsToBitmapMaximum 1569 * @tc.desc: test for testCanvasReadPixelsToBitmapMaximum. 1570 * @tc.size : SmallTest 1571 * @tc.type : Function 1572 * @tc.level : Level 3 1573 */ 1574HWTEST_F(DrawingNativeCanvasTest, testCanvasReadPixelsToBitmapMaximum, TestSize.Level3) { 1575 // 1. Create a canvas object by calling OH_Drawing_CanvasCreate 1576 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1577 // 2. Create a bitmap object by calling OH_Drawing_BitmapCreate 1578 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate(); 1579 // 3. Call OH_Drawing_CanvasReadPixelsToBitmap with the third parameter set to the maximum value 0x7FFFFFFF 1580 OH_Drawing_CanvasReadPixelsToBitmap(canvas, bitmap, 0x7FFFFFFF, 0); 1581 // 4. Call OH_Drawing_CanvasReadPixelsToBitmap with the fourth parameter set to the maximum value 0x7FFFFFFF 1582 OH_Drawing_CanvasReadPixelsToBitmap(canvas, bitmap, 1, 0x7FFFFFFF); 1583 // 5. Free memory 1584 OH_Drawing_BitmapDestroy(bitmap); 1585 OH_Drawing_CanvasDestroy(canvas); 1586} 1587/* 1588 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_4104 1589 * @tc.name: testCanvasDrawSingleCharacter 1590 * @tc.desc: test for testCanvasDrawSingleCharacter. 1591 * @tc.size : SmallTest 1592 * @tc.type : Function 1593 * @tc.level : Level 1 1594 */ 1595HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawSingleCharacter, TestSize.Level1) 1596{ 1597 // 1. Create a canvas object by calling OH_Drawing_CanvasCreate 1598 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1599 const char* strOne = "a"; 1600 const char* strTwo = "你好"; 1601 OH_Drawing_Font *font = OH_Drawing_FontCreate(); 1602 EXPECT_NE(font, nullptr); 1603 float x = 0.f; 1604 float y = 0.f; 1605 EXPECT_EQ(OH_Drawing_CanvasDrawSingleCharacter(canvas, strOne, font, x, y), OH_DRAWING_SUCCESS); 1606 EXPECT_EQ(OH_Drawing_CanvasDrawSingleCharacter(canvas, strTwo, font, x, y), OH_DRAWING_SUCCESS); 1607 EXPECT_EQ(OH_Drawing_CanvasDrawSingleCharacter(nullptr, strOne, font, x, y), OH_DRAWING_ERROR_INVALID_PARAMETER); 1608 EXPECT_EQ(OH_Drawing_CanvasDrawSingleCharacter(canvas, nullptr, font, x, y), OH_DRAWING_ERROR_INVALID_PARAMETER); 1609 EXPECT_EQ(OH_Drawing_CanvasDrawSingleCharacter(canvas, strOne, nullptr, x, y), 1610 OH_DRAWING_ERROR_INVALID_PARAMETER); 1611 const char* strThree = ""; 1612 EXPECT_EQ(OH_Drawing_CanvasDrawSingleCharacter(canvas, strThree, font, x, y), OH_DRAWING_ERROR_INVALID_PARAMETER); 1613 OH_Drawing_FontDestroy(font); 1614 OH_Drawing_CanvasDestroy(canvas); 1615} 1616 1617/* 1618 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_4200 1619 * @tc.name: testCanvasDrawSingleCharacterNormal 1620 * @tc.desc: test for testCanvasDrawSingleCharacterNormal. 1621 * @tc.size : SmallTest 1622 * @tc.type : Function 1623 * @tc.level : Level 0 1624 */ 1625HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawSingleCharacterNormal, TestSize.Level0) { 1626 //1. OH_Drawing_CanvasCreate 1627 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1628 //2. OH_Drawing_BrushCreate 1629 OH_Drawing_Brush *brush = OH_Drawing_BrushCreate(); 1630 //3. OH_Drawing_BrushSetColor 1631 OH_Drawing_BrushSetColor(brush, 0xFFFFFFFF); 1632 //4. OH_Drawing_FontCreate 1633 OH_Drawing_Font *font = OH_Drawing_FontCreate(); 1634 //5. OH_Drawing_FontSetTextSize 1635 const float textSize = 10.f; 1636 OH_Drawing_FontSetTextSize(font, textSize); 1637 //6. OH_Drawing_CanvasDrawSingleCharacter parameter is normal, where str is a single character,UTF-8 encoded, and 1638 // Chinese/English characters are passed 1639 float x = 0.f; 1640 float y = 0.f; 1641 const char* str = "a"; 1642 const char* str1 = "我"; 1643 OH_Drawing_CanvasDrawSingleCharacter(canvas, str, font, x, y); 1644 OH_Drawing_CanvasDrawSingleCharacter(canvas, str1, font, x, y); 1645 //7. OH_Drawing_CanvasDrawSingleCharacter parameters are entered normally, where str is a multi-character, UTF-8 1646 // encoded, and English/Chinese characters are in 1647 str = "abc"; 1648 str1 = "你是谁"; 1649 OH_Drawing_CanvasDrawSingleCharacter(canvas, str, font, x, y); 1650 OH_Drawing_CanvasDrawSingleCharacter(canvas, str1, font, x, y); 1651 //8. free memory 1652 OH_Drawing_CanvasDestroy(canvas); 1653 OH_Drawing_BrushDestroy(brush); 1654 OH_Drawing_FontDestroy(font); 1655} 1656 1657/* 1658 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_4201 1659 * @tc.name: testCanvasDrawSingleCharacterNull 1660 * @tc.desc: test for testCanvasDrawSingleCharacterNull. 1661 * @tc.size : SmallTest 1662 * @tc.type : Function 1663 * @tc.level : Level 3 1664 */ 1665HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawSingleCharacterNull, TestSize.Level3) { 1666 //1. OH_Drawing_CanvasCreate 1667 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1668 //2. OH_Drawing_BrushCreate 1669 OH_Drawing_Brush *brush = OH_Drawing_BrushCreate(); 1670 //3. OH_Drawing_BrushSetColor 1671 OH_Drawing_BrushSetColor(brush, 0xFFFFFFFF); 1672 //4. OH_Drawing_FontCreate 1673 OH_Drawing_Font *font = OH_Drawing_FontCreate(); 1674 //5. OH_Drawing_FontSetTextSize 1675 const float textSize = 10.f; 1676 OH_Drawing_FontSetTextSize(font, textSize); 1677 //6. OH_Drawing_CanvasDrawSingleCharacter parameter canvas is empty 1678 float x = 0.f; 1679 float y = 0.f; 1680 const char *str = "a"; 1681 OH_Drawing_CanvasDrawSingleCharacter(nullptr, str, font, x, y); 1682 //7. OH_Drawing_CanvasDrawSingleCharacter parameter str is empty 1683 str = ""; 1684 OH_Drawing_CanvasDrawSingleCharacter(canvas, str, font, x, y); 1685 //8. OH_Drawing_CanvasDrawSingleCharacter parameter font is empty 1686 str = "a"; 1687 OH_Drawing_CanvasDrawSingleCharacter(canvas, str, nullptr, x, y); 1688 //9. OH_Drawing_CanvasDrawSingleCharacter parameter str to 0 characters 1689 OH_Drawing_CanvasDrawSingleCharacter(canvas, str, font, x, y); 1690 //10.free memory 1691 OH_Drawing_CanvasDestroy(canvas); 1692 OH_Drawing_BrushDestroy(brush); 1693 OH_Drawing_FontDestroy(font); 1694} 1695 1696/* 1697 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_4300 1698 * @tc.name: testCanvasDrawPointNormal 1699 * @tc.desc: test for testCanvasDrawPointNormal. 1700 * @tc.size : SmallTest 1701 * @tc.type : Function 1702 * @tc.level : Level 0 1703 */ 1704HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawPointNormal, TestSize.Level0) { 1705 //1. OH_Drawing_CanvasCreate 1706 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1707 //2. OH_Drawing_Point2D create an array of points 1708 OH_Drawing_Point2D texs_one = {0.0f, 0.0f}; 1709 OH_Drawing_Point2D texs_two = {1.0f, 1.0f}; 1710 OH_Drawing_Point2D texs_three = {2.0f, 2.0f}; 1711 OH_Drawing_Point2D point_vertices[1] = {texs_one}; 1712 for (int i = 0; i < 1; i++) { 1713 OH_Drawing_CanvasDrawPoint(canvas, &point_vertices[i]); 1714 } 1715 //3. OH_Drawing_Point2D create an array of multiple points 1716 OH_Drawing_Point2D texs_vertices[3] = {texs_one, texs_two, texs_three}; 1717 for (int i = 0; i < 3; i++) { 1718 OH_Drawing_CanvasDrawPoint(canvas, &texs_vertices[i]); 1719 } 1720 //4. free memory 1721 OH_Drawing_CanvasDestroy(canvas); 1722} 1723 1724/* 1725 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_4301 1726 * @tc.name: testCanvasDrawPointNull 1727 * @tc.desc: test for testCanvasDrawPointNull. 1728 * @tc.size : SmallTest 1729 * @tc.type : Function 1730 * @tc.level : Level 3 1731 */ 1732HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawPointNull, TestSize.Level3) { 1733 //1. OH_Drawing_CanvasCreate 1734 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1735 //2. OH_Drawing_CanvasDrawPoint the first parameter is empty 1736 const OH_Drawing_Point2D point = {0.0f, 0.0f}; 1737 OH_Drawing_CanvasDrawPoint(nullptr, &point); 1738 //3. OH_Drawing_CanvasDrawPoint the second parameter is empty 1739 OH_Drawing_CanvasDrawPoint(canvas, nullptr); 1740 //4.free memory 1741 OH_Drawing_CanvasDestroy(canvas); 1742} 1743 1744/* 1745 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_4302 1746 * @tc.name: testCanvasDrawPointMultipleCalls 1747 * @tc.desc: test for testCanvasDrawPointMultipleCalls. 1748 * @tc.size : SmallTest 1749 * @tc.type : Function 1750 * @tc.level : Level 3 1751 */ 1752HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawPointMultipleCalls, TestSize.Level3) { 1753 //1. OH_Drawing_CanvasCreate 1754 OH_Drawing_Canvas *canvases[10]; 1755 for (int i = 0; i < 10; i++) { 1756 canvases[i]= OH_Drawing_CanvasCreate(); 1757 } 1758 //2. Call OH_Drawing_CanvasDrawPoint 10 times 1759 OH_Drawing_Point2D point1 = {0.0f, 0.0f}; 1760 for (int i = 0; i < 10; i++) { 1761 OH_Drawing_CanvasDrawPoint(canvases[i], &point1); 1762 } 1763} 1764 1765/* 1766 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_4400 1767 * @tc.name: testCanvasDrawColorNormal 1768 * @tc.desc: test for testCanvasDrawColorNormal. 1769 * @tc.size : SmallTest 1770 * @tc.type : Function 1771 * @tc.level : Level 0 1772 */ 1773HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawColorNormal, TestSize.Level0) { 1774 //1. OH_Drawing_CanvasCreate 1775 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1776 //2. OH_Drawing_CanvasDrawColor enumeration traversal 1777 uint32_t color[3] = {0xFFFF0000, 0xFFFF0000, 0xFFFF0000}; 1778 OH_Drawing_BlendMode blendMode[] = { 1779 BLEND_MODE_CLEAR, BLEND_MODE_SRC, BLEND_MODE_DST, BLEND_MODE_SRC_OVER, 1780 BLEND_MODE_DST_OVER, BLEND_MODE_SRC_IN, BLEND_MODE_DST_IN, BLEND_MODE_SRC_OUT, 1781 BLEND_MODE_DST_OUT, BLEND_MODE_SRC_ATOP, BLEND_MODE_DST_ATOP, BLEND_MODE_XOR, 1782 BLEND_MODE_PLUS, BLEND_MODE_MODULATE, BLEND_MODE_SCREEN, BLEND_MODE_OVERLAY, 1783 BLEND_MODE_DARKEN, BLEND_MODE_LIGHTEN, BLEND_MODE_COLOR_DODGE, BLEND_MODE_COLOR_BURN, 1784 BLEND_MODE_HARD_LIGHT, BLEND_MODE_SOFT_LIGHT, BLEND_MODE_DIFFERENCE, BLEND_MODE_EXCLUSION, 1785 BLEND_MODE_MULTIPLY, BLEND_MODE_HUE, BLEND_MODE_SATURATION, BLEND_MODE_COLOR, 1786 BLEND_MODE_LUMINOSITY, 1787 }; 1788 for (int i = 0; i < 29; i++) { 1789 for (int j = 0; j < 3; j++) { 1790 OH_Drawing_CanvasDrawColor(canvas, color[j], blendMode[i]); 1791 } 1792 } 1793} 1794 1795/* 1796 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_4401 1797 * @tc.name: testCanvasDrawColorNull 1798 * @tc.desc: test for testCanvasDrawColorNull. 1799 * @tc.size : SmallTest 1800 * @tc.type : Function 1801 * @tc.level : Level 3 1802 */ 1803HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawColorNull, TestSize.Level3) { 1804 //1. OH_Drawing_CanvasCreate 1805 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1806 //2. OH_Drawing_CanvasDrawColor with the first parameter as nullptr 1807 OH_Drawing_BlendMode blendMode[] = { 1808 BLEND_MODE_CLEAR, BLEND_MODE_SRC, BLEND_MODE_DST, BLEND_MODE_SRC_OVER, 1809 BLEND_MODE_DST_OVER, BLEND_MODE_SRC_IN, BLEND_MODE_DST_IN, BLEND_MODE_SRC_OUT, 1810 BLEND_MODE_DST_OUT, BLEND_MODE_SRC_ATOP, BLEND_MODE_DST_ATOP, BLEND_MODE_XOR, 1811 BLEND_MODE_PLUS, BLEND_MODE_MODULATE, BLEND_MODE_SCREEN, BLEND_MODE_OVERLAY, 1812 BLEND_MODE_DARKEN, BLEND_MODE_LIGHTEN, BLEND_MODE_COLOR_DODGE, BLEND_MODE_COLOR_BURN, 1813 BLEND_MODE_HARD_LIGHT, BLEND_MODE_SOFT_LIGHT, BLEND_MODE_DIFFERENCE, BLEND_MODE_EXCLUSION, 1814 BLEND_MODE_MULTIPLY, BLEND_MODE_HUE, BLEND_MODE_SATURATION, BLEND_MODE_COLOR, 1815 BLEND_MODE_LUMINOSITY, 1816 }; 1817 uint32_t color = 0xFFFF0000; 1818 for (int i = 0; i < 29; i++) { 1819 OH_Drawing_CanvasDrawColor(nullptr, color, blendMode[i]); 1820 } 1821 //3. OH_Drawing_CanvasDrawColor with the first parameter as 0 1822 for (int i = 0; i < 29; i++) { 1823 OH_Drawing_CanvasDrawColor(canvas, 0, blendMode[i]); 1824 } 1825 //4. free memory 1826 OH_Drawing_CanvasDestroy(canvas); 1827} 1828 1829/* 1830 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_4402 1831 * @tc.name: testCanvasDrawColorMaximum 1832 * @tc.desc: test for testCanvasDrawColorMaximum. 1833 * @tc.size : SmallTest 1834 * @tc.type : Function 1835 * @tc.level : Level 3 1836 */ 1837HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawColorMaximum, TestSize.Level3) { 1838 //1. OH_Drawing_CanvasCreate 1839 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1840 //2. OH_Drawing_CanvasDrawColor with the second parameter set to the maximum value 1841 OH_Drawing_BlendMode blendMode[] = { 1842 BLEND_MODE_CLEAR, BLEND_MODE_SRC, BLEND_MODE_DST, BLEND_MODE_SRC_OVER, 1843 BLEND_MODE_DST_OVER, BLEND_MODE_SRC_IN, BLEND_MODE_DST_IN, BLEND_MODE_SRC_OUT, 1844 BLEND_MODE_DST_OUT, BLEND_MODE_SRC_ATOP, BLEND_MODE_DST_ATOP, BLEND_MODE_XOR, 1845 BLEND_MODE_PLUS, BLEND_MODE_MODULATE, BLEND_MODE_SCREEN, BLEND_MODE_OVERLAY, 1846 BLEND_MODE_DARKEN, BLEND_MODE_LIGHTEN, BLEND_MODE_COLOR_DODGE, BLEND_MODE_COLOR_BURN, 1847 BLEND_MODE_HARD_LIGHT, BLEND_MODE_SOFT_LIGHT, BLEND_MODE_DIFFERENCE, BLEND_MODE_EXCLUSION, 1848 BLEND_MODE_MULTIPLY, BLEND_MODE_HUE, BLEND_MODE_SATURATION, BLEND_MODE_COLOR, 1849 BLEND_MODE_LUMINOSITY, 1850 }; 1851 uint32_t color = 0x00000000; 1852 for (int i = 0; i < 29; i++) { 1853 OH_Drawing_CanvasDrawColor(nullptr, color, blendMode[i]); 1854 } 1855 //3. free memory 1856 OH_Drawing_CanvasDestroy(canvas); 1857} 1858 1859/* 1860 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_4403 1861 * @tc.name: testCanvasDrawColorMultipleCalls 1862 * @tc.desc: test for testCanvasDrawColorMultipleCalls. 1863 * @tc.size : SmallTest 1864 * @tc.type : Function 1865 * @tc.level : Level 3 1866 */ 1867HWTEST_F(DrawingNativeCanvasTest, testCanvasDrawColorMultipleCalls, TestSize.Level3) { 1868 //1. OH_Drawing_CanvasCreate 1869 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1870 //2. Call OH_Drawing_CanvasDrawColor 10 times 1871 uint32_t color = 0xFFFF0000; 1872 OH_Drawing_BlendMode blendMode[] = { 1873 BLEND_MODE_CLEAR, BLEND_MODE_SRC, BLEND_MODE_DST, BLEND_MODE_SRC_OVER, 1874 BLEND_MODE_DST_OVER, BLEND_MODE_SRC_IN, BLEND_MODE_DST_IN, BLEND_MODE_SRC_OUT, 1875 BLEND_MODE_DST_OUT, BLEND_MODE_SRC_ATOP, 1876 }; 1877 for (int i = 0; i < 10; i++) { 1878 OH_Drawing_CanvasDrawColor(canvas, color, blendMode[i]); 1879 } 1880 //3. free memory 1881 OH_Drawing_CanvasDestroy(canvas); 1882} 1883 1884/* 1885 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_4500 1886 * @tc.name: testCanvasIsClipEmptyNormal 1887 * @tc.desc: test for testCanvasIsClipEmptyNormal. 1888 * @tc.size : SmallTest 1889 * @tc.type : Function 1890 * @tc.level : Level 0 1891 */ 1892HWTEST_F(DrawingNativeCanvasTest, testCanvasIsClipEmptyNormal, TestSize.Level0) { 1893 //1. OH_Drawing_RectCreate 1894 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1895 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0, 0, 100, 100); 1896 //2. OH_Drawing_RoundRectCreate 1897 OH_Drawing_RoundRect *roundRect = OH_Drawing_RoundRectCreate(rect, 1.0f, 1.0f); 1898 //3. OH_Drawing_CanvasClipRoundRect with the parameter clipOp set DIFFERENCE 1899 OH_Drawing_CanvasClipOp clipOp = {OH_Drawing_CanvasClipOp::DIFFERENCE}; 1900 bool doAntiAlias[] = {true, false}; 1901 for (int i = 0; i < 2; i++) { 1902 OH_Drawing_CanvasClipRoundRect(canvas, roundRect, clipOp, doAntiAlias[i]); 1903 } 1904 //4. OH_Drawing_CanvasIsClipEmpty 1905 bool isClipEmpty[] = {true, false}; 1906 for (int i = 0; i < 2; i++) { 1907 OH_Drawing_CanvasIsClipEmpty(canvas, &isClipEmpty[i]); 1908 } 1909 //5. free memory 1910 OH_Drawing_CanvasDestroy(canvas); 1911 OH_Drawing_RectDestroy(rect); 1912 OH_Drawing_RoundRectDestroy(roundRect); 1913} 1914 1915/* 1916 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_4501 1917 * @tc.name: testCanvasIsClipEmptyNull 1918 * @tc.desc: test for testCanvasIsClipEmptyNull. 1919 * @tc.size : SmallTest 1920 * @tc.type : Function 1921 * @tc.level : Level 3 1922 */ 1923HWTEST_F(DrawingNativeCanvasTest, testCanvasIsClipEmptyNull, TestSize.Level3) { 1924 //1. OH_Drawing_RectCreate 1925 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1926 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0, 0, 100, 100); 1927 //2. OH_Drawing_RoundRectCreate 1928 OH_Drawing_RoundRect *roundRect = OH_Drawing_RoundRectCreate(rect, 1.0f, 1.0f); 1929 //3. OH_Drawing_CanvasClipRoundRect with the parameter clipOp set DIFFERENCE 1930 OH_Drawing_CanvasClipOp clipOp = {OH_Drawing_CanvasClipOp::DIFFERENCE}; 1931 bool doAntiAlias[] = {true, false}; 1932 for (int i = 0; i < 2; i++) { 1933 OH_Drawing_CanvasClipRoundRect(canvas, roundRect, clipOp, doAntiAlias[i]); 1934 } 1935 //4. OH_Drawing_CanvasIsClipEmpty with the first parameter as null 1936 bool isClipEmpty[] = {true, false}; 1937 for (int i = 0; i < 2; i++) { 1938 OH_Drawing_CanvasIsClipEmpty(nullptr, &isClipEmpty[i]); 1939 } 1940 //5. OH_Drawing_CanvasIsClipEmpty with the second parameter as null 1941 OH_Drawing_CanvasIsClipEmpty(canvas, nullptr); 1942 //6. free memory 1943 OH_Drawing_CanvasDestroy(canvas); 1944 OH_Drawing_RectDestroy(rect); 1945 OH_Drawing_RoundRectDestroy(roundRect); 1946} 1947 1948/* 1949 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_4502 1950 * @tc.name: testCanvasIsClipEmptyMultipleCalls 1951 * @tc.desc: test for testCanvasIsClipEmptyMultipleCalls. 1952 * @tc.size : SmallTest 1953 * @tc.type : Function 1954 * @tc.level : Level 3 1955 */ 1956HWTEST_F(DrawingNativeCanvasTest, testCanvasIsClipEmptyMultipleCalls, TestSize.Level3) { 1957 //1. OH_Drawing_RectCreate 1958 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1959 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0, 0, 100, 100); 1960 //2. OH_Drawing_RoundRectCreate 1961 OH_Drawing_RoundRect *roundRect = OH_Drawing_RoundRectCreate(rect, 1.0f, 1.0f); 1962 //3. OH_Drawing_CanvasClipRoundRect with the parameter clipOp set DIFFERENCE 1963 OH_Drawing_CanvasClipOp clipOp = {OH_Drawing_CanvasClipOp::DIFFERENCE}; 1964 bool doAntiAlias[] = {true, false}; 1965 for (int i = 0; i < 2; i++) { 1966 OH_Drawing_CanvasClipRoundRect(canvas, roundRect, clipOp, doAntiAlias[i]); 1967 } 1968 //4. Call OH_Drawing_CanvasIsClipEmpty 10 times 1969 bool isClipEmpty = true; 1970 OH_Drawing_Canvas *canvases[10]; 1971 for (int i = 0; i < 10; i++) { 1972 canvases[i]= OH_Drawing_CanvasCreate(); 1973 } 1974 for (int i = 0; i < 10; i++) { 1975 OH_Drawing_CanvasIsClipEmpty(canvases[i], &isClipEmpty); 1976 } 1977 //5. free memory 1978 OH_Drawing_CanvasDestroy(canvas); 1979 for (int i = 0; i < 10; i++) { 1980 OH_Drawing_CanvasDestroy(canvases[i]); 1981 } 1982 OH_Drawing_RectDestroy(rect); 1983 OH_Drawing_RoundRectDestroy(roundRect); 1984} 1985 1986/* 1987 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_4600 1988 * @tc.name: testCanvasGetImageInfoNormal 1989 * @tc.desc: test for testCanvasGetImageInfoNormal. 1990 * @tc.size : SmallTest 1991 * @tc.type : Function 1992 * @tc.level : Level 0 1993 */ 1994HWTEST_F(DrawingNativeCanvasTest, testCanvasGetImageInfoNormal, TestSize.Level0) { 1995 //1. OH_Drawing_BitmapCreate 1996 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate(); 1997 //2. OH_Drawing_BitmapGetPixels 1998 void *pixels = OH_Drawing_BitmapGetPixels(bitmap); 1999 //3. OH_Drawing_BitmapBuild 2000 OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE}; 2001 constexpr uint32_t width = 200; 2002 constexpr uint32_t height = 200; 2003 OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat); 2004 //4. OH_Drawing_BitmapCreateFromPixels 2005 const uint32_t bytesPerPixel = 3; 2006 const uint32_t padding = 32; 2007 const uint32_t rowBytes = width * bytesPerPixel + padding; 2008 OH_Drawing_Image_Info imageInfo; 2009 OH_Drawing_Bitmap *frompixels = OH_Drawing_BitmapCreateFromPixels(&imageInfo, pixels, rowBytes); 2010 //5. OH_Drawing_CanvasBind 2011 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 2012 OH_Drawing_CanvasBind(canvas, bitmap); 2013 //6. OH_Drawing_CanvasGetImageInfo 2014 OH_Drawing_CanvasGetImageInfo(canvas, &imageInfo); 2015 //7. free memory 2016 OH_Drawing_CanvasDestroy(canvas); 2017 OH_Drawing_BitmapDestroy(bitmap); 2018 OH_Drawing_BitmapDestroy(frompixels); 2019} 2020 2021/* 2022 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_4601 2023 * @tc.name: testCanvasGetImageInfoNull 2024 * @tc.desc: test for testCanvasGetImageInfoNull. 2025 * @tc.size : SmallTest 2026 * @tc.type : Function 2027 * @tc.level : Level 3 2028 */ 2029HWTEST_F(DrawingNativeCanvasTest, testCanvasGetImageInfoNull, TestSize.Level3) { 2030 //1. OH_Drawing_BitmapCreate 2031 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate(); 2032 //2. OH_Drawing_BitmapGetPixels 2033 void *pixels = OH_Drawing_BitmapGetPixels(bitmap); 2034 //3. OH_Drawing_BitmapBuild 2035 OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE}; 2036 constexpr uint32_t width = 200; 2037 constexpr uint32_t height = 200; 2038 OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat); 2039 //4. OH_Drawing_BitmapCreateFromPixels 2040 const uint32_t bytesPerPixel = 3; 2041 const uint32_t padding = 32; 2042 const uint32_t rowBytes = width * bytesPerPixel + padding; 2043 OH_Drawing_Image_Info imageInfo; 2044 OH_Drawing_Bitmap *frompixels = OH_Drawing_BitmapCreateFromPixels(&imageInfo, pixels, rowBytes); 2045 //5. OH_Drawing_CanvasBind 2046 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 2047 OH_Drawing_CanvasBind(canvas, bitmap); 2048 //6. OH_Drawing_CanvasGetImageInfo with the first parameter as null 2049 OH_Drawing_CanvasGetImageInfo(nullptr, &imageInfo); 2050 //7. OH_Drawing_CanvasGetImageInfo with the second parameter as null 2051 OH_Drawing_CanvasGetImageInfo(canvas, nullptr); 2052 //8. free memory 2053 OH_Drawing_CanvasDestroy(canvas); 2054 OH_Drawing_BitmapDestroy(bitmap); 2055 OH_Drawing_BitmapDestroy(frompixels); 2056} 2057 2058/* 2059 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_4602 2060 * @tc.name: testCanvasGetImageInfoMultipleCalls 2061 * @tc.desc: test for testCanvasGetImageInfoMultipleCalls. 2062 * @tc.size : SmallTest 2063 * @tc.type : Function 2064 * @tc.level : Level 3 2065 */ 2066HWTEST_F(DrawingNativeCanvasTest, testCanvasGetImageInfoMultipleCalls, TestSize.Level3) { 2067 //1. OH_Drawing_BitmapCreate 2068 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate(); 2069 //2. OH_Drawing_BitmapGetPixels 2070 void *pixels = OH_Drawing_BitmapGetPixels(bitmap); 2071 //3. OH_Drawing_BitmapBuild 2072 OH_Drawing_BitmapFormat cFormat{COLOR_FORMAT_RGBA_8888, ALPHA_FORMAT_OPAQUE}; 2073 constexpr uint32_t width = 200; 2074 constexpr uint32_t height = 200; 2075 OH_Drawing_BitmapBuild(bitmap, width, height, &cFormat); 2076 //4. OH_Drawing_BitmapCreateFromPixels 2077 const uint32_t bytesPerPixel = 3; 2078 const uint32_t padding = 32; 2079 const uint32_t rowBytes = width * bytesPerPixel + padding; 2080 OH_Drawing_Image_Info imageInfo; 2081 OH_Drawing_Bitmap *frompixels = OH_Drawing_BitmapCreateFromPixels(&imageInfo, pixels, rowBytes); 2082 //5. OH_Drawing_CanvasBind 2083 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 2084 OH_Drawing_CanvasBind(canvas, bitmap); 2085 //6. Call OH_Drawing_CanvasGetImageInfo 10 times 2086 OH_Drawing_Canvas *canvases[10]; 2087 for (int i = 0; i < 10; i++) { 2088 canvases[i]= OH_Drawing_CanvasCreate(); 2089 } 2090 for (int i = 0; i < 10; i++) { 2091 OH_Drawing_CanvasGetImageInfo(canvases[i], &imageInfo); 2092 } 2093 //7. free memory 2094 OH_Drawing_CanvasDestroy(canvas); 2095 for (int i = 0; i < 10; i++) { 2096 OH_Drawing_CanvasDestroy(canvases[i]); 2097 } 2098 OH_Drawing_BitmapDestroy(bitmap); 2099 OH_Drawing_BitmapDestroy(frompixels); 2100} 2101 2102/* 2103 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_4700 2104 * @tc.name: testCanvasClipRegionNormal 2105 * @tc.desc: test for testCanvasClipRegionNormal. 2106 * @tc.size : SmallTest 2107 * @tc.type : Function 2108 * @tc.level : Level 0 2109 */ 2110HWTEST_F(DrawingNativeCanvasTest, testCanvasClipRegionNormal, TestSize.Level0) { 2111 //1. OH_Drawing_RectCreate 2112 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0, 0, 100, 100); 2113 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 2114 OH_Drawing_CanvasClipOp clipOp = {OH_Drawing_CanvasClipOp::DIFFERENCE}; 2115 //2. OH_Drawing_RegionCreate 2116 OH_Drawing_Region *region = OH_Drawing_RegionCreate(); 2117 //3. OH_Drawing_RegionSetRect 2118 OH_Drawing_RegionSetRect(region, rect); 2119 //4. OH_Drawing_CanvasClipRegion 2120 OH_Drawing_CanvasClipRegion(canvas, region, clipOp); 2121 //5. free memory 2122 OH_Drawing_CanvasDestroy(canvas); 2123 OH_Drawing_RectDestroy(rect); 2124 OH_Drawing_RegionDestroy(region); 2125} 2126 2127/* 2128 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_4701 2129 * @tc.name: testCanvasClipRegionNull 2130 * @tc.desc: test for testCanvasClipRegionNull. 2131 * @tc.size : SmallTest 2132 * @tc.type : Function 2133 * @tc.level : Level 3 2134 */ 2135HWTEST_F(DrawingNativeCanvasTest, testCanvasClipRegionNull, TestSize.Level3) { 2136 //1. OH_Drawing_RectCreate 2137 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 2138 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0, 0, 100, 100); 2139 OH_Drawing_CanvasClipOp clipOp = {OH_Drawing_CanvasClipOp::DIFFERENCE}; 2140 //2. OH_Drawing_RegionCreate 2141 OH_Drawing_Region *region = OH_Drawing_RegionCreate(); 2142 //3. OH_Drawing_RegionSetRect 2143 OH_Drawing_RegionSetRect(region, rect); 2144 //4. OH_Drawing_CanvasClipRegion with the first parameter as nullptr 2145 OH_Drawing_CanvasClipRegion(nullptr, region, clipOp); 2146 //5. OH_Drawing_CanvasClipRegion with the second parameter as nullptr 2147 OH_Drawing_CanvasClipRegion(canvas, nullptr, clipOp); 2148 //6. free memory 2149 OH_Drawing_CanvasDestroy(canvas); 2150 OH_Drawing_RectDestroy(rect); 2151 OH_Drawing_RegionDestroy(region); 2152} 2153 2154/* 2155 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_4702 2156 * @tc.name: testCanvasClipRegionMultipleCalls 2157 * @tc.desc: test for testCanvasClipRegionMultipleCalls. 2158 * @tc.size : SmallTest 2159 * @tc.type : Function 2160 * @tc.level : Level 3 2161 */ 2162HWTEST_F(DrawingNativeCanvasTest, testCanvasClipRegionMultipleCalls, TestSize.Level3) { 2163 //1. OH_Drawing_RectCreate 2164 OH_Drawing_Canvas *canvases[10]; 2165 for (int i = 0; i < 10; i++) { 2166 canvases[i]= OH_Drawing_CanvasCreate(); 2167 } 2168 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0, 0, 100, 100); 2169 OH_Drawing_CanvasClipOp clipOp = {OH_Drawing_CanvasClipOp::DIFFERENCE}; 2170 //2. OH_Drawing_RegionCreate 2171 OH_Drawing_Region *region = OH_Drawing_RegionCreate(); 2172 //3. OH_Drawing_RegionSetRect 2173 OH_Drawing_RegionSetRect(region, rect); 2174 //4. Call OH_Drawing_CanvasClipRegion 10 times 2175 for (int i = 0; i < 10; i++) { 2176 OH_Drawing_CanvasClipRegion(canvases[i], region, clipOp); 2177 } 2178 //5. free memory 2179 for (int i = 0; i < 10; i++) { 2180 OH_Drawing_CanvasDestroy(canvases[i]); 2181 } 2182 OH_Drawing_RectDestroy(rect); 2183 OH_Drawing_RegionDestroy(region); 2184} 2185 2186} // namespace Drawing 2187} // namespace Rosen 2188} // namespace OHOS