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 "drawing_error_code.h" 19 #include "drawing_path.h" 20 #include "drawing_point.h" 21 #include "drawing_rect.h" 22 #include "drawing_region.h" 23 24 using namespace testing; 25 using namespace testing::ext; 26 27 namespace OHOS { 28 namespace Rosen { 29 namespace Drawing { 30 class DrawingNativeRegionTest : public testing::Test { 31 protected: 32 // 在每个测试用例执行前调用 SetUp()33 void SetUp() override 34 { 35 // 设置代码 36 std::cout << "DrawingNativeRegionTest Setup code called before each test case." << std::endl; 37 OH_Drawing_ErrorCodeReset(); 38 std::cout << "DrawingNativeRegionTest errorCodeReset before each test case." << std::endl; 39 } TearDown()40 void TearDown() override 41 { 42 std::cout << "DrawingNativeRegionTest Setup code called after each test case." << std::endl; 43 OH_Drawing_ErrorCodeReset(); 44 std::cout << "DrawingNativeRegionTest errorCodeReset after each test case." << std::endl; 45 } 46 }; 47 48 /* 49 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_REGION_0100 50 * @tc.name: testRegionCreateNormal 51 * @tc.desc: test for testRegionCreateNormal. 52 * @tc.size : SmallTest 53 * @tc.type : Function 54 * @tc.level : Level 0 55 */ 56 HWTEST_F(DrawingNativeRegionTest, testRegionCreateNormal, TestSize.Level0) { 57 // 1. OH_Drawing_RegionCreate 58 OH_Drawing_Region *region = OH_Drawing_RegionCreate(); 59 EXPECT_NE(region, nullptr); 60 OH_Drawing_RegionDestroy(region); 61 } 62 63 /* 64 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_REGION_0101 65 * @tc.name: testRegionCreateMoreTimes 66 * @tc.desc: test for testRegionCreateMoreTimes. 67 * @tc.size : SmallTest 68 * @tc.type : Function 69 * @tc.level : Level 1 70 */ 71 HWTEST_F(DrawingNativeRegionTest, testRegionCreateMoreTimes, TestSize.Level1) { 72 // 1. OH_Drawing_RegionCreate 73 OH_Drawing_Region *region = OH_Drawing_RegionCreate(); 74 EXPECT_NE(region, nullptr); 75 76 // 2. Create another region object using OH_Drawing_RegionCreate 77 OH_Drawing_Region *region2 = OH_Drawing_RegionCreate(); 78 EXPECT_NE(region2, nullptr); 79 80 OH_Drawing_RegionDestroy(region); 81 OH_Drawing_RegionDestroy(region2); 82 } 83 84 /* 85 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_REGION_0200 86 * @tc.name: testRegionDestroyNormal 87 * @tc.desc: test for testRegionDestroyNormal. 88 * @tc.size : SmallTest 89 * @tc.type : Function 90 * @tc.level : Level 0 91 */ 92 HWTEST_F(DrawingNativeRegionTest, testRegionDestroyNormal, TestSize.Level0) { 93 // 1. OH_Drawing_RegionCreate returns a pointer value regionObject 94 OH_Drawing_Region *regionObject = OH_Drawing_RegionCreate(); 95 EXPECT_NE(regionObject, nullptr); 96 // 2. OH_Drawing_RegionDestroy takes regionObject as input 97 OH_Drawing_RegionDestroy(regionObject); 98 } 99 100 /* 101 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_REGION_0201 102 * @tc.name: testRegionDestroyNull 103 * @tc.desc: test for testRegionDestroyNull. 104 * @tc.size : SmallTest 105 * @tc.type : Function 106 * @tc.level : Level 1 107 */ 108 HWTEST_F(DrawingNativeRegionTest, testRegionDestroyNull, TestSize.Level1) { 109 // 1. OH_Drawing_RegionDestroy takes nullptr as input 110 OH_Drawing_RegionDestroy(nullptr); 111 // add assert 112 EXPECT_TRUE(true); 113 } 114 115 /* 116 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_REGION_0300 117 * @tc.name: testRegionContainsInRange 118 * @tc.desc: test for testRegionContainsInRange. 119 * @tc.size : SmallTest 120 * @tc.type : Function 121 * @tc.level : Level 0 122 */ 123 HWTEST_F(DrawingNativeRegionTest, testRegionContainsInRange, TestSize.Level0) { 124 // 1. OH_Drawing_RegionCreate returns a pointer value regionObject, the call is successful and the return value is 125 // not nullptr 126 OH_Drawing_Region *regionObject = OH_Drawing_RegionCreate(); 127 EXPECT_NE(regionObject, nullptr); 128 129 // 2. OH_Drawing_RegionContains takes regionObject as input, x: a value within the range, y: a value within the 130 // range, the call is successful and the return value is true 131 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0.0f, 0.0f, 256.0f, 256.0f); 132 // add assert 133 EXPECT_NE(rect, nullptr); 134 OH_Drawing_RegionSetRect(regionObject, rect); 135 bool ret = OH_Drawing_RegionContains(regionObject, 100, 100); 136 EXPECT_TRUE(ret); 137 // add assert 138 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_SUCCESS); 139 140 OH_Drawing_RegionDestroy(regionObject); 141 OH_Drawing_RectDestroy(rect); 142 } 143 144 /* 145 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_REGION_0301 146 * @tc.name: testRegionContainsXvalueNotInRange 147 * @tc.desc: test for testRegionContainsXvalueNotInRange. 148 * @tc.size : SmallTest 149 * @tc.type : Function 150 * @tc.level : Level 1 151 */ 152 HWTEST_F(DrawingNativeRegionTest, testRegionContainsXvalueNotInRange, TestSize.Level1) { 153 // 1. OH_Drawing_RegionCreate returns a pointer value regionObject 154 OH_Drawing_Region *regionObject = OH_Drawing_RegionCreate(); 155 EXPECT_NE(regionObject, nullptr); 156 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0.0f, 0.0f, 256.0f, 256.0f); 157 // add assert 158 EXPECT_NE(rect, nullptr); 159 OH_Drawing_RegionSetRect(regionObject, rect); 160 161 // 2. OH_Drawing_RegionContains takes regionObject as input, x: a value not within the range, y: a value within the 162 // range 163 bool ret = OH_Drawing_RegionContains(regionObject, 300, 100); 164 EXPECT_FALSE(ret); 165 // add assert 166 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_SUCCESS); 167 168 OH_Drawing_RegionDestroy(regionObject); 169 OH_Drawing_RectDestroy(rect); 170 } 171 172 /* 173 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_REGION_0302 174 * @tc.name: testRegionContainsYvalueNotInRange 175 * @tc.desc: test for testRegionContainsYvalueNotInRange. 176 * @tc.size : SmallTest 177 * @tc.type : Function 178 * @tc.level : Level 1 179 */ 180 HWTEST_F(DrawingNativeRegionTest, testRegionContainsYvalueNotInRange, TestSize.Level1) { 181 // 1. OH_Drawing_RegionCreate returns a pointer value regionObject 182 OH_Drawing_Region *regionObject = OH_Drawing_RegionCreate(); 183 EXPECT_NE(regionObject, nullptr); 184 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0.0f, 0.0f, 256.0f, 256.0f); 185 // add assert 186 EXPECT_NE(rect, nullptr); 187 OH_Drawing_RegionSetRect(regionObject, rect); 188 189 // 2. OH_Drawing_RegionContains takes regionObject as input, x: a value within the range, y: a value not within the 190 // range 191 bool ret = OH_Drawing_RegionContains(regionObject, 100, 300); 192 EXPECT_FALSE(ret); 193 // add assert 194 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_SUCCESS); 195 196 OH_Drawing_RegionDestroy(regionObject); 197 OH_Drawing_RectDestroy(rect); 198 } 199 200 /* 201 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_REGION_0303 202 * @tc.name: testRegionContainsAllNotInRange 203 * @tc.desc: test for testRegionContainsAllNotInRange. 204 * @tc.size : SmallTest 205 * @tc.type : Function 206 * @tc.level : Level 1 207 */ 208 HWTEST_F(DrawingNativeRegionTest, testRegionContainsAllNotInRange, TestSize.Level1) { 209 // 1. OH_Drawing_RegionCreate returns a pointer value regionObject 210 OH_Drawing_Region *regionObject = OH_Drawing_RegionCreate(); 211 EXPECT_NE(regionObject, nullptr); 212 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0.0f, 0.0f, 256.0f, 256.0f); 213 // add assert 214 EXPECT_NE(rect, nullptr); 215 OH_Drawing_RegionSetRect(regionObject, rect); 216 217 // 2. OH_Drawing_RegionContains takes regionObject as input, x: a value not within the range, y: a value not within 218 // the range 219 bool ret = OH_Drawing_RegionContains(regionObject, 300, 300); 220 EXPECT_FALSE(ret); 221 // add assert 222 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_SUCCESS); 223 224 OH_Drawing_RegionDestroy(regionObject); 225 OH_Drawing_RectDestroy(rect); 226 } 227 228 /* 229 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_REGION_0304 230 * @tc.name: testRegionContainsRegionNull 231 * @tc.desc: test for testRegionContainsRegionNull. 232 * @tc.size : SmallTest 233 * @tc.type : Function 234 * @tc.level : Level 1 235 */ 236 HWTEST_F(DrawingNativeRegionTest, testRegionContainsRegionNull, TestSize.Level1) { 237 // 1. OH_Drawing_RegionContains takes nullptr as input, x: a value within the range, y: a value within the range 238 OH_Drawing_RegionContains(nullptr, 100, 100); 239 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER); 240 } 241 242 /* 243 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_REGION_0400 244 * @tc.name: testRegionOpNormal 245 * @tc.desc: test for testRegionOpNormal. 246 * @tc.size : SmallTest 247 * @tc.type : Function 248 * @tc.level : Level 0 249 */ 250 HWTEST_F(DrawingNativeRegionTest, testRegionOpNormal, TestSize.Level0) { 251 // 1. OH_Drawing_RegionCreate returns a pointer value regionObject 252 OH_Drawing_Region *regionObject = OH_Drawing_RegionCreate(); 253 EXPECT_NE(regionObject, nullptr); 254 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0.0f, 0.0f, 256.0f, 256.0f); 255 // add assert 256 EXPECT_NE(rect, nullptr); 257 OH_Drawing_RegionSetRect(regionObject, rect); 258 // 2. OH_Drawing_RegionCreate returns a pointer value dst 259 OH_Drawing_Region *dst = OH_Drawing_RegionCreate(); 260 EXPECT_NE(dst, nullptr); 261 OH_Drawing_RegionSetRect(dst, rect); 262 // 3. OH_Drawing_RegionOp takes regionObject, dst, and op: perform OH_Drawing_RegionOpMode operations in sequence 263 OH_Drawing_RegionOpMode modes[] = { 264 REGION_OP_MODE_DIFFERENCE, REGION_OP_MODE_INTERSECT, REGION_OP_MODE_UNION, 265 REGION_OP_MODE_XOR, REGION_OP_MODE_REVERSE_DIFFERENCE, REGION_OP_MODE_REPLACE, 266 }; 267 for (OH_Drawing_RegionOpMode mode : modes) { 268 OH_Drawing_ErrorCodeReset(); 269 OH_Drawing_RegionOp(regionObject, dst, mode); 270 // add assert 271 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_SUCCESS); 272 } 273 274 OH_Drawing_RegionDestroy(regionObject); 275 OH_Drawing_RectDestroy(rect); 276 OH_Drawing_RegionDestroy(dst); 277 } 278 279 /* 280 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_REGION_0401 281 * @tc.name: testRegionOpRegionNull 282 * @tc.desc: test for testRegionOpRegionNull. 283 * @tc.size : SmallTest 284 * @tc.type : Function 285 * @tc.level : Level 1 286 */ 287 HWTEST_F(DrawingNativeRegionTest, testRegionOpRegionNull, TestSize.Level1) { 288 // 1. OH_Drawing_RegionCreate returns a pointer value dst 289 OH_Drawing_Region *dst = OH_Drawing_RegionCreate(); 290 EXPECT_NE(dst, nullptr); 291 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0.0f, 0.0f, 256.0f, 256.0f); 292 // add assert 293 EXPECT_NE(rect, nullptr); 294 OH_Drawing_RegionSetRect(dst, rect); 295 // 2. OH_Drawing_RegionOp takes nullptr as input for region, dst as input, and op: REGION_OP_MODE_DIFFERENCE, 296 // returns OH_DRAWING_ERROR_INVALID_PARAMETER 297 OH_Drawing_RegionOp(nullptr, dst, REGION_OP_MODE_DIFFERENCE); 298 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER); 299 300 OH_Drawing_RectDestroy(rect); 301 OH_Drawing_RegionDestroy(dst); 302 } 303 304 /* 305 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_REGION_0402 306 * @tc.name: testRegionOpRegionDstNull 307 * @tc.desc: test for testRegionOpRegionDstNull. 308 * @tc.size : SmallTest 309 * @tc.type : Function 310 * @tc.level : Level 1 311 */ 312 HWTEST_F(DrawingNativeRegionTest, testRegionOpRegionDstNull, TestSize.Level1) { 313 // 1. OH_Drawing_RegionCreate returns a pointer value region 314 OH_Drawing_Region *region = OH_Drawing_RegionCreate(); 315 EXPECT_NE(region, nullptr); 316 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0.0f, 0.0f, 256.0f, 256.0f); 317 // add assert 318 EXPECT_NE(rect, nullptr); 319 OH_Drawing_RegionSetRect(region, rect); 320 // 2. OH_Drawing_RegionOp takes region as input, dst: nullptr, op: REGION_OP_MODE_DIFFERENCE 321 OH_Drawing_RegionOp(region, nullptr, REGION_OP_MODE_DIFFERENCE); 322 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER); 323 324 OH_Drawing_RectDestroy(rect); 325 OH_Drawing_RegionDestroy(region); 326 } 327 328 /* 329 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_REGION_0500 330 * @tc.name: testRegionSetRectResultTrue 331 * @tc.desc: test for testRegionSetRectResultTrue. 332 * @tc.size : SmallTest 333 * @tc.type : Function 334 * @tc.level : Level 0 335 */ 336 HWTEST_F(DrawingNativeRegionTest, testRegionSetRectResultTrue, TestSize.Level0) { 337 OH_Drawing_Region *region = OH_Drawing_RegionCreate(); 338 EXPECT_NE(region, nullptr); 339 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0.0f, 0.0f, 256.0f, 256.0f); 340 // add assert 341 EXPECT_NE(rect, nullptr); 342 // 1. OH_Drawing_RegionSetRect takes correct region and rect object pointers as input 343 bool ret = OH_Drawing_RegionSetRect(region, rect); 344 EXPECT_TRUE(ret); 345 346 OH_Drawing_RectDestroy(rect); 347 OH_Drawing_RegionDestroy(region); 348 } 349 350 /* 351 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_REGION_0501 352 * @tc.name: testRegionSetRectRegionNull 353 * @tc.desc: test for testRegionSetRectRegionNull. 354 * @tc.size : SmallTest 355 * @tc.type : Function 356 * @tc.level : Level 1 357 */ 358 HWTEST_F(DrawingNativeRegionTest, testRegionSetRectRegionNull, TestSize.Level1) { 359 // 1. OH_Drawing_RegionSetRect takes a correct rect object pointer as input, region is nullptr, returns 360 // OH_DRAWING_ERROR_INVALID_PARAMETER 361 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0.0f, 0.0f, 256.0f, 256.0f); 362 // add assert 363 EXPECT_NE(rect, nullptr); 364 OH_Drawing_RegionSetRect(nullptr, rect); 365 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER); 366 OH_Drawing_RectDestroy(rect); 367 } 368 369 /* 370 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_REGION_0502 371 * @tc.name: testRegionSetRectRectNull 372 * @tc.desc: test for testRegionSetRectRectNull. 373 * @tc.size : SmallTest 374 * @tc.type : Function 375 * @tc.level : Level 1 376 */ 377 HWTEST_F(DrawingNativeRegionTest, testRegionSetRectRectNull, TestSize.Level1) { 378 OH_Drawing_Region *region = OH_Drawing_RegionCreate(); 379 // add assert 380 EXPECT_NE(region, nullptr); 381 // 1. OH_Drawing_RegionSetRect takes a correct region object pointer as input, rect is nullptr 382 OH_Drawing_RegionSetRect(region, nullptr); 383 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER); 384 OH_Drawing_RegionDestroy(region); 385 } 386 387 /* 388 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_REGION_0503 389 * @tc.name: testRegionSetRectResultFalse 390 * @tc.desc: test for testRegionSetRectResultFalse. 391 * @tc.size : SmallTest 392 * @tc.type : Function 393 * @tc.level : Level 1 394 */ 395 HWTEST_F(DrawingNativeRegionTest, testRegionSetRectResultFalse, TestSize.Level1) { 396 OH_Drawing_Region *region = OH_Drawing_RegionCreate(); 397 EXPECT_NE(region, nullptr); 398 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0.0f, 0.0f, 0.0f, 0.0f); 399 // add assert 400 EXPECT_NE(rect, nullptr); 401 402 // 1. OH_Drawing_RegionSetRect takes correct region and rect object pointers as input 403 bool ret = OH_Drawing_RegionSetRect(region, rect); 404 EXPECT_FALSE(ret); 405 406 OH_Drawing_RectDestroy(rect); 407 OH_Drawing_RegionDestroy(region); 408 } 409 410 /* 411 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_REGION_0600 412 * @tc.name: testRegionSetPathResultTrue 413 * @tc.desc: test for testRegionSetPathResultTrue. 414 * @tc.size : SmallTest 415 * @tc.type : Function 416 * @tc.level : Level 0 417 */ 418 HWTEST_F(DrawingNativeRegionTest, testRegionSetPathResultTrue, TestSize.Level0) { 419 OH_Drawing_Path *path = OH_Drawing_PathCreate(); 420 // add assert 421 EXPECT_NE(path, nullptr); 422 OH_Drawing_Region *region = OH_Drawing_RegionCreate(); 423 // add assert 424 EXPECT_NE(region, nullptr); 425 OH_Drawing_Region *clip = OH_Drawing_RegionCreate(); 426 // add assert 427 EXPECT_NE(clip, nullptr); 428 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(150.0f, 180.0f, 200.0f, 200.0f); 429 // add assert 430 EXPECT_NE(rect, nullptr); 431 OH_Drawing_RegionSetRect(clip, rect); 432 OH_Drawing_PathAddRect(path, 100.0f, 100.0f, 256.0f, 256.0f, OH_Drawing_PathDirection::PATH_DIRECTION_CW); 433 434 // 1. OH_Drawing_RegionSetPath takes correct region, path, and clip object pointers as input 435 EXPECT_TRUE(OH_Drawing_RegionSetPath(region, path, clip)); 436 // add assert 437 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_SUCCESS); 438 439 OH_Drawing_PathDestroy(path); 440 OH_Drawing_RegionDestroy(region); 441 OH_Drawing_RegionDestroy(clip); 442 OH_Drawing_RectDestroy(rect); 443 } 444 445 /* 446 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_REGION_0601 447 * @tc.name: testRegionSetPathRegionNull 448 * @tc.desc: test for testRegionSetPathRegionNull. 449 * @tc.size : SmallTest 450 * @tc.type : Function 451 * @tc.level : Level 1 452 */ 453 HWTEST_F(DrawingNativeRegionTest, testRegionSetPathRegionNull, TestSize.Level1) { 454 OH_Drawing_Path *path = OH_Drawing_PathCreate(); 455 // add assert 456 EXPECT_NE(path, nullptr); 457 OH_Drawing_Region *region = OH_Drawing_RegionCreate(); 458 // add assert 459 EXPECT_NE(region, nullptr); 460 OH_Drawing_Region *clip = OH_Drawing_RegionCreate(); 461 // add assert 462 EXPECT_NE(clip, nullptr); 463 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(150.0f, 180.0f, 200.0f, 200.0f); 464 // add assert 465 EXPECT_NE(rect, nullptr); 466 OH_Drawing_RegionSetRect(clip, rect); 467 468 // 1. OH_Drawing_RegionSetPath takes correct path and clip object pointers as input, region is nullptr 469 OH_Drawing_RegionSetPath(nullptr, path, clip); 470 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER); 471 472 OH_Drawing_PathDestroy(path); 473 OH_Drawing_RegionDestroy(region); 474 OH_Drawing_RegionDestroy(clip); 475 OH_Drawing_RectDestroy(rect); 476 } 477 478 /* 479 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_REGION_0602 480 * @tc.name: testRegionSetPathPathNull 481 * @tc.desc: test for testRegionSetPathPathNull. 482 * @tc.size : SmallTest 483 * @tc.type : Function 484 * @tc.level : Level 1 485 */ 486 HWTEST_F(DrawingNativeRegionTest, testRegionSetPathPathNull, TestSize.Level1) { 487 OH_Drawing_Path *path = OH_Drawing_PathCreate(); 488 // add assert 489 EXPECT_NE(path, nullptr); 490 OH_Drawing_Region *region = OH_Drawing_RegionCreate(); 491 // add assert 492 EXPECT_NE(region, nullptr); 493 OH_Drawing_Region *clip = OH_Drawing_RegionCreate(); 494 // add assert 495 EXPECT_NE(clip, nullptr); 496 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(150.0f, 180.0f, 200.0f, 200.0f); 497 // add assert 498 EXPECT_NE(rect, nullptr); 499 OH_Drawing_RegionSetRect(clip, rect); 500 501 // 1. OH_Drawing_RegionSetPath takes correct region and clip object pointers as input, path is nullptr 502 OH_Drawing_RegionSetPath(region, nullptr, clip); 503 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER); 504 505 OH_Drawing_PathDestroy(path); 506 OH_Drawing_RegionDestroy(region); 507 OH_Drawing_RegionDestroy(clip); 508 OH_Drawing_RectDestroy(rect); 509 } 510 511 /* 512 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_REGION_0603 513 * @tc.name: testRegionSetPathClipNull 514 * @tc.desc: test for testRegionSetPathClipNull. 515 * @tc.size : SmallTest 516 * @tc.type : Function 517 * @tc.level : Level 1 518 */ 519 HWTEST_F(DrawingNativeRegionTest, testRegionSetPathClipNull, TestSize.Level1) { 520 OH_Drawing_Path *path = OH_Drawing_PathCreate(); 521 // add assert 522 EXPECT_NE(path, nullptr); 523 OH_Drawing_Region *region = OH_Drawing_RegionCreate(); 524 // add assert 525 EXPECT_NE(region, nullptr); 526 OH_Drawing_Region *clip = OH_Drawing_RegionCreate(); 527 // add assert 528 EXPECT_NE(clip, nullptr); 529 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(150.0f, 180.0f, 200.0f, 200.0f); 530 // add assert 531 EXPECT_NE(rect, nullptr); 532 OH_Drawing_RegionSetRect(clip, rect); 533 534 // 1. OH_Drawing_RegionSetPath takes correct region, path object pointers as input, and clip is nullptr 535 OH_Drawing_RegionSetPath(region, path, nullptr); 536 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER); 537 538 OH_Drawing_PathDestroy(path); 539 OH_Drawing_RegionDestroy(region); 540 OH_Drawing_RegionDestroy(clip); 541 OH_Drawing_RectDestroy(rect); 542 } 543 544 /* 545 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_REGION_0604 546 * @tc.name: testRegionSetPathResultFalse 547 * @tc.desc: test for testRegionSetPathResultFalse. 548 * @tc.size : SmallTest 549 * @tc.type : Function 550 * @tc.level : Level 1 551 */ 552 HWTEST_F(DrawingNativeRegionTest, testRegionSetPathResultFalse, TestSize.Level1) { 553 OH_Drawing_Path *path = OH_Drawing_PathCreate(); 554 // add assert 555 EXPECT_NE(path, nullptr); 556 OH_Drawing_Region *region = OH_Drawing_RegionCreate(); 557 // add assert 558 EXPECT_NE(region, nullptr); 559 OH_Drawing_Region *clip = OH_Drawing_RegionCreate(); 560 // add assert 561 EXPECT_NE(clip, nullptr); 562 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0.0f, 0.0f, 0.0f, 0.0f); 563 // add assert 564 EXPECT_NE(rect, nullptr); 565 OH_Drawing_RegionSetRect(clip, rect); 566 567 // 1. OH_Drawing_RegionSetPath takes correct region, path, and clip object pointers as input 568 bool ret = OH_Drawing_RegionSetPath(region, path, clip); 569 EXPECT_FALSE(ret); 570 // add assert 571 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_SUCCESS); 572 573 OH_Drawing_PathDestroy(path); 574 OH_Drawing_RegionDestroy(region); 575 OH_Drawing_RegionDestroy(clip); 576 OH_Drawing_RectDestroy(rect); 577 } 578 579 } // namespace Drawing 580 } // namespace Rosen 581 } // namespace OHOS