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 "drawing_color.h" 17 #include "drawing_error_code.h" 18 #include "drawing_filter.h" 19 #include "drawing_mask_filter.h" 20 #include "drawing_rect.h" 21 #include "drawing_round_rect.h" 22 #include "gtest/gtest.h" 23 #include <random> 24 #include "DrawingNativeScalarCommon.h" 25 26 using namespace testing; 27 using namespace testing::ext; 28 29 namespace OHOS { 30 namespace Rosen { 31 namespace Drawing { 32 class DrawingNativeRoundRectTest : public testing::Test { 33 protected: 34 // 在每个测试用例执行前调用 SetUp()35 void SetUp() override 36 { 37 // 设置代码 38 std::cout << "DrawingNativeRoundRectTest Setup code called before each test case." << std::endl; 39 OH_Drawing_ErrorCodeReset(); 40 std::cout << "DrawingNativeRoundRectTest errorCodeReset before each test case." << std::endl; 41 } TearDown()42 void TearDown() override 43 { 44 std::cout << "DrawingNativeRoundRectTest Setup code called after each test case." << std::endl; 45 OH_Drawing_ErrorCodeReset(); 46 std::cout << "DrawingNativeRoundRectTest errorCodeReset after each test case." << std::endl; 47 } 48 }; 49 50 /* 51 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_ROUND_RECT_0100 52 * @tc.name: testRoundRectCreateNormal 53 * @tc.desc: test for testRoundRectCreateNormal. 54 * @tc.size : SmallTest 55 * @tc.type : Function 56 * @tc.level : Level 0 57 */ 58 HWTEST_F(DrawingNativeRoundRectTest, testRoundRectCreateNormal, Function | SmallTest | Level0) { 59 // 1. OH_Drawing_RoundRectCreate 60 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0, 0, 100, 100); 61 // add assert 62 EXPECT_NE(rect, nullptr); 63 OH_Drawing_RoundRect *roundRect = OH_Drawing_RoundRectCreate(rect, 20, 20); 64 // add assert 65 EXPECT_NE(roundRect, nullptr); 66 // add assert 67 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_SUCCESS); 68 // 2. Free memory 69 OH_Drawing_RoundRectDestroy(roundRect); 70 OH_Drawing_RectDestroy(rect); 71 } 72 73 /* 74 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_ROUND_RECT_0101 75 * @tc.name: testRoundRectCreateNull 76 * @tc.desc: test for testRoundRectCreateNull. 77 * @tc.size : SmallTest 78 * @tc.type : Function 79 * @tc.level : Level 3 80 */ 81 HWTEST_F(DrawingNativeRoundRectTest, testRoundRectCreateNull, Function | SmallTest | Level3) { 82 // 1. OH_Drawing_RoundRectCreate with nullptr as the first parameter, check the error code using 83 // OH_Drawing_ErrorCodeGet 84 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0, 0, 100, 100); 85 // add assert 86 EXPECT_NE(rect, nullptr); 87 OH_Drawing_RoundRect *roundRect = OH_Drawing_RoundRectCreate(nullptr, 20, 20); 88 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER); 89 // 2. OH_Drawing_RoundRectCreate with 0 as the second parameter 90 OH_Drawing_RoundRect *roundRect2 = OH_Drawing_RoundRectCreate(rect, 0, 20); 91 // add assert 92 EXPECT_NE(roundRect2, nullptr); 93 // 3. OH_Drawing_RoundRectCreate with 0 as the third parameter 94 OH_Drawing_RoundRect *roundRect3 = OH_Drawing_RoundRectCreate(rect, 20, 0); 95 // add assert 96 EXPECT_NE(roundRect3, nullptr); 97 // 4. Free memory 98 OH_Drawing_RoundRectDestroy(roundRect); 99 OH_Drawing_RoundRectDestroy(roundRect2); 100 OH_Drawing_RoundRectDestroy(roundRect3); 101 OH_Drawing_RectDestroy(rect); 102 } 103 104 /* 105 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_ROUND_RECT_0102 106 * @tc.name: testRoundRectCreateAbnormal 107 * @tc.desc: test for testRoundRectCreateAbnormal. 108 * @tc.size : SmallTest 109 * @tc.type : Function 110 * @tc.level : Level 3 111 */ 112 HWTEST_F(DrawingNativeRoundRectTest, testRoundRectCreateAbnormal, Function | SmallTest | Level3) { 113 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0, 0, 100, 100); 114 // add assert 115 EXPECT_NE(rect, nullptr); 116 // 1. OH_Drawing_RoundRectCreate with a negative value for the second parameter xRad 117 OH_Drawing_RoundRect *roundRect = OH_Drawing_RoundRectCreate(rect, -20, 20); 118 // add assert 119 EXPECT_NE(roundRect, nullptr); 120 // add assert 121 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_SUCCESS); 122 // 2. OH_Drawing_RoundRectCreate with a negative value for the third parameter yRad 123 OH_Drawing_RoundRect *roundRect2 = OH_Drawing_RoundRectCreate(rect, 20, -20); 124 // add assert 125 EXPECT_NE(roundRect2, nullptr); 126 // add assert 127 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_SUCCESS); 128 // 3. Free memory 129 OH_Drawing_RoundRectDestroy(roundRect); 130 OH_Drawing_RoundRectDestroy(roundRect2); 131 OH_Drawing_RectDestroy(rect); 132 } 133 134 /* 135 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_ROUND_RECT_0103 136 * @tc.name: testRoundRectCreateMaximum 137 * @tc.desc: test for testRoundRectCreateMaximum. 138 * @tc.size : SmallTest 139 * @tc.type : Function 140 * @tc.level : Level 3 141 */ 142 HWTEST_F(DrawingNativeRoundRectTest, testRoundRectCreateMaximum, Function | SmallTest | Level3) { 143 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0, 0, 100, 100); 144 // add assert 145 EXPECT_NE(rect, nullptr); 146 // 1. OH_Drawing_RoundRectCreate with the second parameter xRad as the maximum value 147 OH_Drawing_RoundRect *roundRect = OH_Drawing_RoundRectCreate(rect, FLT_MAX, 20); 148 // add assert 149 EXPECT_NE(roundRect, nullptr); 150 // add assert 151 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_SUCCESS); 152 // 2. OH_Drawing_RoundRectCreate with the third parameter yRad as the maximum value 153 OH_Drawing_RoundRect *roundRect2 = OH_Drawing_RoundRectCreate(rect, 20, FLT_MAX); 154 // add assert 155 EXPECT_NE(roundRect2, nullptr); 156 // add assert 157 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_SUCCESS); 158 // 3. Free memory 159 OH_Drawing_RoundRectDestroy(roundRect); 160 OH_Drawing_RoundRectDestroy(roundRect2); 161 OH_Drawing_RectDestroy(rect); 162 } 163 164 /* 165 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_ROUND_RECT_0104 166 * @tc.name: testRoundRectCreateMultipleCalls 167 * @tc.desc: test for testRoundRectCreateMultipleCalls. 168 * @tc.size : SmallTest 169 * @tc.type : Function 170 * @tc.level : Level 3 171 */ 172 HWTEST_F(DrawingNativeRoundRectTest, testRoundRectCreateMultipleCalls, Function | SmallTest | Level3) { 173 // 1. Call OH_Drawing_RoundRectCreate 10 times 174 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0, 0, 100, 100); 175 for (int i = 0; i < 10; i++) { 176 OH_Drawing_RoundRect *roundRect = OH_Drawing_RoundRectCreate(rect, 20, 20); 177 EXPECT_NE(roundRect, nullptr); 178 // add assert 179 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_SUCCESS); 180 OH_Drawing_RoundRectDestroy(roundRect); 181 } 182 } 183 184 /* 185 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_ROUND_RECT_0200 186 * @tc.name: testRoundRectSetGetCornerNormal 187 * @tc.desc: test for testRoundRectSetGetCornerNormal. 188 * @tc.size : SmallTest 189 * @tc.type : Function 190 * @tc.level : Level 0 191 */ 192 HWTEST_F(DrawingNativeRoundRectTest, testRoundRectSetGetCornerNormal, Function | SmallTest | Level0) { 193 // 1. OH_Drawing_RoundRectCreate 194 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0, 0, 100, 100); 195 // add assert 196 EXPECT_NE(rect, nullptr); 197 OH_Drawing_RoundRect *roundRect = OH_Drawing_RoundRectCreate(rect, 20, 20); 198 // add assert 199 EXPECT_NE(roundRect, nullptr); 200 // 2. Enumerate OH_Drawing_RoundRectSetCorner and OH_Drawing_RoundRectGetCorner with OH_Drawing_CornerPos values 201 OH_Drawing_CornerPos posArray[] = { 202 CORNER_POS_TOP_LEFT, 203 CORNER_POS_TOP_RIGHT, 204 CORNER_POS_BOTTOM_RIGHT, 205 CORNER_POS_BOTTOM_LEFT, 206 }; 207 for (OH_Drawing_CornerPos pos : posArray) { 208 OH_Drawing_RoundRectSetCorner(roundRect, pos, {10.0f, 10.0f}); 209 OH_Drawing_Corner_Radii radii = OH_Drawing_RoundRectGetCorner(roundRect, pos); 210 EXPECT_EQ(IsScalarAlmostEqual(radii.x, 10.0f), true); 211 EXPECT_EQ(IsScalarAlmostEqual(radii.y, 10.0f), true); 212 } 213 // 3. OH_Drawing_RoundRectSetCorner with integer values for x and y radii, and call OH_Drawing_RoundRectGetCorner to 214 // retrieve the values 215 OH_Drawing_RoundRectSetCorner(roundRect, CORNER_POS_TOP_LEFT, {10, 10}); 216 OH_Drawing_Corner_Radii radii = OH_Drawing_RoundRectGetCorner(roundRect, CORNER_POS_TOP_LEFT); 217 EXPECT_EQ(IsScalarAlmostEqual(radii.x, 10), true); 218 EXPECT_EQ(IsScalarAlmostEqual(radii.y, 10), true); 219 // 4. OH_Drawing_RoundRectSetCorner with decimal values for x and y radii, and call OH_Drawing_RoundRectGetCorner to 220 // retrieve the values 221 OH_Drawing_RoundRectSetCorner(roundRect, CORNER_POS_TOP_LEFT, {10.1f, 10.1f}); 222 OH_Drawing_Corner_Radii radii2 = OH_Drawing_RoundRectGetCorner(roundRect, CORNER_POS_TOP_LEFT); 223 EXPECT_EQ(IsScalarAlmostEqual(radii2.x, 10.1f), true); 224 EXPECT_EQ(IsScalarAlmostEqual(radii2.y, 10.1f), true); 225 // 5. Free memory 226 OH_Drawing_RoundRectDestroy(roundRect); 227 OH_Drawing_RectDestroy(rect); 228 } 229 230 /* 231 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_ROUND_RECT_0201 232 * @tc.name: testRoundRectSetGetCornerNull 233 * @tc.desc: test for testRoundRectSetGetCornerNull. 234 * @tc.size : SmallTest 235 * @tc.type : Function 236 * @tc.level : Level 3 237 */ 238 HWTEST_F(DrawingNativeRoundRectTest, testRoundRectSetGetCornerNull, Function | SmallTest | Level3) { 239 // 1. OH_Drawing_RoundRectCreate 240 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0, 0, 100, 100); 241 // add assert 242 EXPECT_NE(rect, nullptr); 243 OH_Drawing_RoundRect *roundRect = OH_Drawing_RoundRectCreate(rect, 20, 20); 244 // add assert 245 EXPECT_NE(roundRect, nullptr); 246 // 2. OH_Drawing_RoundRectSetCorner with nullptr as the first parameter, check the error code using 247 // OH_Drawing_ErrorCodeGet 248 OH_Drawing_RoundRectSetCorner(nullptr, CORNER_POS_TOP_LEFT, {10.0f, 10.0f}); 249 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER); 250 OH_Drawing_ErrorCodeReset(); 251 // 3. OH_Drawing_RoundRectSetCorner with 0 as the third parameter 252 OH_Drawing_RoundRectSetCorner(roundRect, CORNER_POS_TOP_LEFT, {0, 0}); 253 // 4. OH_Drawing_RoundRectGetCorner with nullptr as the first parameter, check the error code using 254 // OH_Drawing_ErrorCodeGet 255 OH_Drawing_RoundRectGetCorner(nullptr, CORNER_POS_TOP_LEFT); 256 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER); 257 // 5. Free memory 258 OH_Drawing_RoundRectDestroy(roundRect); 259 OH_Drawing_RectDestroy(rect); 260 } 261 262 /* 263 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_ROUND_RECT_0202 264 * @tc.name: testRoundRectSetGetCornerAbnormal 265 * @tc.desc: test for testRoundRectSetGetCornerAbnormal. 266 * @tc.size : SmallTest 267 * @tc.type : Function 268 * @tc.level : Level 3 269 */ 270 HWTEST_F(DrawingNativeRoundRectTest, testRoundRectSetGetCornerAbnormal, Function | SmallTest | Level3) { 271 // 1. OH_Drawing_RoundRectCreate 272 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0, 0, 100, 100); 273 // add assert 274 EXPECT_NE(rect, nullptr); 275 OH_Drawing_RoundRect *roundRect = OH_Drawing_RoundRectCreate(rect, 20, 20); 276 // add assert 277 EXPECT_NE(roundRect, nullptr); 278 // 2. OH_Drawing_RoundRectSetCorner with negative value for x-axis in OH_Drawing_Corner_Radii, followed by 279 // OH_Drawing_RoundRectGetCorner 280 OH_Drawing_RoundRectSetCorner(roundRect, CORNER_POS_TOP_LEFT, {-10.0f, 10.0f}); 281 OH_Drawing_Corner_Radii radii = OH_Drawing_RoundRectGetCorner(roundRect, CORNER_POS_TOP_LEFT); 282 EXPECT_EQ(IsScalarAlmostEqual(radii.x, -10.0f), true); 283 EXPECT_EQ(IsScalarAlmostEqual(radii.y, 10.0f), true); 284 // 3. OH_Drawing_RoundRectSetCorner with negative value for y-axis in OH_Drawing_Corner_Radii, followed by 285 // OH_Drawing_RoundRectGetCorner 286 OH_Drawing_RoundRectSetCorner(roundRect, CORNER_POS_TOP_LEFT, {10.0f, -10.0f}); 287 OH_Drawing_Corner_Radii radii2 = OH_Drawing_RoundRectGetCorner(roundRect, CORNER_POS_TOP_LEFT); 288 EXPECT_EQ(IsScalarAlmostEqual(radii2.x, 10.0f), true); 289 EXPECT_EQ(IsScalarAlmostEqual(radii2.y, -10.0f), true); 290 // 4. Free memory 291 OH_Drawing_RoundRectDestroy(roundRect); 292 OH_Drawing_RectDestroy(rect); 293 } 294 295 /* 296 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_ROUND_RECT_0203 297 * @tc.name: testRoundRectSetGetCornerMaximum 298 * @tc.desc: test for testRoundRectSetGetCornerMaximum. 299 * @tc.size : SmallTest 300 * @tc.type : Function 301 * @tc.level : Level 3 302 */ 303 HWTEST_F(DrawingNativeRoundRectTest, testRoundRectSetGetCornerMaximum, Function | SmallTest | Level3) { 304 // 1. OH_Drawing_RoundRectCreate 305 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0, 0, 100, 100); 306 // add assert 307 EXPECT_NE(rect, nullptr); 308 OH_Drawing_RoundRect *roundRect = OH_Drawing_RoundRectCreate(rect, 20, 20); 309 // add assert 310 EXPECT_NE(roundRect, nullptr); 311 // 2. Call OH_Drawing_RoundRectSetCorner with the maximum value for the x-axis in OH_Drawing_Corner_Radii, followed 312 // by OH_Drawing_RoundRectGetCorner 313 OH_Drawing_RoundRectSetCorner(roundRect, CORNER_POS_TOP_LEFT, {FLT_MAX, 10.0f}); 314 OH_Drawing_Corner_Radii radii = OH_Drawing_RoundRectGetCorner(roundRect, CORNER_POS_TOP_LEFT); 315 EXPECT_EQ(IsScalarAlmostEqual(radii.x, FLT_MAX), true); 316 EXPECT_EQ(IsScalarAlmostEqual(radii.y, 10.0f), true); 317 // 3. Call OH_Drawing_RoundRectSetCorner with the maximum value for the y-axis in OH_Drawing_Corner_Radii, followed 318 // by OH_Drawing_RoundRectGetCorner 319 OH_Drawing_RoundRectSetCorner(roundRect, CORNER_POS_TOP_LEFT, {10.0f, FLT_MAX}); 320 OH_Drawing_Corner_Radii radii2 = OH_Drawing_RoundRectGetCorner(roundRect, CORNER_POS_TOP_LEFT); 321 EXPECT_EQ(IsScalarAlmostEqual(radii2.x, 10.0f), true); 322 EXPECT_EQ(IsScalarAlmostEqual(radii2.y, FLT_MAX), true); 323 // 4. Free memory 324 OH_Drawing_RoundRectDestroy(roundRect); 325 OH_Drawing_RectDestroy(rect); 326 } 327 328 /* 329 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_ROUND_RECT_0204 330 * @tc.name: testRoundRectSetGetCornerMultipleCalls 331 * @tc.desc: test for testRoundRectSetGetCornerMultipleCalls. 332 * @tc.size : SmallTest 333 * @tc.type : Function 334 * @tc.level : Level 3 335 */ 336 HWTEST_F(DrawingNativeRoundRectTest, testRoundRectSetGetCornerMultipleCalls, Function | SmallTest | Level3) { 337 // 1. OH_Drawing_RoundRectCreate 338 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0, 0, 100, 100); 339 // add assert 340 EXPECT_NE(rect, nullptr); 341 OH_Drawing_RoundRect *roundRect = OH_Drawing_RoundRectCreate(rect, 20, 20); 342 // add assert 343 EXPECT_NE(roundRect, nullptr); 344 // 2. OH_Drawing_RoundRectSetCorner (pass random values for x-axis and y-axis radii, and a random enum value for 345 // OH_Drawing_CornerPos), followed by calling OH_Drawing_RoundRectGetCorner 346 std::random_device rd; 347 std::mt19937 gen(rd()); 348 std::uniform_real_distribution<float> dis(0, 100); 349 std::uniform_int_distribution<int> dis2(0, 3); 350 for (int i = 0; i < 10; i++) { 351 float x = dis(gen); 352 float y = dis(gen); 353 OH_Drawing_CornerPos pos = static_cast<OH_Drawing_CornerPos>(dis2(gen)); 354 OH_Drawing_RoundRectSetCorner(roundRect, pos, {x, y}); 355 OH_Drawing_Corner_Radii radii = OH_Drawing_RoundRectGetCorner(roundRect, pos); 356 EXPECT_EQ(IsScalarAlmostEqual(radii.x, x), true); 357 EXPECT_EQ(IsScalarAlmostEqual(radii.y, y), true); 358 } 359 // 3. Free memory 360 OH_Drawing_RoundRectDestroy(roundRect); 361 OH_Drawing_RectDestroy(rect); 362 } 363 364 /* 365 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_ROUND_RECT_0205 366 * @tc.name: testRoundRectGetCornerWhenNoSet 367 * @tc.desc: test for testRoundRectGetCornerWhenNoSet. 368 * @tc.size : SmallTest 369 * @tc.type : Function 370 * @tc.level : Level 2 371 */ 372 HWTEST_F(DrawingNativeRoundRectTest, testRoundRectGetCornerWhenNoSet, Function | SmallTest | Level2) { 373 // 1. OH_Drawing_RoundRectCreate 374 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0, 0, 100, 100); 375 // add assert 376 EXPECT_NE(rect, nullptr); 377 OH_Drawing_RoundRect *roundRect = OH_Drawing_RoundRectCreate(rect, 20, 20); 378 // add assert 379 EXPECT_NE(roundRect, nullptr); 380 // add assert 381 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_SUCCESS); 382 // 2. Call OH_Drawing_RoundRectGetCorner directly 383 OH_Drawing_Corner_Radii radii = OH_Drawing_RoundRectGetCorner(roundRect, CORNER_POS_TOP_LEFT); 384 EXPECT_EQ(IsScalarAlmostEqual(radii.x, 20), true); 385 EXPECT_EQ(IsScalarAlmostEqual(radii.y, 20), true); 386 // 3. Free memory 387 OH_Drawing_RoundRectDestroy(roundRect); 388 OH_Drawing_RectDestroy(rect); 389 } 390 391 /* 392 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_ROUND_RECT_0300 393 * @tc.name: testRoundRectDestroyNormal 394 * @tc.desc: test for testRoundRectDestroyNormal. 395 * @tc.size : SmallTest 396 * @tc.type : Function 397 * @tc.level : Level 0 398 */ 399 HWTEST_F(DrawingNativeRoundRectTest, testRoundRectDestroyNormal, Function | SmallTest | Level0) { 400 // 1. OH_Drawing_RoundRectCreate 401 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0, 0, 100, 100); 402 // add assert 403 EXPECT_NE(rect, nullptr); 404 // add assert 405 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_SUCCESS); 406 OH_Drawing_RoundRect *roundRect = OH_Drawing_RoundRectCreate(rect, 20, 20); 407 // add assert 408 EXPECT_NE(roundRect, nullptr); 409 // add assert 410 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_SUCCESS); 411 // 2. OH_Drawing_RoundRectDestroy 412 OH_Drawing_RoundRectDestroy(roundRect); 413 OH_Drawing_RectDestroy(rect); 414 } 415 416 /* 417 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_ROUND_RECT_0301 418 * @tc.name: testRoundRectDestroyNull 419 * @tc.desc: test for testRoundRectDestroyNull. 420 * @tc.size : SmallTest 421 * @tc.type : Function 422 * @tc.level : Level 3 423 */ 424 HWTEST_F(DrawingNativeRoundRectTest, testRoundRectDestroyNull, Function | SmallTest | Level3) { 425 // 1. OH_Drawing_RoundRectDestroy with nullptr as the parameter 426 OH_Drawing_RoundRectDestroy(nullptr); 427 // add assert 428 EXPECT_TRUE(true); 429 } 430 431 /* 432 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_ROUND_RECT_0400 433 * @tc.name: testRoundRectOffsetNormal 434 * @tc.desc: test for testRoundRectOffsetNormal. 435 * @tc.size : SmallTest 436 * @tc.type : Function 437 * @tc.level : Level 0 438 */ 439 HWTEST_F(DrawingNativeRoundRectTest, testRoundRectOffsetNormal, Function | SmallTest | Level0) { 440 //1. OH_Drawing_RoundRectCreate with the second parameter as integar values 441 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0, 0, 100, 100); 442 // add assert 443 EXPECT_NE(rect, nullptr); 444 OH_Drawing_RoundRect *roundRect = OH_Drawing_RoundRectCreate(rect, 20, 20); 445 // add assert 446 EXPECT_NE(roundRect, nullptr); 447 // add assert 448 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_SUCCESS); 449 //2. OH_Drawing_RoundRectCreate with the second parameter as floating-point values 450 OH_Drawing_RoundRect *roundRect1 = OH_Drawing_RoundRectCreate(rect, 20.f, 20); 451 // add assert 452 EXPECT_NE(roundRect1, nullptr); 453 // add assert 454 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_SUCCESS); 455 //3. OH_Drawing_RoundRectCreate with the first parameter as integar values 456 OH_Drawing_RoundRect *roundRect2 = OH_Drawing_RoundRectCreate(rect, 20, 20); 457 // add assert 458 EXPECT_NE(roundRect2, nullptr); 459 // add assert 460 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_SUCCESS); 461 //4. OH_Drawing_RoundRectCreate with the first parameter as floating-point values 462 OH_Drawing_Rect *rect1 = OH_Drawing_RectCreate(0.f, 0.f, 100.f, 100.f); 463 // add assert 464 EXPECT_NE(rect1, nullptr); 465 OH_Drawing_RoundRect *roundRect3 = OH_Drawing_RoundRectCreate(rect1, 20, 20); 466 // add assert 467 EXPECT_NE(roundRect3, nullptr); 468 // add assert 469 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_SUCCESS); 470 OH_Drawing_RoundRectDestroy(roundRect); 471 OH_Drawing_RoundRectDestroy(roundRect1); 472 OH_Drawing_RoundRectDestroy(roundRect2); 473 OH_Drawing_RoundRectDestroy(roundRect3); 474 } 475 476 /* 477 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_ROUND_RECT_0401 478 * @tc.name: testRoundRectOffsetNull 479 * @tc.desc: test for testRoundRectOffsetNull. 480 * @tc.size : SmallTest 481 * @tc.type : Function 482 * @tc.level : Level 3 483 */ 484 HWTEST_F(DrawingNativeRoundRectTest, testRoundRectOffsetNull, Function | SmallTest | Level3) { 485 // 1. Call OH_Drawing_RoundRectOffset with nullptr as the first parameter, check the error code using 486 // OH_Drawing_ErrorCodeGet 487 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0, 0, 100, 100); 488 // add assert 489 EXPECT_NE(rect, nullptr); 490 OH_Drawing_RoundRect *roundRect = OH_Drawing_RoundRectCreate(rect, 20, 20); 491 // add assert 492 EXPECT_NE(roundRect, nullptr); 493 EXPECT_EQ(OH_Drawing_RoundRectOffset(nullptr, 1.0f, 1.0f), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 494 // 2. Call OH_Drawing_RoundRectOffset with 0 as the second parameter, check the error code using 495 // OH_Drawing_ErrorCodeGet 496 EXPECT_EQ(OH_Drawing_RoundRectOffset(roundRect, 0, 1.0f), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 497 // 3. Call OH_Drawing_RoundRectOffset with 0 as the third parameter, check the error code using 498 // OH_Drawing_ErrorCodeGet 499 EXPECT_EQ(OH_Drawing_RoundRectOffset(roundRect, 1.0f, 0), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 500 //4. free memory 501 OH_Drawing_RoundRectDestroy(roundRect); 502 OH_Drawing_RectDestroy(rect); 503 } 504 505 /* 506 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_ROUND_RECT_0402 507 * @tc.name: testRoundRectOffsetMultipleCalls 508 * @tc.desc: test for testRoundRectOffsetMultipleCalls. 509 * @tc.size : SmallTest 510 * @tc.type : Function 511 * @tc.level : Level 3 512 */ 513 HWTEST_F(DrawingNativeRoundRectTest, testRoundRectOffsetMultipleCalls, Function | SmallTest | Level3) { 514 //1. Call OH_Drawing_RoundRectCreate with random values 515 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0, 0, 100, 100); 516 // add assert 517 EXPECT_NE(rect, nullptr); 518 std::random_device rd; 519 std::mt19937 gen(rd()); 520 std::uniform_real_distribution<float> dis(0, 100); 521 for (int i = 0; i < 10; i++) { 522 OH_Drawing_RoundRect *roundRect = OH_Drawing_RoundRectCreate(rect, dis(gen), dis(gen)); 523 // add assert 524 EXPECT_NE(roundRect, nullptr); 525 // add assert 526 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_SUCCESS); 527 OH_Drawing_RoundRectDestroy(roundRect); 528 } 529 //2. free memory 530 OH_Drawing_RectDestroy(rect); 531 } 532 533 /* 534 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_ROUND_RECT_0500 535 * @tc.name: testRoundRectCopyNormal 536 * @tc.desc: test for testRoundRectCopyNormal 537 * @tc.size : SmallTest 538 * @tc.type : Function 539 * @tc.level : Level 0 540 */ 541 HWTEST_F(DrawingNativeRoundRectTest, testRoundRectCopyNormal, Function | SmallTest | Level0) { 542 // 1. Create a rect object by OH_Drawing_RectCreate. 543 OH_Drawing_Rect *rect1 = OH_Drawing_RectCreate(0, 0, 100, 100); 544 EXPECT_NE(rect1, nullptr); 545 // 2. Create a roundRect object by OH_Drawing_RoundRectCreate. 546 OH_Drawing_RoundRect *roundRect1 = OH_Drawing_RoundRectCreate(rect1, 0, 0); 547 EXPECT_NE(roundRect1, nullptr); 548 // 3. Copy a roundRect object by OH_Drawing_RoundRectCopy. 549 OH_Drawing_RoundRect *roundRect2 = OH_Drawing_RoundRectCopy(roundRect1); 550 EXPECT_NE(roundRect2, nullptr); 551 // 4. Create a rect object by OH_Drawing_RectCreate. 552 OH_Drawing_Rect *rect2 = OH_Drawing_RectCreate(0, 0, 100, 100); 553 EXPECT_NE(rect2, nullptr); 554 // 5. Create a roundRect object by OH_Drawing_RoundRectCreate. 555 OH_Drawing_RoundRect *roundRect3 = OH_Drawing_RoundRectCreate(rect2, 20, 20); 556 EXPECT_NE(roundRect3, nullptr); 557 // 6. Copy a roundRect object by OH_Drawing_RoundRectCopy. 558 OH_Drawing_RoundRect *roundRect4 = OH_Drawing_RoundRectCopy(roundRect3); 559 EXPECT_NE(roundRect4, nullptr); 560 // 7. Create a rect object by OH_Drawing_RectCreate. 561 OH_Drawing_Rect *rect3 = OH_Drawing_RectCreate(0, 0, 100, 100); 562 EXPECT_NE(rect3, nullptr); 563 // 8. Create a roundRect object by OH_Drawing_RoundRectCreate. 564 OH_Drawing_RoundRect *roundRect5 = OH_Drawing_RoundRectCreate(rect3, 0, 0); 565 EXPECT_NE(roundRect5, nullptr); 566 // 9. Set the upper left corner of the rectangle as a rounded corner. 567 OH_Drawing_RoundRectSetCorner(roundRect5, OH_Drawing_CornerPos::CORNER_POS_TOP_LEFT, {20, 20}); 568 // 10. Copy a roundRect object by OH_Drawing_RoundRectCopy. 569 OH_Drawing_RoundRect *roundRect6 = OH_Drawing_RoundRectCopy(roundRect5); 570 EXPECT_NE(roundRect6, nullptr); 571 // 11. free memory 572 OH_Drawing_RectDestroy(rect1); 573 OH_Drawing_RectDestroy(rect2); 574 OH_Drawing_RectDestroy(rect3); 575 OH_Drawing_RoundRectDestroy(roundRect1); 576 OH_Drawing_RoundRectDestroy(roundRect2); 577 OH_Drawing_RoundRectDestroy(roundRect3); 578 OH_Drawing_RoundRectDestroy(roundRect4); 579 OH_Drawing_RoundRectDestroy(roundRect5); 580 OH_Drawing_RoundRectDestroy(roundRect6); 581 } 582 583 /* 584 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_ROUND_RECT_0501 585 * @tc.name: testRoundRectCopyNull 586 * @tc.desc: test for testRoundRectCopyNull 587 * @tc.size : SmallTest 588 * @tc.type : Function 589 * @tc.level : Level 3 590 */ 591 HWTEST_F(DrawingNativeRoundRectTest, testRoundRectCopyNull, Function | SmallTest | Level3) { 592 // 1. Create a rect object by OH_Drawing_RectCreate. 593 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0, 0, 100, 100); 594 EXPECT_NE(rect, nullptr); 595 // 2. Create a roundRect object by OH_Drawing_RoundRectCreate. 596 OH_Drawing_RoundRect *roundRect1 = OH_Drawing_RoundRectCreate(rect, 0, 0); 597 EXPECT_NE(roundRect1, nullptr); 598 // 3. Copy a roundRect object by OH_Drawing_RoundRectCopy. 599 OH_Drawing_RoundRect *roundRect2 = OH_Drawing_RoundRectCopy(nullptr); 600 EXPECT_EQ(roundRect2, nullptr); 601 // 11. free memory 602 OH_Drawing_RectDestroy(rect); 603 OH_Drawing_RoundRectDestroy(roundRect1); 604 OH_Drawing_RoundRectDestroy(roundRect2); 605 } 606 607 /* 608 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_ROUND_RECT_0502 609 * @tc.name: testRoundRectCopyMultipleCalls 610 * @tc.desc: test for testRoundRectCopyMultipleCalls 611 * @tc.size : SmallTest 612 * @tc.type : Function 613 * @tc.level : Level 3 614 */ 615 HWTEST_F(DrawingNativeRoundRectTest, testRoundRectCopyMultipleCalls, Function | SmallTest | Level3) { 616 // 1. Create a rect object by OH_Drawing_RectCreate. 617 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0, 0, 100, 100); 618 EXPECT_NE(rect, nullptr); 619 // 2. Create a roundRect object by OH_Drawing_RoundRectCreate. 620 OH_Drawing_RoundRect *roundRect1 = OH_Drawing_RoundRectCreate(rect, 0, 0); 621 EXPECT_NE(roundRect1, nullptr); 622 // 3. Copy a roundRect object by OH_Drawing_RoundRectCopy. 623 OH_Drawing_RoundRect *roundRect2 = nullptr; 624 // 4. The function OH_Drawing_RoundRectCopy is called 10 times. 625 for (int i = 0; i < 10; i++) { 626 roundRect2 = OH_Drawing_RoundRectCopy(roundRect1); 627 EXPECT_NE(roundRect2, nullptr); 628 } 629 // 5. free memory 630 OH_Drawing_RectDestroy(rect); 631 OH_Drawing_RoundRectDestroy(roundRect1); 632 OH_Drawing_RoundRectDestroy(roundRect2); 633 } 634 } // namespace Drawing 635 } // namespace Rosen 636 } // namespace OHOS