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 41 using namespace testing; 42 using namespace testing::ext; 43 44 namespace OHOS { 45 namespace Rosen { 46 namespace Drawing { 47 class DrawingNativeCanvasPart3Test : public testing::Test { 48 protected: 49 // 在每个测试用例执行前调用 SetUp()50 void SetUp() override 51 { 52 // 设置代码 53 std::cout << "DrawingNativeCanvasPart3Test Setup code called before each test case." << std::endl; 54 OH_Drawing_ErrorCodeReset(); 55 std::cout << "DrawingNativeCanvasPart3Test errorCodeReset before each test case." << std::endl; 56 } TearDown()57 void TearDown() override 58 { 59 std::cout << "DrawingNativeCanvasPart3Test Setup code called after each test case." << std::endl; 60 OH_Drawing_ErrorCodeReset(); 61 std::cout << "DrawingNativeCanvasPart3Test errorCodeReset after each test case." << std::endl; 62 } 63 }; 64 65 /* 66 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_1900 67 * @tc.name: testCanvasDrawOvalNormal 68 * @tc.desc: test for testCanvasDrawOvalNormal. 69 * @tc.size : SmallTest 70 * @tc.type : Function 71 * @tc.level : Level 0 72 */ 73 HWTEST_F(DrawingNativeCanvasPart3Test, testCanvasDrawOvalNormal, TestSize.Level0) { 74 // 1. Create OH_Drawing_Canvas 75 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 76 // add assert 77 EXPECT_NE(canvas, nullptr); 78 79 // 2. Create OH_Drawing_Rect 80 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0, 0, 100, 100); 81 // add assert 82 EXPECT_NE(rect, nullptr); 83 84 // 3. Draw oval on canvas 85 OH_Drawing_CanvasDrawOval(canvas, rect); 86 // add assert 87 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 88 89 // 4. Free memory 90 OH_Drawing_CanvasDestroy(canvas); 91 OH_Drawing_RectDestroy(rect); 92 } 93 94 /* 95 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_1901 96 * @tc.name: testCanvasDrawOvalNull 97 * @tc.desc: test for testCanvasDrawOvalNull. 98 * @tc.size : SmallTest 99 * @tc.type : Function 100 * @tc.level : Level 3 101 */ 102 HWTEST_F(DrawingNativeCanvasPart3Test, testCanvasDrawOvalNull, TestSize.Level3) { 103 // 1. Create OH_Drawing_Canvas 104 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 105 // add assert 106 EXPECT_NE(canvas, nullptr); 107 // 2. Create OH_Drawing_Rect 108 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0, 0, 200, 200); 109 // add assert 110 EXPECT_NE(rect, nullptr); 111 // 3. OH_Drawing_CanvasDrawOval with nullptr as the first parameter 112 OH_Drawing_CanvasDrawOval(nullptr, rect); 113 // add assert 114 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 115 OH_Drawing_ErrorCodeReset(); 116 // 4. OH_Drawing_CanvasDrawOval with OH_Drawing_Rect created with 0 for left, top, right, and bottom 117 OH_Drawing_Rect *rect2 = OH_Drawing_RectCreate(0, 200, 200, 200); 118 // add assert 119 EXPECT_NE(rect2, nullptr); 120 OH_Drawing_CanvasDrawOval(canvas, rect2); 121 rect2 = OH_Drawing_RectCreate(200, 0, 200, 200); 122 // add assert 123 EXPECT_NE(rect2, nullptr); 124 OH_Drawing_CanvasDrawOval(canvas, rect2); 125 rect2 = OH_Drawing_RectCreate(200, 200, 0, 200); 126 // add assert 127 EXPECT_NE(rect2, nullptr); 128 OH_Drawing_CanvasDrawOval(canvas, rect2); 129 rect2 = OH_Drawing_RectCreate(200, 200, 200, 0); 130 // add assert 131 EXPECT_NE(rect2, nullptr); 132 OH_Drawing_CanvasDrawOval(canvas, rect2); 133 // 5. OH_Drawing_CanvasDrawOval with OH_Drawing_Rect created with all 0 values 134 OH_Drawing_Rect *rect3 = OH_Drawing_RectCreate(0, 0, 0, 0); 135 // add assert 136 EXPECT_NE(rect3, nullptr); 137 OH_Drawing_CanvasDrawOval(canvas, rect3); 138 // 6. OH_Drawing_CanvasDrawOval with nullptr as the second parameter 139 OH_Drawing_CanvasDrawOval(canvas, nullptr); 140 // add assert 141 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 142 // 7. Free memory 143 OH_Drawing_CanvasDestroy(canvas); 144 OH_Drawing_RectDestroy(rect); 145 OH_Drawing_RectDestroy(rect2); 146 OH_Drawing_RectDestroy(rect3); 147 } 148 149 /* 150 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_1902 151 * @tc.name: testCanvasDrawOvalAbnormal 152 * @tc.desc: test for testCanvasDrawOvalAbnormal. 153 * @tc.size : SmallTest 154 * @tc.type : Function 155 * @tc.level : Level 3 156 */ 157 HWTEST_F(DrawingNativeCanvasPart3Test, testCanvasDrawOvalAbnormal, TestSize.Level3) { 158 // 1. OH_Drawing_CanvasCreate 159 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 160 // add assert 161 EXPECT_NE(canvas, nullptr); 162 // 2. Create OH_Drawing_Rect with left, top, right, and bottom values as negative numbers 163 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(-100, 100, 200, 200); 164 // add assert 165 EXPECT_NE(rect, nullptr); 166 OH_Drawing_CanvasDrawOval(canvas, rect); 167 rect = OH_Drawing_RectCreate(100, -100, 200, 200); 168 // add assert 169 EXPECT_NE(rect, nullptr); 170 OH_Drawing_CanvasDrawOval(canvas, rect); 171 rect = OH_Drawing_RectCreate(100, 100, -200, 200); 172 // add assert 173 EXPECT_NE(rect, nullptr); 174 OH_Drawing_CanvasDrawOval(canvas, rect); 175 rect = OH_Drawing_RectCreate(100, 100, 200, -200); 176 // add assert 177 EXPECT_NE(rect, nullptr); 178 OH_Drawing_CanvasDrawOval(canvas, rect); 179 // 3. Create OH_Drawing_Rect with the horizontal coordinate of the top-left corner equal to the horizontal 180 // coordinate of the bottom-right corner, or the vertical coordinate of the top-left corner equal to the vertical 181 // coordinate of the bottom-right corner 182 OH_Drawing_Rect *rect2 = OH_Drawing_RectCreate(100, 0, 100, 100); 183 // add assert 184 EXPECT_NE(rect2, nullptr); 185 OH_Drawing_CanvasDrawOval(canvas, rect2); 186 OH_Drawing_Rect *rect3 = OH_Drawing_RectCreate(0, 100, 100, 100); 187 // add assert 188 EXPECT_NE(rect3, nullptr); 189 OH_Drawing_CanvasDrawOval(canvas, rect3); 190 // 4. Create OH_Drawing_Rect with the top-left corner coordinates equal to the bottom-right corner coordinates 191 OH_Drawing_Rect *rect4 = OH_Drawing_RectCreate(100, 100, 100, 100); 192 // add assert 193 EXPECT_NE(rect4, nullptr); 194 OH_Drawing_CanvasDrawOval(canvas, rect4); 195 // 5. Create OH_Drawing_Rect with the top-left corner coordinates greater than the bottom-right corner coordinates 196 OH_Drawing_Rect *rect5 = OH_Drawing_RectCreate(200, 200, 100, 100); 197 // add assert 198 EXPECT_NE(rect5, nullptr); 199 OH_Drawing_CanvasDrawOval(canvas, rect5); 200 // 6. Free memory 201 OH_Drawing_CanvasDestroy(canvas); 202 OH_Drawing_RectDestroy(rect); 203 OH_Drawing_RectDestroy(rect2); 204 OH_Drawing_RectDestroy(rect3); 205 OH_Drawing_RectDestroy(rect4); 206 OH_Drawing_RectDestroy(rect5); 207 } 208 209 /* 210 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_1903 211 * @tc.name: testCanvasDrawOvalMaximum 212 * @tc.desc: test for testCanvasDrawOvalMaximum. 213 * @tc.size : SmallTest 214 * @tc.type : Function 215 * @tc.level : Level 3 216 */ 217 HWTEST_F(DrawingNativeCanvasPart3Test, testCanvasDrawOvalMaximum, TestSize.Level3) { 218 // 1. OH_Drawing_CanvasCreate 219 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 220 // add assert 221 EXPECT_NE(canvas, nullptr); 222 // 2. Create OH_Drawing_Rect with FLT_MAX as the values for left, top, right, and bottom 223 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(FLT_MAX, 0, 0, 0); 224 // add assert 225 EXPECT_NE(rect, nullptr); 226 OH_Drawing_CanvasDrawOval(canvas, rect); 227 rect = OH_Drawing_RectCreate(0, FLT_MAX, 0, 0); 228 // add assert 229 EXPECT_NE(rect, nullptr); 230 OH_Drawing_CanvasDrawOval(canvas, rect); 231 rect = OH_Drawing_RectCreate(0, 0, FLT_MAX, 0); 232 // add assert 233 EXPECT_NE(rect, nullptr); 234 OH_Drawing_CanvasDrawOval(canvas, rect); 235 rect = OH_Drawing_RectCreate(0, 0, 0, FLT_MAX); 236 // add assert 237 EXPECT_NE(rect, nullptr); 238 OH_Drawing_CanvasDrawOval(canvas, rect); 239 // 3. Free memory 240 OH_Drawing_CanvasDestroy(canvas); 241 OH_Drawing_RectDestroy(rect); 242 } 243 244 /* 245 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_1904 246 * @tc.name: testCanvasDrawOvalInputDestroyed 247 * @tc.desc: test for testCanvasDrawOvalInputDestroyed. 248 * @tc.size : SmallTest 249 * @tc.type : Function 250 * @tc.level : Level 3 251 */ 252 HWTEST_F(DrawingNativeCanvasPart3Test, testCanvasDrawOvalInputDestroyed, TestSize.Level3) { 253 // Deprecated 254 } 255 256 /* 257 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_2000 258 * @tc.name: testCanvasDrawArcNormal 259 * @tc.desc: test for testCanvasDrawArcNormal. 260 * @tc.size : SmallTest 261 * @tc.type : Function 262 * @tc.level : Level 0 263 */ 264 HWTEST_F(DrawingNativeCanvasPart3Test, testCanvasDrawArcNormal, TestSize.Level0) { 265 // 1. OH_Drawing_CanvasCreate 266 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 267 // add assert 268 EXPECT_NE(canvas, nullptr); 269 // 2. OH_Drawing_RectCreate 270 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0, 0, 100, 100); 271 // add assert 272 EXPECT_NE(rect, nullptr); 273 // 3. OH_Drawing_CanvasDrawArc with startAngle iterating over 0°, 180°, and 360° 274 float startAngles[] = {0.0f, 180.0f, 360.0f}; 275 for (float startAngle : startAngles) { 276 OH_Drawing_ErrorCodeReset(); 277 OH_Drawing_CanvasDrawArc(canvas, rect, startAngle, 90.0f); 278 // add assert 279 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 280 } 281 // 4. OH_Drawing_CanvasDrawArc with sweepAngle iterating over 0°, 180°, and 360° 282 float sweepAngles[] = {0.0f, 180.0f, 360.0f}; 283 for (float sweepAngle : sweepAngles) { 284 OH_Drawing_ErrorCodeReset(); 285 OH_Drawing_CanvasDrawArc(canvas, rect, 0.0f, sweepAngle); 286 // add assert 287 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 288 } 289 // 5. Free memory 290 OH_Drawing_CanvasDestroy(canvas); 291 OH_Drawing_RectDestroy(rect); 292 } 293 294 /* 295 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_2001 296 * @tc.name: testCanvasDrawArcNull 297 * @tc.desc: test for testCanvasDrawArcNull. 298 * @tc.size : SmallTest 299 * @tc.type : Function 300 * @tc.level : Level 3 301 */ 302 HWTEST_F(DrawingNativeCanvasPart3Test, testCanvasDrawArcNull, TestSize.Level3) { 303 // 1. OH_Drawing_CanvasCreate 304 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 305 // add assert 306 EXPECT_NE(canvas, nullptr); 307 // 2. OH_Drawing_RectCreate 308 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0, 0, 100, 100); 309 // add assert 310 EXPECT_NE(rect, nullptr); 311 // 3. OH_Drawing_CanvasDrawArc with nullptr as the first parameter 312 OH_Drawing_CanvasDrawArc(nullptr, rect, 0.0f, 90.0f); 313 // add assert 314 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 315 OH_Drawing_ErrorCodeReset(); 316 // 4. OH_Drawing_CanvasDrawArc with OH_Drawing_Rect created with 0 for left, top, right, and bottom 317 OH_Drawing_Rect *rect2 = OH_Drawing_RectCreate(0, 100, 200, 200); 318 OH_Drawing_CanvasDrawArc(canvas, rect2, 0.0f, 90.0f); 319 rect2 = OH_Drawing_RectCreate(100, 0, 200, 200); 320 OH_Drawing_CanvasDrawArc(canvas, rect2, 0.0f, 90.0f); 321 rect2 = OH_Drawing_RectCreate(100, 100, 0, 200); 322 OH_Drawing_CanvasDrawArc(canvas, rect2, 0.0f, 90.0f); 323 rect2 = OH_Drawing_RectCreate(100, 100, 200, 0); 324 OH_Drawing_CanvasDrawArc(canvas, rect2, 0.0f, 90.0f); 325 // 5. OH_Drawing_CanvasDrawArc with OH_Drawing_Rect created with all 0 values 326 OH_Drawing_Rect *rect3 = OH_Drawing_RectCreate(0, 0, 0, 0); 327 OH_Drawing_CanvasDrawArc(canvas, rect3, 0.0f, 90.0f); 328 // 6. OH_Drawing_CanvasDrawArc with nullptr as the second parameter 329 OH_Drawing_CanvasDrawArc(canvas, nullptr, 0.0f, 90.0f); 330 // add assert 331 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 332 // 7. Free memory 333 OH_Drawing_CanvasDestroy(canvas); 334 OH_Drawing_RectDestroy(rect); 335 OH_Drawing_RectDestroy(rect2); 336 OH_Drawing_RectDestroy(rect3); 337 } 338 339 /* 340 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_2002 341 * @tc.name: testCanvasDrawArcAbnormal 342 * @tc.desc: test for testCanvasDrawArcAbnormal. 343 * @tc.size : SmallTest 344 * @tc.type : Function 345 * @tc.level : Level 3 346 */ 347 HWTEST_F(DrawingNativeCanvasPart3Test, testCanvasDrawArcAbnormal, TestSize.Level3) { 348 // 1. OH_Drawing_CanvasCreate 349 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 350 // add assert 351 EXPECT_NE(canvas, nullptr); 352 // 2. OH_Drawing_CanvasDrawArc with OH_Drawing_Rect created with negative values for left, top, right, and bottom 353 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(-100, -100, -200, -200); 354 // add assert 355 EXPECT_NE(rect, nullptr); 356 OH_Drawing_CanvasDrawArc(canvas, rect, 0.0f, 90.0f); 357 rect = OH_Drawing_RectCreate(-100, 100, 200, 200); 358 // add assert 359 EXPECT_NE(rect, nullptr); 360 OH_Drawing_CanvasDrawArc(canvas, rect, 0.0f, 90.0f); 361 rect = OH_Drawing_RectCreate(100, -100, 200, 200); 362 // add assert 363 EXPECT_NE(rect, nullptr); 364 OH_Drawing_CanvasDrawArc(canvas, rect, 0.0f, 90.0f); 365 rect = OH_Drawing_RectCreate(100, 100, -200, 200); 366 // add assert 367 EXPECT_NE(rect, nullptr); 368 OH_Drawing_CanvasDrawArc(canvas, rect, 0.0f, 90.0f); 369 rect = OH_Drawing_RectCreate(100, 100, 200, -200); 370 // add assert 371 EXPECT_NE(rect, nullptr); 372 OH_Drawing_CanvasDrawArc(canvas, rect, 0.0f, 90.0f); 373 // 3. OH_Drawing_CanvasDrawArc with OH_Drawing_Rect created with the horizontal coordinate of the top-left corner 374 // equal to the horizontal coordinate of the bottom-right corner, or the vertical coordinate of the top-left corner 375 // equal to the vertical coordinate of the bottom-right corner 376 OH_Drawing_Rect *rect2 = OH_Drawing_RectCreate(100, 0, 100, 100); 377 // add assert 378 EXPECT_NE(rect2, nullptr); 379 OH_Drawing_CanvasDrawArc(canvas, rect2, 0.0f, 90.0f); 380 OH_Drawing_Rect *rect3 = OH_Drawing_RectCreate(0, 100, 100, 100); 381 // add assert 382 EXPECT_NE(rect3, nullptr); 383 OH_Drawing_CanvasDrawArc(canvas, rect3, 0.0f, 90.0f); 384 // 4. OH_Drawing_CanvasDrawArc with OH_Drawing_Rect created with the top-left corner coordinates equal to the 385 // bottom-right corner coordinates 386 OH_Drawing_Rect *rect4 = OH_Drawing_RectCreate(100, 100, 100, 100); 387 // add assert 388 EXPECT_NE(rect4, nullptr); 389 OH_Drawing_CanvasDrawArc(canvas, rect4, 0.0f, 90.0f); 390 // 5. OH_Drawing_CanvasDrawArc with OH_Drawing_Rect created with the top-left corner coordinates greater than the 391 // bottom-right corner coordinates 392 OH_Drawing_Rect *rect5 = OH_Drawing_RectCreate(200, 200, 100, 100); 393 // add assert 394 EXPECT_NE(rect5, nullptr); 395 OH_Drawing_CanvasDrawArc(canvas, rect5, 0.0f, 90.0f); 396 // 6. OH_Drawing_CanvasDrawArc with negative startAngle 397 OH_Drawing_CanvasDrawArc(canvas, rect, -90.0f, 90.0f); 398 // 7. OH_Drawing_CanvasDrawArc with startAngle greater than 360° 399 OH_Drawing_CanvasDrawArc(canvas, rect, 400.0f, 90.0f); 400 // 8. OH_Drawing_CanvasDrawArc with negative sweepAngle 401 OH_Drawing_CanvasDrawArc(canvas, rect, 0.0f, -90.0f); 402 // 9. OH_Drawing_CanvasDrawArc with sweepAngle greater than 360° 403 OH_Drawing_CanvasDrawArc(canvas, rect, 0.0f, 400.0f); 404 // 10. Free memory 405 OH_Drawing_CanvasDestroy(canvas); 406 OH_Drawing_RectDestroy(rect); 407 OH_Drawing_RectDestroy(rect2); 408 OH_Drawing_RectDestroy(rect3); 409 OH_Drawing_RectDestroy(rect4); 410 OH_Drawing_RectDestroy(rect5); 411 } 412 413 /* 414 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_2003 415 * @tc.name: testCanvasDrawArcMaximum 416 * @tc.desc: test for testCanvasDrawArcMaximum. 417 * @tc.size : SmallTest 418 * @tc.type : Function 419 * @tc.level : Level 3 420 */ 421 HWTEST_F(DrawingNativeCanvasPart3Test, testCanvasDrawArcMaximum, TestSize.Level3) { 422 // 1. OH_Drawing_CanvasCreate 423 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 424 // add assert 425 EXPECT_NE(canvas, nullptr); 426 // 2. OH_Drawing_CanvasDrawArc with OH_Drawing_Rect created with FLT_MAX as the values for left, top, right, and 427 // bottom 428 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(FLT_MAX, 0, 0, 0); 429 // add assert 430 EXPECT_NE(rect, nullptr); 431 OH_Drawing_CanvasDrawArc(canvas, rect, 0.0f, 90.0f); 432 OH_Drawing_RectDestroy(rect); 433 rect = OH_Drawing_RectCreate(0, FLT_MAX, 0, 0); 434 // add assert 435 EXPECT_NE(rect, nullptr); 436 OH_Drawing_CanvasDrawArc(canvas, rect, 0.0f, 90.0f); 437 OH_Drawing_RectDestroy(rect); 438 rect = OH_Drawing_RectCreate(0, 0, FLT_MAX, 0); 439 // add assert 440 EXPECT_NE(rect, nullptr); 441 OH_Drawing_CanvasDrawArc(canvas, rect, 0.0f, 90.0f); 442 OH_Drawing_RectDestroy(rect); 443 rect = OH_Drawing_RectCreate(0, 0, 0, FLT_MAX); 444 // add assert 445 EXPECT_NE(rect, nullptr); 446 OH_Drawing_CanvasDrawArc(canvas, rect, 0.0f, 90.0f); 447 OH_Drawing_RectDestroy(rect); 448 // 3. OH_Drawing_CanvasDrawArc with startAngle FLT_MAX 449 rect = OH_Drawing_RectCreate(0, 0, 100, 100); 450 // add assert 451 EXPECT_NE(rect, nullptr); 452 OH_Drawing_CanvasDrawArc(canvas, rect, FLT_MAX, 90.0f); 453 OH_Drawing_RectDestroy(rect); 454 // 4. OH_Drawing_CanvasDrawArc with sweepAngle FLT_MAX 455 rect = OH_Drawing_RectCreate(0, 0, 100, 100); 456 // add assert 457 EXPECT_NE(rect, nullptr); 458 OH_Drawing_CanvasDrawArc(canvas, rect, 0.0f, FLT_MAX); 459 OH_Drawing_RectDestroy(rect); 460 // 5. Free memory 461 OH_Drawing_CanvasDestroy(canvas); 462 } 463 464 /* 465 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_2004 466 * @tc.name: testCanvasDrawArcInputDestroyed 467 * @tc.desc: test for testCanvasDrawArcInputDestroyed. 468 * @tc.size : SmallTest 469 * @tc.type : Function 470 * @tc.level : Level 3 471 */ 472 HWTEST_F(DrawingNativeCanvasPart3Test, testCanvasDrawArcInputDestroyed, TestSize.Level3) { 473 // Deprecated 474 } 475 476 /* 477 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_2100 478 * @tc.name: testCanvasDrawRoundRectNormal 479 * @tc.desc: test for testCanvasDrawRoundRectNormal. 480 * @tc.size : SmallTest 481 * @tc.type : Function 482 * @tc.level : Level 0 483 */ 484 HWTEST_F(DrawingNativeCanvasPart3Test, testCanvasDrawRoundRectNormal, TestSize.Level0) { 485 // 1. OH_Drawing_CanvasCreate 486 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 487 // add assert 488 EXPECT_NE(canvas, nullptr); 489 490 // 2. OH_Drawing_RoundRectCreate 491 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(10, 100, 200, 300); 492 // add assert 493 EXPECT_NE(rect, nullptr); 494 OH_Drawing_RoundRect *roundRect = OH_Drawing_RoundRectCreate(rect, 1.0f, 1.0f); 495 // add assert 496 EXPECT_NE(roundRect, nullptr); 497 498 // 3. OH_Drawing_CanvasDrawRoundRect 499 OH_Drawing_CanvasDrawRoundRect(canvas, roundRect); 500 // add assert 501 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 502 503 // 4. Free memory 504 OH_Drawing_CanvasDestroy(canvas); 505 OH_Drawing_RectDestroy(rect); 506 OH_Drawing_RoundRectDestroy(roundRect); 507 } 508 509 /* 510 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_2101 511 * @tc.name: testCanvasDrawRoundRectNull 512 * @tc.desc: test for testCanvasDrawRoundRectNull. 513 * @tc.size : SmallTest 514 * @tc.type : Function 515 * @tc.level : Level 3 516 */ 517 HWTEST_F(DrawingNativeCanvasPart3Test, testCanvasDrawRoundRectNull, TestSize.Level3) { 518 // 1. OH_Drawing_CanvasCreate 519 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 520 // add assert 521 EXPECT_NE(canvas, nullptr); 522 523 // 2. OH_Drawing_RoundRectCreate 524 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(10, 100, 200, 300); 525 // add assert 526 EXPECT_NE(rect, nullptr); 527 OH_Drawing_RoundRect *roundRect = OH_Drawing_RoundRectCreate(rect, 1.0f, 1.0f); 528 // add assert 529 EXPECT_NE(roundRect, nullptr); 530 531 // 3. OH_Drawing_CanvasDrawRoundRect with the first parameter being nullptr 532 OH_Drawing_CanvasDrawRoundRect(nullptr, roundRect); 533 // add assert 534 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 535 OH_Drawing_ErrorCodeReset(); 536 // 4. OH_Drawing_CanvasDrawRoundRect with the second parameter being nullptr 537 OH_Drawing_CanvasDrawRoundRect(canvas, nullptr); 538 // add assert 539 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 540 541 // 5. OH_Drawing_CanvasDrawRoundRect with the second parameter OH_Drawing_RoundRectCreate created with rect having 0 542 // in any of the four positions 543 OH_Drawing_Rect *rect2 = OH_Drawing_RectCreate(0, 100, 200, 300); 544 // add assert 545 EXPECT_NE(rect2, nullptr); 546 OH_Drawing_RoundRect *roundRect2 = OH_Drawing_RoundRectCreate(rect2, 1.0f, 1.0f); 547 // add assert 548 EXPECT_NE(roundRect2, nullptr); 549 OH_Drawing_CanvasDrawRoundRect(canvas, roundRect2); 550 551 OH_Drawing_Rect *rect3 = OH_Drawing_RectCreate(10, 0, 200, 300); 552 // add assert 553 EXPECT_NE(rect3, nullptr); 554 OH_Drawing_RoundRect *roundRect3 = OH_Drawing_RoundRectCreate(rect3, 1.0f, 1.0f); 555 // add assert 556 EXPECT_NE(roundRect3, nullptr); 557 OH_Drawing_CanvasDrawRoundRect(canvas, roundRect3); 558 559 OH_Drawing_Rect *rect4 = OH_Drawing_RectCreate(10, 100, 0, 300); 560 // add assert 561 EXPECT_NE(rect4, nullptr); 562 OH_Drawing_RoundRect *roundRect4 = OH_Drawing_RoundRectCreate(rect4, 1.0f, 1.0f); 563 // add assert 564 EXPECT_NE(roundRect4, nullptr); 565 OH_Drawing_CanvasDrawRoundRect(canvas, roundRect4); 566 567 OH_Drawing_Rect *rect5 = OH_Drawing_RectCreate(10, 100, 200, 0); 568 // add assert 569 EXPECT_NE(rect5, nullptr); 570 OH_Drawing_RoundRect *roundRect5 = OH_Drawing_RoundRectCreate(rect5, 1.0f, 1.0f); 571 // add assert 572 EXPECT_NE(roundRect5, nullptr); 573 OH_Drawing_CanvasDrawRoundRect(canvas, roundRect5); 574 575 // 6. OH_Drawing_CanvasDrawRoundRect with the second parameter OH_Drawing_RoundRectCreate created with rect having 576 // all positions as 0 577 OH_Drawing_Rect *rect6 = OH_Drawing_RectCreate(0, 0, 0, 0); 578 // add assert 579 EXPECT_NE(rect6, nullptr); 580 OH_Drawing_RoundRect *roundRect6 = OH_Drawing_RoundRectCreate(rect6, 1.0f, 1.0f); 581 // add assert 582 EXPECT_NE(roundRect6, nullptr); 583 OH_Drawing_CanvasDrawRoundRect(canvas, roundRect6); 584 585 // 7. OH_Drawing_CanvasDrawRoundRect with the second parameter OH_Drawing_RoundRectCreate created with xRad as 0 586 OH_Drawing_Rect *rect7 = OH_Drawing_RectCreate(10, 100, 200, 300); 587 // add assert 588 EXPECT_NE(rect7, nullptr); 589 OH_Drawing_RoundRect *roundRect7 = OH_Drawing_RoundRectCreate(rect7, 0.0f, 1.0f); 590 // add assert 591 EXPECT_NE(roundRect7, nullptr); 592 OH_Drawing_CanvasDrawRoundRect(canvas, roundRect7); 593 594 // 8. OH_Drawing_CanvasDrawRoundRect with the second parameter OH_Drawing_RoundRectCreate created with yRad as 0 595 OH_Drawing_Rect *rect8 = OH_Drawing_RectCreate(10, 100, 200, 300); 596 // add assert 597 EXPECT_NE(rect8, nullptr); 598 OH_Drawing_RoundRect *roundRect8 = OH_Drawing_RoundRectCreate(rect8, 1.0f, 0.0f); 599 // add assert 600 EXPECT_NE(roundRect8, nullptr); 601 OH_Drawing_CanvasDrawRoundRect(canvas, roundRect8); 602 603 // 9. Free memory 604 OH_Drawing_CanvasDestroy(canvas); 605 OH_Drawing_RectDestroy(rect); 606 OH_Drawing_RoundRectDestroy(roundRect); 607 OH_Drawing_RectDestroy(rect2); 608 OH_Drawing_RoundRectDestroy(roundRect2); 609 OH_Drawing_RectDestroy(rect3); 610 OH_Drawing_RoundRectDestroy(roundRect3); 611 OH_Drawing_RectDestroy(rect4); 612 OH_Drawing_RoundRectDestroy(roundRect4); 613 OH_Drawing_RectDestroy(rect5); 614 OH_Drawing_RoundRectDestroy(roundRect5); 615 OH_Drawing_RectDestroy(rect6); 616 OH_Drawing_RoundRectDestroy(roundRect6); 617 OH_Drawing_RectDestroy(rect7); 618 OH_Drawing_RoundRectDestroy(roundRect7); 619 OH_Drawing_RectDestroy(rect8); 620 OH_Drawing_RoundRectDestroy(roundRect8); 621 } 622 623 /* 624 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_2102 625 * @tc.name: testCanvasDrawRoundRectAbnormal 626 * @tc.desc: test for testCanvasDrawRoundRectAbnormal. 627 * @tc.size : SmallTest 628 * @tc.type : Function 629 * @tc.level : Level 3 630 */ 631 HWTEST_F(DrawingNativeCanvasPart3Test, testCanvasDrawRoundRectAbnormal, TestSize.Level3) { 632 // 1. OH_Drawing_CanvasCreate 633 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 634 // add assert 635 EXPECT_NE(canvas, nullptr); 636 637 // 2. OH_Drawing_CanvasDrawRoundRect with OH_Drawing_RoundRectCreate creating rect with left, top, right, bottom 638 // being set to negative numbers 639 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(-10, 100, 200, 300); 640 // add assert 641 EXPECT_NE(rect, nullptr); 642 OH_Drawing_RoundRect *roundRect = OH_Drawing_RoundRectCreate(rect, 0.0f, 1.0f); 643 // add assert 644 EXPECT_NE(roundRect, nullptr); 645 OH_Drawing_CanvasDrawRoundRect(canvas, roundRect); 646 647 rect = OH_Drawing_RectCreate(10, -100, 200, 300); 648 // add assert 649 EXPECT_NE(rect, nullptr); 650 roundRect = OH_Drawing_RoundRectCreate(rect, 0.0f, 1.0f); 651 OH_Drawing_CanvasDrawRoundRect(canvas, roundRect); 652 653 rect = OH_Drawing_RectCreate(10, 100, -200, 300); 654 // add assert 655 EXPECT_NE(rect, nullptr); 656 roundRect = OH_Drawing_RoundRectCreate(rect, 0.0f, 1.0f); 657 OH_Drawing_CanvasDrawRoundRect(canvas, roundRect); 658 659 rect = OH_Drawing_RectCreate(10, 100, 200, -300); 660 // add assert 661 EXPECT_NE(rect, nullptr); 662 roundRect = OH_Drawing_RoundRectCreate(rect, 0.0f, 1.0f); 663 OH_Drawing_CanvasDrawRoundRect(canvas, roundRect); 664 665 // 3. OH_Drawing_CanvasDrawRoundRect with OH_Drawing_CanvasDrawRoundRect creating rect with the horizontal 666 // coordinate of the top-left corner equal to the horizontal coordinate of the bottom-right corner, or the vertical 667 // coordinate of the top-left corner equal to the vertical coordinate of the bottom-right corner 668 rect = OH_Drawing_RectCreate(100, 0, 100, 100); 669 // add assert 670 EXPECT_NE(rect, nullptr); 671 roundRect = OH_Drawing_RoundRectCreate(rect, 0.0f, 1.0f); 672 OH_Drawing_CanvasDrawRoundRect(canvas, roundRect); 673 674 rect = OH_Drawing_RectCreate(0, 100, 100, 100); 675 // add assert 676 EXPECT_NE(rect, nullptr); 677 roundRect = OH_Drawing_RoundRectCreate(rect, 0.0f, 1.0f); 678 OH_Drawing_CanvasDrawRoundRect(canvas, roundRect); 679 680 // 4. OH_Drawing_CanvasDrawRoundRect with OH_Drawing_RoundRectCreate creating rect with the top-left corner 681 // coordinates equal to the bottom-right corner coordinates 682 rect = OH_Drawing_RectCreate(100, 100, 100, 100); 683 // add assert 684 EXPECT_NE(rect, nullptr); 685 roundRect = OH_Drawing_RoundRectCreate(rect, 0.0f, 1.0f); 686 OH_Drawing_CanvasDrawRoundRect(canvas, roundRect); 687 688 // 5. OH_Drawing_CanvasDrawRoundRect with OH_Drawing_RoundRectCreate creating rect with the top-left corner 689 // coordinates greater than the bottom-right corner coordinates 690 rect = OH_Drawing_RectCreate(200, 200, 100, 100); 691 // add assert 692 EXPECT_NE(rect, nullptr); 693 roundRect = OH_Drawing_RoundRectCreate(rect, 0.0f, 1.0f); 694 OH_Drawing_CanvasDrawRoundRect(canvas, roundRect); 695 696 // 6. OH_Drawing_CanvasDrawRoundRect with the second parameter OH_Drawing_RoundRectCreate creating roundRect with a 697 // negative xRad 698 rect = OH_Drawing_RectCreate(10, 100, 200, 300); 699 // add assert 700 EXPECT_NE(rect, nullptr); 701 roundRect = OH_Drawing_RoundRectCreate(rect, -1.0f, 1.0f); 702 OH_Drawing_CanvasDrawRoundRect(canvas, roundRect); 703 704 // 7. OH_Drawing_CanvasDrawRoundRect with the second parameter OH_Drawing_RoundRectCreate creating roundRect with a 705 // negative yRad 706 rect = OH_Drawing_RectCreate(10, 100, 200, 300); 707 // add assert 708 EXPECT_NE(rect, nullptr); 709 roundRect = OH_Drawing_RoundRectCreate(rect, 0.0f, -1.0f); 710 OH_Drawing_CanvasDrawRoundRect(canvas, roundRect); 711 712 // 8. Free memory 713 OH_Drawing_CanvasDestroy(canvas); 714 OH_Drawing_RectDestroy(rect); 715 OH_Drawing_RoundRectDestroy(roundRect); 716 } 717 718 /* 719 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_2103 720 * @tc.name: testCanvasDrawRoundRectMaximum 721 * @tc.desc: test for testCanvasDrawRoundRectMaximum. 722 * @tc.size : SmallTest 723 * @tc.type : Function 724 * @tc.level : Level 3 725 */ 726 HWTEST_F(DrawingNativeCanvasPart3Test, testCanvasDrawRoundRectMaximum, TestSize.Level3) { 727 // 1. OH_Drawing_CanvasCreate 728 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 729 // add assert 730 EXPECT_NE(canvas, nullptr); 731 // 2. OH_Drawing_CanvasDrawRoundRect with OH_Drawing_RoundRectCreate creating rect with left, top, right, bottom 732 // being set to FLT_MAX 733 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(FLT_MAX, 100, 200, 300); 734 // add assert 735 EXPECT_NE(rect, nullptr); 736 OH_Drawing_RoundRect *roundRect = OH_Drawing_RoundRectCreate(rect, 1.0f, 1.0f); 737 // add assert 738 EXPECT_NE(roundRect, nullptr); 739 OH_Drawing_CanvasDrawRoundRect(canvas, roundRect); 740 741 rect = OH_Drawing_RectCreate(10, FLT_MAX, 200, 300); 742 // add assert 743 EXPECT_NE(rect, nullptr); 744 roundRect = OH_Drawing_RoundRectCreate(rect, 1.0f, 1.0f); 745 OH_Drawing_CanvasDrawRoundRect(canvas, roundRect); 746 747 rect = OH_Drawing_RectCreate(10, 100, FLT_MAX, 300); 748 // add assert 749 EXPECT_NE(rect, nullptr); 750 roundRect = OH_Drawing_RoundRectCreate(rect, 1.0f, 1.0f); 751 OH_Drawing_CanvasDrawRoundRect(canvas, roundRect); 752 753 rect = OH_Drawing_RectCreate(10, 100, 200, FLT_MAX); 754 // add assert 755 EXPECT_NE(rect, nullptr); 756 roundRect = OH_Drawing_RoundRectCreate(rect, 1.0f, 1.0f); 757 OH_Drawing_CanvasDrawRoundRect(canvas, roundRect); 758 759 // 3. OH_Drawing_CanvasDrawRoundRect with the second parameter OH_Drawing_RoundRectCreate created with xRad being 760 // set to FLT_MAX 761 rect = OH_Drawing_RectCreate(10, 100, 200, 300); 762 // add assert 763 EXPECT_NE(rect, nullptr); 764 roundRect = OH_Drawing_RoundRectCreate(rect, FLT_MAX, 1.0f); 765 OH_Drawing_CanvasDrawRoundRect(canvas, roundRect); 766 767 // 4. OH_Drawing_CanvasDrawRoundRect with the second parameter OH_Drawing_RoundRectCreate created with yRad being 768 // set to FLT_MAX 769 rect = OH_Drawing_RectCreate(10, 100, 200, 300); 770 // add assert 771 EXPECT_NE(rect, nullptr); 772 roundRect = OH_Drawing_RoundRectCreate(rect, 1.0f, FLT_MAX); 773 OH_Drawing_CanvasDrawRoundRect(canvas, roundRect); 774 775 // 5. Free memory 776 OH_Drawing_CanvasDestroy(canvas); 777 OH_Drawing_RectDestroy(rect); 778 OH_Drawing_RoundRectDestroy(roundRect); 779 } 780 781 /* 782 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_2104 783 * @tc.name: testCanvasDrawRoundRectInputDestroyed 784 * @tc.desc: test for testCanvasDrawRoundRectInputDestroyed. 785 * @tc.size : SmallTest 786 * @tc.type : Function 787 * @tc.level : Level 3 788 */ 789 HWTEST_F(DrawingNativeCanvasPart3Test, testCanvasDrawRoundRectInputDestroyed, TestSize.Level3) { 790 // Deprecated 791 } 792 793 /* 794 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_2200 795 * @tc.name: testCanvasDrawTextBlobNormal 796 * @tc.desc: test for testCanvasDrawTextBlobNormal. 797 * @tc.size : SmallTest 798 * @tc.type : Function 799 * @tc.level : Level 0 800 */ 801 HWTEST_F(DrawingNativeCanvasPart3Test, testCanvasDrawTextBlobNormal, TestSize.Level0) { 802 // 1. OH_Drawing_CanvasCreate 803 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 804 // add assert 805 EXPECT_NE(canvas, nullptr); 806 807 // 2. OH_Drawing_TextBlobCreateFromText 808 const char *str = "123456"; 809 810 OH_Drawing_Font *font = OH_Drawing_FontCreate(); 811 // add assert 812 EXPECT_NE(font, nullptr); 813 OH_Drawing_TextBlob *textBlob = 814 OH_Drawing_TextBlobCreateFromText(str, strlen(str), font, OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8); 815 // add assert 816 EXPECT_NE(textBlob, nullptr); 817 // 3. OH_Drawing_CanvasDrawTextBlob 818 OH_Drawing_CanvasDrawTextBlob(canvas, textBlob, 10, 10); 819 // 4. Free memory 820 OH_Drawing_TextBlobDestroy(textBlob); 821 822 OH_Drawing_CanvasDestroy(canvas); 823 } 824 825 /* 826 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_2201 827 * @tc.name: testCanvasDrawTextBlobNull 828 * @tc.desc: test for testCanvasDrawTextBlobNull. 829 * @tc.size : SmallTest 830 * @tc.type : Function 831 * @tc.level : Level 3 832 */ 833 HWTEST_F(DrawingNativeCanvasPart3Test, testCanvasDrawTextBlobNull, TestSize.Level3) { 834 // 1. OH_Drawing_CanvasCreate 835 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 836 // add assert 837 EXPECT_NE(canvas, nullptr); 838 // 2. OH_Drawing_TextBlobCreateFromString 839 const char *str = "123456"; 840 841 OH_Drawing_Font *font = OH_Drawing_FontCreate(); 842 // add assert 843 EXPECT_NE(font, nullptr); 844 OH_Drawing_TextBlob *textBlob = 845 OH_Drawing_TextBlobCreateFromText(str, strlen(str), font, OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8); 846 // add assert 847 EXPECT_NE(textBlob, nullptr); 848 // 3. OH_Drawing_CanvasDrawTextBlob with the first parameter being nullptr 849 OH_Drawing_CanvasDrawTextBlob(nullptr, textBlob, 10, 10); 850 // add assert 851 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 852 OH_Drawing_ErrorCodeReset(); 853 // 4. OH_Drawing_CanvasDrawTextBlob with the second parameter being nullptr 854 OH_Drawing_CanvasDrawTextBlob(canvas, nullptr, 10, 10); 855 // add assert 856 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 857 // 5. OH_Drawing_CanvasDrawTextBlob with the third parameter being 0 858 OH_Drawing_CanvasDrawTextBlob(canvas, textBlob, 0, 10); 859 // 6. OH_Drawing_CanvasDrawTextBlob with the fourth parameter being 0 860 OH_Drawing_CanvasDrawTextBlob(canvas, textBlob, 10, 0); 861 // 7. Free memory 862 OH_Drawing_TextBlobDestroy(textBlob); 863 864 OH_Drawing_CanvasDestroy(canvas); 865 } 866 867 /* 868 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_2202 869 * @tc.name: testCanvasDrawTextBlobAbnormal 870 * @tc.desc: test for testCanvasDrawTextBlobAbnormal. 871 * @tc.size : SmallTest 872 * @tc.type : Function 873 * @tc.level : Level 3 874 */ 875 HWTEST_F(DrawingNativeCanvasPart3Test, testCanvasDrawTextBlobAbnormal, TestSize.Level3) { 876 // 1. OH_Drawing_CanvasCreate 877 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 878 // add assert 879 EXPECT_NE(canvas, nullptr); 880 // 2. Create OH_Drawing_TextBlob from text 881 const char *str = "123456"; 882 OH_Drawing_Font *font = OH_Drawing_FontCreate(); 883 // add assert 884 EXPECT_NE(font, nullptr); 885 OH_Drawing_TextBlob *textBlob = 886 OH_Drawing_TextBlobCreateFromText(str, strlen(str), font, OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8); 887 // add assert 888 EXPECT_NE(textBlob, nullptr); 889 // 3. Draw OH_Drawing_TextBlob on canvas with x-coordinate of the bottom left corner of the text object set to a 890 // negative value 891 OH_Drawing_CanvasDrawTextBlob(canvas, textBlob, -10, 10); 892 // 4. Draw OH_Drawing_TextBlob on canvas with y-coordinate of the bottom left corner of the text object set to a 893 // negative value 894 OH_Drawing_CanvasDrawTextBlob(canvas, textBlob, 10, -10); 895 // 5. Release memory 896 OH_Drawing_TextBlobDestroy(textBlob); 897 OH_Drawing_CanvasDestroy(canvas); 898 } 899 900 /* 901 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_2203 902 * @tc.name: testCanvasDrawTextBlobMaximum 903 * @tc.desc: test for testCanvasDrawTextBlobMaximum. 904 * @tc.size : SmallTest 905 * @tc.type : Function 906 * @tc.level : Level 3 907 */ 908 HWTEST_F(DrawingNativeCanvasPart3Test, testCanvasDrawTextBlobMaximum, TestSize.Level3) { 909 // 1. Create OH_Drawing_Canvas 910 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 911 // add assert 912 EXPECT_NE(canvas, nullptr); 913 // 2. Create OH_Drawing_TextBlob from text 914 const char *str = "123456"; 915 OH_Drawing_Font *font = OH_Drawing_FontCreate(); 916 // add assert 917 EXPECT_NE(font, nullptr); 918 OH_Drawing_TextBlob *textBlob = 919 OH_Drawing_TextBlobCreateFromText(str, strlen(str), font, OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8); 920 // add assert 921 EXPECT_NE(textBlob, nullptr); 922 // 3. Draw OH_Drawing_TextBlob on canvas with x-coordinate of the bottom left corner of the text object set to 923 // maximum value 924 OH_Drawing_CanvasDrawTextBlob(canvas, textBlob, FLT_MAX, 10); 925 // 4. Draw OH_Drawing_TextBlob on canvas with y-coordinate of the bottom left corner of the text object set to 926 // maximum value 927 OH_Drawing_CanvasDrawTextBlob(canvas, textBlob, 10, FLT_MAX); 928 // 5. Release memory 929 OH_Drawing_TextBlobDestroy(textBlob); 930 // 5. Release memory 931 OH_Drawing_CanvasDestroy(canvas); 932 } 933 934 /* 935 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_2204 936 * @tc.name: testCanvasDrawTextBlobInputDestroyed 937 * @tc.desc: test for testCanvasDrawTextBlobInputDestroyed. 938 * @tc.size : SmallTest 939 * @tc.type : Function 940 * @tc.level : Level 3 941 */ 942 HWTEST_F(DrawingNativeCanvasPart3Test, testCanvasDrawTextBlobInputDestroyed, TestSize.Level3) { 943 // Deprecated 944 } 945 946 /* 947 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_2300 948 * @tc.name: testCanvasClipRectNormal 949 * @tc.desc: test for testCanvasClipRectNormal. 950 * @tc.size : SmallTest 951 * @tc.type : Function 952 * @tc.level : Level 0 953 */ 954 HWTEST_F(DrawingNativeCanvasPart3Test, testCanvasClipRectNormal, TestSize.Level0) { 955 // 1. OH_Drawing_CanvasCreate 956 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 957 // add assert 958 EXPECT_NE(canvas, nullptr); 959 // 2. OH_Drawing_RectCreate 960 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(10, 10, 100, 100); 961 // add assert 962 EXPECT_NE(rect, nullptr); 963 // 3. OH_Drawing_CanvasClipRect with clipOp and doAntiAlias parameters, iterate through enum values 964 OH_Drawing_CanvasClipOp clipOp[] = {OH_Drawing_CanvasClipOp::DIFFERENCE, OH_Drawing_CanvasClipOp::INTERSECT}; 965 bool doAntiAlias[] = {true, false}; 966 for (int i = 0; i < 2; i++) { 967 for (int j = 0; j < 2; j++) { 968 OH_Drawing_ErrorCodeReset(); 969 OH_Drawing_CanvasClipRect(canvas, rect, clipOp[i], doAntiAlias[j]); 970 // add assert 971 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 972 } 973 } 974 // 4. Free memory 975 OH_Drawing_CanvasDestroy(canvas); 976 } 977 978 /* 979 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_2301 980 * @tc.name: testCanvasClipRectNull 981 * @tc.desc: test for testCanvasClipRectNull. 982 * @tc.size : SmallTest 983 * @tc.type : Function 984 * @tc.level : Level 3 985 */ 986 HWTEST_F(DrawingNativeCanvasPart3Test, testCanvasClipRectNull, TestSize.Level3) { 987 // 1. OH_Drawing_CanvasCreate 988 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 989 // add assert 990 EXPECT_NE(canvas, nullptr); 991 // 2. OH_Drawing_RectCreate 992 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(10, 10, 100, 100); 993 // add assert 994 EXPECT_NE(rect, nullptr); 995 // 3. OH_Drawing_CanvasClipRect with the first parameter being nullptr 996 OH_Drawing_CanvasClipRect(nullptr, rect, OH_Drawing_CanvasClipOp::DIFFERENCE, true); 997 // add assert 998 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 999 OH_Drawing_ErrorCodeReset(); 1000 // 4. OH_Drawing_CanvasClipRect with the second parameter OH_Drawing_Rect created with left, top, right, and bottom 1001 // values being 0 1002 OH_Drawing_Rect *rect2 = OH_Drawing_RectCreate(0, 10, 100, 100); 1003 // add assert 1004 EXPECT_NE(rect2, nullptr); 1005 OH_Drawing_CanvasClipRect(canvas, rect2, OH_Drawing_CanvasClipOp::DIFFERENCE, true); 1006 rect2 = OH_Drawing_RectCreate(10, 0, 100, 100); 1007 // add assert 1008 EXPECT_NE(rect2, nullptr); 1009 OH_Drawing_CanvasClipRect(canvas, rect2, OH_Drawing_CanvasClipOp::DIFFERENCE, true); 1010 rect2 = OH_Drawing_RectCreate(10, 10, 0, 100); 1011 // add assert 1012 EXPECT_NE(rect2, nullptr); 1013 OH_Drawing_CanvasClipRect(canvas, rect2, OH_Drawing_CanvasClipOp::DIFFERENCE, true); 1014 rect2 = OH_Drawing_RectCreate(10, 10, 100, 0); 1015 // add assert 1016 EXPECT_NE(rect2, nullptr); 1017 OH_Drawing_CanvasClipRect(canvas, rect2, OH_Drawing_CanvasClipOp::DIFFERENCE, true); 1018 // 5. OH_Drawing_CanvasClipRect with the second parameter OH_Drawing_Rect created with all values being 0 1019 OH_Drawing_Rect *rect3 = OH_Drawing_RectCreate(0, 0, 0, 0); 1020 // add assert 1021 EXPECT_NE(rect3, nullptr); 1022 OH_Drawing_CanvasClipRect(canvas, rect3, OH_Drawing_CanvasClipOp::DIFFERENCE, true); 1023 // 6. OH_Drawing_CanvasClipRect with the second parameter being nullptr 1024 OH_Drawing_CanvasClipRect(canvas, nullptr, OH_Drawing_CanvasClipOp::DIFFERENCE, true); 1025 // add assert 1026 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 1027 // 7. Free memory 1028 OH_Drawing_CanvasDestroy(canvas); 1029 OH_Drawing_RectDestroy(rect); 1030 OH_Drawing_RectDestroy(rect2); 1031 OH_Drawing_RectDestroy(rect3); 1032 } 1033 1034 /* 1035 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_2302 1036 * @tc.name: testCanvasClipRectAbnormal 1037 * @tc.desc: test for testCanvasClipRectAbnormal. 1038 * @tc.size : SmallTest 1039 * @tc.type : Function 1040 * @tc.level : Level 3 1041 */ 1042 HWTEST_F(DrawingNativeCanvasPart3Test, testCanvasClipRectAbnormal, TestSize.Level3) { 1043 // 1. OH_Drawing_CanvasCreate 1044 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1045 // add assert 1046 EXPECT_NE(canvas, nullptr); 1047 // 2. OH_Drawing_CanvasClipRect with OH_Drawing_Rect created with negative values for left, top, right, and bottom 1048 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(-10, 10, 100, 100); 1049 // add assert 1050 EXPECT_NE(rect, nullptr); 1051 OH_Drawing_CanvasClipRect(canvas, rect, OH_Drawing_CanvasClipOp::DIFFERENCE, true); 1052 rect = OH_Drawing_RectCreate(10, -10, 100, 100); 1053 // add assert 1054 EXPECT_NE(rect, nullptr); 1055 OH_Drawing_CanvasClipRect(canvas, rect, OH_Drawing_CanvasClipOp::DIFFERENCE, true); 1056 rect = OH_Drawing_RectCreate(10, 10, -100, 100); 1057 // add assert 1058 EXPECT_NE(rect, nullptr); 1059 OH_Drawing_CanvasClipRect(canvas, rect, OH_Drawing_CanvasClipOp::DIFFERENCE, true); 1060 rect = OH_Drawing_RectCreate(10, 10, 100, -100); 1061 // add assert 1062 EXPECT_NE(rect, nullptr); 1063 OH_Drawing_CanvasClipRect(canvas, rect, OH_Drawing_CanvasClipOp::DIFFERENCE, true); 1064 // 3. OH_Drawing_CanvasClipRect with OH_Drawing_Rect created where the x-coordinate of the top-left corner is equal 1065 // to the x-coordinate of the bottom-right corner, or the y-coordinate of the top-left corner is equal to the 1066 // y-coordinate of the bottom-right corner 1067 rect = OH_Drawing_RectCreate(100, 10, 100, 100); 1068 // add assert 1069 EXPECT_NE(rect, nullptr); 1070 OH_Drawing_CanvasClipRect(canvas, rect, OH_Drawing_CanvasClipOp::DIFFERENCE, true); 1071 rect = OH_Drawing_RectCreate(10, 100, 100, 100); 1072 // add assert 1073 EXPECT_NE(rect, nullptr); 1074 OH_Drawing_CanvasClipRect(canvas, rect, OH_Drawing_CanvasClipOp::DIFFERENCE, true); 1075 // 4. OH_Drawing_CanvasClipRect with OH_Drawing_Rect created where the top-left corner coordinates are equal to the 1076 // bottom-right corner coordinates 1077 rect = OH_Drawing_RectCreate(100, 100, 100, 100); 1078 // add assert 1079 EXPECT_NE(rect, nullptr); 1080 OH_Drawing_CanvasClipRect(canvas, rect, OH_Drawing_CanvasClipOp::DIFFERENCE, true); 1081 // 5. OH_Drawing_CanvasClipRect with OH_Drawing_Rect created where the top-left corner coordinates are greater than 1082 // the bottom-right corner coordinates 1083 rect = OH_Drawing_RectCreate(200, 200, 100, 100); 1084 // add assert 1085 EXPECT_NE(rect, nullptr); 1086 OH_Drawing_CanvasClipRect(canvas, rect, OH_Drawing_CanvasClipOp::DIFFERENCE, true); 1087 // 6. Release memory 1088 OH_Drawing_CanvasDestroy(canvas); 1089 OH_Drawing_RectDestroy(rect); 1090 } 1091 1092 /* 1093 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_2303 1094 * @tc.name: testCanvasClipRectMaximum 1095 * @tc.desc: test for testCanvasClipRectMaximum. 1096 * @tc.size : SmallTest 1097 * @tc.type : Function 1098 * @tc.level : Level 3 1099 */ 1100 HWTEST_F(DrawingNativeCanvasPart3Test, testCanvasClipRectMaximum, TestSize.Level3) { 1101 // 1. OH_Drawing_CanvasCreate 1102 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1103 // add assert 1104 EXPECT_NE(canvas, nullptr); 1105 // 2. OH_Drawing_CanvasClipRect with OH_Drawing_Rect created with extreme values for left, top, right, and bottom 1106 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(FLT_MAX, 10, 100, 100); 1107 // add assert 1108 EXPECT_NE(rect, nullptr); 1109 OH_Drawing_CanvasClipRect(canvas, rect, OH_Drawing_CanvasClipOp::DIFFERENCE, true); 1110 rect = OH_Drawing_RectCreate(10, FLT_MAX, 100, 100); 1111 // add assert 1112 EXPECT_NE(rect, nullptr); 1113 OH_Drawing_CanvasClipRect(canvas, rect, OH_Drawing_CanvasClipOp::DIFFERENCE, true); 1114 rect = OH_Drawing_RectCreate(10, 10, FLT_MAX, 100); 1115 // add assert 1116 EXPECT_NE(rect, nullptr); 1117 OH_Drawing_CanvasClipRect(canvas, rect, OH_Drawing_CanvasClipOp::DIFFERENCE, true); 1118 rect = OH_Drawing_RectCreate(10, 10, 100, FLT_MAX); 1119 // add assert 1120 EXPECT_NE(rect, nullptr); 1121 OH_Drawing_CanvasClipRect(canvas, rect, OH_Drawing_CanvasClipOp::DIFFERENCE, true); 1122 // 3. Release memory 1123 OH_Drawing_CanvasDestroy(canvas); 1124 OH_Drawing_RectDestroy(rect); 1125 } 1126 1127 /* 1128 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_2304 1129 * @tc.name: testCanvasClipRectInputDestroyed 1130 * @tc.desc: test for testCanvasClipRectInputDestroyed. 1131 * @tc.size : SmallTest 1132 * @tc.type : Function 1133 * @tc.level : Level 3 1134 */ 1135 HWTEST_F(DrawingNativeCanvasPart3Test, testCanvasClipRectInputDestroyed, TestSize.Level3) { 1136 // Deprecated 1137 } 1138 1139 /* 1140 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_2400 1141 * @tc.name: testCanvasClipRoundRectNormal 1142 * @tc.desc: test for testCanvasClipRoundRectNormal. 1143 * @tc.size : SmallTest 1144 * @tc.type : Function 1145 * @tc.level : Level 0 1146 */ 1147 HWTEST_F(DrawingNativeCanvasPart3Test, testCanvasClipRoundRectNormal, TestSize.Level0) { 1148 // 1. OH_Drawing_CanvasCreate 1149 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1150 // add assert 1151 EXPECT_NE(canvas, nullptr); 1152 // 2. OH_Drawing_RoundRectCreate 1153 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(10, 10, 100, 100); 1154 // add assert 1155 EXPECT_NE(rect, nullptr); 1156 OH_Drawing_RoundRect *roundRect = OH_Drawing_RoundRectCreate(rect, 10, 10); 1157 // add assert 1158 EXPECT_NE(roundRect, nullptr); 1159 // 3. OH_Drawing_CanvasClipRoundRect with parameters clipOp and doAntiAlias, iterate through the enumeration values 1160 OH_Drawing_CanvasClipOp clipOp[] = {OH_Drawing_CanvasClipOp::DIFFERENCE, OH_Drawing_CanvasClipOp::INTERSECT}; 1161 bool doAntiAlias[] = {true, false}; 1162 for (int i = 0; i < 2; i++) { 1163 for (int j = 0; j < 2; j++) { 1164 OH_Drawing_ErrorCodeReset(); 1165 OH_Drawing_CanvasClipRoundRect(canvas, roundRect, clipOp[i], doAntiAlias[j]); 1166 // add assert 1167 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 1168 } 1169 } 1170 // 4. Free memory 1171 OH_Drawing_CanvasDestroy(canvas); 1172 OH_Drawing_RectDestroy(rect); 1173 } 1174 1175 /* 1176 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_2401 1177 * @tc.name: testCanvasClipRoundRectNull 1178 * @tc.desc: test for testCanvasClipRoundRectNull. 1179 * @tc.size : SmallTest 1180 * @tc.type : Function 1181 * @tc.level : Level 3 1182 */ 1183 HWTEST_F(DrawingNativeCanvasPart3Test, testCanvasClipRoundRectNull, TestSize.Level3) { 1184 // 1. OH_Drawing_CanvasCreate 1185 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1186 // add assert 1187 EXPECT_NE(canvas, nullptr); 1188 // 2. OH_Drawing_RoundRectCreate 1189 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(10, 10, 100, 100); 1190 // add assert 1191 EXPECT_NE(rect, nullptr); 1192 OH_Drawing_RoundRect *roundRect = OH_Drawing_RoundRectCreate(rect, 10, 10); 1193 // add assert 1194 EXPECT_NE(roundRect, nullptr); 1195 // 3. OH_Drawing_CanvasClipRoundRect with the first parameter being null 1196 OH_Drawing_CanvasClipRoundRect(nullptr, roundRect, OH_Drawing_CanvasClipOp::DIFFERENCE, true); 1197 // add assert 1198 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 1199 OH_Drawing_ErrorCodeReset(); 1200 // 4. OH_Drawing_CanvasClipRoundRect with the second parameter being null 1201 OH_Drawing_CanvasClipRoundRect(canvas, nullptr, OH_Drawing_CanvasClipOp::DIFFERENCE, true); 1202 // add assert 1203 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 1204 // 5. OH_Drawing_CanvasClipRoundRect with the second parameter OH_Drawing_RoundRectCreate created with rect's left, 1205 // top, right, and bottom values all set to 0 1206 OH_Drawing_Rect *rect2 = OH_Drawing_RectCreate(0, 10, 100, 100); 1207 // add assert 1208 EXPECT_NE(rect2, nullptr); 1209 OH_Drawing_RoundRect *roundRect2 = OH_Drawing_RoundRectCreate(rect2, 10, 10); 1210 // add assert 1211 EXPECT_NE(roundRect2, nullptr); 1212 OH_Drawing_CanvasClipRoundRect(canvas, roundRect2, OH_Drawing_CanvasClipOp::DIFFERENCE, true); 1213 rect2 = OH_Drawing_RectCreate(10, 0, 100, 100); 1214 // add assert 1215 EXPECT_NE(rect2, nullptr); 1216 roundRect2 = OH_Drawing_RoundRectCreate(rect2, 10, 10); 1217 // add assert 1218 EXPECT_NE(roundRect2, nullptr); 1219 OH_Drawing_CanvasClipRoundRect(canvas, roundRect2, OH_Drawing_CanvasClipOp::DIFFERENCE, true); 1220 rect2 = OH_Drawing_RectCreate(10, 10, 0, 100); 1221 // add assert 1222 EXPECT_NE(rect2, nullptr); 1223 roundRect2 = OH_Drawing_RoundRectCreate(rect2, 10, 10); 1224 // add assert 1225 EXPECT_NE(roundRect2, nullptr); 1226 OH_Drawing_CanvasClipRoundRect(canvas, roundRect2, OH_Drawing_CanvasClipOp::DIFFERENCE, true); 1227 rect2 = OH_Drawing_RectCreate(10, 10, 100, 0); 1228 // add assert 1229 EXPECT_NE(rect2, nullptr); 1230 roundRect2 = OH_Drawing_RoundRectCreate(rect2, 10, 10); 1231 // add assert 1232 EXPECT_NE(roundRect2, nullptr); 1233 OH_Drawing_CanvasClipRoundRect(canvas, roundRect2, OH_Drawing_CanvasClipOp::DIFFERENCE, true); 1234 // 6. OH_Drawing_CanvasClipRoundRect with the second parameter OH_Drawing_RoundRectCreate created with all rect's 1235 // left, top, right, and bottom values set to 0 1236 rect2 = OH_Drawing_RectCreate(0, 0, 0, 0); 1237 // add assert 1238 EXPECT_NE(rect2, nullptr); 1239 roundRect2 = OH_Drawing_RoundRectCreate(rect2, 10, 10); 1240 // add assert 1241 EXPECT_NE(roundRect2, nullptr); 1242 OH_Drawing_CanvasClipRoundRect(canvas, roundRect2, OH_Drawing_CanvasClipOp::DIFFERENCE, true); 1243 // 7. OH_Drawing_CanvasClipRoundRect with the second parameter OH_Drawing_RoundRectCreate created with xRad set to 0 1244 rect2 = OH_Drawing_RectCreate(10, 10, 100, 100); 1245 // add assert 1246 EXPECT_NE(rect2, nullptr); 1247 roundRect2 = OH_Drawing_RoundRectCreate(rect2, 0, 10); 1248 // add assert 1249 EXPECT_NE(roundRect2, nullptr); 1250 OH_Drawing_CanvasClipRoundRect(canvas, roundRect2, OH_Drawing_CanvasClipOp::DIFFERENCE, true); 1251 // 8. OH_Drawing_CanvasClipRoundRect with the second parameter OH_Drawing_RoundRectCreate created with yRad set to 0 1252 rect2 = OH_Drawing_RectCreate(10, 10, 100, 100); 1253 // add assert 1254 EXPECT_NE(rect2, nullptr); 1255 roundRect2 = OH_Drawing_RoundRectCreate(rect2, 10, 0); 1256 // add assert 1257 EXPECT_NE(roundRect2, nullptr); 1258 OH_Drawing_CanvasClipRoundRect(canvas, roundRect2, OH_Drawing_CanvasClipOp::DIFFERENCE, true); 1259 // 9. Release memory 1260 OH_Drawing_CanvasDestroy(canvas); 1261 OH_Drawing_RectDestroy(rect); 1262 OH_Drawing_RectDestroy(rect2); 1263 OH_Drawing_RoundRectDestroy(roundRect); 1264 OH_Drawing_RoundRectDestroy(roundRect2); 1265 } 1266 1267 /* 1268 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_2402 1269 * @tc.name: testCanvasClipRoundRectAbnormal 1270 * @tc.desc: test for testCanvasClipRoundRectAbnormal. 1271 * @tc.size : SmallTest 1272 * @tc.type : Function 1273 * @tc.level : Level 3 1274 */ 1275 HWTEST_F(DrawingNativeCanvasPart3Test, testCanvasClipRoundRectAbnormal, TestSize.Level3) { 1276 // 1. OH_Drawing_CanvasCreate 1277 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1278 // add assert 1279 EXPECT_NE(canvas, nullptr); 1280 // 2. OH_Drawing_CanvasClipRoundRect, pass negative values for left, top, right, and bottom when creating 1281 // OH_Drawing_RoundRect 1282 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(-10, 10, 100, 100); 1283 // add assert 1284 EXPECT_NE(rect, nullptr); 1285 OH_Drawing_RoundRect *roundRect = OH_Drawing_RoundRectCreate(rect, 10, 10); 1286 // add assert 1287 EXPECT_NE(roundRect, nullptr); 1288 OH_Drawing_CanvasClipRoundRect(canvas, roundRect, OH_Drawing_CanvasClipOp::DIFFERENCE, true); 1289 rect = OH_Drawing_RectCreate(10, -10, 100, 100); 1290 // add assert 1291 EXPECT_NE(rect, nullptr); 1292 roundRect = OH_Drawing_RoundRectCreate(rect, 10, 10); 1293 // add assert 1294 EXPECT_NE(roundRect, nullptr); 1295 OH_Drawing_CanvasClipRoundRect(canvas, roundRect, OH_Drawing_CanvasClipOp::DIFFERENCE, true); 1296 rect = OH_Drawing_RectCreate(10, 10, -100, 100); 1297 // add assert 1298 EXPECT_NE(rect, nullptr); 1299 roundRect = OH_Drawing_RoundRectCreate(rect, 10, 10); 1300 // add assert 1301 EXPECT_NE(roundRect, nullptr); 1302 OH_Drawing_CanvasClipRoundRect(canvas, roundRect, OH_Drawing_CanvasClipOp::DIFFERENCE, true); 1303 rect = OH_Drawing_RectCreate(10, 10, 100, -100); 1304 // add assert 1305 EXPECT_NE(rect, nullptr); 1306 roundRect = OH_Drawing_RoundRectCreate(rect, 10, 10); 1307 // add assert 1308 EXPECT_NE(roundRect, nullptr); 1309 OH_Drawing_CanvasClipRoundRect(canvas, roundRect, OH_Drawing_CanvasClipOp::DIFFERENCE, true); 1310 1311 // 3. OH_Drawing_CanvasClipRoundRect, pass OH_Drawing_RoundRect with left-top coordinates equal to right-bottom 1312 // coordinates 1313 rect = OH_Drawing_RectCreate(100, 10, 100, 100); 1314 // add assert 1315 EXPECT_NE(rect, nullptr); 1316 roundRect = OH_Drawing_RoundRectCreate(rect, 10, 10); 1317 // add assert 1318 EXPECT_NE(roundRect, nullptr); 1319 OH_Drawing_CanvasClipRoundRect(canvas, roundRect, OH_Drawing_CanvasClipOp::DIFFERENCE, true); 1320 rect = OH_Drawing_RectCreate(10, 100, 100, 100); 1321 // add assert 1322 EXPECT_NE(rect, nullptr); 1323 roundRect = OH_Drawing_RoundRectCreate(rect, 10, 10); 1324 // add assert 1325 EXPECT_NE(roundRect, nullptr); 1326 OH_Drawing_CanvasClipRoundRect(canvas, roundRect, OH_Drawing_CanvasClipOp::DIFFERENCE, true); 1327 1328 // 4. OH_Drawing_CanvasClipRoundRect, pass OH_Drawing_RoundRect with left-top coordinates equal to right-bottom 1329 // coordinates 1330 rect = OH_Drawing_RectCreate(100, 100, 100, 100); 1331 // add assert 1332 EXPECT_NE(rect, nullptr); 1333 roundRect = OH_Drawing_RoundRectCreate(rect, 10, 10); 1334 // add assert 1335 EXPECT_NE(roundRect, nullptr); 1336 OH_Drawing_CanvasClipRoundRect(canvas, roundRect, OH_Drawing_CanvasClipOp::DIFFERENCE, true); 1337 1338 // 5. OH_Drawing_CanvasClipRoundRect, pass OH_Drawing_RoundRect with left-top coordinates greater than right-bottom 1339 // coordinates 1340 rect = OH_Drawing_RectCreate(200, 200, 100, 100); 1341 // add assert 1342 EXPECT_NE(rect, nullptr); 1343 roundRect = OH_Drawing_RoundRectCreate(rect, 10, 10); 1344 // add assert 1345 EXPECT_NE(roundRect, nullptr); 1346 OH_Drawing_CanvasClipRoundRect(canvas, roundRect, OH_Drawing_CanvasClipOp::DIFFERENCE, true); 1347 1348 // 6. OH_Drawing_CanvasClipRoundRect, pass OH_Drawing_RoundRect with negative xRad 1349 rect = OH_Drawing_RectCreate(10, 10, 100, 100); 1350 // add assert 1351 EXPECT_NE(rect, nullptr); 1352 roundRect = OH_Drawing_RoundRectCreate(rect, -10, 10); 1353 // add assert 1354 EXPECT_NE(roundRect, nullptr); 1355 OH_Drawing_CanvasClipRoundRect(canvas, roundRect, OH_Drawing_CanvasClipOp::DIFFERENCE, true); 1356 1357 // 7. OH_Drawing_CanvasClipRoundRect, pass OH_Drawing_RoundRect with negative yRad 1358 rect = OH_Drawing_RectCreate(10, 10, 100, 100); 1359 // add assert 1360 EXPECT_NE(rect, nullptr); 1361 roundRect = OH_Drawing_RoundRectCreate(rect, 10, -10); 1362 // add assert 1363 EXPECT_NE(roundRect, nullptr); 1364 OH_Drawing_CanvasClipRoundRect(canvas, roundRect, OH_Drawing_CanvasClipOp::DIFFERENCE, true); 1365 1366 // 8. Release memory 1367 OH_Drawing_CanvasDestroy(canvas); 1368 OH_Drawing_RectDestroy(rect); 1369 OH_Drawing_RoundRectDestroy(roundRect); 1370 } 1371 1372 /* 1373 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_2403 1374 * @tc.name: testCanvasClipRoundRectMaximum 1375 * @tc.desc: test for testCanvasClipRoundRectMaximum. 1376 * @tc.size : SmallTest 1377 * @tc.type : Function 1378 * @tc.level : Level 3 1379 */ 1380 HWTEST_F(DrawingNativeCanvasPart3Test, testCanvasClipRoundRectMaximum, TestSize.Level3) { 1381 // 1. OH_Drawing_CanvasCreate 1382 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1383 // add assert 1384 EXPECT_NE(canvas, nullptr); 1385 // 2. OH_Drawing_CanvasClipRoundRect, pass extreme values for left, top, right, and bottom when creating 1386 // OH_Drawing_RoundRect 1387 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(FLT_MAX, 10, 100, 100); 1388 // add assert 1389 EXPECT_NE(rect, nullptr); 1390 OH_Drawing_RoundRect *roundRect = OH_Drawing_RoundRectCreate(rect, 10, 10); 1391 // add assert 1392 EXPECT_NE(roundRect, nullptr); 1393 OH_Drawing_CanvasClipRoundRect(canvas, roundRect, OH_Drawing_CanvasClipOp::DIFFERENCE, true); 1394 rect = OH_Drawing_RectCreate(10, FLT_MAX, 100, 100); 1395 // add assert 1396 EXPECT_NE(rect, nullptr); 1397 roundRect = OH_Drawing_RoundRectCreate(rect, 10, 10); 1398 // add assert 1399 EXPECT_NE(roundRect, nullptr); 1400 OH_Drawing_CanvasClipRoundRect(canvas, roundRect, OH_Drawing_CanvasClipOp::DIFFERENCE, true); 1401 rect = OH_Drawing_RectCreate(10, 10, FLT_MAX, 100); 1402 // add assert 1403 EXPECT_NE(rect, nullptr); 1404 roundRect = OH_Drawing_RoundRectCreate(rect, 10, 10); 1405 // add assert 1406 EXPECT_NE(roundRect, nullptr); 1407 OH_Drawing_CanvasClipRoundRect(canvas, roundRect, OH_Drawing_CanvasClipOp::DIFFERENCE, true); 1408 rect = OH_Drawing_RectCreate(10, 10, 100, FLT_MAX); 1409 // add assert 1410 EXPECT_NE(rect, nullptr); 1411 roundRect = OH_Drawing_RoundRectCreate(rect, 10, 10); 1412 // add assert 1413 EXPECT_NE(roundRect, nullptr); 1414 OH_Drawing_CanvasClipRoundRect(canvas, roundRect, OH_Drawing_CanvasClipOp::DIFFERENCE, true); 1415 // 3. OH_Drawing_CanvasClipRoundRect, pass FLT_MAX for xRad when creating OH_Drawing_RoundRect 1416 rect = OH_Drawing_RectCreate(10, 10, 100, 100); 1417 // add assert 1418 EXPECT_NE(rect, nullptr); 1419 roundRect = OH_Drawing_RoundRectCreate(rect, FLT_MAX, 10); 1420 // add assert 1421 EXPECT_NE(roundRect, nullptr); 1422 OH_Drawing_CanvasClipRoundRect(canvas, roundRect, OH_Drawing_CanvasClipOp::DIFFERENCE, true); 1423 // 4. OH_Drawing_CanvasClipRoundRect, pass FLT_MAX for yRad when creating OH_Drawing_RoundRect 1424 rect = OH_Drawing_RectCreate(10, 10, 100, 100); 1425 // add assert 1426 EXPECT_NE(rect, nullptr); 1427 roundRect = OH_Drawing_RoundRectCreate(rect, 10, FLT_MAX); 1428 // add assert 1429 EXPECT_NE(roundRect, nullptr); 1430 OH_Drawing_CanvasClipRoundRect(canvas, roundRect, OH_Drawing_CanvasClipOp::DIFFERENCE, true); 1431 // 5. Free memory 1432 OH_Drawing_CanvasDestroy(canvas); 1433 OH_Drawing_RectDestroy(rect); 1434 OH_Drawing_RoundRectDestroy(roundRect); 1435 } 1436 1437 /* 1438 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_2404 1439 * @tc.name: testCanvasClipRoundRectInputDestroyed 1440 * @tc.desc: test for testCanvasClipRoundRectInputDestroyed. 1441 * @tc.size : SmallTest 1442 * @tc.type : Function 1443 * @tc.level : Level 3 1444 */ 1445 HWTEST_F(DrawingNativeCanvasPart3Test, testCanvasClipRoundRectInputDestroyed, TestSize.Level3) { 1446 // Deprecated 1447 } 1448 1449 /* 1450 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_2500 1451 * @tc.name: testCanvasClipPathNormal 1452 * @tc.desc: test for testCanvasClipPathNormal. 1453 * @tc.size : SmallTest 1454 * @tc.type : Function 1455 * @tc.level : Level 0 1456 */ 1457 HWTEST_F(DrawingNativeCanvasPart3Test, testCanvasClipPathNormal, TestSize.Level0) { 1458 // 1. OH_Drawing_CanvasCreate 1459 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1460 // add assert 1461 EXPECT_NE(canvas, nullptr); 1462 // 2. OH_Drawing_PathCreate 1463 OH_Drawing_Path *path = OH_Drawing_PathCreate(); 1464 // add assert 1465 EXPECT_NE(path, nullptr); 1466 OH_Drawing_PathMoveTo(path, 0, 0); 1467 OH_Drawing_PathLineTo(path, 100, 0); 1468 OH_Drawing_PathLineTo(path, 100, 100); 1469 OH_Drawing_PathLineTo(path, 0, 100); 1470 OH_Drawing_PathClose(path); 1471 // 3. OH_Drawing_PathAddRect 1472 OH_Drawing_PathAddRect(path, 10, 10, 100, 100, OH_Drawing_PathDirection::PATH_DIRECTION_CW); 1473 // 4. OH_Drawing_CanvasClipPath 1474 OH_Drawing_CanvasClipOp clipOp[] = {OH_Drawing_CanvasClipOp::DIFFERENCE, OH_Drawing_CanvasClipOp::INTERSECT}; 1475 bool doAntiAlias[] = {true, false}; 1476 for (int i = 0; i < 2; i++) { 1477 for (int j = 0; j < 2; j++) { 1478 OH_Drawing_ErrorCodeReset(); 1479 OH_Drawing_CanvasClipPath(canvas, path, clipOp[i], doAntiAlias[j]); 1480 // add assert 1481 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 1482 } 1483 } 1484 // 5. Free memory 1485 OH_Drawing_PathDestroy(path); 1486 OH_Drawing_CanvasDestroy(canvas); 1487 } 1488 1489 /* 1490 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_2501 1491 * @tc.name: testCanvasClipPathNull 1492 * @tc.desc: test for testCanvasClipPathNull. 1493 * @tc.size : SmallTest 1494 * @tc.type : Function 1495 * @tc.level : Level 3 1496 */ 1497 HWTEST_F(DrawingNativeCanvasPart3Test, testCanvasClipPathNull, TestSize.Level3) { 1498 // 1. OH_Drawing_CanvasCreate 1499 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1500 // add assert 1501 EXPECT_NE(canvas, nullptr); 1502 // 2. OH_Drawing_PathCreate 1503 OH_Drawing_Path *path = OH_Drawing_PathCreate(); 1504 // add assert 1505 EXPECT_NE(path, nullptr); 1506 OH_Drawing_PathMoveTo(path, 0, 0); 1507 OH_Drawing_PathLineTo(path, 100, 0); 1508 OH_Drawing_PathLineTo(path, 100, 100); 1509 OH_Drawing_PathLineTo(path, 0, 100); 1510 OH_Drawing_PathClose(path); 1511 // 3. OH_Drawing_PathAddRect 1512 OH_Drawing_PathAddRect(path, 10, 10, 100, 100, OH_Drawing_PathDirection::PATH_DIRECTION_CW); 1513 // 4. OH_Drawing_CanvasClipPath with the first parameter being null 1514 OH_Drawing_CanvasClipPath(nullptr, path, OH_Drawing_CanvasClipOp::DIFFERENCE, true); 1515 // add assert 1516 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 1517 OH_Drawing_ErrorCodeReset(); 1518 // 5. OH_Drawing_CanvasClipPath with the second parameter being null 1519 OH_Drawing_CanvasClipPath(canvas, nullptr, OH_Drawing_CanvasClipOp::DIFFERENCE, true); 1520 // add assert 1521 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 1522 // 6. OH_Drawing_CanvasClipPath with the second parameter being an empty path 1523 OH_Drawing_Path *path2 = OH_Drawing_PathCreate(); 1524 // add assert 1525 EXPECT_NE(path2, nullptr); 1526 OH_Drawing_CanvasClipPath(canvas, path2, OH_Drawing_CanvasClipOp::DIFFERENCE, true); 1527 // 7. Free memory 1528 OH_Drawing_PathDestroy(path); 1529 OH_Drawing_PathDestroy(path2); 1530 OH_Drawing_CanvasDestroy(canvas); 1531 } 1532 1533 /* 1534 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_2502 1535 * @tc.name: testCanvasClipPathInputDestroyed 1536 * @tc.desc: test for testCanvasClipPathInputDestroyed. 1537 * @tc.size : SmallTest 1538 * @tc.type : Function 1539 * @tc.level : Level 3 1540 */ 1541 HWTEST_F(DrawingNativeCanvasPart3Test, testCanvasClipPathInputDestroyed, TestSize.Level3) { 1542 // Deprecated 1543 } 1544 1545 /* 1546 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_2600 1547 * @tc.name: testCanvasRotateNormal 1548 * @tc.desc: test for testCanvasRotateNormal. 1549 * @tc.size : SmallTest 1550 * @tc.type : Function 1551 * @tc.level : Level 0 1552 */ 1553 HWTEST_F(DrawingNativeCanvasPart3Test, testCanvasRotateNormal, TestSize.Level0) { 1554 // 1. OH_Drawing_CanvasCreate 1555 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1556 // add assert 1557 EXPECT_NE(canvas, nullptr); 1558 // 2. OH_Drawing_CanvasRotate, rotate degrees with values 0, 180, 360 1559 float degrees[] = {0, 180, 360}; 1560 for (int i = 0; i < 3; i++) { 1561 OH_Drawing_ErrorCodeReset(); 1562 OH_Drawing_CanvasRotate(canvas, degrees[i], 10, 10); 1563 // add assert 1564 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 1565 } 1566 // 3. Call drawing class interface to draw a rectangle 1567 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(10, 10, 100, 100); 1568 // add assert 1569 EXPECT_NE(rect, nullptr); 1570 OH_Drawing_CanvasDrawRect(canvas, rect); 1571 // 4. Free memory 1572 OH_Drawing_CanvasDestroy(canvas); 1573 } 1574 1575 /* 1576 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_2601 1577 * @tc.name: testCanvasRotateNull 1578 * @tc.desc: test for testCanvasRotateNull. 1579 * @tc.size : SmallTest 1580 * @tc.type : Function 1581 * @tc.level : Level 3 1582 */ 1583 HWTEST_F(DrawingNativeCanvasPart3Test, testCanvasRotateNull, TestSize.Level3) { 1584 // 1. OH_Drawing_CanvasCreate 1585 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1586 // add assert 1587 EXPECT_NE(canvas, nullptr); 1588 // 2. OH_Drawing_CanvasRotate with the first parameter being null 1589 OH_Drawing_CanvasRotate(nullptr, 0, 10, 10); 1590 // add assert 1591 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 1592 // 3. OH_Drawing_CanvasRotate with the third parameter being 0 1593 OH_Drawing_CanvasRotate(canvas, 0, 0, 10); 1594 // 4. OH_Drawing_CanvasRotate with the fourth parameter being 0 1595 OH_Drawing_CanvasRotate(canvas, 0, 10, 0); 1596 // 5. Free memory 1597 OH_Drawing_CanvasDestroy(canvas); 1598 } 1599 1600 /* 1601 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_2602 1602 * @tc.name: testCanvasRotateAbnormal 1603 * @tc.desc: test for testCanvasRotateAbnormal. 1604 * @tc.size : SmallTest 1605 * @tc.type : Function 1606 * @tc.level : Level 3 1607 */ 1608 HWTEST_F(DrawingNativeCanvasPart3Test, testCanvasRotateAbnormal, TestSize.Level3) { 1609 // 1. OH_Drawing_CanvasCreate 1610 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1611 // add assert 1612 EXPECT_NE(canvas, nullptr); 1613 // 2. OH_Drawing_CanvasRotate with negative degrees input 1614 OH_Drawing_CanvasRotate(canvas, -180, 10, 10); 1615 // 3. OH_Drawing_CanvasRotate with degrees input greater than 360 1616 OH_Drawing_CanvasRotate(canvas, 370, 10, 10); 1617 // 4. OH_Drawing_CanvasRotate with negative px input for rotation center 1618 OH_Drawing_CanvasRotate(canvas, 180, -10, 10); 1619 // 5. OH_Drawing_CanvasRotate with negative py input for rotation center 1620 OH_Drawing_CanvasRotate(canvas, 180, 10, -10); 1621 // 6. Free memory 1622 OH_Drawing_CanvasDestroy(canvas); 1623 } 1624 1625 /* 1626 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_2603 1627 * @tc.name: testCanvasRotateMaximum 1628 * @tc.desc: test for testCanvasRotateMaximum. 1629 * @tc.size : SmallTest 1630 * @tc.type : Function 1631 * @tc.level : Level 3 1632 */ 1633 HWTEST_F(DrawingNativeCanvasPart3Test, testCanvasRotateMaximum, TestSize.Level3) { 1634 // 1. OH_Drawing_CanvasCreate 1635 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1636 // add assert 1637 EXPECT_NE(canvas, nullptr); 1638 // 2. OH_Drawing_CanvasRotate with maximum rotation angle degrees input 1639 OH_Drawing_CanvasRotate(canvas, FLT_MAX, 10, 10); 1640 // 3. OH_Drawing_CanvasRotate with maximum x-coordinate px input for rotation center 1641 OH_Drawing_CanvasRotate(canvas, 180, FLT_MAX, 10); 1642 // 4. OH_Drawing_CanvasRotate with maximum y-coordinate py input for rotation center 1643 OH_Drawing_CanvasRotate(canvas, 180, 10, FLT_MAX); 1644 // 5. Free memory 1645 OH_Drawing_CanvasDestroy(canvas); 1646 } 1647 1648 /* 1649 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_2604 1650 * @tc.name: testCanvasRotateInputDestroyed 1651 * @tc.desc: test for testCanvasRotateInputDestroyed. 1652 * @tc.size : SmallTest 1653 * @tc.type : Function 1654 * @tc.level : Level 3 1655 */ 1656 HWTEST_F(DrawingNativeCanvasPart3Test, testCanvasRotateInputDestroyed, TestSize.Level3) { 1657 // Deprecated 1658 } 1659 1660 /* 1661 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_2605 1662 * @tc.name: testCanvasRotateMultipleCalls 1663 * @tc.desc: test for testCanvasRotateMultipleCalls. 1664 * @tc.size : SmallTest 1665 * @tc.type : Function 1666 * @tc.level : Level 3 1667 */ 1668 HWTEST_F(DrawingNativeCanvasPart3Test, testCanvasRotateMultipleCalls, TestSize.Level3) { 1669 // 1. OH_Drawing_CanvasCreate 1670 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1671 // add assert 1672 EXPECT_NE(canvas, nullptr); 1673 // 2. Call OH_Drawing_CanvasRotate 10 times, each time with different rotation angles and rotation center 1674 // coordinates 1675 for (int i = 0; i < 10; i++) { 1676 OH_Drawing_CanvasRotate(canvas, i * 10, i * 10, i * 10); 1677 // 3. Call drawing class interface 1678 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(10, 10, 100, 100); 1679 // add assert 1680 EXPECT_NE(rect, nullptr); 1681 OH_Drawing_CanvasDrawRect(canvas, rect); 1682 OH_Drawing_RectDestroy(rect); 1683 } 1684 // 4. Free memory 1685 OH_Drawing_CanvasDestroy(canvas); 1686 } 1687 1688 /* 1689 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_2700 1690 * @tc.name: testCanvasTranslateNormal 1691 * @tc.desc: test for testCanvasTranslateNormal. 1692 * @tc.size : SmallTest 1693 * @tc.type : Function 1694 * @tc.level : Level 0 1695 */ 1696 HWTEST_F(DrawingNativeCanvasPart3Test, testCanvasTranslateNormal, TestSize.Level0) { 1697 // 1. OH_Drawing_CanvasCreate 1698 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1699 // add assert 1700 EXPECT_NE(canvas, nullptr); 1701 // 2. OH_Drawing_CanvasTranslate 1702 OH_Drawing_CanvasTranslate(canvas, 10, 10); 1703 // add assert 1704 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 1705 // 3. Call drawing class interface to draw a rectangle 1706 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(10, 10, 100, 100); 1707 // add assert 1708 EXPECT_NE(rect, nullptr); 1709 OH_Drawing_CanvasDrawRect(canvas, rect); 1710 // 4. Free memory 1711 OH_Drawing_RectDestroy(rect); 1712 OH_Drawing_CanvasDestroy(canvas); 1713 } 1714 1715 /* 1716 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_2701 1717 * @tc.name: testCanvasTranslateNull 1718 * @tc.desc: test for testCanvasTranslateNull. 1719 * @tc.size : SmallTest 1720 * @tc.type : Function 1721 * @tc.level : Level 3 1722 */ 1723 HWTEST_F(DrawingNativeCanvasPart3Test, testCanvasTranslateNull, TestSize.Level3) { 1724 // 1. OH_Drawing_CanvasCreate 1725 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1726 // add assert 1727 EXPECT_NE(canvas, nullptr); 1728 // 2. OH_Drawing_CanvasTranslate with the first parameter being null 1729 OH_Drawing_CanvasTranslate(nullptr, 10, 10); 1730 // add assert 1731 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 1732 // 3. OH_Drawing_CanvasTranslate with the second parameter being 0 1733 OH_Drawing_CanvasTranslate(canvas, 0, 10); 1734 // 4. OH_Drawing_CanvasTranslate with the third parameter being 0 1735 OH_Drawing_CanvasTranslate(canvas, 10, 0); 1736 // 5. Free memory 1737 OH_Drawing_CanvasDestroy(canvas); 1738 } 1739 1740 /* 1741 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_2702 1742 * @tc.name: testCanvasTranslateAbnormal 1743 * @tc.desc: test for testCanvasTranslateAbnormal. 1744 * @tc.size : SmallTest 1745 * @tc.type : Function 1746 * @tc.level : Level 3 1747 */ 1748 HWTEST_F(DrawingNativeCanvasPart3Test, testCanvasTranslateAbnormal, TestSize.Level3) { 1749 // 1. OH_Drawing_CanvasCreate 1750 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1751 // add assert 1752 EXPECT_NE(canvas, nullptr); 1753 // 2. OH_Drawing_CanvasTranslate with negative movement distance dx in the x-axis direction 1754 OH_Drawing_CanvasTranslate(canvas, -10, 10); 1755 // 3. OH_Drawing_CanvasTranslate with negative movement distance dy in the y-axis direction 1756 OH_Drawing_CanvasTranslate(canvas, 10, -10); 1757 // 4. Free memory 1758 OH_Drawing_CanvasDestroy(canvas); 1759 } 1760 1761 /* 1762 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_2703 1763 * @tc.name: testCanvasTranslateMaximum 1764 * @tc.desc: test for testCanvasTranslateMaximum. 1765 * @tc.size : SmallTest 1766 * @tc.type : Function 1767 * @tc.level : Level 3 1768 */ 1769 HWTEST_F(DrawingNativeCanvasPart3Test, testCanvasTranslateMaximum, TestSize.Level3) { 1770 // 1. OH_Drawing_CanvasCreate 1771 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1772 // add assert 1773 EXPECT_NE(canvas, nullptr); 1774 // 2. OH_Drawing_CanvasTranslate with the movement distance dx in the x-axis direction being the maximum value 1775 OH_Drawing_CanvasTranslate(canvas, FLT_MAX, 10); 1776 // 3. OH_Drawing_CanvasTranslate with the movement distance dy in the y-axis direction being the maximum value 1777 OH_Drawing_CanvasTranslate(canvas, 10, FLT_MAX); 1778 // 4. Free memory 1779 OH_Drawing_CanvasDestroy(canvas); 1780 } 1781 1782 /* 1783 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_2704 1784 * @tc.name: testCanvasTranslateInputDestroyed 1785 * @tc.desc: test for testCanvasTranslateInputDestroyed. 1786 * @tc.size : SmallTest 1787 * @tc.type : Function 1788 * @tc.level : Level 3 1789 */ 1790 HWTEST_F(DrawingNativeCanvasPart3Test, testCanvasTranslateInputDestroyed, TestSize.Level3) { 1791 // Deprecated 1792 } 1793 1794 /* 1795 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_2705 1796 * @tc.name: testCanvasTranslateMultipleCalls 1797 * @tc.desc: test for testCanvasTranslateMultipleCalls. 1798 * @tc.size : SmallTest 1799 * @tc.type : Function 1800 * @tc.level : Level 3 1801 */ 1802 HWTEST_F(DrawingNativeCanvasPart3Test, testCanvasTranslateMultipleCalls, TestSize.Level3) { 1803 // 1. OH_Drawing_CanvasCreate 1804 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1805 // add assert 1806 EXPECT_NE(canvas, nullptr); 1807 // 2. Call OH_Drawing_CanvasTranslate 10 times, each time with different movement distances 1808 for (int i = 0; i < 10; i++) { 1809 OH_Drawing_CanvasTranslate(canvas, i * 10, i * 10); 1810 // 3. Call drawing class interface 1811 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(10, 10, 100, 100); 1812 // add assert 1813 EXPECT_NE(rect, nullptr); 1814 OH_Drawing_CanvasDrawRect(canvas, rect); 1815 OH_Drawing_RectDestroy(rect); 1816 } 1817 // 4. Free memory 1818 OH_Drawing_CanvasDestroy(canvas); 1819 } 1820 1821 /* 1822 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_2800 1823 * @tc.name: testCanvasScaleNormal 1824 * @tc.desc: test for testCanvasScaleNormal. 1825 * @tc.size : SmallTest 1826 * @tc.type : Function 1827 * @tc.level : Level 0 1828 */ 1829 HWTEST_F(DrawingNativeCanvasPart3Test, testCanvasScaleNormal, TestSize.Level0) { 1830 // 1. Create a canvas 1831 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1832 // add assert 1833 EXPECT_NE(canvas, nullptr); 1834 1835 // 2. Scale the canvas 1836 OH_Drawing_CanvasScale(canvas, 2.0, 2.0); 1837 1838 // 3. Call drawing class interface 1839 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(10, 10, 100, 100); 1840 // add assert 1841 EXPECT_NE(rect, nullptr); 1842 OH_Drawing_CanvasDrawRect(canvas, rect); 1843 OH_Drawing_RectDestroy(rect); 1844 1845 // 4. Free memory 1846 OH_Drawing_CanvasDestroy(canvas); 1847 } 1848 1849 /* 1850 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_2801 1851 * @tc.name: testCanvasScaleNull 1852 * @tc.desc: test for testCanvasScaleNull. 1853 * @tc.size : SmallTest 1854 * @tc.type : Function 1855 * @tc.level : Level 3 1856 */ 1857 HWTEST_F(DrawingNativeCanvasPart3Test, testCanvasScaleNull, TestSize.Level3) { 1858 // 1. Create a canvas 1859 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1860 // add assert 1861 EXPECT_NE(canvas, nullptr); 1862 1863 // 2. Scale the canvas, with the first parameter being null 1864 OH_Drawing_CanvasScale(nullptr, 2.0, 2.0); 1865 // add assert 1866 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 1867 1868 // 3. Scale the canvas, with the second parameter being 0 1869 OH_Drawing_CanvasScale(canvas, 0, 2.0); 1870 1871 // 4. Scale the canvas, with the third parameter being 0 1872 OH_Drawing_CanvasScale(canvas, 2.0, 0); 1873 1874 // 5. Free memory 1875 OH_Drawing_CanvasDestroy(canvas); 1876 } 1877 1878 /* 1879 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_2802 1880 * @tc.name: testCanvasScaleAbnormal 1881 * @tc.desc: test for testCanvasScaleAbnormal. 1882 * @tc.size : SmallTest 1883 * @tc.type : Function 1884 * @tc.level : Level 3 1885 */ 1886 HWTEST_F(DrawingNativeCanvasPart3Test, testCanvasScaleAbnormal, TestSize.Level3) { 1887 // 1. Create a canvas 1888 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1889 // add assert 1890 EXPECT_NE(canvas, nullptr); 1891 1892 // 2. Scale the canvas, with a negative scale ratio in the x-axis 1893 OH_Drawing_CanvasScale(canvas, -2.0, 2.0); 1894 1895 // 3. Scale the canvas, with a negative scale ratio in the y-axis 1896 OH_Drawing_CanvasScale(canvas, 2.0, -2.0); 1897 1898 // 4. Free memory 1899 OH_Drawing_CanvasDestroy(canvas); 1900 } 1901 1902 /* 1903 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_2803 1904 * @tc.name: testCanvasScaleMaximum 1905 * @tc.desc: test for testCanvasScaleMaximum. 1906 * @tc.size : SmallTest 1907 * @tc.type : Function 1908 * @tc.level : Level 3 1909 */ 1910 HWTEST_F(DrawingNativeCanvasPart3Test, testCanvasScaleMaximum, TestSize.Level3) { 1911 // 1. Create a canvas 1912 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1913 // add assert 1914 EXPECT_NE(canvas, nullptr); 1915 1916 // 2. Scale the canvas, with the maximum scale ratio in the x-axis 1917 OH_Drawing_CanvasScale(canvas, DBL_MAX, 2.0); 1918 1919 // 3. Scale the canvas, with the maximum scale ratio in the y-axis 1920 OH_Drawing_CanvasScale(canvas, 2.0, DBL_MAX); 1921 1922 // 4. Free memory 1923 OH_Drawing_CanvasDestroy(canvas); 1924 } 1925 1926 /* 1927 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_2804 1928 * @tc.name: testCanvasScaleInputDestroyed 1929 * @tc.desc: test for testCanvasScaleInputDestroyed. 1930 * @tc.size : SmallTest 1931 * @tc.type : Function 1932 * @tc.level : Level 3 1933 */ 1934 HWTEST_F(DrawingNativeCanvasPart3Test, testCanvasScaleInputDestroyed, TestSize.Level3) { 1935 // Deprecated 1936 } 1937 1938 /* 1939 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_CANVAS_2805 1940 * @tc.name: testCanvasScaleMultipleCalls 1941 * @tc.desc: test for testCanvasScaleMultipleCalls. 1942 * @tc.size : SmallTest 1943 * @tc.type : Function 1944 * @tc.level : Level 3 1945 */ 1946 HWTEST_F(DrawingNativeCanvasPart3Test, testCanvasScaleMultipleCalls, TestSize.Level3) { 1947 // 1. Create a canvas 1948 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 1949 // add assert 1950 EXPECT_NE(canvas, nullptr); 1951 1952 // 2. Call OH_Drawing_CanvasScale 10 times, each time with different compression ratios 1953 for (int i = 1; i <= 10; i++) { 1954 OH_Drawing_CanvasScale(canvas, i * 1.0, i * 1.0); 1955 } 1956 1957 // 3. Call drawing class interface 1958 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(10, 10, 100, 100); 1959 // add assert 1960 EXPECT_NE(rect, nullptr); 1961 OH_Drawing_CanvasDrawRect(canvas, rect); 1962 OH_Drawing_RectDestroy(rect); 1963 1964 // 4. Free memory 1965 OH_Drawing_CanvasDestroy(canvas); 1966 } 1967 1968 } // namespace Drawing 1969 } // namespace Rosen 1970 } // namespace OHOS