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_bitmap.h" 19 #include "drawing_brush.h" 20 #include "drawing_canvas.h" 21 #include "drawing_color.h" 22 #include "drawing_color_filter.h" 23 #include "drawing_filter.h" 24 #include "drawing_font.h" 25 #include "drawing_image.h" 26 #include "drawing_mask_filter.h" 27 #include "drawing_matrix.h" 28 #include "drawing_memory_stream.h" 29 #include "drawing_path.h" 30 #include "drawing_pen.h" 31 #include "drawing_point.h" 32 #include "drawing_rect.h" 33 #include "drawing_region.h" 34 #include "drawing_round_rect.h" 35 #include "drawing_sampling_options.h" 36 #include "drawing_shader_effect.h" 37 #include "drawing_text_blob.h" 38 #include "drawing_typeface.h" 39 40 using namespace testing; 41 using namespace testing::ext; 42 43 namespace OHOS { 44 namespace Rosen { 45 namespace Drawing { 46 class DrawingNativeTextBlobTest : public testing::Test { 47 protected: 48 // 在每个测试用例执行前调用 SetUp()49 void SetUp() override 50 { 51 // 设置代码 52 std::cout << "DrawingNativeTextBlobTest Setup code called before each test case." << std::endl; 53 OH_Drawing_ErrorCodeReset(); 54 std::cout << "DrawingNativeTextBlobTest errorCodeReset before each test case." << std::endl; 55 } TearDown()56 void TearDown() override 57 { 58 std::cout << "DrawingNativeTextBlobTest Setup code called after each test case." << std::endl; 59 OH_Drawing_ErrorCodeReset(); 60 std::cout << "DrawingNativeTextBlobTest errorCodeReset after each test case." << std::endl; 61 } 62 }; 63 64 /* 65 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_TEXTBLOB_0100 66 * @tc.name: testTextBlobBuilderCreateDestroyNormal 67 * @tc.desc: test for testTextBlobBuilderCreateDestroyNormal. 68 * @tc.size : SmallTest 69 * @tc.type : Function 70 * @tc.level : Level 0 71 */ 72 HWTEST_F(DrawingNativeTextBlobTest, testTextBlobBuilderCreateDestroyNormal, Function | SmallTest | Level0) { 73 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 74 EXPECT_NE(nullptr, canvas); 75 // 1. Use OH_Drawing_TextBlobBuilderCreate and OH_Drawing_CanvasDrawTextBlob together 76 OH_Drawing_TextBlobBuilder *builder = OH_Drawing_TextBlobBuilderCreate(); 77 // add assert 78 EXPECT_NE(builder, nullptr); 79 OH_Drawing_TextBlob *textBlob = OH_Drawing_TextBlobBuilderMake(builder); 80 OH_Drawing_CanvasDrawTextBlob(canvas, textBlob, 0, 0); 81 // add assert 82 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 83 if (0) { 84 // todo cpp crash 85 // 2. OH_Drawing_TextBlobBuilderDestroy 86 OH_Drawing_TextBlobBuilderDestroy(builder); 87 } 88 OH_Drawing_CanvasDestroy(canvas); 89 } 90 91 /* 92 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_TEXTBLOB_0101 93 * @tc.name: testTextBlobBuilderCreateDestroyNull 94 * @tc.desc: test for testTextBlobBuilderCreateDestroyNull. 95 * @tc.size : SmallTest 96 * @tc.type : Function 97 * @tc.level : Level 3 98 */ 99 HWTEST_F(DrawingNativeTextBlobTest, testTextBlobBuilderCreateDestroyNull, Function | SmallTest | Level3) { 100 // 1. OH_Drawing_TextBlobBuilderDestroy with nullptr parameter 101 OH_Drawing_TextBlobBuilderDestroy(nullptr); 102 // add assert 103 EXPECT_TRUE(true); 104 } 105 106 /* 107 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_TEXTBLOB_0102 108 * @tc.name: testTextBlobBuilderCreateDestroyMultipleCalls 109 * @tc.desc: test for testTextBlobBuilderCreateDestroyMultipleCalls. 110 * @tc.size : SmallTest 111 * @tc.type : Function 112 * @tc.level : Level 3 113 */ 114 HWTEST_F(DrawingNativeTextBlobTest, testTextBlobBuilderCreateDestroyMultipleCalls, Function | SmallTest | Level3) { 115 OH_Drawing_TextBlobBuilder *builders[10]; 116 // 1. Call OH_Drawing_TextBlobBuilderCreate 10 times 117 for (int i = 0; i < 10; i++) { 118 builders[i] = OH_Drawing_TextBlobBuilderCreate(); 119 EXPECT_NE(nullptr, builders[i]); 120 } 121 // 2. Call OH_Drawing_TextBlobBuilderDestroy 10 times 122 for (int i = 0; i < 10; i++) { 123 if (0) { 124 // todo cpp crash 125 OH_Drawing_TextBlobBuilderDestroy(builders[i]); 126 } 127 } 128 // 3. Call OH_Drawing_TextBlobBuilderCreate and OH_Drawing_TextBlobBuilderDestroy alternately 10 times 129 for (int i = 0; i < 10; i++) { 130 OH_Drawing_TextBlobBuilder *builder = OH_Drawing_TextBlobBuilderCreate(); 131 EXPECT_NE(nullptr, builder); 132 if (0) { 133 // todo cpp crash 134 OH_Drawing_TextBlobBuilderDestroy(builder); 135 } 136 } 137 } 138 139 /* 140 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_TEXTBLOB_0200 141 * @tc.name: testTextBlobCreateFromTextNormal 142 * @tc.desc: test for testTextBlobCreateFromTextNormal. 143 * @tc.size : SmallTest 144 * @tc.type : Function 145 * @tc.level : Level 0 146 */ 147 HWTEST_F(DrawingNativeTextBlobTest, testTextBlobCreateFromTextNormal, Function | SmallTest | Level0) { 148 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 149 EXPECT_NE(nullptr, canvas); 150 // 1. Traverse the enumeration values of OH_Drawing_TextEncoding and use OH_Drawing_CanvasDrawTextBlob in 151 // combination 152 const char *str = "123456"; 153 char16_t c[] = {1, 2, 3}; 154 OH_Drawing_Font *font = OH_Drawing_FontCreate(); 155 EXPECT_NE(font, nullptr); 156 OH_Drawing_Typeface *typeSurface = OH_Drawing_TypefaceCreateDefault(); 157 OH_Drawing_FontSetTypeface(font, typeSurface); 158 OH_Drawing_TextEncoding encodeArray[] = { 159 TEXT_ENCODING_UTF8, 160 TEXT_ENCODING_UTF32, 161 TEXT_ENCODING_GLYPH_ID, 162 }; 163 for (OH_Drawing_TextEncoding encode : encodeArray) { 164 size_t byteLength = 0; 165 if (encode == TEXT_ENCODING_UTF8) { 166 byteLength = strlen(str); 167 } else if (encode == TEXT_ENCODING_UTF32) { 168 byteLength = strlen(str) * 4; 169 } else if (encode == TEXT_ENCODING_GLYPH_ID) { 170 byteLength = strlen(str) * 16; 171 } 172 OH_Drawing_TextBlob *textBlob = OH_Drawing_TextBlobCreateFromText(str, byteLength, font, encode); 173 // add assert 174 EXPECT_NE(textBlob, nullptr); 175 OH_Drawing_ErrorCodeReset(); 176 OH_Drawing_CanvasDrawTextBlob(canvas, textBlob, 0, 0); 177 // add assert 178 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_SUCCESS); 179 } 180 OH_Drawing_TextBlob *textBlob2 = OH_Drawing_TextBlobCreateFromText(c, 6, font, TEXT_ENCODING_UTF16); 181 // add assert 182 EXPECT_NE(textBlob2, nullptr); 183 OH_Drawing_ErrorCodeReset(); 184 OH_Drawing_CanvasDrawTextBlob(canvas, textBlob2, 0, 0); 185 // add assert 186 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_SUCCESS); 187 // 2. free memory 188 OH_Drawing_FontDestroy(font); 189 OH_Drawing_TypefaceDestroy(typeSurface); 190 OH_Drawing_CanvasDestroy(canvas); 191 } 192 193 /* 194 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_TEXTBLOB_0201 195 * @tc.name: testTextBlobCreateFromTextNull 196 * @tc.desc: test for testTextBlobCreateFromTextNull. 197 * @tc.size : SmallTest 198 * @tc.type : Function 199 * @tc.level : Level 3 200 */ 201 HWTEST_F(DrawingNativeTextBlobTest, testTextBlobCreateFromTextNull, Function | SmallTest | Level3) { 202 const char *str = "123456"; 203 OH_Drawing_Font *font = OH_Drawing_FontCreate(); 204 EXPECT_NE(font, nullptr); 205 OH_Drawing_Typeface *typeSurface = OH_Drawing_TypefaceCreateDefault(); 206 OH_Drawing_FontSetTypeface(font, typeSurface); 207 // 1. OH_Drawing_TextBlobCreateFromText with the first parameter being nullptr, check the error code with 208 // OH_Drawing_ErrorCodeGet 209 OH_Drawing_TextBlob *textBlob1 = OH_Drawing_TextBlobCreateFromText(nullptr, strlen(str), font, TEXT_ENCODING_UTF8); 210 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER); 211 OH_Drawing_ErrorCodeReset(); 212 // 2. OH_Drawing_TextBlobCreateFromText with the second parameter being empty, check the error code with 213 // OH_Drawing_ErrorCodeGet 214 OH_Drawing_TextBlob *textBlob2 = OH_Drawing_TextBlobCreateFromText(str, 0, font, TEXT_ENCODING_UTF8); 215 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_SUCCESS); 216 OH_Drawing_ErrorCodeReset(); 217 // 3. OH_Drawing_TextBlobCreateFromText with the third parameter being nullptr, check the error code with 218 // OH_Drawing_ErrorCodeGet 219 OH_Drawing_TextBlob *textBlob3 = OH_Drawing_TextBlobCreateFromText(str, strlen(str), nullptr, TEXT_ENCODING_UTF8); 220 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER); 221 // 4. OH_Drawing_TextBlobCreateFromText with the first parameter being a string 222 OH_Drawing_TextBlob *textBlob4 = OH_Drawing_TextBlobCreateFromText("123456", 6, font, TEXT_ENCODING_UTF8); 223 // 5. Free memory 224 OH_Drawing_FontDestroy(font); 225 OH_Drawing_TypefaceDestroy(typeSurface); 226 OH_Drawing_TextBlobDestroy(textBlob1); 227 OH_Drawing_TextBlobDestroy(textBlob2); 228 OH_Drawing_TextBlobDestroy(textBlob3); 229 OH_Drawing_TextBlobDestroy(textBlob4); 230 } 231 232 /* 233 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_TEXTBLOB_0203 234 * @tc.name: testTextBlobCreateFromTextMultipleCalls 235 * @tc.desc: test for testTextBlobCreateFromTextMultipleCalls. 236 * @tc.size : SmallTest 237 * @tc.type : Function 238 * @tc.level : Level 3 239 */ 240 HWTEST_F(DrawingNativeTextBlobTest, testTextBlobCreateFromTextMultipleCalls, Function | SmallTest | Level3) { 241 const char *strs[] = { 242 "Hello World", "你好世界", "Hello 世界", "Hello 世界123", "Hello $#@!", "繁體中文", 243 }; 244 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 245 EXPECT_NE(nullptr, canvas); 246 OH_Drawing_Font *font = OH_Drawing_FontCreate(); 247 EXPECT_NE(font, nullptr); 248 OH_Drawing_Typeface *typeSurface = OH_Drawing_TypefaceCreateDefault(); 249 // add assert 250 EXPECT_NE(typeSurface, nullptr); 251 OH_Drawing_FontSetTypeface(font, typeSurface); 252 // 1. Call OH_Drawing_TextBlobCreateFromText 10 times (passing in different types of strings with different lengths, 253 // such as Chinese, English, special characters, numbers, traditional Chinese characters, etc.) and use 254 // OH_Drawing_CanvasDrawTextBlob in combination 255 for (int i = 0; i < 10; i++) { 256 const char *str = strs[i % 6]; 257 OH_Drawing_TextBlob *textBlob = OH_Drawing_TextBlobCreateFromText(str, strlen(str), font, TEXT_ENCODING_UTF8); 258 // add assert 259 EXPECT_NE(textBlob, nullptr); 260 OH_Drawing_CanvasDrawTextBlob(canvas, textBlob, 0, 0); 261 OH_Drawing_TextBlobDestroy(textBlob); 262 } 263 // 2. Free memory 264 OH_Drawing_FontDestroy(font); 265 OH_Drawing_TypefaceDestroy(typeSurface); 266 OH_Drawing_CanvasDestroy(canvas); 267 } 268 269 /* 270 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_TEXTBLOB_0204 271 * @tc.name: testTextBlobCreateFromTextAbnormal 272 * @tc.desc: test for testTextBlobCreateFromTextAbnormal. 273 * @tc.size : SmallTest 274 * @tc.type : Function 275 * @tc.level : Level 3 276 */ 277 HWTEST_F(DrawingNativeTextBlobTest, testTextBlobCreateFromTextAbnormal, Function | SmallTest | Level3) { 278 const char *str = "123456"; 279 OH_Drawing_Font *font = OH_Drawing_FontCreate(); 280 EXPECT_NE(font, nullptr); 281 OH_Drawing_Typeface *typeSurface = OH_Drawing_TypefaceCreateDefault(); 282 // add assert 283 EXPECT_NE(typeSurface, nullptr); 284 OH_Drawing_FontSetTypeface(font, typeSurface); 285 // 1. OH_Drawing_TextBlobCreateFromText interface with OH_Drawing_TextEncoding out of range, check the error code 286 // with OH_Drawing_ErrorCodeGet 287 OH_Drawing_TextBlob *textBlob = 288 OH_Drawing_TextBlobCreateFromText(str, strlen(str), font, static_cast<OH_Drawing_TextEncoding>(-1)); 289 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_PARAMETER_OUT_OF_RANGE); 290 // 2. Free memory 291 OH_Drawing_FontDestroy(font); 292 OH_Drawing_TextBlobDestroy(textBlob); 293 OH_Drawing_TypefaceDestroy(typeSurface); 294 } 295 296 /* 297 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_TEXTBLOB_0300 298 * @tc.name: testTextBlobCreateFromPosTextNormal 299 * @tc.desc: test for testTextBlobCreateFromPosTextNormal. 300 * @tc.size : SmallTest 301 * @tc.type : Function 302 * @tc.level : Level 0 303 */ 304 HWTEST_F(DrawingNativeTextBlobTest, testTextBlobCreateFromPosTextNormal, Function | SmallTest | Level0) { 305 const char *str = "123456"; 306 OH_Drawing_Font *font = OH_Drawing_FontCreate(); 307 EXPECT_NE(font, nullptr); 308 OH_Drawing_Typeface *typeSurface = OH_Drawing_TypefaceCreateDefault(); 309 OH_Drawing_FontSetTypeface(font, typeSurface); 310 // 1. Traverse the enumeration values of OH_Drawing_TextEncoding and use OH_Drawing_CanvasDrawTextBlob in 311 // combination 312 size_t byteLength = strlen(str); 313 int count = OH_Drawing_FontCountText(font, str, byteLength, TEXT_ENCODING_UTF8); 314 OH_Drawing_Point2D pts[count]; 315 OH_Drawing_TextBlobCreateFromPosText(str, count, &pts[0], font, TEXT_ENCODING_UTF8); 316 // add assert 317 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_SUCCESS); 318 // 2. Free memory 319 OH_Drawing_FontDestroy(font); 320 OH_Drawing_TypefaceDestroy(typeSurface); 321 } 322 323 /* 324 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_TEXTBLOB_0301 325 * @tc.name: testTextBlobCreateFromPosTextNull 326 * @tc.desc: test for testTextBlobCreateFromPosTextNull. 327 * @tc.size : SmallTest 328 * @tc.type : Function 329 * @tc.level : Level 3 330 */ 331 HWTEST_F(DrawingNativeTextBlobTest, testTextBlobCreateFromPosTextNull, Function | SmallTest | Level3) { 332 const char *str = "123456"; 333 OH_Drawing_Font *font = OH_Drawing_FontCreate(); 334 EXPECT_NE(font, nullptr); 335 OH_Drawing_Typeface *typeSurface = OH_Drawing_TypefaceCreateDefault(); 336 // add assert 337 EXPECT_NE(typeSurface, nullptr); 338 OH_Drawing_FontSetTypeface(font, typeSurface); 339 int count = OH_Drawing_FontCountText(font, str, strlen(str), TEXT_ENCODING_UTF8); 340 OH_Drawing_Point2D pts[count]; 341 // 1. OH_Drawing_TextBlobCreateFromPosText with the first parameter being nullptr, check the error code with 342 // OH_Drawing_ErrorCodeGet 343 OH_Drawing_TextBlobCreateFromPosText(nullptr, strlen(str), &pts[0], font, TEXT_ENCODING_UTF8); 344 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER); 345 OH_Drawing_ErrorCodeReset(); 346 // 2. OH_Drawing_TextBlobCreateFromPosText with the second parameter being empty, check the error code with 347 // OH_Drawing_ErrorCodeGet 348 OH_Drawing_TextBlobCreateFromPosText(str, 0, &pts[0], font, TEXT_ENCODING_UTF8); 349 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER); 350 OH_Drawing_ErrorCodeReset(); 351 // 3. OH_Drawing_TextBlobCreateFromPosText with the third parameter being nullptr, check the error code with 352 // OH_Drawing_ErrorCodeGet 353 OH_Drawing_TextBlobCreateFromPosText(str, strlen(str), nullptr, font, TEXT_ENCODING_UTF8); 354 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER); 355 OH_Drawing_ErrorCodeReset(); 356 // 4. OH_Drawing_TextBlobCreateFromPosText with the first parameter being a string 357 OH_Drawing_TextBlobCreateFromPosText("123456", 6, &pts[0], font, TEXT_ENCODING_UTF8); 358 // 5. OH_Drawing_TextBlobCreateFromPosText with the fourth parameter being nullptr, check the error code with 359 // OH_Drawing_ErrorCodeGet 360 OH_Drawing_TextBlobCreateFromPosText(str, strlen(str), &pts[0], nullptr, TEXT_ENCODING_UTF8); 361 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER); 362 // 6. Free memory 363 OH_Drawing_FontDestroy(font); 364 OH_Drawing_TypefaceDestroy(typeSurface); 365 } 366 367 /* 368 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_TEXTBLOB_0302 369 * @tc.name: testTextBlobCreateFromPosTextMultipleCalls 370 * @tc.desc: test for testTextBlobCreateFromPosTextMultipleCalls. 371 * @tc.size : SmallTest 372 * @tc.type : Function 373 * @tc.level : Level 3 374 */ 375 HWTEST_F(DrawingNativeTextBlobTest, testTextBlobCreateFromPosTextMultipleCalls, Function | SmallTest | Level3) { 376 const char *strs[] = { 377 "Hello World", "你好世界", "Hello 世界", "Hello 世界123", "Hello $#@!", "繁體中文", 378 }; 379 OH_Drawing_Font *font = OH_Drawing_FontCreate(); 380 EXPECT_NE(font, nullptr); 381 OH_Drawing_Typeface *typeSurface = OH_Drawing_TypefaceCreateDefault(); 382 // add assert 383 EXPECT_NE(typeSurface, nullptr); 384 OH_Drawing_FontSetTypeface(font, typeSurface); 385 // 1. Call OH_Drawing_TextBlobCreateFromPosText 10 times (passing in different types of strings with different 386 // lengths, such as Chinese, English, special characters, numbers, traditional Chinese characters, etc.) and use 387 // OH_Drawing_CanvasDrawTextBlob in combination 388 for (int i = 0; i < 10; i++) { 389 const char *str = strs[i % 6]; 390 int count = OH_Drawing_FontCountText(font, str, strlen(str), TEXT_ENCODING_UTF8); 391 OH_Drawing_Point2D pts[count]; 392 OH_Drawing_TextBlobCreateFromPosText(str, strlen(str), &pts[0], font, TEXT_ENCODING_UTF8); 393 // add assert 394 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_SUCCESS); 395 } 396 // 2. Free memory 397 OH_Drawing_FontDestroy(font); 398 OH_Drawing_TypefaceDestroy(typeSurface); 399 } 400 401 /* 402 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_TEXTBLOB_0303 403 * @tc.name: testTextBlobCreateFromPosTextAbnormal 404 * @tc.desc: test for testTextBlobCreateFromPosTextAbnormal. 405 * @tc.size : SmallTest 406 * @tc.type : Function 407 * @tc.level : Level 3 408 */ 409 HWTEST_F(DrawingNativeTextBlobTest, testTextBlobCreateFromPosTextAbnormal, Function | SmallTest | Level3) { 410 const char *str = "123456"; 411 OH_Drawing_Font *font = OH_Drawing_FontCreate(); 412 EXPECT_NE(font, nullptr); 413 OH_Drawing_Typeface *typeSurface = OH_Drawing_TypefaceCreateDefault(); 414 // add assert 415 EXPECT_NE(typeSurface, nullptr); 416 OH_Drawing_FontSetTypeface(font, typeSurface); 417 int count = OH_Drawing_FontCountText(font, str, strlen(str), TEXT_ENCODING_UTF8); 418 OH_Drawing_Point2D pts[count]; 419 // 1. Call OH_Drawing_TextBlobCreateFromPosText interface with OH_Drawing_TextEncoding out of range, check the error 420 // code with OH_Drawing_ErrorCodeGet 421 OH_Drawing_TextBlobCreateFromPosText(str, strlen(str), &pts[0], font, static_cast<OH_Drawing_TextEncoding>(-1)); 422 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_PARAMETER_OUT_OF_RANGE); 423 // 2. Free memory 424 OH_Drawing_FontDestroy(font); 425 OH_Drawing_TypefaceDestroy(typeSurface); 426 } 427 428 /* 429 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_TEXTBLOB_0400 430 * @tc.name: testTextBlobCreateFromStringNormal 431 * @tc.desc: test for testTextBlobCreateFromStringNormal. 432 * @tc.size : SmallTest 433 * @tc.type : Function 434 * @tc.level : Level 0 435 */ 436 HWTEST_F(DrawingNativeTextBlobTest, testTextBlobCreateFromStringNormal, Function | SmallTest | Level0) { 437 const char *str = "123456"; 438 OH_Drawing_Font *font = OH_Drawing_FontCreate(); 439 EXPECT_NE(font, nullptr); 440 OH_Drawing_Typeface *typeSurface = OH_Drawing_TypefaceCreateDefault(); 441 // add assert 442 EXPECT_NE(typeSurface, nullptr); 443 OH_Drawing_FontSetTypeface(font, typeSurface); 444 OH_Drawing_TextEncoding encodeArray[] = { 445 TEXT_ENCODING_UTF8, 446 TEXT_ENCODING_UTF32, 447 TEXT_ENCODING_GLYPH_ID, 448 }; 449 // 1. Traverse the enumeration values of OH_Drawing_TextEncoding and use OH_Drawing_CanvasDrawTextBlob in 450 // combination 451 for (OH_Drawing_TextEncoding encode : encodeArray) { 452 OH_Drawing_TextBlob *textBlob = OH_Drawing_TextBlobCreateFromString(str, font, encode); 453 // add assert 454 EXPECT_NE(textBlob, nullptr); 455 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 456 EXPECT_NE(nullptr, canvas); 457 OH_Drawing_ErrorCodeReset(); 458 OH_Drawing_CanvasDrawTextBlob(canvas, textBlob, 0, 0); 459 // add assert 460 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_SUCCESS); 461 OH_Drawing_CanvasDestroy(canvas); 462 } 463 // 2. Free memory 464 OH_Drawing_FontDestroy(font); 465 OH_Drawing_TypefaceDestroy(typeSurface); 466 } 467 468 /* 469 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_TEXTBLOB_0401 470 * @tc.name: testTextBlobCreateFromStringNull 471 * @tc.desc: test for testTextBlobCreateFromStringNull. 472 * @tc.size : SmallTest 473 * @tc.type : Function 474 * @tc.level : Level 3 475 */ 476 HWTEST_F(DrawingNativeTextBlobTest, testTextBlobCreateFromStringNull, Function | SmallTest | Level3) { 477 const char *str = "123456"; 478 OH_Drawing_Font *font = OH_Drawing_FontCreate(); 479 EXPECT_NE(font, nullptr); 480 OH_Drawing_Typeface *typeSurface = OH_Drawing_TypefaceCreateDefault(); 481 // add assert 482 EXPECT_NE(typeSurface, nullptr); 483 OH_Drawing_FontSetTypeface(font, typeSurface); 484 // 1. OH_Drawing_TextBlobCreateFromString with the first parameter being nullptr, check the error code with 485 // OH_Drawing_ErrorCodeGet 486 OH_Drawing_TextBlob *textBlob1 = OH_Drawing_TextBlobCreateFromString(nullptr, font, TEXT_ENCODING_UTF8); 487 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER); 488 OH_Drawing_ErrorCodeReset(); 489 // 2. OH_Drawing_TextBlobCreateFromString with the second parameter being nullptr, check the error code with 490 // OH_Drawing_ErrorCodeGet 491 OH_Drawing_TextBlob *textBlob2 = OH_Drawing_TextBlobCreateFromString(str, nullptr, TEXT_ENCODING_UTF8); 492 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER); 493 // 3. OH_Drawing_TextBlobCreateFromPosText with the first parameter being a string 494 OH_Drawing_TextBlob *textBlob3 = OH_Drawing_TextBlobCreateFromString("123456", font, TEXT_ENCODING_UTF8); 495 // 4. Free memory 496 OH_Drawing_FontDestroy(font); 497 OH_Drawing_TextBlobDestroy(textBlob1); 498 OH_Drawing_TextBlobDestroy(textBlob2); 499 OH_Drawing_TextBlobDestroy(textBlob3); 500 OH_Drawing_TypefaceDestroy(typeSurface); 501 } 502 503 /* 504 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_TEXTBLOB_0402 505 * @tc.name: testTextBlobCreateFromStringMultipleCalls 506 * @tc.desc: test for testTextBlobCreateFromStringMultipleCalls. 507 * @tc.size : SmallTest 508 * @tc.type : Function 509 * @tc.level : Level 3 510 */ 511 HWTEST_F(DrawingNativeTextBlobTest, testTextBlobCreateFromStringMultipleCalls, Function | SmallTest | Level3) { 512 const char *strs[] = { 513 "Hello World", "你好世界", "Hello 世界", "Hello 世界123", "Hello $#@!", "繁體中文", 514 }; 515 OH_Drawing_Font *font = OH_Drawing_FontCreate(); 516 EXPECT_NE(font, nullptr); 517 OH_Drawing_Typeface *typeSurface = OH_Drawing_TypefaceCreateDefault(); 518 // add assert 519 EXPECT_NE(typeSurface, nullptr); 520 OH_Drawing_FontSetTypeface(font, typeSurface); 521 // 1. Call OH_Drawing_TextBlobCreateFromString 10 times (passing in strings of different lengths and types, such as 522 // Chinese, English, special characters, numbers, traditional Chinese characters, etc.) and use 523 // OH_Drawing_CanvasDrawTextBlob in combination 524 for (int i = 0; i < 10; i++) { 525 const char *str = strs[i % 6]; 526 OH_Drawing_TextBlob *textBlob = OH_Drawing_TextBlobCreateFromString(str, font, TEXT_ENCODING_UTF8); 527 OH_Drawing_Canvas *canvas = OH_Drawing_CanvasCreate(); 528 EXPECT_NE(nullptr, canvas); 529 OH_Drawing_CanvasDrawTextBlob(canvas, textBlob, 0, 0); 530 // add assert 531 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_SUCCESS); 532 OH_Drawing_CanvasDestroy(canvas); 533 } 534 // 2. Free memory 535 OH_Drawing_FontDestroy(font); 536 OH_Drawing_TypefaceDestroy(typeSurface); 537 } 538 539 /* 540 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_TEXTBLOB_0403 541 * @tc.name: testTextBlobCreateFromStringAbnormal 542 * @tc.desc: test for testTextBlobCreateFromStringAbnormal. 543 * @tc.size : SmallTest 544 * @tc.type : Function 545 * @tc.level : Level 3 546 */ 547 HWTEST_F(DrawingNativeTextBlobTest, testTextBlobCreateFromStringAbnormal, Function | SmallTest | Level3) { 548 const char *str = "123456"; 549 OH_Drawing_Font *font = OH_Drawing_FontCreate(); 550 EXPECT_NE(font, nullptr); 551 OH_Drawing_Typeface *typeSurface = OH_Drawing_TypefaceCreateDefault(); 552 // add assert 553 EXPECT_NE(typeSurface, nullptr); 554 OH_Drawing_FontSetTypeface(font, typeSurface); 555 // 1. Call OH_Drawing_TextBlobCreateFromString interface with OH_Drawing_TextEncoding out of range, check the error 556 // code with OH_Drawing_ErrorCodeGet 557 OH_Drawing_TextBlob *textBlob = 558 OH_Drawing_TextBlobCreateFromString(str, font, static_cast<OH_Drawing_TextEncoding>(-1)); 559 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_PARAMETER_OUT_OF_RANGE); 560 // 2. Free memory 561 OH_Drawing_FontDestroy(font); 562 OH_Drawing_TextBlobDestroy(textBlob); 563 OH_Drawing_TypefaceDestroy(typeSurface); 564 } 565 566 /* 567 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_TEXTBLOB_0500 568 * @tc.name: testTextBlobGetBoundsNormal 569 * @tc.desc: test for testTextBlobGetBoundsNormal. 570 * @tc.size : SmallTest 571 * @tc.type : Function 572 * @tc.level : Level 0 573 */ 574 HWTEST_F(DrawingNativeTextBlobTest, testTextBlobGetBoundsNormal, Function | SmallTest | Level0) { 575 // 1、创建OH_Drawing_TextBlob、OH_Drawing_Rect 576 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0, 0, 0, 0); 577 EXPECT_NE(rect, nullptr); 578 OH_Drawing_Font *font = OH_Drawing_FontCreate(); 579 EXPECT_NE(font, nullptr); 580 const char *str = "123456"; 581 OH_Drawing_TextBlob *textBlob = 582 OH_Drawing_TextBlobCreateFromString(str, font, OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8); 583 // 2. Call OH_Drawing_TextBlobGetBounds 584 OH_Drawing_TextBlobGetBounds(textBlob, rect); 585 float left = OH_Drawing_RectGetLeft(rect); 586 float right = OH_Drawing_RectGetRight(rect); 587 EXPECT_EQ(right - left > 0, true); 588 // 3. Free memory 589 OH_Drawing_RectDestroy(rect); 590 OH_Drawing_FontDestroy(font); 591 OH_Drawing_TextBlobDestroy(textBlob); 592 } 593 594 /* 595 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_TEXTBLOB_0501 596 * @tc.name: testTextBlobGetBoundsNull 597 * @tc.desc: test for testTextBlobGetBoundsNull. 598 * @tc.size : SmallTest 599 * @tc.type : Function 600 * @tc.level : Level 3 601 */ 602 HWTEST_F(DrawingNativeTextBlobTest, testTextBlobGetBoundsNull, Function | SmallTest | Level3) { 603 // 1. Create OH_Drawing_TextBlob and OH_Drawing_Rect 604 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0, 0, 0, 0); 605 EXPECT_NE(rect, nullptr); 606 OH_Drawing_Font *font = OH_Drawing_FontCreate(); 607 EXPECT_NE(font, nullptr); 608 const char *str = "123456"; 609 OH_Drawing_TextBlob *textBlob = 610 OH_Drawing_TextBlobCreateFromString(str, font, OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8); 611 // 2. Pass nullptr as the first parameter to OH_Drawing_TextBlobGetBounds and check the error code with 612 // OH_Drawing_ErrorCodeGet 613 OH_Drawing_TextBlobGetBounds(nullptr, rect); 614 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER); 615 OH_Drawing_ErrorCodeReset(); 616 // 3. Pass nullptr as the second parameter to OH_Drawing_TextBlobGetBounds and check the error code with 617 // OH_Drawing_ErrorCodeGet 618 OH_Drawing_TextBlobGetBounds(textBlob, nullptr); 619 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER); 620 // 4. Free memory 621 OH_Drawing_RectDestroy(rect); 622 OH_Drawing_FontDestroy(font); 623 OH_Drawing_TextBlobDestroy(textBlob); 624 } 625 626 /* 627 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_TEXTBLOB_0502 628 * @tc.name: testTextBlobGetBoundsMultipleCalls 629 * @tc.desc: test for testTextBlobGetBoundsMultipleCalls. 630 * @tc.size : SmallTest 631 * @tc.type : Function 632 * @tc.level : Level 3 633 */ 634 HWTEST_F(DrawingNativeTextBlobTest, testTextBlobGetBoundsMultipleCalls, Function | SmallTest | Level3) { 635 // 1. Create OH_Drawing_TextBlob and OH_Drawing_Rect 636 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0, 0, 0, 0); 637 EXPECT_NE(rect, nullptr); 638 OH_Drawing_Font *font = OH_Drawing_FontCreate(); 639 EXPECT_NE(font, nullptr); 640 // 2. Call OH_Drawing_TextBlobGetBounds 10 times (passing in strings of different lengths and types, such as 641 // Chinese, English, special characters, numbers, traditional Chinese characters, etc.) 642 const char *strs[] = { 643 "Hello World", "你好世界", "Hello 世界", "Hello 世界123", "Hello $#@!", "繁體中文", 644 }; 645 for (int i = 0; i < 10; i++) { 646 const char *str = strs[i % 6]; 647 OH_Drawing_TextBlob *textBlob = 648 OH_Drawing_TextBlobCreateFromString(str, font, OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8); 649 OH_Drawing_TextBlobGetBounds(textBlob, rect); 650 float left = OH_Drawing_RectGetLeft(rect); 651 float right = OH_Drawing_RectGetRight(rect); 652 EXPECT_EQ(right - left > 0, true); 653 OH_Drawing_TextBlobDestroy(textBlob); 654 } 655 // 3. Free memory 656 OH_Drawing_RectDestroy(rect); 657 OH_Drawing_FontDestroy(font); 658 } 659 660 /* 661 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_TEXTBLOB_0503 662 * @tc.name: testTextBlobGetBoundsAbnormal 663 * @tc.desc: test for testTextBlobGetBoundsAbnormal. 664 * @tc.size : SmallTest 665 * @tc.type : Function 666 * @tc.level : Level 3 667 */ 668 HWTEST_F(DrawingNativeTextBlobTest, testTextBlobGetBoundsAbnormal, Function | SmallTest | Level3) { 669 // 1. Create OH_Drawing_TextBlob and OH_Drawing_Rect 670 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(-1, -1, -1, -1); 671 EXPECT_NE(rect, nullptr); 672 OH_Drawing_Font *font = OH_Drawing_FontCreate(); 673 EXPECT_NE(font, nullptr); 674 const char *str = "123456"; 675 OH_Drawing_TextBlob *textBlob = 676 OH_Drawing_TextBlobCreateFromString(str, font, OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8); 677 // 2. Call OH_Drawing_TextBlobGetBounds with rect initialized with negative values 678 OH_Drawing_TextBlobGetBounds(textBlob, rect); 679 float left = OH_Drawing_RectGetLeft(rect); 680 float right = OH_Drawing_RectGetRight(rect); 681 EXPECT_EQ(right - left > 0, true); 682 // 3. Free memory 683 OH_Drawing_RectDestroy(rect); 684 OH_Drawing_FontDestroy(font); 685 OH_Drawing_TextBlobDestroy(textBlob); 686 } 687 688 /* 689 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_TEXTBLOB_0600 690 * @tc.name: testTextBlobUniqueIDNormal 691 * @tc.desc: test for testTextBlobUniqueIDNormal. 692 * @tc.size : SmallTest 693 * @tc.type : Function 694 * @tc.level : Level 0 695 */ 696 HWTEST_F(DrawingNativeTextBlobTest, testTextBlobUniqueIDNormal, Function | SmallTest | Level0) { 697 // 1. Create OH_Drawing_TextBlob 698 OH_Drawing_Font *font = OH_Drawing_FontCreate(); 699 EXPECT_NE(font, nullptr); 700 const char *str = "123456"; 701 OH_Drawing_TextBlob *textBlob = 702 OH_Drawing_TextBlobCreateFromString(str, font, OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8); 703 // 2. Call OH_Drawing_TextBlobUniqueID 704 uint32_t ret = OH_Drawing_TextBlobUniqueID(textBlob); 705 EXPECT_EQ(ret > 0, true); 706 // add assert 707 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_SUCCESS); 708 // 3. Free memory 709 OH_Drawing_FontDestroy(font); 710 OH_Drawing_TextBlobDestroy(textBlob); 711 } 712 713 /* 714 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_TEXTBLOB_0601 715 * @tc.name: testTextBlobUniqueIDNull 716 * @tc.desc: test for testTextBlobUniqueIDNull. 717 * @tc.size : SmallTest 718 * @tc.type : Function 719 * @tc.level : Level 3 720 */ 721 HWTEST_F(DrawingNativeTextBlobTest, testTextBlobUniqueIDNull, Function | SmallTest | Level3) { 722 // 1. Create OH_Drawing_TextBlob 723 OH_Drawing_Font *font = OH_Drawing_FontCreate(); 724 EXPECT_NE(font, nullptr); 725 const char *str = "123456"; 726 OH_Drawing_TextBlob *textBlob = 727 OH_Drawing_TextBlobCreateFromString(str, font, OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8); 728 // 2. Pass nullptr as the parameter to OH_Drawing_TextBlobUniqueID and check the error code with 729 // OH_Drawing_ErrorCodeGet 730 OH_Drawing_TextBlobUniqueID(nullptr); 731 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER); 732 // 3. Free memory 733 OH_Drawing_FontDestroy(font); 734 OH_Drawing_TextBlobDestroy(textBlob); 735 } 736 737 /* 738 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_TEXTBLOB_0602 739 * @tc.name: testTextBlobUniqueIDMultipleCalls 740 * @tc.desc: test for testTextBlobUniqueIDMultipleCalls. 741 * @tc.size : SmallTest 742 * @tc.type : Function 743 * @tc.level : Level 3 744 */ 745 HWTEST_F(DrawingNativeTextBlobTest, testTextBlobUniqueIDMultipleCalls, Function | SmallTest | Level3) { 746 // 1. Create OH_Drawing_TextBlob 747 OH_Drawing_Font *font = OH_Drawing_FontCreate(); 748 EXPECT_NE(font, nullptr); 749 const char *strs[] = { 750 "Hello World", "你好世界", "Hello 世界", "Hello 世界123", "Hello $#@!", "繁體中文", 751 }; 752 // 2. Call OH_Drawing_TextBlobUniqueID 10 times (passing in strings of different lengths and types, such as Chinese, 753 // English, special characters, numbers, traditional Chinese characters, etc.) 754 for (int i = 0; i < 10; i++) { 755 const char *str = strs[i % 6]; 756 OH_Drawing_TextBlob *textBlob = 757 OH_Drawing_TextBlobCreateFromString(str, font, OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8); 758 uint32_t ret = OH_Drawing_TextBlobUniqueID(textBlob); 759 EXPECT_EQ(ret > 0, true); 760 // add assert 761 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_SUCCESS); 762 OH_Drawing_TextBlobDestroy(textBlob); 763 } 764 // 3. Free memory 765 OH_Drawing_FontDestroy(font); 766 } 767 768 /* 769 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_TEXTBLOB_0700 770 * @tc.name: testTextBlobBuilderAllocRunPosNormal 771 * @tc.desc: test for testTextBlobBuilderAllocRunPosNormal. 772 * @tc.size : SmallTest 773 * @tc.type : Function 774 * @tc.level : Level 0 775 */ 776 HWTEST_F(DrawingNativeTextBlobTest, testTextBlobBuilderAllocRunPosNormal, Function | SmallTest | Level0) { 777 // 1. Create OH_Drawing_TextBlobBuilder, OH_Drawing_Font, OH_Drawing_Rect 778 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0, 0, 0, 0); 779 EXPECT_NE(rect, nullptr); 780 OH_Drawing_Font *font = OH_Drawing_FontCreate(); 781 EXPECT_NE(font, nullptr); 782 OH_Drawing_TextBlobBuilder *builder = OH_Drawing_TextBlobBuilderCreate(); 783 // 2. OH_Drawing_TextBlobBuilderAllocRunPos 784 const OH_Drawing_RunBuffer *runBuffer = OH_Drawing_TextBlobBuilderAllocRunPos(builder, font, 9, rect); 785 // add assert 786 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_SUCCESS); 787 EXPECT_NE(runBuffer, nullptr); 788 // 3. Free memory 789 OH_Drawing_RectDestroy(rect); 790 OH_Drawing_FontDestroy(font); 791 if (0) { 792 // todo cpp crash 793 OH_Drawing_TextBlobBuilderDestroy(builder); 794 } 795 } 796 797 /* 798 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_TEXTBLOB_0701 799 * @tc.name: testTextBlobBuilderAllocRunPosNull 800 * @tc.desc: test for testTextBlobBuilderAllocRunPosNull. 801 * @tc.size : SmallTest 802 * @tc.type : Function 803 * @tc.level : Level 3 804 */ 805 HWTEST_F(DrawingNativeTextBlobTest, testTextBlobBuilderAllocRunPosNull, Function | SmallTest | Level3) { 806 // 1. Create OH_Drawing_TextBlobBuilder, OH_Drawing_Font, OH_Drawing_Rect 807 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0, 0, 0, 0); 808 EXPECT_NE(rect, nullptr); 809 OH_Drawing_Font *font = OH_Drawing_FontCreate(); 810 EXPECT_NE(font, nullptr); 811 OH_Drawing_TextBlobBuilder *builder = OH_Drawing_TextBlobBuilderCreate(); 812 // 2. Call OH_Drawing_TextBlobBuilderAllocRunPos with the first parameter as nullptr and check the error code with 813 // OH_Drawing_ErrorCodeGet 814 OH_Drawing_TextBlobBuilderAllocRunPos(nullptr, font, 9, rect); 815 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER); 816 OH_Drawing_ErrorCodeReset(); 817 // 3. Call OH_Drawing_TextBlobBuilderAllocRunPos with the second parameter as nullptr and check the error code with 818 // OH_Drawing_ErrorCodeGet 819 OH_Drawing_TextBlobBuilderAllocRunPos(builder, nullptr, 9, rect); 820 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER); 821 OH_Drawing_ErrorCodeReset(); 822 // 4. Call OH_Drawing_TextBlobBuilderAllocRunPos with the third parameter as nullptr and check the error code with 823 // OH_Drawing_ErrorCodeGet 824 OH_Drawing_TextBlobBuilderAllocRunPos(builder, font, 0, rect); 825 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER); 826 OH_Drawing_ErrorCodeReset(); 827 // 5. Call OH_Drawing_TextBlobBuilderAllocRunPos with the fourth parameter as nullptr and check the error code with 828 // OH_Drawing_ErrorCodeGet 829 OH_Drawing_TextBlobBuilderAllocRunPos(builder, font, 9, nullptr); 830 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_SUCCESS); 831 // 6. Free memory 832 OH_Drawing_RectDestroy(rect); 833 OH_Drawing_FontDestroy(font); 834 if (0) { 835 // todo cpp crash 836 OH_Drawing_TextBlobBuilderDestroy(builder); 837 } 838 } 839 840 /* 841 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_TEXTBLOB_0702 842 * @tc.name: testTextBlobBuilderAllocRunPosMultipleCalls 843 * @tc.desc: test for testTextBlobBuilderAllocRunPosMultipleCalls. 844 * @tc.size : SmallTest 845 * @tc.type : Function 846 * @tc.level : Level 3 847 */ 848 HWTEST_F(DrawingNativeTextBlobTest, testTextBlobBuilderAllocRunPosMultipleCalls, Function | SmallTest | Level3) { 849 OH_Drawing_Rect *rect = OH_Drawing_RectCreate(0, 0, 0, 0); 850 EXPECT_NE(rect, nullptr); 851 OH_Drawing_Font *font = OH_Drawing_FontCreate(); 852 EXPECT_NE(font, nullptr); 853 OH_Drawing_TextBlobBuilder *builder = OH_Drawing_TextBlobBuilderCreate(); 854 // 1. Call OH_Drawing_TextBlobBuilderAllocRunPos 10 times 855 for (int i = 0; i < 10; i++) { 856 const OH_Drawing_RunBuffer *runBuffer = OH_Drawing_TextBlobBuilderAllocRunPos(builder, font, 9, rect); 857 EXPECT_NE(runBuffer, nullptr); 858 } 859 // 2. Call OH_Drawing_TextBlobBuilderMake and then call OH_Drawing_TextBlobBuilderAllocRunPos again 860 OH_Drawing_TextBlobBuilderMake(builder); 861 const OH_Drawing_RunBuffer *runBuffer = OH_Drawing_TextBlobBuilderAllocRunPos(builder, font, 9, rect); 862 EXPECT_NE(runBuffer, nullptr); 863 // 3. Free memory 864 OH_Drawing_RectDestroy(rect); 865 OH_Drawing_FontDestroy(font); 866 if (0) { 867 // todo cpp crash 868 OH_Drawing_TextBlobBuilderDestroy(builder); 869 } 870 } 871 872 /* 873 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_TEXTBLOB_0800 874 * @tc.name: testTextBlobBuilderMakeNormal 875 * @tc.desc: test for testTextBlobBuilderMakeNormal. 876 * @tc.size : SmallTest 877 * @tc.type : Function 878 * @tc.level : Level 0 879 */ 880 HWTEST_F(DrawingNativeTextBlobTest, testTextBlobBuilderMakeNormal, Function | SmallTest | Level0) { 881 // 1. Create OH_Drawing_TextBlobBuilder 882 OH_Drawing_TextBlobBuilder *builder = OH_Drawing_TextBlobBuilderCreate(); 883 // add assert 884 EXPECT_NE(builder, nullptr); 885 // 2. Call OH_Drawing_TextBlobBuilderMake 886 OH_Drawing_TextBlob *textBlob = OH_Drawing_TextBlobBuilderMake(builder); 887 // add assert 888 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_SUCCESS); 889 // add assert 890 EXPECT_EQ(textBlob, nullptr); 891 // 3. Free memory 892 OH_Drawing_TextBlobDestroy(textBlob); 893 if (0) { 894 // todo cpp crash 895 OH_Drawing_TextBlobBuilderDestroy(builder); 896 } 897 } 898 899 /* 900 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_TEXTBLOB_0801 901 * @tc.name: testTextBlobBuilderMakeNull 902 * @tc.desc: test for testTextBlobBuilderMakeNull. 903 * @tc.size : SmallTest 904 * @tc.type : Function 905 * @tc.level : Level 3 906 */ 907 HWTEST_F(DrawingNativeTextBlobTest, testTextBlobBuilderMakeNull, Function | SmallTest | Level3) { 908 // 1. Call OH_Drawing_TextBlobBuilderMake with nullptr as the parameter and check the error code with 909 // OH_Drawing_ErrorCodeGet 910 OH_Drawing_TextBlobBuilderMake(nullptr); 911 // 1. No crash, error code returns OH_DRAWING_ERROR_INVALID_PARAMETER 912 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER); 913 } 914 915 /* 916 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_TEXTBLOB_0802 917 * @tc.name: testTextBlobBuilderMakeMultipleCalls 918 * @tc.desc: test for testTextBlobBuilderMakeMultipleCalls. 919 * @tc.size : SmallTest 920 * @tc.type : Function 921 * @tc.level : Level 3 922 */ 923 HWTEST_F(DrawingNativeTextBlobTest, testTextBlobBuilderMakeMultipleCalls, Function | SmallTest | Level3) { 924 // 1. Create OH_Drawing_TextBlobBuilder 925 OH_Drawing_TextBlobBuilder *builder = OH_Drawing_TextBlobBuilderCreate(); 926 // add assert 927 EXPECT_NE(builder, nullptr); 928 // 2. Call OH_Drawing_TextBlobBuilderMake 10 times 929 for (int i = 0; i < 10; i++) { 930 OH_Drawing_TextBlob *textBlob = OH_Drawing_TextBlobBuilderMake(builder); 931 // add assert 932 EXPECT_EQ(textBlob, nullptr); 933 OH_Drawing_TextBlobDestroy(textBlob); 934 } 935 // 3. Free memory 936 if (0) { 937 // todo cpp crash 938 OH_Drawing_TextBlobBuilderDestroy(builder); 939 } 940 } 941 942 /* 943 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_TEXTBLOB_0800 944 * @tc.name: testTextBlobDestroyNormal 945 * @tc.desc: test for testTextBlobDestroyNormal. 946 * @tc.size : SmallTest 947 * @tc.type : Function 948 * @tc.level : Level 0 949 */ 950 HWTEST_F(DrawingNativeTextBlobTest, testTextBlobDestroyNormal, Function | SmallTest | Level0) { 951 const char *str = "123456"; 952 OH_Drawing_Font *font = OH_Drawing_FontCreate(); 953 EXPECT_NE(font, nullptr); 954 OH_Drawing_Typeface *typeSurface = OH_Drawing_TypefaceCreateDefault(); 955 // add assert 956 EXPECT_NE(typeSurface, nullptr); 957 OH_Drawing_FontSetTypeface(font, typeSurface); 958 // 1. Create OH_Drawing_TextBlob 959 OH_Drawing_TextBlob *textBlob = OH_Drawing_TextBlobCreateFromString(str, font, TEXT_ENCODING_UTF8); 960 // add assert 961 EXPECT_NE(textBlob, nullptr); 962 // 2. OH_Drawing_TextBlobDestroy 963 OH_Drawing_TextBlobDestroy(textBlob); 964 } 965 966 /* 967 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_TEXTBLOB_0801 968 * @tc.name: testTextBlobDestroyNull 969 * @tc.desc: test for testTextBlobDestroyNull. 970 * @tc.size : SmallTest 971 * @tc.type : Function 972 * @tc.level : Level 3 973 */ 974 HWTEST_F(DrawingNativeTextBlobTest, testTextBlobDestroyNull, Function | SmallTest | Level3) { 975 // 1. OH_Drawing_TextBlobDestroy with null parameter 976 OH_Drawing_TextBlobDestroy(nullptr); 977 // add assert 978 EXPECT_TRUE(true); 979 } 980 981 } // namespace Drawing 982 } // namespace Rosen 983 } // namespace OHOS