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_color.h" 19 #include "drawing_color_filter.h" 20 #include "drawing_filter.h" 21 #include "drawing_matrix.h" 22 #include "drawing_path.h" 23 #include "drawing_path_effect.h" 24 #include "drawing_pen.h" 25 #include "drawing_point.h" 26 #include "drawing_rect.h" 27 #include "drawing_shader_effect.h" 28 #include "drawing_shadow_layer.h" 29 30 using namespace testing; 31 using namespace testing::ext; 32 33 namespace OHOS { 34 namespace Rosen { 35 namespace Drawing { 36 class DrawingNativePenTest : public testing::Test { 37 protected: 38 // 在每个测试用例执行前调用 SetUp()39 void SetUp() override 40 { 41 // 设置代码 42 std::cout << "DrawingNativePenTest Setup code called before each test case." << std::endl; 43 OH_Drawing_ErrorCodeReset(); 44 std::cout << "DrawingNativePenTest errorCodeReset before each test case." << std::endl; 45 } TearDown()46 void TearDown() override 47 { 48 std::cout << "DrawingNativePenTest Setup code called after each test case." << std::endl; 49 OH_Drawing_ErrorCodeReset(); 50 std::cout << "DrawingNativePenTest errorCodeReset after each test case." << std::endl; 51 } 52 }; 53 54 /* 55 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_PEN_0100 56 * @tc.name: testPenCreateNormal 57 * @tc.desc: Test for testPenCreateNormal. 58 * @tc.size: SmallTest 59 * @tc.type: Function 60 * @tc.level: Level 0 61 */ 62 HWTEST_F(DrawingNativePenTest, testPenCreateNormal, TestSize.Level0) { 63 // 1. Create a pen object using OH_Drawing_PenCreate 64 OH_Drawing_Pen *pen = OH_Drawing_PenCreate(); 65 // add assert 66 EXPECT_NE(pen, nullptr); 67 // 2. Free the memory using OH_Drawing_PenDestroy 68 OH_Drawing_PenDestroy(pen); 69 } 70 71 /* 72 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_PEN_0200 73 * @tc.name: testPenCopyNormal 74 * @tc.desc: Test for testPenCopyNormal. 75 * @tc.size: SmallTest 76 * @tc.type: Function 77 * @tc.level: Level 0 78 */ 79 HWTEST_F(DrawingNativePenTest, testPenCopyNormal, TestSize.Level0) { 80 // 1. Create a pen object 1 using OH_Drawing_PenCreate 81 OH_Drawing_Pen *pen1 = OH_Drawing_PenCreate(); 82 // add assert 83 EXPECT_NE(pen1, nullptr); 84 // 2. Set color for pen 1 using OH_Drawing_PenSetColor 85 OH_Drawing_PenSetColor(pen1, 0x00000000); 86 // 3. Copy pen 1 to pen 2 using OH_Drawing_PenCopy 87 OH_Drawing_Pen *pen2 = OH_Drawing_PenCopy(pen1); 88 // add assert 89 EXPECT_NE(pen2, nullptr); 90 // add assert 91 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 92 // 4. Get color of pen 2 using OH_Drawing_PenGetColor 93 uint32_t color = OH_Drawing_PenGetColor(pen2); 94 EXPECT_EQ(color, 0x00000000); 95 // 5. Modify color of pen 1 using OH_Drawing_PenSetColor 96 OH_Drawing_PenSetColor(pen1, 0x00FF0000); 97 // 6. Get color of pen 2 using OH_Drawing_PenGetColor 98 uint32_t color2 = OH_Drawing_PenGetColor(pen2); 99 EXPECT_EQ(color2, 0x00000000); 100 // 7. Free the memory 101 OH_Drawing_PenDestroy(pen1); 102 OH_Drawing_PenDestroy(pen2); 103 } 104 105 /* 106 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_PEN_0201 107 * @tc.name: testPenCopyNull 108 * @tc.desc: Test for testPenCopyNull. 109 * @tc.size: SmallTest 110 * @tc.type: Function 111 * @tc.level: Level 3 112 */ 113 HWTEST_F(DrawingNativePenTest, testPenCopyNull, TestSize.Level3) { 114 // 1. Create a pen object using OH_Drawing_PenCreate 115 OH_Drawing_Pen *pen = OH_Drawing_PenCreate(); 116 // add assert 117 EXPECT_NE(pen, nullptr); 118 // 2. Copy pen object with nullptr using OH_Drawing_PenCopy 119 OH_Drawing_Pen *pen2 = OH_Drawing_PenCopy(nullptr); 120 // add assert 121 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 122 // 3. Free the memory 123 OH_Drawing_PenDestroy(pen); 124 OH_Drawing_PenDestroy(pen2); 125 } 126 127 /* 128 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_PEN_0202 129 * @tc.name: testPenCopyInputDestroyed 130 * @tc.desc: Test for testPenCopyInputDestroyed. 131 * @tc.size: SmallTest 132 * @tc.type: Function 133 * @tc.level: Level 3 134 */ 135 HWTEST_F(DrawingNativePenTest, testPenCopyInputDestroyed, TestSize.Level3) { 136 // 1. Create a pen object 1 using OH_Drawing_PenCreate 137 OH_Drawing_Pen *pen1 = OH_Drawing_PenCreate(); 138 // add assert 139 EXPECT_NE(pen1, nullptr); 140 // 2. Copy pen 1 to pen 2 using OH_Drawing_PenCopy 141 OH_Drawing_Pen *pen2 = OH_Drawing_PenCopy(pen1); 142 // add assert 143 EXPECT_NE(pen2, nullptr); 144 // add assert 145 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 146 // 3. Destroy pen 1 using OH_Drawing_PenDestroy 147 OH_Drawing_PenDestroy(pen1); 148 // 4. Set color for pen 2 using OH_Drawing_PenSetColor 149 OH_Drawing_PenSetColor(pen2, 0x00000000); 150 // 5. Get color of pen 2 using OH_Drawing_PenGetColor 151 uint32_t color = OH_Drawing_PenGetColor(pen2); 152 EXPECT_EQ(color, 0x00000000); 153 // 6. Free the memory 154 OH_Drawing_PenDestroy(pen2); 155 } 156 157 /* 158 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_PEN_0300 159 * @tc.name: testPenDestroyNormal 160 * @tc.desc: Test for testPenDestroyNormal. 161 * @tc.size: SmallTest 162 * @tc.type: Function 163 * @tc.level: Level 0 164 */ 165 HWTEST_F(DrawingNativePenTest, testPenDestroyNormal, TestSize.Level0) { 166 // 1. Create a pen object using OH_Drawing_PenCreate 167 OH_Drawing_Pen *pen = OH_Drawing_PenCreate(); 168 // add assert 169 EXPECT_NE(pen, nullptr); 170 // 2. Destroy the object using OH_Drawing_PenDestroy 171 OH_Drawing_PenDestroy(pen); 172 } 173 174 /* 175 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_PEN_0301 176 * @tc.name: testPenDestroyNull 177 * @tc.desc: Test for testPenDestroyNull. 178 * @tc.size: SmallTest 179 * @tc.type: Function 180 * @tc.level: Level 3 181 */ 182 HWTEST_F(DrawingNativePenTest, testPenDestroyNull, TestSize.Level3) { 183 // 1. Create a pen object using OH_Drawing_PenCreate 184 OH_Drawing_Pen *pen = OH_Drawing_PenCreate(); 185 // add assert 186 EXPECT_NE(pen, nullptr); 187 // 2. Destroy the object with nullptr using OH_Drawing_PenDestroy 188 OH_Drawing_PenDestroy(nullptr); 189 // 3. Free the memory 190 OH_Drawing_PenDestroy(pen); 191 } 192 193 /* 194 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_PEN_0400 195 * @tc.name: testPenIsAntiAliasNormal 196 * @tc.desc: Test for testPenIsAntiAliasNormal. 197 * @tc.size: SmallTest 198 * @tc.type: Function 199 * @tc.level: Level 0 200 */ 201 HWTEST_F(DrawingNativePenTest, testPenIsAntiAliasNormal, TestSize.Level0) { 202 // 1. Create a pen object using OH_Drawing_PenCreate 203 OH_Drawing_Pen *pen = OH_Drawing_PenCreate(); 204 // add assert 205 EXPECT_NE(pen, nullptr); 206 // 2. Set anti-aliasing for the pen using OH_Drawing_PenSetAntiAlias 207 OH_Drawing_PenSetAntiAlias(pen, true); 208 // 3. Get the anti-aliasing status of the pen using OH_Drawing_PenIsAntiAlias 209 bool isAntiAlias = OH_Drawing_PenIsAntiAlias(pen); 210 EXPECT_EQ(isAntiAlias, true); 211 // 4. Free the memory 212 OH_Drawing_PenDestroy(pen); 213 } 214 215 /* 216 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_PEN_0401 217 * @tc.name: testPenIsAntiAliasNull 218 * @tc.desc: Test for testPenIsAntiAliasNull. 219 * @tc.size: SmallTest 220 * @tc.type: Function 221 * @tc.level: Level 3 222 */ 223 HWTEST_F(DrawingNativePenTest, testPenIsAntiAliasNull, TestSize.Level3) { 224 // 1. Create a pen object using OH_Drawing_PenCreate 225 OH_Drawing_Pen *pen = OH_Drawing_PenCreate(); 226 // add assert 227 EXPECT_NE(pen, nullptr); 228 // 2. Call OH_Drawing_PenIsAntiAlias with nullptr as parameter 229 bool isAntiAlias = OH_Drawing_PenIsAntiAlias(nullptr); 230 EXPECT_EQ(isAntiAlias, false); 231 // 3. Free the memory 232 OH_Drawing_PenDestroy(pen); 233 } 234 235 /* 236 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_PEN_0500 237 * @tc.name: testPenSetAntiAliasNormal 238 * @tc.desc: Test for testPenSetAntiAliasNormal. 239 * @tc.size: SmallTest 240 * @tc.type: Function 241 * @tc.level: Level 0 242 */ 243 HWTEST_F(DrawingNativePenTest, testPenSetAntiAliasNormal, TestSize.Level0) { 244 // 1. Create a pen object using OH_Drawing_PenCreate 245 OH_Drawing_Pen *pen = OH_Drawing_PenCreate(); 246 // add assert 247 EXPECT_NE(pen, nullptr); 248 // 2. Set anti-aliasing for the pen using OH_Drawing_PenSetAntiAlias 249 OH_Drawing_PenSetAntiAlias(pen, true); 250 // 3. Get the anti-aliasing status of the pen using OH_Drawing_PenIsAntiAlias 251 bool isAntiAlias = OH_Drawing_PenIsAntiAlias(pen); 252 EXPECT_EQ(isAntiAlias, true); 253 // 4. Free the memory 254 OH_Drawing_PenDestroy(pen); 255 } 256 257 /* 258 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_PEN_0501 259 * @tc.name: testPenSetAntiAliasNull 260 * @tc.desc: Test for testPenSetAntiAliasNull. 261 * @tc.size: SmallTest 262 * @tc.type: Function 263 * @tc.level: Level 3 264 */ 265 HWTEST_F(DrawingNativePenTest, testPenSetAntiAliasNull, TestSize.Level3) { 266 // 1. Create a pen object using OH_Drawing_PenCreate 267 OH_Drawing_Pen *pen = OH_Drawing_PenCreate(); 268 // add assert 269 EXPECT_NE(pen, nullptr); 270 // 2. Set anti-aliasing for the pen using OH_Drawing_PenSetAntiAlias 271 OH_Drawing_PenSetAntiAlias(nullptr, true); 272 // add assert 273 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 274 // 3. Free the memory 275 OH_Drawing_PenDestroy(pen); 276 } 277 278 /* 279 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_PEN_0600 280 * @tc.name: testPenGetColorNormal 281 * @tc.desc: Test for testPenGetColorNormal. 282 * @tc.size: SmallTest 283 * @tc.type: Function 284 * @tc.level: Level 0 285 */ 286 HWTEST_F(DrawingNativePenTest, testPenGetColorNormal, TestSize.Level0) { 287 // 1. Create a pen object using OH_Drawing_PenCreate 288 OH_Drawing_Pen *pen = OH_Drawing_PenCreate(); 289 // add assert 290 EXPECT_NE(pen, nullptr); 291 // 2. Set color for the pen using OH_Drawing_PenSetColor 292 OH_Drawing_PenSetColor(pen, 0x00000000); 293 // 3. Get color of the pen using OH_Drawing_PenGetColor 294 uint32_t color = OH_Drawing_PenGetColor(pen); 295 EXPECT_EQ(color, 0x00000000); 296 // 4. Free the memory 297 OH_Drawing_PenDestroy(pen); 298 } 299 300 /* 301 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_PEN_0601 302 * @tc.name: testPenGetColorNull 303 * @tc.desc: Test for testPenGetColorNull. 304 * @tc.size: SmallTest 305 * @tc.type: Function 306 * @tc.level: Level 3 307 */ 308 HWTEST_F(DrawingNativePenTest, testPenGetColorNull, TestSize.Level3) { 309 // 1. Create a pen object using OH_Drawing_PenCreate 310 OH_Drawing_Pen *pen = OH_Drawing_PenCreate(); 311 // add assert 312 EXPECT_NE(pen, nullptr); 313 // 2. Call OH_Drawing_PenGetColor with nullptr as parameter 314 OH_Drawing_PenGetColor(nullptr); 315 // add assert 316 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 317 // 3. Free the memory 318 OH_Drawing_PenDestroy(pen); 319 } 320 321 /* 322 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_PEN_0700 323 * @tc.name: testPenSetColorNormal 324 * @tc.desc: Test for testPenSetColorNormal. 325 * @tc.size: SmallTest 326 * @tc.type: Function 327 * @tc.level: Level 0 328 */ 329 HWTEST_F(DrawingNativePenTest, testPenSetColorNormal, TestSize.Level0) { 330 // 1. Create a pen object using OH_Drawing_PenCreate 331 OH_Drawing_Pen *pen = OH_Drawing_PenCreate(); 332 // add assert 333 EXPECT_NE(pen, nullptr); 334 // 2. Set color for the pen using OH_Drawing_PenSetColor 335 OH_Drawing_PenSetColor(pen, 0x00000000); 336 // 3. Get color of the pen using OH_Drawing_PenGetColor 337 uint32_t color = OH_Drawing_PenGetColor(pen); 338 EXPECT_EQ(color, 0x00000000); 339 // 4. Free the memory 340 OH_Drawing_PenDestroy(pen); 341 } 342 343 /* 344 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_PEN_0701 345 * @tc.name: testPenSetColorNull 346 * @tc.desc: Test for testPenSetColorNull. 347 * @tc.size: SmallTest 348 * @tc.type: Function 349 * @tc.level: Level 3 350 */ 351 HWTEST_F(DrawingNativePenTest, testPenSetColorNull, TestSize.Level3) { 352 // 1. Create a pen object using OH_Drawing_PenCreate 353 OH_Drawing_Pen *pen = OH_Drawing_PenCreate(); 354 // add assert 355 EXPECT_NE(pen, nullptr); 356 // 2. Set color for the pen using OH_Drawing_PenSetColor with nullptr as the first parameter 357 OH_Drawing_PenSetColor(nullptr, 0x00000000); 358 // add assert 359 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 360 // 3. Set color for the pen using OH_Drawing_PenSetColor with 0x00000000 as the second parameter 361 OH_Drawing_PenSetColor(pen, 0x00000000); 362 // 4. Free the memory 363 OH_Drawing_PenDestroy(pen); 364 } 365 366 /* 367 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_PEN_0702 368 * @tc.name: testPenSetColorAbnormal 369 * @tc.desc: Test for testPenSetColorAbnormal. 370 * @tc.size: SmallTest 371 * @tc.type: Function 372 * @tc.level: Level 3 373 */ 374 HWTEST_F(DrawingNativePenTest, testPenSetColorAbnormal, TestSize.Level3) { 375 // 1. Create a pen object using OH_Drawing_PenCreate 376 OH_Drawing_Pen *pen = OH_Drawing_PenCreate(); 377 // add assert 378 EXPECT_NE(pen, nullptr); 379 // 2. Set the second parameter of OH_Drawing_PenSetColor to a negative number or a floating-point number 380 OH_Drawing_PenSetColor(pen, -1); 381 // 3. Call OH_Drawing_PenGetColor 382 uint32_t color = OH_Drawing_PenGetColor(pen); 383 EXPECT_EQ(static_cast<uint32_t>(-1), color); 384 // 4. Free the memory 385 OH_Drawing_PenDestroy(pen); 386 } 387 388 /* 389 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_PEN_0703 390 * @tc.name: testPenSetColorMaximum 391 * @tc.desc: Test for testPenSetColorMaximum. 392 * @tc.size: SmallTest 393 * @tc.type: Function 394 * @tc.level: Level 3 395 */ 396 HWTEST_F(DrawingNativePenTest, testPenSetColorMaximum, TestSize.Level3) { 397 // 1. Create a pen object using OH_Drawing_PenCreate 398 OH_Drawing_Pen *pen = OH_Drawing_PenCreate(); 399 // add assert 400 EXPECT_NE(pen, nullptr); 401 // 2. Set the second parameter of OH_Drawing_PenSetColor to a maximum value of 0xFFFFFFFF + 1 402 OH_Drawing_PenSetColor(pen, 0xFFFFFFFF + 1); 403 // 3. Get the color of the pen using OH_Drawing_PenGetColor 404 uint32_t color = OH_Drawing_PenGetColor(pen); 405 EXPECT_EQ(0xFFFFFFFF + 1, color); 406 // 4. Free the memory 407 OH_Drawing_PenDestroy(pen); 408 } 409 410 /* 411 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_PEN_0800 412 * @tc.name: testPenGetAlphaNormal 413 * @tc.desc: Test for testPenGetAlphaNormal. 414 * @tc.size: SmallTest 415 * @tc.type: Function 416 * @tc.level: Level 0 417 */ 418 HWTEST_F(DrawingNativePenTest, testPenGetAlphaNormal, TestSize.Level0) { 419 // 1. Create a pen object using OH_Drawing_PenCreate 420 OH_Drawing_Pen *pen = OH_Drawing_PenCreate(); 421 // add assert 422 EXPECT_NE(pen, nullptr); 423 // 2. Set the alpha value for the pen using OH_Drawing_PenSetAlpha 424 OH_Drawing_PenSetAlpha(pen, 0x00); 425 // 3. Get the alpha value of the pen using OH_Drawing_PenGetAlpha 426 uint8_t alpha = OH_Drawing_PenGetAlpha(pen); 427 EXPECT_EQ(alpha, 0x00); 428 // 4. Free the memory 429 OH_Drawing_PenDestroy(pen); 430 } 431 432 /* 433 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_PEN_0801 434 * @tc.name: testPenGetAlphaNull 435 * @tc.desc: Test for testPenGetAlphaNull. 436 * @tc.size: SmallTest 437 * @tc.type: Function 438 * @tc.level: Level 3 439 */ 440 HWTEST_F(DrawingNativePenTest, testPenGetAlphaNull, TestSize.Level3) { 441 // 1. Create a pen object using OH_Drawing_PenCreate 442 OH_Drawing_Pen *pen = OH_Drawing_PenCreate(); 443 // add assert 444 EXPECT_NE(pen, nullptr); 445 // 2. Call OH_Drawing_PenGetAlpha with nullptr as parameter 446 OH_Drawing_PenGetAlpha(nullptr); 447 // add assert 448 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 449 // 3. Free the memory 450 OH_Drawing_PenDestroy(pen); 451 } 452 453 /* 454 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_PEN_0900 455 * @tc.name: testPenSetAlphaNormal 456 * @tc.desc: Test for testPenSetAlphaNormal. 457 * @tc.size: SmallTest 458 * @tc.type: Function 459 * @tc.level: Level 0 460 */ 461 HWTEST_F(DrawingNativePenTest, testPenSetAlphaNormal, TestSize.Level0) { 462 // 1. Create a pen object using OH_Drawing_PenCreate 463 OH_Drawing_Pen *pen = OH_Drawing_PenCreate(); 464 // add assert 465 EXPECT_NE(pen, nullptr); 466 // 2. Set the alpha value for the pen using OH_Drawing_PenSetAlpha 467 OH_Drawing_PenSetAlpha(pen, 0x00); 468 // 3. Get the alpha value of the pen using OH_Drawing_PenGetAlpha 469 uint8_t alpha = OH_Drawing_PenGetAlpha(pen); 470 EXPECT_EQ(alpha, 0x00); 471 // 4. Free the memory 472 OH_Drawing_PenDestroy(pen); 473 } 474 475 /* 476 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_PEN_0901 477 * @tc.name: testPenSetAlphaNull 478 * @tc.desc: Test for testPenSetAlphaNull. 479 * @tc.size: SmallTest 480 * @tc.type: Function 481 * @tc.level: Level 3 482 */ 483 HWTEST_F(DrawingNativePenTest, testPenSetAlphaNull, TestSize.Level3) { 484 // 1. Create a pen object using OH_Drawing_PenCreate 485 OH_Drawing_Pen *pen = OH_Drawing_PenCreate(); 486 // add assert 487 EXPECT_NE(pen, nullptr); 488 // 2. Set the alpha value for the pen using OH_Drawing_PenSetAlpha with nullptr as the first parameter 489 OH_Drawing_PenSetAlpha(nullptr, 0xff); 490 // add assert 491 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 492 // 3. Set the alpha value for the pen using OH_Drawing_PenSetAlpha with 0x00 as the second parameter 493 OH_Drawing_PenSetAlpha(pen, 0x00); 494 // 4. Free the memory 495 OH_Drawing_PenDestroy(pen); 496 } 497 498 /* 499 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_PEN_0902 500 * @tc.name: testPenSetAlphaAbnormal 501 * @tc.desc: Test for testPenSetAlphaAbnormal. 502 * @tc.size: SmallTest 503 * @tc.type: Function 504 * @tc.level: Level 3 505 */ 506 HWTEST_F(DrawingNativePenTest, testPenSetAlphaAbnormal, TestSize.Level3) { 507 // 1. Create a pen object using OH_Drawing_PenCreate 508 OH_Drawing_Pen *pen = OH_Drawing_PenCreate(); 509 // add assert 510 EXPECT_NE(pen, nullptr); 511 // 2. Set the second parameter of OH_Drawing_PenSetAlpha to a negative number or a floating-point number 512 OH_Drawing_PenSetAlpha(pen, -1); 513 // 3. Call OH_Drawing_PenGetAlpha 514 uint8_t alpha = OH_Drawing_PenGetAlpha(pen); 515 EXPECT_EQ(static_cast<uint8_t>(-1), alpha); 516 // 4. Free the memory 517 OH_Drawing_PenDestroy(pen); 518 } 519 520 /* 521 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_PEN_0903 522 * @tc.name: testPenSetAlphaMaximum 523 * @tc.desc: Test for testPenSetAlphaMaximum. 524 * @tc.size: SmallTest 525 * @tc.type: Function 526 * @tc.level: Level 3 527 */ 528 HWTEST_F(DrawingNativePenTest, testPenSetAlphaMaximum, TestSize.Level3) { 529 // 1. Create a pen object using OH_Drawing_PenCreate 530 OH_Drawing_Pen *pen = OH_Drawing_PenCreate(); 531 // add assert 532 EXPECT_NE(pen, nullptr); 533 // 2. Set the second parameter of OH_Drawing_PenSetAlpha to a maximum value of 0xFF + 1 534 uint8_t alpha1 = 0xFF; 535 OH_Drawing_PenSetAlpha(pen, alpha1 + 1); 536 // 3. Call OH_Drawing_PenGetAlpha 537 uint8_t alpha2 = OH_Drawing_PenGetAlpha(pen); 538 EXPECT_EQ(alpha2, 0); 539 // 4. Free the memory 540 OH_Drawing_PenDestroy(pen); 541 } 542 543 /* 544 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_PEN_1000 545 * @tc.name: testPenGetWidthNormal 546 * @tc.desc: Test for testPenGetWidthNormal. 547 * @tc.size: SmallTest 548 * @tc.type: Function 549 * @tc.level: Level 0 550 */ 551 HWTEST_F(DrawingNativePenTest, testPenGetWidthNormal, TestSize.Level0) { 552 // 1. Create a pen object using OH_Drawing_PenCreate 553 OH_Drawing_Pen *pen = OH_Drawing_PenCreate(); 554 // add assert 555 EXPECT_NE(pen, nullptr); 556 // 2. Set the pen width using OH_Drawing_PenSetWidth 557 OH_Drawing_PenSetWidth(pen, 1.0); 558 // 3. Get the pen width using OH_Drawing_PenGetWidth 559 float width = OH_Drawing_PenGetWidth(pen); 560 EXPECT_EQ(width, 1.0); 561 // 4. Free the memory 562 OH_Drawing_PenDestroy(pen); 563 } 564 565 /* 566 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_PEN_1001 567 * @tc.name: testPenGetWidthNull 568 * @tc.desc: Test for testPenGetWidthNull. 569 * @tc.size: SmallTest 570 * @tc.type: Function 571 * @tc.level: Level 3 572 */ 573 HWTEST_F(DrawingNativePenTest, testPenGetWidthNull, TestSize.Level3) { 574 // 1. Create a pen object using OH_Drawing_PenCreate 575 OH_Drawing_Pen *pen = OH_Drawing_PenCreate(); 576 // add assert 577 EXPECT_NE(pen, nullptr); 578 // 2. Call OH_Drawing_PenGetWidth with nullptr as parameter 579 OH_Drawing_PenGetWidth(nullptr); 580 // add assert 581 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 582 // 3. Free the memory 583 OH_Drawing_PenDestroy(pen); 584 } 585 586 /* 587 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_PEN_1002 588 * @tc.name: testPenGetWidthBoundary 589 * @tc.desc: Test for testPenGetWidthBoundary. 590 * @tc.size: SmallTest 591 * @tc.type: Function 592 * @tc.level: Level 0 593 */ 594 HWTEST_F(DrawingNativePenTest, testPenGetWidthBoundary, TestSize.Level0) { 595 // 1. Create a pen object using OH_Drawing_PenCreate 596 OH_Drawing_Pen *pen = OH_Drawing_PenCreate(); 597 // add assert 598 EXPECT_NE(pen, nullptr); 599 // 2. Set the pen width using OH_Drawing_PenSetWidth 600 float width = 4096.0; 601 OH_Drawing_PenSetWidth(pen, width); 602 // 3. Get the pen width using OH_Drawing_PenGetWidth 603 float getWidth = OH_Drawing_PenGetWidth(pen); 604 EXPECT_EQ(width, getWidth); 605 // 4. Free the memory 606 OH_Drawing_PenDestroy(pen); 607 } 608 609 /* 610 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_PEN_1100 611 * @tc.name: testPenSetWidthNormal 612 * @tc.desc: Test for testPenSetWidthNormal. 613 * @tc.size: SmallTest 614 * @tc.type: Function 615 * @tc.level: Level 0 616 */ 617 HWTEST_F(DrawingNativePenTest, testPenSetWidthNormal, TestSize.Level0) { 618 // 1. Create a pen object using OH_Drawing_PenCreate 619 OH_Drawing_Pen *pen = OH_Drawing_PenCreate(); 620 // add assert 621 EXPECT_NE(pen, nullptr); 622 // 2. Set the pen width using OH_Drawing_PenSetWidth 623 OH_Drawing_PenSetWidth(pen, 1.0); 624 // 3. Get the pen width using OH_Drawing_PenGetWidth 625 float width = OH_Drawing_PenGetWidth(pen); 626 EXPECT_EQ(width, 1.0); 627 // 4. Free the memory 628 OH_Drawing_PenDestroy(pen); 629 } 630 631 /* 632 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_PEN_1101 633 * @tc.name: testPenSetWidthNull 634 * @tc.desc: Test for testPenSetWidthNull. 635 * @tc.size: SmallTest 636 * @tc.type: Function 637 * @tc.level: Level 3 638 */ 639 HWTEST_F(DrawingNativePenTest, testPenSetWidthNull, TestSize.Level3) { 640 // 1. Create a pen object using OH_Drawing_PenCreate 641 OH_Drawing_Pen *pen = OH_Drawing_PenCreate(); 642 // add assert 643 EXPECT_NE(pen, nullptr); 644 // 2. Call OH_Drawing_PenSetWidth with nullptr as the first parameter 645 OH_Drawing_PenSetWidth(nullptr, 1.00); 646 // add assert 647 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 648 // 3. Call OH_Drawing_PenSetWidth with 0.00 as the second parameter 649 OH_Drawing_PenSetWidth(pen, 0.00); 650 // 4. Free the memory 651 OH_Drawing_PenDestroy(pen); 652 } 653 654 /* 655 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_PEN_1102 656 * @tc.name: testPenSetWidthAbnormal 657 * @tc.desc: Test for testPenSetWidthAbnormal. 658 * @tc.size: SmallTest 659 * @tc.type: Function 660 * @tc.level: Level 3 661 */ 662 HWTEST_F(DrawingNativePenTest, testPenSetWidthAbnormal, TestSize.Level3) { 663 // 1. Create a pen object using OH_Drawing_PenCreate 664 OH_Drawing_Pen *pen = OH_Drawing_PenCreate(); 665 // add assert 666 EXPECT_NE(pen, nullptr); 667 // 2. Set the pen width using OH_Drawing_PenSetWidth with an integer or character data as the second parameter 668 int width = 1; 669 OH_Drawing_PenSetWidth(pen, width); 670 // 3. Get the pen width using OH_Drawing_PenGetWidth 671 float width2 = OH_Drawing_PenGetWidth(pen); 672 EXPECT_EQ(static_cast<float>(1), width2); 673 // 4. Free the memory 674 OH_Drawing_PenDestroy(pen); 675 } 676 677 /* 678 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_PEN_1103 679 * @tc.name: testPenSetWidthMultipleCalls 680 * @tc.desc: Test for testPenSetWidthMultipleCalls. 681 * @tc.size: SmallTest 682 * @tc.type: Function 683 * @tc.level: Level 3 684 */ 685 HWTEST_F(DrawingNativePenTest, testPenSetWidthMultipleCalls, TestSize.Level3) { 686 // 1. Create a pen object using OH_Drawing_PenCreate 687 OH_Drawing_Pen *pen = OH_Drawing_PenCreate(); 688 // add assert 689 EXPECT_NE(pen, nullptr); 690 // 2. Loop through 10 times and set the pen width using OH_Drawing_PenSetWidth 691 for (int i = 0; i < 10; i++) { 692 OH_Drawing_PenSetWidth(pen, 1.0); 693 } 694 // 3. Loop through 10 times and get the pen width using OH_Drawing_PenGetWidth 695 for (int i = 0; i < 10; i++) { 696 float width = OH_Drawing_PenGetWidth(pen); 697 EXPECT_EQ(width, 1.0); 698 } 699 // 4. Free the memory 700 OH_Drawing_PenDestroy(pen); 701 } 702 703 /* 704 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_PEN_1104 705 * @tc.name: testPenSetWidthMultipleCallsBoundary 706 * @tc.desc: Test for testPenSetWidthMultipleCallsBoundary. 707 * @tc.size: SmallTest 708 * @tc.type: Function 709 * @tc.level: Level 3 710 */ 711 HWTEST_F(DrawingNativePenTest, testPenSetWidthMultipleCallsBoundary, TestSize.Level3) { 712 // 1. Create a pen object using OH_Drawing_PenCreate 713 OH_Drawing_Pen *pen = OH_Drawing_PenCreate(); 714 // add assert 715 EXPECT_NE(pen, nullptr); 716 // 2. Loop through 10 times and set the pen width using OH_Drawing_PenSetWidth 717 for (int i = 0; i < 10; i++) { 718 OH_Drawing_PenSetWidth(pen, 4096.0); 719 } 720 // 3. Loop through 10 times and get the pen width using OH_Drawing_PenGetWidth 721 for (int i = 0; i < 10; i++) { 722 float width = OH_Drawing_PenGetWidth(pen); 723 EXPECT_EQ(width, 4096.0); 724 } 725 // 4. Free the memory 726 OH_Drawing_PenDestroy(pen); 727 } 728 729 /* 730 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_PEN_1200 731 * @tc.name: testPenGetMiterLimitNormal 732 * @tc.desc: Test for testPenGetMiterLimitNormal. 733 * @tc.size: SmallTest 734 * @tc.type: Function 735 * @tc.level: Level 0 736 */ 737 HWTEST_F(DrawingNativePenTest, testPenGetMiterLimitNormal, TestSize.Level0) { 738 // 1. Create a pen object using OH_Drawing_PenCreate 739 OH_Drawing_Pen *pen = OH_Drawing_PenCreate(); 740 // add assert 741 EXPECT_NE(pen, nullptr); 742 // 2. Set the miter limit for the pen using OH_Drawing_PenSetMiterLimit 743 OH_Drawing_PenSetMiterLimit(pen, 1.0); 744 // 3. Get the miter limit using OH_Drawing_PenGetMiterLimit 745 float miterLimit = OH_Drawing_PenGetMiterLimit(pen); 746 EXPECT_EQ(miterLimit, 1.0); 747 // 4. Free the memory 748 OH_Drawing_PenDestroy(pen); 749 } 750 751 /* 752 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_PEN_1201 753 * @tc.name: testPenGetMiterLimitNull 754 * @tc.desc: Test for testPenGetMiterLimitNull. 755 * @tc.size: SmallTest 756 * @tc.type: Function 757 * @tc.level: Level 3 758 */ 759 HWTEST_F(DrawingNativePenTest, testPenGetMiterLimitNull, TestSize.Level3) { 760 // 1. Create a pen object using OH_Drawing_PenCreate 761 OH_Drawing_Pen *pen = OH_Drawing_PenCreate(); 762 // add assert 763 EXPECT_NE(pen, nullptr); 764 // 2. Call OH_Drawing_PenGetMiterLimit with nullptr as parameter 765 OH_Drawing_PenGetMiterLimit(nullptr); 766 // add assert 767 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 768 // 3. Free the memory 769 OH_Drawing_PenDestroy(pen); 770 } 771 772 /* 773 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_PEN_1300 774 * @tc.name: testPenSetMiterLimitNormal 775 * @tc.desc: Test for testPenSetMiterLimitNormal. 776 * @tc.size: SmallTest 777 * @tc.type: Function 778 * @tc.level: Level 0 779 */ 780 HWTEST_F(DrawingNativePenTest, testPenSetMiterLimitNormal, TestSize.Level0) { 781 // 1. Create a pen object using OH_Drawing_PenCreate 782 OH_Drawing_Pen *pen = OH_Drawing_PenCreate(); 783 // add assert 784 EXPECT_NE(pen, nullptr); 785 // 2. Set the miter limit for the pen using OH_Drawing_PenSetMiterLimit 786 OH_Drawing_PenSetMiterLimit(pen, 1.0); 787 // 3. Get the miter limit using OH_Drawing_PenGetMiterLimit 788 float miterLimit = OH_Drawing_PenGetMiterLimit(pen); 789 EXPECT_EQ(miterLimit, 1.0); 790 // 4. Free the memory 791 OH_Drawing_PenDestroy(pen); 792 } 793 794 /* 795 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_PEN_1301 796 * @tc.name: testPenSetMiterLimitNull 797 * @tc.desc: Test for testPenSetMiterLimitNull. 798 * @tc.size: SmallTest 799 * @tc.type: Function 800 * @tc.level: Level 3 801 */ 802 HWTEST_F(DrawingNativePenTest, testPenSetMiterLimitNull, TestSize.Level3) { 803 // 1. Create a pen object using OH_Drawing_PenCreate 804 OH_Drawing_Pen *pen = OH_Drawing_PenCreate(); 805 // add assert 806 EXPECT_NE(pen, nullptr); 807 // 2. Call OH_Drawing_PenSetMiterLimit with nullptr as the first parameter 808 OH_Drawing_PenSetMiterLimit(nullptr, 1.0); 809 // add assert 810 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 811 // 3. Call OH_Drawing_PenSetMiterLimit with 0.0 as the second parameter 812 OH_Drawing_PenSetMiterLimit(pen, 0.0); 813 // 4. Free the memory 814 OH_Drawing_PenDestroy(pen); 815 } 816 817 /* 818 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_PEN_1302 819 * @tc.name: testPenSetMiterLimitAbnormal 820 * @tc.desc: Test for testPenSetMiterLimitAbnormal. 821 * @tc.size: SmallTest 822 * @tc.type: Function 823 * @tc.level: Level 3 824 */ 825 HWTEST_F(DrawingNativePenTest, testPenSetMiterLimitAbnormal, TestSize.Level3) { 826 // 1. Create a pen object using OH_Drawing_PenCreate 827 OH_Drawing_Pen *pen = OH_Drawing_PenCreate(); 828 // add assert 829 EXPECT_NE(pen, nullptr); 830 // 2. Set the miter limit for the pen using OH_Drawing_PenSetMiterLimit with an integer or character data as the 831 // second parameter 832 int miterLimit = 1; 833 OH_Drawing_PenSetMiterLimit(pen, miterLimit); 834 // 3. Get the miter limit using OH_Drawing_PenGetMiterLimit 835 float miterLimit2 = OH_Drawing_PenGetMiterLimit(pen); 836 EXPECT_EQ(static_cast<float>(1), miterLimit2); 837 // 4. Free the memory 838 OH_Drawing_PenDestroy(pen); 839 } 840 841 /* 842 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_PEN_1303 843 * @tc.name: testPenSetMiterLimitMultipleCalls 844 * @tc.desc: Test for testPenSetMiterLimitMultipleCalls. 845 * @tc.size: SmallTest 846 * @tc.type: Function 847 * @tc.level: Level 3 848 */ 849 HWTEST_F(DrawingNativePenTest, testPenSetMiterLimitMultipleCalls, TestSize.Level3) { 850 // 1. Create a pen object using OH_Drawing_PenCreate 851 OH_Drawing_Pen *pen = OH_Drawing_PenCreate(); 852 // add assert 853 EXPECT_NE(pen, nullptr); 854 // 2. Loop through 10 times and set the miter limit for the pen using OH_Drawing_PenSetMiterLimit 855 for (int i = 0; i < 10; i++) { 856 OH_Drawing_PenSetMiterLimit(pen, 1.0); 857 } 858 // 3. Loop through 10 times and get the miter limit using OH_Drawing_PenGetMiterLimit 859 for (int i = 0; i < 10; i++) { 860 OH_Drawing_PenGetMiterLimit(pen); 861 } 862 // 4. Free the memory 863 OH_Drawing_PenDestroy(pen); 864 } 865 866 /* 867 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_PEN_1400 868 * @tc.name: testPenGetCapNormal 869 * @tc.desc: Test for testPenGetCapNormal. 870 * @tc.size: SmallTest 871 * @tc.type: Function 872 * @tc.level: Level 0 873 */ 874 HWTEST_F(DrawingNativePenTest, testPenGetCapNormal, TestSize.Level0) { 875 // 1. Create a pen object using OH_Drawing_PenCreate 876 OH_Drawing_Pen *pen = OH_Drawing_PenCreate(); 877 // add assert 878 EXPECT_NE(pen, nullptr); 879 // 2. Set the pen cap style using OH_Drawing_PenSetCap 880 OH_Drawing_PenSetCap(pen, LINE_FLAT_CAP); 881 // 3. Get the pen cap style using OH_Drawing_PenGetCap 882 OH_Drawing_PenLineCapStyle cap = OH_Drawing_PenGetCap(pen); 883 EXPECT_EQ(cap, LINE_FLAT_CAP); 884 // 4. Free the memory 885 OH_Drawing_PenDestroy(pen); 886 } 887 888 /* 889 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_PEN_1401 890 * @tc.name: testPenGetCapNull 891 * @tc.desc: Test for testPenGetCapNull. 892 * @tc.size: SmallTest 893 * @tc.type: Function 894 * @tc.level: Level 3 895 */ 896 HWTEST_F(DrawingNativePenTest, testPenGetCapNull, TestSize.Level3) { 897 // 1. Create a pen object using OH_Drawing_PenCreate 898 OH_Drawing_Pen *pen = OH_Drawing_PenCreate(); 899 // add assert 900 EXPECT_NE(pen, nullptr); 901 // 2. Call OH_Drawing_PenGetCap with nullptr as parameter 902 OH_Drawing_PenGetCap(nullptr); 903 // add assert 904 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 905 // 3. Free the memory 906 OH_Drawing_PenDestroy(pen); 907 } 908 909 /* 910 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_PEN_1500 911 * @tc.name: testPenSetCapNormal 912 * @tc.desc: Test for testPenSetCapNormal. 913 * @tc.size: SmallTest 914 * @tc.type: Function 915 * @tc.level: Level 0 916 */ 917 HWTEST_F(DrawingNativePenTest, testPenSetCapNormal, TestSize.Level0) { 918 // 1. Create a pen object using OH_Drawing_PenCreate 919 OH_Drawing_Pen *pen = OH_Drawing_PenCreate(); 920 // add assert 921 EXPECT_NE(pen, nullptr); 922 // 2. Call OH_Drawing_PenSetCap with the second parameter as an enumeration by looping through the styles array 923 OH_Drawing_PenLineCapStyle styles[] = {LINE_FLAT_CAP, LINE_SQUARE_CAP, LINE_ROUND_CAP}; 924 for (int i = 0; i < 3; i++) { 925 OH_Drawing_PenSetCap(pen, styles[i]); 926 // 3. Get the pen cap style using OH_Drawing_PenGetCap 927 OH_Drawing_PenLineCapStyle cap = OH_Drawing_PenGetCap(pen); 928 EXPECT_EQ(cap, styles[i]); 929 } 930 // 4. Free the memory 931 OH_Drawing_PenDestroy(pen); 932 } 933 934 /* 935 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_PEN_1501 936 * @tc.name: testPenSetCapNull 937 * @tc.desc: Test for testPenSetCapNull. 938 * @tc.size: SmallTest 939 * @tc.type: Function 940 * @tc.level: Level 3 941 */ 942 HWTEST_F(DrawingNativePenTest, testPenSetCapNull, TestSize.Level3) { 943 // 1. Create a pen object using OH_Drawing_PenCreate 944 OH_Drawing_Pen *pen = OH_Drawing_PenCreate(); 945 // add assert 946 EXPECT_NE(pen, nullptr); 947 // 2. Call OH_Drawing_PenSetCap with nullptr as the first parameter 948 OH_Drawing_PenSetCap(nullptr, LINE_FLAT_CAP); 949 // add assert 950 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 951 // 3. Free the memory 952 OH_Drawing_PenDestroy(pen); 953 } 954 955 /* 956 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_PEN_1502 957 * @tc.name: testPenSetCapMultipleCalls 958 * @tc.desc: Test for testPenSetCapMultipleCalls. 959 * @tc.size: SmallTest 960 * @tc.type: Function 961 * @tc.level: Level 3 962 */ 963 HWTEST_F(DrawingNativePenTest, testPenSetCapMultipleCalls, TestSize.Level3) { 964 // 1. Create a pen object using OH_Drawing_PenCreate 965 OH_Drawing_Pen *pen = OH_Drawing_PenCreate(); 966 // add assert 967 EXPECT_NE(pen, nullptr); 968 // 2. Loop through 10 times and set the pen cap style using OH_Drawing_PenSetCap 969 for (int i = 0; i < 10; i++) { 970 OH_Drawing_PenSetCap(pen, LINE_FLAT_CAP); 971 } 972 // 3. Loop through 10 times and get the pen cap style using OH_Drawing_PenGetCap 973 for (int i = 0; i < 10; i++) { 974 OH_Drawing_PenGetCap(pen); 975 } 976 // 4. Free the memory 977 OH_Drawing_PenDestroy(pen); 978 } 979 980 /* 981 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_PEN_1600 982 * @tc.name: testPenGetJoinNormal 983 * @tc.desc: Test for testPenGetJoinNormal. 984 * @tc.size: SmallTest 985 * @tc.type: Function 986 * @tc.level: Level 0 987 */ 988 HWTEST_F(DrawingNativePenTest, testPenGetJoinNormal, TestSize.Level0) { 989 // 1. Create a pen object using OH_Drawing_PenCreate 990 OH_Drawing_Pen *pen = OH_Drawing_PenCreate(); 991 // add assert 992 EXPECT_NE(pen, nullptr); 993 // 2. Set the join style for the pen using OH_Drawing_PenSetJoin 994 OH_Drawing_PenSetJoin(pen, LINE_MITER_JOIN); 995 // 3. Get the join style using OH_Drawing_PenGetJoin 996 OH_Drawing_PenLineJoinStyle join = OH_Drawing_PenGetJoin(pen); 997 EXPECT_EQ(join, LINE_MITER_JOIN); 998 // 4. Free the memory 999 OH_Drawing_PenDestroy(pen); 1000 } 1001 1002 /* 1003 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_PEN_1601 1004 * @tc.name: testPenGetJoinNull 1005 * @tc.desc: Test for testPenGetJoinNull. 1006 * @tc.size: SmallTest 1007 * @tc.type: Function 1008 * @tc.level: Level 3 1009 */ 1010 HWTEST_F(DrawingNativePenTest, testPenGetJoinNull, TestSize.Level3) { 1011 // 1. Create a pen object using OH_Drawing_PenCreate 1012 OH_Drawing_Pen *pen = OH_Drawing_PenCreate(); 1013 // add assert 1014 EXPECT_NE(pen, nullptr); 1015 // 2. Call OH_Drawing_PenGetJoin with nullptr as parameter 1016 OH_Drawing_PenGetJoin(nullptr); 1017 // add assert 1018 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 1019 // 3. Free the memory 1020 OH_Drawing_PenDestroy(pen); 1021 } 1022 1023 /* 1024 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_PEN_1700 1025 * @tc.name: testPenSetJoinNormal 1026 * @tc.desc: test for testPenSetJoinNormal. 1027 * @tc.size : SmallTest 1028 * @tc.type : Function 1029 * @tc.level : Level 0 1030 */ 1031 HWTEST_F(DrawingNativePenTest, testPenSetJoinNormal, TestSize.Level0) { 1032 // 1. Create a pen object using OH_Drawing_PenCreate 1033 OH_Drawing_Pen *pen = OH_Drawing_PenCreate(); 1034 // add assert 1035 EXPECT_NE(pen, nullptr); 1036 // 2. Call OH_Drawing_PenSetJoin with the second parameter as an enumeration by looping through the styles array 1037 OH_Drawing_PenLineJoinStyle styles[] = {LINE_MITER_JOIN, LINE_ROUND_JOIN, LINE_BEVEL_JOIN}; 1038 for (int i = 0; i < 3; i++) { 1039 OH_Drawing_PenSetJoin(pen, styles[i]); 1040 // 3. Get the join style using OH_Drawing_PenGetJoin 1041 OH_Drawing_PenLineJoinStyle join = OH_Drawing_PenGetJoin(pen); 1042 EXPECT_EQ(join, styles[i]); 1043 } 1044 // 4. Free the memory 1045 OH_Drawing_PenDestroy(pen); 1046 } 1047 1048 /* 1049 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_PEN_1701 1050 * @tc.name: testPenSetJoinNull 1051 * @tc.desc: test for testPenSetJoinNull. 1052 * @tc.size : SmallTest 1053 * @tc.type : Function 1054 * @tc.level : Level 3 1055 */ 1056 HWTEST_F(DrawingNativePenTest, testPenSetJoinNull, TestSize.Level3) { 1057 // 1. Create a pen object using OH_Drawing_PenCreate 1058 OH_Drawing_Pen *pen = OH_Drawing_PenCreate(); 1059 // add assert 1060 EXPECT_NE(pen, nullptr); 1061 // 2. Call OH_Drawing_PenSetJoin with nullptr as the first parameter 1062 OH_Drawing_PenSetJoin(nullptr, LINE_MITER_JOIN); 1063 // add assert 1064 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 1065 // 3. Free the memory 1066 OH_Drawing_PenDestroy(pen); 1067 } 1068 1069 /* 1070 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_PEN_1702 1071 * @tc.name: testPenSetJoinMultipleCalls 1072 * @tc.desc: test for testPenSetJoinMultipleCalls. 1073 * @tc.size : SmallTest 1074 * @tc.type : Function 1075 * @tc.level : Level 3 1076 */ 1077 HWTEST_F(DrawingNativePenTest, testPenSetJoinMultipleCalls, TestSize.Level3) { 1078 // 1. Create a pen object using OH_Drawing_PenCreate 1079 OH_Drawing_Pen *pen = OH_Drawing_PenCreate(); 1080 // add assert 1081 EXPECT_NE(pen, nullptr); 1082 // 2. Loop through 10 times and set the pen join style using OH_Drawing_PenSetJoin 1083 for (int i = 0; i < 10; i++) { 1084 OH_Drawing_PenSetJoin(pen, LINE_MITER_JOIN); 1085 } 1086 // 3. Loop through 10 times and get the pen join style using OH_Drawing_PenGetJoin 1087 for (int i = 0; i < 10; i++) { 1088 OH_Drawing_PenGetJoin(pen); 1089 } 1090 // 4. Free the memory 1091 OH_Drawing_PenDestroy(pen); 1092 } 1093 1094 /* 1095 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_PEN_1800 1096 * @tc.name: testPenSetShaderEffectNormal 1097 * @tc.desc: test for testPenSetShaderEffectNormal. 1098 * @tc.size : SmallTest 1099 * @tc.type : Function 1100 * @tc.level : Level 0 1101 */ 1102 HWTEST_F(DrawingNativePenTest, testPenSetShaderEffectNormal, TestSize.Level0) { 1103 // 1. Create a pen object using OH_Drawing_PenCreate 1104 OH_Drawing_Pen *pen = OH_Drawing_PenCreate(); 1105 // add assert 1106 EXPECT_NE(pen, nullptr); 1107 // 2. Create a shader object using OH_Drawing_ShaderEffectCreate 1108 OH_Drawing_Point *startPt = OH_Drawing_PointCreate(100, 400); 1109 // add assert 1110 EXPECT_NE(startPt, nullptr); 1111 OH_Drawing_Point *endPt = OH_Drawing_PointCreate(200, 500); 1112 // add assert 1113 EXPECT_NE(endPt, nullptr); 1114 uint32_t color[] = {0xffff0000, 0xff00ff00}; 1115 float pos[] = {0., 1.0}; 1116 OH_Drawing_ShaderEffect *linearGradient = 1117 OH_Drawing_ShaderEffectCreateLinearGradient(startPt, endPt, color, pos, 2, OH_Drawing_TileMode::CLAMP); 1118 // add assert 1119 EXPECT_NE(linearGradient, nullptr); 1120 // 3. Set the shader effect for the pen using OH_Drawing_PenSetShaderEffect 1121 OH_Drawing_PenSetShaderEffect(pen, linearGradient); 1122 // add assert 1123 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 1124 // 4. Free the memory 1125 OH_Drawing_PointDestroy(startPt); 1126 OH_Drawing_PointDestroy(endPt); 1127 OH_Drawing_ShaderEffectDestroy(linearGradient); 1128 OH_Drawing_PenDestroy(pen); 1129 } 1130 1131 /* 1132 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_PEN_1801 1133 * @tc.name: testPenSetShaderEffectNull 1134 * @tc.desc: test for testPenSetShaderEffectNull. 1135 * @tc.size : SmallTest 1136 * @tc.type : Function 1137 * @tc.level : Level 3 1138 */ 1139 HWTEST_F(DrawingNativePenTest, testPenSetShaderEffectNull, TestSize.Level3) { 1140 // 1. Create a pen object using OH_Drawing_PenCreate 1141 OH_Drawing_Pen *pen = OH_Drawing_PenCreate(); 1142 // add assert 1143 EXPECT_NE(pen, nullptr); 1144 // 2. Create a shader object using OH_Drawing_ShaderEffectCreate 1145 OH_Drawing_Point *startPt = OH_Drawing_PointCreate(100, 400); 1146 // add assert 1147 EXPECT_NE(startPt, nullptr); 1148 OH_Drawing_Point *endPt = OH_Drawing_PointCreate(200, 500); 1149 // add assert 1150 EXPECT_NE(endPt, nullptr); 1151 uint32_t color[] = {0xffff0000, 0xff00ff00}; 1152 float pos[] = {0., 1.0}; 1153 OH_Drawing_ShaderEffect *linearGradient = 1154 OH_Drawing_ShaderEffectCreateLinearGradient(startPt, endPt, color, pos, 2, OH_Drawing_TileMode::CLAMP); 1155 // add assert 1156 EXPECT_NE(linearGradient, nullptr); 1157 // 3. Call OH_Drawing_PenSetShaderEffect with nullptr as the first parameter 1158 OH_Drawing_PenSetShaderEffect(nullptr, linearGradient); 1159 // add assert 1160 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 1161 // 4. Call OH_Drawing_PenSetShaderEffect with nullptr as the second parameter 1162 OH_Drawing_PenSetShaderEffect(pen, nullptr); 1163 // 5. Free the memory 1164 OH_Drawing_PointDestroy(startPt); 1165 OH_Drawing_PointDestroy(endPt); 1166 OH_Drawing_ShaderEffectDestroy(linearGradient); 1167 OH_Drawing_PenDestroy(pen); 1168 } 1169 1170 /* 1171 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_PEN_1900 1172 * @tc.name: testPenSetShadowLayerNormal 1173 * @tc.desc: test for testPenSetShadowLayerNormal. 1174 * @tc.size : SmallTest 1175 * @tc.type : Function 1176 * @tc.level : Level 0 1177 */ 1178 HWTEST_F(DrawingNativePenTest, testPenSetShadowLayerNormal, TestSize.Level0) { 1179 // 1. Create a pen object using OH_Drawing_PenCreate 1180 OH_Drawing_Pen *pen = OH_Drawing_PenCreate(); 1181 // add assert 1182 EXPECT_NE(pen, nullptr); 1183 // 2. Create a shadow layer object using OH_Drawing_ShadowLayerCreate 1184 OH_Drawing_ShadowLayer *shadowLayer = OH_Drawing_ShadowLayerCreate(10, 10, 10, 0xff000000); 1185 // add assert 1186 EXPECT_NE(shadowLayer, nullptr); 1187 // 3. Set the shadow layer for the pen using OH_Drawing_PenSetShadowLayer 1188 OH_Drawing_PenSetShadowLayer(pen, shadowLayer); 1189 // add assert 1190 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 1191 // 4. Free the memory 1192 OH_Drawing_ShadowLayerDestroy(shadowLayer); 1193 OH_Drawing_PenDestroy(pen); 1194 } 1195 1196 /* 1197 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_PEN_1901 1198 * @tc.name: testPenSetShadowLayerNull 1199 * @tc.desc: test for testPenSetShadowLayerNull. 1200 * @tc.size : SmallTest 1201 * @tc.type : Function 1202 * @tc.level : Level 3 1203 */ 1204 HWTEST_F(DrawingNativePenTest, testPenSetShadowLayerNull, TestSize.Level3) { 1205 // 1. Create a pen object using OH_Drawing_PenCreate 1206 OH_Drawing_Pen *pen = OH_Drawing_PenCreate(); 1207 // add assert 1208 EXPECT_NE(pen, nullptr); 1209 // 2. Create a shadow layer object using OH_Drawing_ShadowLayerCreate 1210 OH_Drawing_ShadowLayer *shadowLayer = OH_Drawing_ShadowLayerCreate(10, 10, 10, 0xff000000); 1211 // add assert 1212 EXPECT_NE(shadowLayer, nullptr); 1213 // 3. Set the shadow layer for the pen using OH_Drawing_PenSetShadowLayer with nullptr as the first parameter 1214 OH_Drawing_PenSetShadowLayer(nullptr, shadowLayer); 1215 // add assert 1216 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 1217 // 4. Set the shadow layer for the pen using OH_Drawing_PenSetShadowLayer with nullptr as the second parameter 1218 OH_Drawing_PenSetShadowLayer(pen, nullptr); 1219 // 5. Free the memory 1220 OH_Drawing_ShadowLayerDestroy(shadowLayer); 1221 OH_Drawing_PenDestroy(pen); 1222 } 1223 1224 /* 1225 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_PEN_2000 1226 * @tc.name: testPenSetPathEffectNormal 1227 * @tc.desc: test for testPenSetPathEffectNormal. 1228 * @tc.size : SmallTest 1229 * @tc.type : Function 1230 * @tc.level : Level 0 1231 */ 1232 HWTEST_F(DrawingNativePenTest, testPenSetPathEffectNormal, TestSize.Level0) { 1233 // 1. Create a pen object using OH_Drawing_PenCreate 1234 OH_Drawing_Pen *pen = OH_Drawing_PenCreate(); 1235 // add assert 1236 EXPECT_NE(pen, nullptr); 1237 // 2. Create a path effect object using OH_Drawing_PathEffectCreate 1238 float intervals[] = {1, 1, 1}; 1239 OH_Drawing_PathEffect *pathEffect = OH_Drawing_CreateDashPathEffect(intervals, 3, 0.0); 1240 // add assert 1241 EXPECT_NE(pathEffect, nullptr); 1242 // 3. Set the path effect for the pen using OH_Drawing_PenSetPathEffect 1243 OH_Drawing_PenSetPathEffect(pen, pathEffect); 1244 // add assert 1245 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 1246 // 4. Free the memory 1247 OH_Drawing_PathEffectDestroy(pathEffect); 1248 OH_Drawing_PenDestroy(pen); 1249 } 1250 1251 /* 1252 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_PEN_2001 1253 * @tc.name: testPenSetPathEffectNull 1254 * @tc.desc: test for testPenSetPathEffectNull. 1255 * @tc.size : SmallTest 1256 * @tc.type : Function 1257 * @tc.level : Level 3 1258 */ 1259 HWTEST_F(DrawingNativePenTest, testPenSetPathEffectNull, TestSize.Level3) { 1260 // 1. Create a pen object using OH_Drawing_PenCreate 1261 OH_Drawing_Pen *pen = OH_Drawing_PenCreate(); 1262 // add assert 1263 EXPECT_NE(pen, nullptr); 1264 // 2. Create a path effect object using OH_Drawing_PathEffectCreate 1265 float intervals[] = {1, 1, 1}; 1266 OH_Drawing_PathEffect *pathEffect = OH_Drawing_CreateDashPathEffect(intervals, 3, 0.0); 1267 // add assert 1268 EXPECT_NE(pathEffect, nullptr); 1269 // 3. Set the path effect for the pen with nullptr as the first parameter 1270 OH_Drawing_PenSetPathEffect(nullptr, pathEffect); 1271 // add assert 1272 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 1273 // 4. Set the path effect for the pen with nullptr as the second parameter 1274 OH_Drawing_PenSetPathEffect(pen, nullptr); 1275 // 5. Free the memory 1276 OH_Drawing_PathEffectDestroy(pathEffect); 1277 OH_Drawing_PenDestroy(pen); 1278 } 1279 1280 /* 1281 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_PEN_2100 1282 * @tc.name: testPenSetFilterNormal 1283 * @tc.desc: test for testPenSetFilterNormal. 1284 * @tc.size : SmallTest 1285 * @tc.type : Function 1286 * @tc.level : Level 0 1287 */ 1288 HWTEST_F(DrawingNativePenTest, testPenSetFilterNormal, TestSize.Level0) { 1289 // 1. Create a pen object using OH_Drawing_PenCreate 1290 OH_Drawing_Pen *pen = OH_Drawing_PenCreate(); 1291 // add assert 1292 EXPECT_NE(pen, nullptr); 1293 // 2. Create a filter object using OH_Drawing_FilterCreate 1294 OH_Drawing_Filter *filter = OH_Drawing_FilterCreate(); 1295 // add assert 1296 EXPECT_NE(filter, nullptr); 1297 // 3. Set the filter effect for the pen using OH_Drawing_PenSetFilter 1298 OH_Drawing_PenSetFilter(pen, filter); 1299 // add assert 1300 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 1301 // 4. Get the filter effect for the pen using OH_Drawing_PenGetFilter 1302 OH_Drawing_Filter *filter2 = OH_Drawing_FilterCreate(); 1303 // add assert 1304 EXPECT_NE(filter2, nullptr); 1305 OH_Drawing_PenGetFilter(pen, filter2); 1306 // add assert 1307 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 1308 // 5. Free the memory 1309 OH_Drawing_FilterDestroy(filter); 1310 OH_Drawing_FilterDestroy(filter2); 1311 OH_Drawing_PenDestroy(pen); 1312 } 1313 1314 /* 1315 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_PEN_2101 1316 * @tc.name: testPenSetFilterNull 1317 * @tc.desc: test for testPenSetFilterNull. 1318 * @tc.size : SmallTest 1319 * @tc.type : Function 1320 * @tc.level : Level 3 1321 */ 1322 HWTEST_F(DrawingNativePenTest, testPenSetFilterNull, TestSize.Level3) { 1323 // 1. Create a pen object using OH_Drawing_PenCreate 1324 OH_Drawing_Pen *pen = OH_Drawing_PenCreate(); 1325 // add assert 1326 EXPECT_NE(pen, nullptr); 1327 // 2. Create a filter object using OH_Drawing_FilterCreate 1328 OH_Drawing_Filter *filter = OH_Drawing_FilterCreate(); 1329 // add assert 1330 EXPECT_NE(filter, nullptr); 1331 // 3. Call OH_Drawing_PenSetFilter with nullptr as the first parameter 1332 OH_Drawing_PenSetFilter(nullptr, filter); 1333 // add assert 1334 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 1335 // 4. Call OH_Drawing_PenSetFilter with nullptr as the second parameter 1336 OH_Drawing_PenSetFilter(pen, nullptr); 1337 // 5. Free the memory 1338 OH_Drawing_FilterDestroy(filter); 1339 OH_Drawing_PenDestroy(pen); 1340 } 1341 1342 /* 1343 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_PEN_2200 1344 * @tc.name: testPenGetFilterNormal 1345 * @tc.desc: test for testPenGetFilterNormal. 1346 * @tc.size : SmallTest 1347 * @tc.type : Function 1348 * @tc.level : Level 0 1349 */ 1350 HWTEST_F(DrawingNativePenTest, testPenGetFilterNormal, TestSize.Level0) { 1351 // 1. Create a pen object using OH_Drawing_PenCreate 1352 OH_Drawing_Pen *pen = OH_Drawing_PenCreate(); 1353 // add assert 1354 EXPECT_NE(pen, nullptr); 1355 // 2. Create a filter object using OH_Drawing_FilterCreate 1356 OH_Drawing_Filter *filter = OH_Drawing_FilterCreate(); 1357 // add assert 1358 EXPECT_NE(filter, nullptr); 1359 // 3. Set the filter effect for the pen using OH_Drawing_PenSetFilter 1360 OH_Drawing_PenSetFilter(pen, filter); 1361 // 4. Get the filter effect for the pen using OH_Drawing_PenGetFilter 1362 OH_Drawing_Filter *filter2 = OH_Drawing_FilterCreate(); 1363 // add assert 1364 EXPECT_NE(filter2, nullptr); 1365 OH_Drawing_PenGetFilter(pen, filter2); 1366 // 5. Free the memory 1367 OH_Drawing_FilterDestroy(filter); 1368 OH_Drawing_FilterDestroy(filter2); 1369 OH_Drawing_PenDestroy(pen); 1370 } 1371 1372 /* 1373 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_PEN_2201 1374 * @tc.name: testPenGetFilterNull 1375 * @tc.desc: test for testPenGetFilterNull. 1376 * @tc.size : SmallTest 1377 * @tc.type : Function 1378 * @tc.level : Level 3 1379 */ 1380 HWTEST_F(DrawingNativePenTest, testPenGetFilterNull, TestSize.Level3) { 1381 // 1. Create a pen object using OH_Drawing_PenCreate 1382 OH_Drawing_Pen *pen = OH_Drawing_PenCreate(); 1383 // add assert 1384 EXPECT_NE(pen, nullptr); 1385 // 2. Create a filter object using OH_Drawing_FilterCreate 1386 OH_Drawing_Filter *filter = OH_Drawing_FilterCreate(); 1387 // add assert 1388 EXPECT_NE(filter, nullptr); 1389 // 3. Call OH_Drawing_PenGetFilter with nullptr as the first parameter 1390 OH_Drawing_PenGetFilter(nullptr, filter); 1391 // add assert 1392 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 1393 OH_Drawing_ErrorCodeReset(); 1394 // 4. Call OH_Drawing_PenGetFilter with nullptr as the second parameter 1395 OH_Drawing_PenGetFilter(pen, nullptr); 1396 // add assert 1397 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 1398 // 5. Free the memory 1399 OH_Drawing_FilterDestroy(filter); 1400 OH_Drawing_PenDestroy(pen); 1401 } 1402 1403 /* 1404 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_PEN_2300 1405 * @tc.name: testPenSetBlendModeNormal 1406 * @tc.desc: test for testPenSetBlendModeNormal. 1407 * @tc.size : SmallTest 1408 * @tc.type : Function 1409 * @tc.level : Level 0 1410 */ 1411 HWTEST_F(DrawingNativePenTest, testPenSetBlendModeNormal, TestSize.Level0) { 1412 // 1. Create a pen object using OH_Drawing_PenCreate 1413 OH_Drawing_Pen *pen = OH_Drawing_PenCreate(); 1414 // add assert 1415 EXPECT_NE(pen, nullptr); 1416 // 2. Use a loop to iterate through the enum values of OH_Drawing_BlendMode and call OH_Drawing_PenSetBlendMode with 1417 // the second parameter 1418 OH_Drawing_BlendMode modes[] = {BLEND_MODE_CLEAR, BLEND_MODE_SRC, BLEND_MODE_DST}; 1419 for (int i = 0; i < 3; i++) { 1420 OH_Drawing_ErrorCodeReset(); 1421 OH_Drawing_PenSetBlendMode(pen, modes[i]); 1422 // add assert 1423 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 1424 } 1425 // 3. Free the memory 1426 OH_Drawing_PenDestroy(pen); 1427 } 1428 1429 /* 1430 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_PEN_2301 1431 * @tc.name: testPenSetBlendModeNull 1432 * @tc.desc: test for testPenSetBlendModeNull. 1433 * @tc.size : SmallTest 1434 * @tc.type : Function 1435 * @tc.level : Level 3 1436 */ 1437 HWTEST_F(DrawingNativePenTest, testPenSetBlendModeNull, TestSize.Level3) { 1438 // 1. Create a pen object using OH_Drawing_PenCreate 1439 OH_Drawing_Pen *pen = OH_Drawing_PenCreate(); 1440 // add assert 1441 EXPECT_NE(pen, nullptr); 1442 // 2. Call OH_Drawing_PenSetBlendMode with nullptr as the first parameter 1443 OH_Drawing_PenSetBlendMode(nullptr, BLEND_MODE_CLEAR); 1444 // add assert 1445 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 1446 // 3. Free the memory 1447 OH_Drawing_PenDestroy(pen); 1448 } 1449 1450 /* 1451 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_PEN_2400 1452 * @tc.name: testPenGetFillPathNormal 1453 * @tc.desc: test for testPenGetFillPathNormal. 1454 * @tc.size : SmallTest 1455 * @tc.type : Function 1456 * @tc.level : Level 0 1457 */ 1458 HWTEST_F(DrawingNativePenTest, testPenGetFillPathNormal, TestSize.Level0) { 1459 // 1. Create a pen object using OH_Drawing_PenCreate 1460 OH_Drawing_Pen *pen = OH_Drawing_PenCreate(); 1461 // add assert 1462 EXPECT_NE(pen, nullptr); 1463 // 2. Create a source path object using OH_Drawing_PathCreate 1464 OH_Drawing_Path *srcPath = OH_Drawing_PathCreate(); 1465 // add assert 1466 EXPECT_NE(srcPath, nullptr); 1467 // 3. Create a destination path object using OH_Drawing_PathCreate 1468 OH_Drawing_Path *dstPath = OH_Drawing_PathCreate(); 1469 // add assert 1470 EXPECT_NE(dstPath, nullptr); 1471 // 4. Create a rectangle object using OH_Drawing_RectCreate 1472 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(100, 100, 200, 200); 1473 // add assert 1474 EXPECT_NE(rect, nullptr); 1475 // 5. Create a matrix object using OH_Drawing_MatrixCreate 1476 OH_Drawing_Matrix *matrix = OH_Drawing_MatrixCreate(); 1477 // add assert 1478 EXPECT_NE(matrix, nullptr); 1479 // 6. Call OH_Drawing_PenGetFillPath 1480 bool isSuccess = OH_Drawing_PenGetFillPath(pen, srcPath, dstPath, rect, matrix); 1481 // add assert 1482 EXPECT_EQ(isSuccess, false); 1483 // add assert 1484 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 1485 // 7. Free the memory 1486 OH_Drawing_PathDestroy(srcPath); 1487 OH_Drawing_PathDestroy(dstPath); 1488 OH_Drawing_RectDestroy(rect); 1489 OH_Drawing_MatrixDestroy(matrix); 1490 OH_Drawing_PenDestroy(pen); 1491 } 1492 1493 /* 1494 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_PEN_2401 1495 * @tc.name: testPenGetFillPathNull 1496 * @tc.desc: test for testPenGetFillPathNull. 1497 * @tc.size : SmallTest 1498 * @tc.type : Function 1499 * @tc.level : Level 3 1500 */ 1501 HWTEST_F(DrawingNativePenTest, testPenGetFillPathNull, TestSize.Level3) { 1502 // 1. Create a pen object using OH_Drawing_PenCreate 1503 OH_Drawing_Pen *pen = OH_Drawing_PenCreate(); 1504 // add assert 1505 EXPECT_NE(pen, nullptr); 1506 // 2. Create a source path object using OH_Drawing_PathCreate 1507 OH_Drawing_Path *srcPath = OH_Drawing_PathCreate(); 1508 // add assert 1509 EXPECT_NE(srcPath, nullptr); 1510 // 3. Create a destination path object using OH_Drawing_PathCreate 1511 OH_Drawing_Path *dstPath = OH_Drawing_PathCreate(); 1512 // add assert 1513 EXPECT_NE(dstPath, nullptr); 1514 // 4. Create a rectangle object using OH_Drawing_RectCreate 1515 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(100, 100, 200, 200); 1516 // add assert 1517 EXPECT_NE(rect, nullptr); 1518 // 5. Create a matrix object using OH_Drawing_MatrixCreate 1519 OH_Drawing_Matrix *matrix = OH_Drawing_MatrixCreate(); 1520 // add assert 1521 EXPECT_NE(matrix, nullptr); 1522 // 6. Call OH_Drawing_PenGetFillPath with nullptr as the first parameter 1523 OH_Drawing_PenGetFillPath(nullptr, srcPath, dstPath, rect, matrix); 1524 // add assert 1525 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 1526 OH_Drawing_ErrorCodeReset(); 1527 // 7. Call OH_Drawing_PenGetFillPath with nullptr as the second parameter 1528 OH_Drawing_PenGetFillPath(pen, nullptr, dstPath, rect, matrix); 1529 // add assert 1530 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 1531 OH_Drawing_ErrorCodeReset(); 1532 // 8. Call OH_Drawing_PenGetFillPath with nullptr as the third parameter 1533 OH_Drawing_PenGetFillPath(pen, srcPath, nullptr, rect, matrix); 1534 // add assert 1535 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 1536 // 9. Call OH_Drawing_PenGetFillPath with nullptr as the fourth parameter 1537 bool isSuccess1 = OH_Drawing_PenGetFillPath(pen, srcPath, dstPath, nullptr, matrix); 1538 // add assert 1539 EXPECT_EQ(isSuccess1, false); 1540 // 10. Call OH_Drawing_PenGetFillPath with nullptr as the fifth parameter 1541 bool isSuccess2 = OH_Drawing_PenGetFillPath(pen, srcPath, dstPath, rect, nullptr); 1542 // add assert 1543 EXPECT_EQ(isSuccess2, false); 1544 // 11. Free the memory 1545 OH_Drawing_PathDestroy(srcPath); 1546 OH_Drawing_PathDestroy(dstPath); 1547 OH_Drawing_RectDestroy(rect); 1548 OH_Drawing_MatrixDestroy(matrix); 1549 OH_Drawing_PenDestroy(pen); 1550 } 1551 1552 /* 1553 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_PEN_2500 1554 * @tc.name: testPenResetNormal 1555 * @tc.desc: test for testPenResetNormal. 1556 * @tc.size : SmallTest 1557 * @tc.type : Function 1558 * @tc.level : Level 0 1559 */ 1560 HWTEST_F(DrawingNativePenTest, testPenResetNormal, TestSize.Level0) { 1561 // 1. Create a pen object using OH_Drawing_PenCreate 1562 OH_Drawing_Pen *pen = OH_Drawing_PenCreate(); 1563 // add assert 1564 EXPECT_NE(pen, nullptr); 1565 // 2. Set the pen color using OH_Drawing_PenSetColor 1566 OH_Drawing_PenSetColor(pen, 0xff0000ff); 1567 // 3. Get the pen color using OH_Drawing_PenGetColor 1568 uint32_t color = OH_Drawing_PenGetColor(pen); 1569 EXPECT_EQ(0xff0000ff, color); 1570 // 4. Reset the pen state using OH_Drawing_PenReset 1571 OH_Drawing_PenReset(pen); 1572 // add assert 1573 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 1574 // 5. Get the pen color using OH_Drawing_PenGetColor 1575 color = OH_Drawing_PenGetColor(pen); 1576 OH_Drawing_Pen *pen2 = OH_Drawing_PenCreate(); 1577 // add assert 1578 EXPECT_NE(pen2, nullptr); 1579 uint32_t color2 = OH_Drawing_PenGetColor(pen2); 1580 EXPECT_EQ(color2, color); 1581 // 6. Free the memory 1582 OH_Drawing_PenDestroy(pen); 1583 } 1584 1585 /* 1586 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_PEN_2501 1587 * @tc.name: testPenResetNull 1588 * @tc.desc: test for testPenResetNull. 1589 * @tc.size : SmallTest 1590 * @tc.type : Function 1591 * @tc.level : Level 3 1592 */ 1593 HWTEST_F(DrawingNativePenTest, testPenResetNull, TestSize.Level3) { 1594 // 1. Create a pen object using OH_Drawing_PenCreate 1595 OH_Drawing_Pen *pen = OH_Drawing_PenCreate(); 1596 // add assert 1597 EXPECT_NE(pen, nullptr); 1598 // 2. Call OH_Drawing_PenReset with nullptr as the parameter 1599 OH_Drawing_PenReset(nullptr); 1600 // add assert 1601 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 1602 // 3. Free the memory 1603 OH_Drawing_PenDestroy(pen); 1604 } 1605 1606 /* 1607 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_PEN_2502 1608 * @tc.name: testPenResetMultipleCalls 1609 * @tc.desc: test for testPenResetMultipleCalls. 1610 * @tc.size : SmallTest 1611 * @tc.type : Function 1612 * @tc.level : Level 3 1613 */ 1614 HWTEST_F(DrawingNativePenTest, testPenResetMultipleCalls, TestSize.Level3) { 1615 // 1. Create a pen object using OH_Drawing_PenCreate 1616 OH_Drawing_Pen *pen = OH_Drawing_PenCreate(); 1617 // add assert 1618 EXPECT_NE(pen, nullptr); 1619 // 2. Use a loop to call OH_Drawing_PenSetColor and set the pen color 10 times 1620 for (int i = 0; i < 10; i++) { 1621 OH_Drawing_PenSetColor(pen, 0xff0000ff); 1622 } 1623 // 3. Use a loop to call OH_Drawing_PenGetColor and get the pen color 10 times 1624 for (int i = 0; i < 10; i++) { 1625 OH_Drawing_PenGetColor(pen); 1626 } 1627 // 4. Use a loop to call OH_Drawing_PenReset and reset the pen state 10 times 1628 for (int i = 0; i < 10; i++) { 1629 OH_Drawing_PenReset(pen); 1630 } 1631 // 5. Use a loop to call OH_Drawing_PenGetColor and get the pen color 10 times 1632 for (int i = 0; i < 10; i++) { 1633 OH_Drawing_PenGetColor(pen); 1634 } 1635 // 6. Free the memory 1636 OH_Drawing_PenDestroy(pen); 1637 } 1638 1639 } // namespace Drawing 1640 } // namespace Rosen 1641 } // namespace OHOS