1 /* 2 * Copyright (c) 2024 Shenzhen Kaihong Digital Industry Development Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16 #include "drawing_bitmap.h" 17 #include "drawing_brush.h" 18 #include "drawing_canvas.h" 19 #include "drawing_color.h" 20 #include "drawing_color_filter.h" 21 #include "drawing_filter.h" 22 #include "drawing_font.h" 23 #include "drawing_image.h" 24 #include "drawing_mask_filter.h" 25 #include "drawing_matrix.h" 26 #include "drawing_memory_stream.h" 27 #include "drawing_path.h" 28 #include "drawing_pen.h" 29 #include "drawing_point.h" 30 #include "drawing_rect.h" 31 #include "drawing_region.h" 32 #include "drawing_round_rect.h" 33 #include "drawing_sampling_options.h" 34 #include "drawing_shader_effect.h" 35 #include "drawing_text_blob.h" 36 #include "drawing_typeface.h" 37 #include "gtest/gtest.h" 38 #include <random> 39 40 #define NUMBER_10 10 41 #define NUMBER_100 100 42 #define NUMBER_400_1 400.1 43 #define NUMBER_900 900 44 #define NUMBER_1000000 1000000 45 46 47 using namespace testing; 48 using namespace testing::ext; 49 50 namespace OHOS { 51 namespace Rosen { 52 namespace Drawing { 53 class DrawingNativeFontPart2Test : public testing::Test { 54 protected: 55 // 在每个测试用例执行前调用 SetUp()56 void SetUp() override 57 { 58 // 设置代码 59 std::cout << "DrawingNativeFontPart2Test Setup code called before each test case." << std::endl; 60 OH_Drawing_ErrorCodeReset(); 61 std::cout << "DrawingNativeFontPart2Test errorCodeReset before each test case." << std::endl; 62 } TearDown()63 void TearDown() override 64 { 65 std::cout << "DrawingNativeFontPart2Test Setup code called after each test case." << std::endl; 66 OH_Drawing_ErrorCodeReset(); 67 std::cout << "DrawingNativeFontPart2Test errorCodeReset after each test case." << std::endl; 68 } 69 }; 70 71 /* 72 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_FONT_2000 73 * @tc.name: testFontArgumentsCreateNormal 74 * @tc.desc: Test for testFontArgumentsCreateNormal. 75 * @tc.size : SmallTest 76 * @tc.type : Function 77 * @tc.level : Level 0 78 */ 79 HWTEST_F(DrawingNativeFontPart2Test, testFontArgumentsCreateNormal, Function | SmallTest | Level0) { 80 // 1. OH_Drawing_FontArgumentsCreate 81 OH_Drawing_FontArguments *fontArguments = OH_Drawing_FontArgumentsCreate(); 82 // add assert 83 EXPECT_NE(fontArguments, nullptr); 84 OH_Drawing_FontArgumentsDestroy(fontArguments); 85 } 86 87 /* 88 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_FONT_2100 89 * @tc.name: testFontArgumentsAddVariationNormal 90 * @tc.desc: test for testFontArgumentsAddVariationNormal. 91 * @tc.size : SmallTest 92 * @tc.type : Function 93 * @tc.level : Level 3 94 */ 95 HWTEST_F(DrawingNativeFontPart2Test, testFontArgumentsAddVariationNormal, Function | SmallTest | Level0) { 96 // 1. OH_Drawing_FontArgumentsCreate 97 OH_Drawing_FontArguments *fontArguments = OH_Drawing_FontArgumentsCreate(); 98 // add assert 99 EXPECT_NE(fontArguments, nullptr); 100 // 2. OH_Drawing_FontArgumentsAddVariation, should return OH_DRAWING_SUCCESS 101 OH_Drawing_ErrorCode drawingErrorCode = OH_DRAWING_ERROR_INVALID_PARAMETER; 102 drawingErrorCode = OH_Drawing_FontArgumentsAddVariation(fontArguments, "wght", 0); 103 EXPECT_EQ(drawingErrorCode, OH_DRAWING_SUCCESS); 104 drawingErrorCode = OH_Drawing_FontArgumentsAddVariation(fontArguments, "wght", -1); 105 EXPECT_EQ(drawingErrorCode, OH_DRAWING_SUCCESS); 106 drawingErrorCode = OH_Drawing_FontArgumentsAddVariation(fontArguments, "wght", NUMBER_100); 107 EXPECT_EQ(drawingErrorCode, OH_DRAWING_SUCCESS); 108 drawingErrorCode = OH_Drawing_FontArgumentsAddVariation(fontArguments, "wght", NUMBER_400_1); 109 EXPECT_EQ(drawingErrorCode, OH_DRAWING_SUCCESS); 110 drawingErrorCode = OH_Drawing_FontArgumentsAddVariation(fontArguments, "wght", NUMBER_900); 111 EXPECT_EQ(drawingErrorCode, OH_DRAWING_SUCCESS); 112 drawingErrorCode = OH_Drawing_FontArgumentsAddVariation(fontArguments, "wght", NUMBER_1000000); 113 EXPECT_EQ(drawingErrorCode, OH_DRAWING_SUCCESS); 114 } 115 116 /* 117 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_FONT_2101 118 * @tc.name: testFontArgumentsAddVariationNull 119 * @tc.desc: test for testFontArgumentsAddVariationNull. 120 * @tc.size : SmallTest 121 * @tc.type : Function 122 * @tc.level : Level 3 123 */ 124 HWTEST_F(DrawingNativeFontPart2Test, testFontArgumentsAddVariationNull, Function | SmallTest | Level3) { 125 // 1. OH_Drawing_FontArgumentsCreate 126 OH_Drawing_FontArguments *fontArguments = OH_Drawing_FontArgumentsCreate(); 127 // add assert 128 EXPECT_NE(fontArguments, nullptr); 129 // 2. OH_Drawing_FontArgumentsAddVariation, the first parameter is nullptr 130 OH_Drawing_ErrorCode drawingErrorCode = OH_DRAWING_SUCCESS; 131 drawingErrorCode = OH_Drawing_FontArgumentsAddVariation(nullptr, "wght", NUMBER_100); 132 EXPECT_EQ(drawingErrorCode, OH_DRAWING_ERROR_INVALID_PARAMETER); 133 // 3. OH_Drawing_FontArgumentsAddVariation, the second parameter is nullptr 134 drawingErrorCode = OH_Drawing_FontArgumentsAddVariation(fontArguments, nullptr, NUMBER_100); 135 EXPECT_EQ(drawingErrorCode, OH_DRAWING_ERROR_INVALID_PARAMETER); 136 } 137 138 /* 139 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_FONT_2102 140 * @tc.name: testFontArgumentsAddVariationAbnormal 141 * @tc.desc: test for testFontArgumentsAddVariationAbnormal. 142 * @tc.size : SmallTest 143 * @tc.type : Function 144 * @tc.level : Level 3 145 */ 146 HWTEST_F(DrawingNativeFontPart2Test, testFontArgumentsAddVariationAbnormal, Function | SmallTest | Level3) { 147 // 1. OH_Drawing_FontArgumentsCreate 148 OH_Drawing_FontArguments *fontArguments = OH_Drawing_FontArgumentsCreate(); 149 // add assert 150 EXPECT_NE(fontArguments, nullptr); 151 // 2. OH_Drawing_FontArgumentsAddVariation, the second parameter is error 152 OH_Drawing_ErrorCode drawingErrorCode = OH_DRAWING_SUCCESS; 153 drawingErrorCode = OH_Drawing_FontArgumentsAddVariation(fontArguments, "WGHT", NUMBER_100); 154 EXPECT_EQ(drawingErrorCode, OH_DRAWING_SUCCESS); 155 // 3. OH_Drawing_FontArgumentsAddVariation, the second parameter is error 156 drawingErrorCode = OH_Drawing_FontArgumentsAddVariation(fontArguments, "w", NUMBER_100); 157 EXPECT_EQ(drawingErrorCode, OH_DRAWING_ERROR_INVALID_PARAMETER); 158 } 159 160 /* 161 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_FONT_2103 162 * @tc.name: testFontArgumentsAddVariationMultipleCalls 163 * @tc.desc: test for testFontArgumentsAddVariationMultipleCalls. 164 * @tc.size : SmallTest 165 * @tc.type : Function 166 * @tc.level : Level 3 167 */ 168 HWTEST_F(DrawingNativeFontPart2Test, testFontArgumentsAddVariationMultipleCalls, Function | SmallTest | Level3) { 169 // 1. OH_Drawing_FontArgumentsCreate 170 OH_Drawing_FontArguments *fontArguments = OH_Drawing_FontArgumentsCreate(); 171 // add assert 172 EXPECT_NE(fontArguments, nullptr); 173 // 2. OH_Drawing_FontArgumentsAddVariation, should return OH_DRAWING_SUCCESS 174 OH_Drawing_ErrorCode drawingErrorCode = OH_DRAWING_ERROR_INVALID_PARAMETER; 175 drawingErrorCode = OH_Drawing_FontArgumentsAddVariation(fontArguments, "wght", NUMBER_100); 176 drawingErrorCode = OH_Drawing_FontArgumentsAddVariation(fontArguments, "wght", NUMBER_900); 177 EXPECT_EQ(drawingErrorCode, OH_DRAWING_SUCCESS); 178 drawingErrorCode = OH_Drawing_FontArgumentsAddVariation(fontArguments, "wght", NUMBER_100); 179 drawingErrorCode = OH_Drawing_FontArgumentsAddVariation(fontArguments, "wght", 0.0f); 180 EXPECT_EQ(drawingErrorCode, OH_DRAWING_SUCCESS); 181 drawingErrorCode = OH_Drawing_FontArgumentsAddVariation(fontArguments, "wght", NUMBER_100); 182 drawingErrorCode = OH_Drawing_FontArgumentsAddVariation(fontArguments, "wght", -1); 183 EXPECT_EQ(drawingErrorCode, OH_DRAWING_SUCCESS); 184 } 185 186 /* 187 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_FONT_2200 188 * @tc.name: testFontArgumentsDestoryNormal 189 * @tc.desc: test for testFontArgumentsDestoryNormal. 190 * @tc.size : SmallTest 191 * @tc.type : Function 192 * @tc.level : Level 3 193 */ 194 HWTEST_F(DrawingNativeFontPart2Test, testFontArgumentsDestoryNormal, Function | SmallTest | Level0) { 195 // 1. OH_Drawing_FontArgumentsCreate 196 OH_Drawing_FontArguments *fontArguments = OH_Drawing_FontArgumentsCreate(); 197 // add assert 198 EXPECT_NE(fontArguments, nullptr); 199 // 2. OH_Drawing_FontArgumentsDestroy 200 OH_Drawing_ErrorCode drawingErrorCode = OH_DRAWING_ERROR_INVALID_PARAMETER; 201 drawingErrorCode = OH_Drawing_FontArgumentsDestroy(fontArguments); 202 EXPECT_EQ(drawingErrorCode, OH_DRAWING_SUCCESS); 203 } 204 205 /* 206 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_FONT_2201 207 * @tc.name: testFontArgumentsDestoryNull 208 * @tc.desc: test for testFontArgumentsDestoryNull. 209 * @tc.size : SmallTest 210 * @tc.type : Function 211 * @tc.level : Level 3 212 */ 213 HWTEST_F(DrawingNativeFontPart2Test, testFontArgumentsDestoryNull, Function | SmallTest | Level0) { 214 // 1. OH_Drawing_FontArgumentsCreate 215 OH_Drawing_FontArguments *fontArguments = OH_Drawing_FontArgumentsCreate(); 216 // add assert 217 EXPECT_NE(fontArguments, nullptr); 218 // 2. OH_Drawing_FontArgumentsDestroy, parameter is null 219 OH_Drawing_ErrorCode drawingErrorCode = OH_DRAWING_SUCCESS; 220 drawingErrorCode = OH_Drawing_FontArgumentsDestroy(nullptr); 221 EXPECT_EQ(drawingErrorCode, OH_DRAWING_ERROR_INVALID_PARAMETER); 222 OH_Drawing_FontArgumentsDestroy(fontArguments); 223 } 224 225 /* 226 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_FONT_2202 227 * @tc.name: testFontArgumentsDestoryMultiplieCalls 228 * @tc.desc: test for testFontArgumentsDestoryMultiplieCalls. 229 * @tc.size : SmallTest 230 * @tc.type : Function 231 * @tc.level : Level 3 232 */ 233 HWTEST_F(DrawingNativeFontPart2Test, testFontArgumentsDestoryMultiplieCalls, Function | SmallTest | Level0) { 234 // 1. OH_Drawing_FontCreate 235 OH_Drawing_FontArguments *fontArguments = nullptr; 236 for (int i = 0; i < NUMBER_10; i++) 237 { 238 fontArguments = OH_Drawing_FontArgumentsCreate(); 239 } 240 // 2. OH_Drawing_FontCreate, OH_Drawing_FontArgumentsAddVariation 241 OH_Drawing_ErrorCode drawingErrorCode1 = OH_DRAWING_ERROR_INVALID_PARAMETER; 242 for (size_t i = 0; i < NUMBER_10; i++) 243 { 244 OH_Drawing_FontArguments *fontArguments1 = OH_Drawing_FontArgumentsCreate(); 245 drawingErrorCode1 = OH_Drawing_FontArgumentsDestroy(fontArguments1); 246 EXPECT_EQ(drawingErrorCode1, OH_DRAWING_SUCCESS); 247 } 248 } 249 /* 250 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_FONT_2300 251 * @tc.name: testFontSetThemeFontFollowedNormal 252 * @tc.desc: test for testFontSetThemeFontFollowedNormal. 253 * @tc.size : SmallTest 254 * @tc.type : Function 255 * @tc.level : Level 0 256 */ 257 HWTEST_F(DrawingNativeFontPart2Test, testFontSetThemeFontFollowedNormal, Function | SmallTest | Level0) { 258 // 1. OH_Drawing_FontCreate 259 OH_Drawing_Font *font = OH_Drawing_FontCreate(); 260 // add assert 261 EXPECT_NE(font, nullptr); 262 OH_Drawing_ErrorCode drawingErrorCode = OH_DRAWING_ERROR_INVALID_PARAMETER; 263 drawingErrorCode = OH_Drawing_FontSetThemeFontFollowed(font, true); 264 EXPECT_EQ(drawingErrorCode, OH_DRAWING_SUCCESS); 265 drawingErrorCode = OH_Drawing_FontSetThemeFontFollowed(font, false); 266 EXPECT_EQ(drawingErrorCode, OH_DRAWING_SUCCESS); 267 // 2. OH_Drawing_FontDestroy 268 OH_Drawing_FontDestroy(font); 269 } 270 /* 271 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_FONT_2301 272 * @tc.name: testFontSetThemeFontFollowedMuitipleCalls 273 * @tc.desc: test for testFontSetThemeFontFollowedMuitipleCalls. 274 * @tc.size : SmallTest 275 * @tc.type : Function 276 * @tc.level : Level 0 277 */ 278 HWTEST_F(DrawingNativeFontPart2Test, testFontSetThemeFontFollowedMuitipleCalls, Function | SmallTest | Level0) { 279 // 1. OH_Drawing_FontCreate 280 OH_Drawing_Font *font = OH_Drawing_FontCreate(); 281 // add assert 282 EXPECT_NE(font, nullptr); 283 for (int i = 0; i < 10; i++) { 284 OH_Drawing_ErrorCode drawingErrorCode = OH_DRAWING_ERROR_INVALID_PARAMETER; 285 drawingErrorCode = OH_Drawing_FontSetThemeFontFollowed(font, true); 286 EXPECT_EQ(drawingErrorCode, OH_DRAWING_SUCCESS); 287 } 288 // 2. OH_Drawing_FontDestroy 289 OH_Drawing_FontDestroy(font); 290 } 291 /* 292 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_FONT_2302 293 * @tc.name: testFontSetThemeFontFollowedNull 294 * @tc.desc: test for testFontSetThemeFontFollowedNull. 295 * @tc.size : SmallTest 296 * @tc.type : Function 297 * @tc.level : Level 0 298 */ 299 HWTEST_F(DrawingNativeFontPart2Test, testFontSetThemeFontFollowedNull, Function | SmallTest | Level0) { 300 // 1. OH_Drawing_FontCreate 301 OH_Drawing_Font *font = OH_Drawing_FontCreate(); 302 // add assert 303 EXPECT_NE(font, nullptr); 304 OH_Drawing_ErrorCode drawingErrorCode = OH_DRAWING_SUCCESS; 305 drawingErrorCode = OH_Drawing_FontSetThemeFontFollowed(nullptr, true); 306 EXPECT_EQ(drawingErrorCode, OH_DRAWING_ERROR_INVALID_PARAMETER); 307 // 2. OH_Drawing_FontDestroy 308 OH_Drawing_FontDestroy(font); 309 } 310 /* 311 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_FONT_2100 312 * @tc.name: testFontIsThemeFontFollowedNormal 313 * @tc.desc: test for testFontIsThemeFontFollowedNormal. 314 * @tc.size : SmallTest 315 * @tc.type : Function 316 * @tc.level : Level 0 317 */ 318 HWTEST_F(DrawingNativeFontPart2Test, testFontIsThemeFontFollowedNormal, Function | SmallTest | Level0) { 319 // 1. OH_Drawing_FontCreate 320 OH_Drawing_Font *font = OH_Drawing_FontCreate(); 321 // add assert 322 EXPECT_NE(font, nullptr); 323 bool followed = true; 324 OH_Drawing_ErrorCode drawingErrorCode = OH_DRAWING_ERROR_INVALID_PARAMETER; 325 OH_Drawing_ErrorCode drawingErrorCode2 = OH_DRAWING_ERROR_INVALID_PARAMETER; 326 drawingErrorCode2 = OH_Drawing_FontIsThemeFontFollowed(font, &followed); 327 EXPECT_EQ(drawingErrorCode2, OH_DRAWING_SUCCESS); 328 EXPECT_EQ(followed, false); 329 drawingErrorCode = OH_Drawing_FontSetThemeFontFollowed(font, true); 330 EXPECT_EQ(drawingErrorCode, OH_DRAWING_SUCCESS); 331 drawingErrorCode2 = OH_Drawing_FontIsThemeFontFollowed(font, &followed); 332 EXPECT_EQ(drawingErrorCode2, OH_DRAWING_SUCCESS); 333 EXPECT_EQ(followed, true); 334 drawingErrorCode = OH_Drawing_FontSetThemeFontFollowed(font, false); 335 EXPECT_EQ(drawingErrorCode, OH_DRAWING_SUCCESS); 336 drawingErrorCode2 = OH_Drawing_FontIsThemeFontFollowed(font, &followed); 337 EXPECT_EQ(drawingErrorCode2, OH_DRAWING_SUCCESS); 338 EXPECT_EQ(followed, false); 339 // 2. OH_Drawing_FontDestroy 340 OH_Drawing_FontDestroy(font); 341 } 342 /* 343 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_FONT_2101 344 * @tc.name: testFontIsThemeFontFollowedMultipleCalls 345 * @tc.desc: test for testFontIsThemeFontFollowedMultipleCalls. 346 * @tc.size : SmallTest 347 * @tc.type : Function 348 * @tc.level : Level 0 349 */ 350 HWTEST_F(DrawingNativeFontPart2Test, testFontIsThemeFontFollowedMultipleCalls, Function | SmallTest | Level0) { 351 // 1. OH_Drawing_FontCreate 352 OH_Drawing_Font *font = OH_Drawing_FontCreate(); 353 // add assert 354 EXPECT_NE(font, nullptr); 355 bool followed = true; 356 bool isFollowed[] = {true, false, false, true, true, true, false, false, true, false}; 357 for (int i = 0; i < 10; i++) { 358 OH_Drawing_ErrorCode drawingErrorCode = OH_DRAWING_ERROR_INVALID_PARAMETER; 359 OH_Drawing_ErrorCode drawingErrorCode2 = OH_DRAWING_ERROR_INVALID_PARAMETER; 360 drawingErrorCode = OH_Drawing_FontSetThemeFontFollowed(font, isFollowed[i]); 361 EXPECT_EQ(drawingErrorCode, OH_DRAWING_SUCCESS); 362 drawingErrorCode2 = OH_Drawing_FontIsThemeFontFollowed(font, &followed); 363 EXPECT_EQ(drawingErrorCode2, OH_DRAWING_SUCCESS); 364 EXPECT_EQ(followed, isFollowed[i]); 365 } 366 // 2. OH_Drawing_FontDestroy 367 OH_Drawing_FontDestroy(font); 368 } 369 /* 370 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_FONT_2400 371 * @tc.name: testFontIsThemeFontFollowedNull 372 * @tc.desc: test for testFontIsThemeFontFollowedNull. 373 * @tc.size : SmallTest 374 * @tc.type : Function 375 * @tc.level : Level 0 376 */ 377 HWTEST_F(DrawingNativeFontPart2Test, testFontIsThemeFontFollowedNull, Function | SmallTest | Level0) { 378 // 1. OH_Drawing_FontCreate 379 OH_Drawing_Font *font = OH_Drawing_FontCreate(); 380 // add assert 381 EXPECT_NE(font, nullptr); 382 bool followed = true; 383 OH_Drawing_ErrorCode drawingErrorCode1 = OH_DRAWING_SUCCESS; 384 OH_Drawing_ErrorCode drawingErrorCode2 = OH_DRAWING_SUCCESS; 385 drawingErrorCode1 = OH_Drawing_FontIsThemeFontFollowed(nullptr, &followed); 386 EXPECT_EQ(drawingErrorCode1, OH_DRAWING_ERROR_INVALID_PARAMETER); 387 drawingErrorCode2 = OH_Drawing_FontIsThemeFontFollowed(font, nullptr); 388 EXPECT_EQ(drawingErrorCode2, OH_DRAWING_ERROR_INVALID_PARAMETER); 389 // 2. OH_Drawing_FontDestroy 390 OH_Drawing_FontDestroy(font); 391 } 392 393 /* 394 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_FONT_2500 395 * @tc.name: testFontGetMetricsNormal 396 * @tc.desc: test for testFontGetMetricsNormal 397 * @tc.size : SmallTest 398 * @tc.type : Function 399 * @tc.level : Level 0 400 */ 401 HWTEST_F(DrawingNativeFontPart2Test, testFontGetMetricsNormal, Function | SmallTest | Level0) { 402 // 1. OH_Drawing_FontCreate 403 OH_Drawing_Font *font = OH_Drawing_FontCreate(); 404 EXPECT_NE(font, nullptr); 405 // 2. Set font size 406 OH_Drawing_FontSetTextSize(font, 100); 407 OH_Drawing_Typeface *typeface = OH_Drawing_TypefaceCreateDefault(); 408 // 3. Set default typeface 409 OH_Drawing_FontSetTypeface(font, typeface); 410 OH_Drawing_Font_Metrics *metrics = (OH_Drawing_Font_Metrics *)malloc(sizeof(OH_Drawing_Font_Metrics)); 411 // 4. Get font measurement information 412 float lineSpace = OH_Drawing_FontGetMetrics(font, metrics); 413 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_SUCCESS); 414 EXPECT_FLOAT_EQ(lineSpace, 117.2); 415 EXPECT_EQ(metrics->flags, 31); 416 EXPECT_FLOAT_EQ(metrics->top, -105.6); 417 EXPECT_FLOAT_EQ(metrics->ascent, -92.7999954); 418 EXPECT_FLOAT_EQ(metrics->descent, 24.4); 419 EXPECT_FLOAT_EQ(metrics->bottom, 27.1); 420 EXPECT_FLOAT_EQ(metrics->leading, 0.000000); 421 EXPECT_FLOAT_EQ(metrics->avgCharWidth, 50.000000); 422 EXPECT_FLOAT_EQ(metrics->maxCharWidth, 248.6); 423 EXPECT_FLOAT_EQ(metrics->xMin, -54.8); 424 EXPECT_FLOAT_EQ(metrics->xMax, 193.8); 425 EXPECT_FLOAT_EQ(metrics->xHeight, 50.000000); 426 EXPECT_FLOAT_EQ(metrics->capHeight, 70.000000); 427 EXPECT_FLOAT_EQ(metrics->underlineThickness, 5.000000); 428 EXPECT_FLOAT_EQ(metrics->underlinePosition, 20.7); 429 EXPECT_FLOAT_EQ(metrics->strikeoutThickness, 5.000000); 430 EXPECT_FLOAT_EQ(metrics->strikeoutPosition, -30.0000019); 431 // 5. OH_Drawing_FontDestroy 432 OH_Drawing_FontDestroy(font); 433 OH_Drawing_TypefaceDestroy(typeface); 434 } 435 436 /* 437 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_FONT_2501 438 * @tc.name: testFontGetMetricsNull 439 * @tc.desc: test for testFontGetMetricsNull 440 * @tc.size : SmallTest 441 * @tc.type : Function 442 * @tc.level : Level 3 443 */ 444 HWTEST_F(DrawingNativeFontPart2Test, testFontGetMetricsNull, Function | SmallTest | Level3) { 445 // 1. OH_Drawing_FontCreate 446 OH_Drawing_Font *font = OH_Drawing_FontCreate(); 447 EXPECT_NE(font, nullptr); 448 // 2. Set font size 449 OH_Drawing_FontSetTextSize(font, 100); 450 OH_Drawing_Typeface *typeface = OH_Drawing_TypefaceCreateDefault(); 451 // 3. Set default typeface 452 OH_Drawing_FontSetTypeface(font, typeface); 453 OH_Drawing_Font_Metrics *metrics = (OH_Drawing_Font_Metrics *)malloc(sizeof(OH_Drawing_Font_Metrics)); 454 // 4. The function OH_Drawing_FontGetMetrics passes a null pointer to the first argument 455 float lineSpace = OH_Drawing_FontGetMetrics(nullptr, metrics); 456 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER); 457 EXPECT_EQ(lineSpace, -1); 458 // 5. The function OH_Drawing_FontGetMetrics passes a null pointer to the second argument 459 lineSpace = OH_Drawing_FontGetMetrics(font, nullptr); 460 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_ERROR_INVALID_PARAMETER); 461 EXPECT_EQ(lineSpace, -1); 462 // 6. OH_Drawing_FontDestroy 463 OH_Drawing_FontDestroy(font); 464 OH_Drawing_TypefaceDestroy(typeface); 465 } 466 467 /* 468 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_FONT_2502 469 * @tc.name: testFontGetMetricsMultiplies 470 * @tc.desc: test for testFontGetMetricsMultiplies 471 * @tc.size : SmallTest 472 * @tc.type : Function 473 * @tc.level : Level 3 474 */ 475 HWTEST_F(DrawingNativeFontPart2Test, testFontGetMetricsMultiplies, Function | SmallTest | Level3) { 476 // 1. OH_Drawing_FontCreate 477 OH_Drawing_Font *font = OH_Drawing_FontCreate(); 478 EXPECT_NE(font, nullptr); 479 // 2. Set font size 480 OH_Drawing_FontSetTextSize(font, 100); 481 OH_Drawing_Typeface *typeface = OH_Drawing_TypefaceCreateDefault(); 482 // 3. Set default typeface 483 OH_Drawing_FontSetTypeface(font, typeface); 484 OH_Drawing_Font_Metrics *metrics = (OH_Drawing_Font_Metrics *)malloc(sizeof(OH_Drawing_Font_Metrics)); 485 // 4. The function OH_Drawing_FontGetMetrics is called 10 times 486 for (int i = 0; i < 10; i++) { 487 OH_Drawing_FontGetMetrics(font, metrics); 488 } 489 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_DRAWING_SUCCESS); 490 // 5. OH_Drawing_FontDestroy 491 OH_Drawing_FontDestroy(font); 492 OH_Drawing_TypefaceDestroy(typeface); 493 } 494 495 /* 496 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_FONT_2600 497 * @tc.name: testFontMeasureTextWithBrushOrPenNormal1 498 * @tc.desc: test for testFontMeasureTextWithBrushOrPenNormal1 499 * @tc.size : SmallTest 500 * @tc.type : Function 501 * @tc.level : Level 0 502 */ 503 HWTEST_F(DrawingNativeFontPart2Test, testFontMeasureTextWithBrushOrPenNormal1, Function | SmallTest | Level0) { 504 OH_Drawing_Font *font = OH_Drawing_FontCreate(); 505 OH_Drawing_FontSetTextSize(font, 50.0f); 506 const char* text = "你好世界"; 507 float textWidth; 508 OH_Drawing_Brush* brush = OH_Drawing_BrushCreate(); 509 OH_Drawing_Pen* pen = OH_Drawing_PenCreate(); 510 OH_Drawing_Rect* bounds = OH_Drawing_RectCreate(0.0, 0.0, 200.0, 200.0); 511 OH_Drawing_Font *font2 = OH_Drawing_FontCreate(); 512 EXPECT_EQ(OH_Drawing_FontMeasureTextWithBrushOrPen(font2, text, strlen(text), 513 TEXT_ENCODING_UTF8, nullptr, pen, bounds, &textWidth), OH_DRAWING_SUCCESS); 514 OH_Drawing_Typeface* typeface = OH_Drawing_TypefaceCreateDefault(); 515 OH_Drawing_FontSetTypeface(font, typeface); 516 OH_Drawing_FontSetFakeBoldText(font, true); 517 OH_Drawing_FontSetScaleX(font, 0.5f); 518 OH_Drawing_FontSetHinting(font, FONT_HINTING_SLIGHT); 519 EXPECT_EQ(OH_Drawing_FontMeasureTextWithBrushOrPen(font, text, strlen(text), 520 TEXT_ENCODING_UTF8, brush, nullptr, bounds, &textWidth), OH_DRAWING_SUCCESS); 521 OH_Drawing_TextEncoding encodes[] = { 522 TEXT_ENCODING_UTF8, 523 TEXT_ENCODING_UTF16, 524 TEXT_ENCODING_UTF32, 525 TEXT_ENCODING_GLYPH_ID, 526 }; 527 for (OH_Drawing_TextEncoding encode : encodes) { 528 OH_Drawing_ErrorCode errorCode = OH_Drawing_FontMeasureTextWithBrushOrPen(font, text, strlen(text), 529 encode, brush, nullptr, bounds, &textWidth); 530 EXPECT_EQ(errorCode, OH_DRAWING_SUCCESS); 531 } 532 OH_Drawing_ErrorCode errorCode = OH_Drawing_FontMeasureTextWithBrushOrPen(font, text, strlen(text), 533 TEXT_ENCODING_UTF8, brush, nullptr, bounds, &textWidth); 534 EXPECT_EQ(errorCode, OH_DRAWING_SUCCESS); 535 EXPECT_EQ(static_cast<int>(textWidth), 100); // Inspection textwidth 536 const char* text1 = "hello world"; 537 errorCode = OH_Drawing_FontMeasureTextWithBrushOrPen(font, text1, strlen(text1), 538 TEXT_ENCODING_UTF8, brush, nullptr, bounds, &textWidth); 539 EXPECT_EQ(errorCode, OH_DRAWING_SUCCESS); 540 EXPECT_EQ(static_cast<int>(textWidth), 126); // Inspection textwidth 541 const char* text2 = "1234567890 !@#$%^&*("; 542 errorCode = OH_Drawing_FontMeasureTextWithBrushOrPen(font, text2, strlen(text2), 543 TEXT_ENCODING_UTF8, nullptr, pen, bounds, &textWidth); 544 EXPECT_EQ(errorCode, OH_DRAWING_SUCCESS); 545 EXPECT_EQ(static_cast<int>(textWidth), 277); // Inspection textwidth 546 OH_Drawing_RectDestroy(bounds); 547 OH_Drawing_BrushDestroy(brush); 548 OH_Drawing_PenDestroy(pen); 549 OH_Drawing_FontDestroy(font); 550 } 551 552 /* 553 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_FONT_2601 554 * @tc.name: testFontMeasureTextWithBrushOrPenNormal2 555 * @tc.desc: test for testFontMeasureTextWithBrushOrPenNormal2 556 * @tc.size : SmallTest 557 * @tc.type : Function 558 * @tc.level : Level 0 559 */ 560 HWTEST_F(DrawingNativeFontPart2Test, testFontMeasureTextWithBrushOrPenNormal2, Function | SmallTest | Level0) { 561 OH_Drawing_Font *font = OH_Drawing_FontCreate(); 562 OH_Drawing_FontSetTextSize(font, 50.0f); 563 const char* text = "你好世界"; 564 float textWidth; 565 OH_Drawing_Brush* brush = OH_Drawing_BrushCreate(); 566 OH_Drawing_Pen* pen = OH_Drawing_PenCreate(); 567 OH_Drawing_Rect* bounds = OH_Drawing_RectCreate(0.0, 0.0, 200.0, 200.0); 568 // Both brush and pen pass to nullptr 569 EXPECT_EQ(OH_Drawing_FontMeasureTextWithBrushOrPen(font, text, strlen(text), 570 TEXT_ENCODING_UTF8, nullptr, nullptr, bounds, &textWidth), OH_DRAWING_SUCCESS); 571 // Pass in the styled brush 572 OH_Drawing_BrushSetColor(brush, 0xFF00FFFF); 573 OH_Drawing_BrushSetAlpha(brush, 100); // Alpha 100 574 OH_Drawing_BrushSetAntiAlias(brush, true); 575 EXPECT_EQ(OH_Drawing_FontMeasureTextWithBrushOrPen(font, text, strlen(text), 576 TEXT_ENCODING_UTF8, brush, nullptr, bounds, &textWidth), OH_DRAWING_SUCCESS); 577 // Pass in the styled pen 578 OH_Drawing_PenSetWidth(pen, 10.0f); 579 OH_Drawing_PenSetColor(pen, 0xFF00FFFF); 580 OH_Drawing_PenSetAlpha(pen, 100); // Alpha 100 581 OH_Drawing_PenSetAntiAlias(pen, true); 582 EXPECT_EQ(OH_Drawing_FontMeasureTextWithBrushOrPen(font, text, strlen(text), 583 TEXT_ENCODING_UTF8, nullptr, pen, bounds, &textWidth), OH_DRAWING_SUCCESS); 584 // Verify the bounds 585 const char* text1 = "hello world"; 586 OH_Drawing_ErrorCode errorCode = OH_Drawing_FontMeasureTextWithBrushOrPen(font, text1, strlen(text1), 587 TEXT_ENCODING_UTF8, brush, nullptr, bounds, &textWidth); 588 EXPECT_EQ(errorCode, OH_DRAWING_SUCCESS); 589 EXPECT_EQ(static_cast<int>(OH_Drawing_RectGetLeft(bounds)), 3); // left 3 590 EXPECT_EQ(static_cast<int>(OH_Drawing_RectGetRight(bounds)), 251); // right 251 591 EXPECT_EQ(static_cast<int>(OH_Drawing_RectGetBottom(bounds)), 1); // bottom 1 592 OH_Drawing_RectDestroy(bounds); 593 OH_Drawing_BrushDestroy(brush); 594 OH_Drawing_PenDestroy(pen); 595 OH_Drawing_FontDestroy(font); 596 } 597 598 /* 599 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_FONT_2602 600 * @tc.name: testFontMeasureTextWithBrushOrPenNull 601 * @tc.desc: test for testFontMeasureTextWithBrushOrPenNull 602 * @tc.size : SmallTest 603 * @tc.type : Function 604 * @tc.level : Level 3 605 */ 606 HWTEST_F(DrawingNativeFontPart2Test, testFontMeasureTextWithBrushOrPenNull, Function | SmallTest | Level3) { 607 OH_Drawing_Font *font = OH_Drawing_FontCreate(); 608 OH_Drawing_FontSetTextSize(font, 50.0f); 609 const char* text = "你好世界"; 610 float textWidth; 611 OH_Drawing_Brush* brush = OH_Drawing_BrushCreate(); 612 OH_Drawing_Pen* pen = OH_Drawing_PenCreate(); 613 OH_Drawing_Rect* bounds = OH_Drawing_RectCreate(0.0, 0.0, 200.0, 200.0); 614 // font passes to nullptr 615 EXPECT_EQ(OH_Drawing_FontMeasureTextWithBrushOrPen(nullptr, text, strlen(text), 616 TEXT_ENCODING_UTF8, brush, nullptr, bounds, &textWidth), OH_DRAWING_ERROR_INVALID_PARAMETER); 617 // text passes to nullptr 618 EXPECT_EQ(OH_Drawing_FontMeasureTextWithBrushOrPen(font, nullptr, strlen(text), 619 TEXT_ENCODING_UTF8, brush, nullptr, bounds, &textWidth), OH_DRAWING_ERROR_INVALID_PARAMETER); 620 // text passes to null 621 const char* text2 = ""; 622 EXPECT_EQ(OH_Drawing_FontMeasureTextWithBrushOrPen(font, text2, strlen(text), 623 TEXT_ENCODING_UTF8, brush, nullptr, bounds, &textWidth), OH_DRAWING_SUCCESS); 624 // text's length mismatch 625 EXPECT_EQ(OH_Drawing_FontMeasureTextWithBrushOrPen(font, text, 0, 626 TEXT_ENCODING_UTF8, brush, nullptr, bounds, &textWidth), OH_DRAWING_ERROR_INVALID_PARAMETER); 627 // Both brush and pen pass to nullptr 628 EXPECT_EQ(OH_Drawing_FontMeasureTextWithBrushOrPen(font, text, strlen(text), 629 TEXT_ENCODING_UTF8, nullptr, nullptr, bounds, &textWidth), OH_DRAWING_SUCCESS); 630 // textWidth passes to nullptr 631 EXPECT_EQ(OH_Drawing_FontMeasureTextWithBrushOrPen(font, text, strlen(text), 632 TEXT_ENCODING_UTF8, brush, pen, bounds, nullptr), OH_DRAWING_ERROR_INVALID_PARAMETER); 633 // bounds passes to nullptr 634 EXPECT_EQ(OH_Drawing_FontMeasureTextWithBrushOrPen(font, text, strlen(text), 635 TEXT_ENCODING_UTF8, brush, pen, nullptr, &textWidth), OH_DRAWING_ERROR_INVALID_PARAMETER); 636 OH_Drawing_RectDestroy(bounds); 637 OH_Drawing_BrushDestroy(brush); 638 OH_Drawing_PenDestroy(pen); 639 OH_Drawing_FontDestroy(font); 640 } 641 642 /* 643 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_FONT_2603 644 * @tc.name: testFontMeasureTextWithBrushOrPenAbnormal 645 * @tc.desc: test for testFontMeasureTextWithBrushOrPenAbnormal 646 * @tc.size : SmallTest 647 * @tc.type : Function 648 * @tc.level : Level 3 649 */ 650 HWTEST_F(DrawingNativeFontPart2Test, testFontMeasureTextWithBrushOrPenAbnormal, Function | SmallTest | Level3) { 651 OH_Drawing_Font *font = OH_Drawing_FontCreate(); 652 OH_Drawing_FontSetTextSize(font, 50.0f); 653 const char* text = "你好世界"; 654 float textWidth; 655 OH_Drawing_Brush* brush = OH_Drawing_BrushCreate(); 656 OH_Drawing_Pen* pen = OH_Drawing_PenCreate(); 657 OH_Drawing_Rect* bounds = OH_Drawing_RectCreate(0.0, 0.0, 200.0, 200.0); 658 // byteLength passes to 0 659 EXPECT_EQ(OH_Drawing_FontMeasureTextWithBrushOrPen(font, text, 0, 660 TEXT_ENCODING_UTF8, brush, nullptr, bounds, &textWidth), OH_DRAWING_ERROR_INVALID_PARAMETER); 661 // brush and pen are not empty 662 EXPECT_EQ(OH_Drawing_FontMeasureTextWithBrushOrPen(font, text, strlen(text), 663 TEXT_ENCODING_UTF8, brush, pen, bounds, &textWidth), OH_DRAWING_ERROR_INVALID_PARAMETER); 664 OH_Drawing_RectDestroy(bounds); 665 OH_Drawing_BrushDestroy(brush); 666 OH_Drawing_PenDestroy(pen); 667 OH_Drawing_FontDestroy(font); 668 } 669 670 /* 671 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_FONT_2604 672 * @tc.name: testFontMeasureTextWithBrushOrPenMultiCalls 673 * @tc.desc: test for testFontMeasureTextWithBrushOrPenMultiCalls 674 * @tc.size : SmallTest 675 * @tc.type : Function 676 * @tc.level : Level 3 677 */ 678 HWTEST_F(DrawingNativeFontPart2Test, testFontMeasureTextWithBrushOrPenMultiCalls, Function | SmallTest | Level3) { 679 OH_Drawing_Font *font = OH_Drawing_FontCreate(); 680 OH_Drawing_FontSetTextSize(font, 50.0f); 681 const char* text = "你好世界"; 682 float textWidth; 683 OH_Drawing_Brush* brush = OH_Drawing_BrushCreate(); 684 OH_Drawing_Pen* pen = OH_Drawing_PenCreate(); 685 OH_Drawing_Rect* bounds = OH_Drawing_RectCreate(0.0, 0.0, 200.0, 200.0); 686 // OH_Drawing_FontMeasureTextWithBrushOrPen is called 20 times. 687 for (int i = 0; i < 20; i++) { //Number of cycles: 20 688 OH_Drawing_ErrorCode errorCode = OH_Drawing_FontMeasureTextWithBrushOrPen(font, text, strlen(text), 689 TEXT_ENCODING_UTF8, nullptr, pen, bounds, &textWidth); 690 EXPECT_EQ(errorCode, OH_DRAWING_SUCCESS); 691 } 692 OH_Drawing_RectDestroy(bounds); 693 OH_Drawing_BrushDestroy(brush); 694 OH_Drawing_PenDestroy(pen); 695 OH_Drawing_FontDestroy(font); 696 } 697 698 /* 699 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_FONT_2700 700 * @tc.name: testFontGetWidthsBoundsNormal1 701 * @tc.desc: test for testFontGetWidthsBoundsNormal1 702 * @tc.size : SmallTest 703 * @tc.type : Function 704 * @tc.level : Level 0 705 */ 706 HWTEST_F(DrawingNativeFontPart2Test, testFontGetWidthsBoundsNormal1, Function | SmallTest | Level0) { 707 OH_Drawing_Font *font = OH_Drawing_FontCreate(); 708 OH_Drawing_FontSetTextSize(font, 50.0f); 709 OH_Drawing_Brush* brush = OH_Drawing_BrushCreate(); 710 OH_Drawing_Pen* pen = OH_Drawing_PenCreate(); 711 const char* text = "你好世界"; 712 uint32_t count = 0; 713 count = OH_Drawing_FontCountText(font, text, strlen(text), TEXT_ENCODING_UTF8); 714 uint16_t glyphs[count]; 715 int glyphsCount = 0; 716 glyphsCount = OH_Drawing_FontTextToGlyphs( 717 font, text, strlen(text), OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8, glyphs, count); 718 float widths[50] = {0.f}; // 50 means widths array number 719 OH_Drawing_Array *outRectarr = OH_Drawing_RectCreateArray(count); 720 // Font does not set any attributes 721 OH_Drawing_Font *font2 = OH_Drawing_FontCreate(); 722 EXPECT_EQ(OH_Drawing_FontGetWidthsBounds(font2, glyphs, glyphsCount, nullptr, pen, widths, outRectarr), 723 OH_DRAWING_SUCCESS); 724 // Font set some attributes 725 OH_Drawing_Typeface* typeface = OH_Drawing_TypefaceCreateDefault(); 726 OH_Drawing_FontSetTypeface(font, typeface); 727 OH_Drawing_FontSetFakeBoldText(font, true); 728 OH_Drawing_FontSetScaleX(font, 0.5f); 729 OH_Drawing_FontSetHinting(font, FONT_HINTING_SLIGHT); 730 count = OH_Drawing_FontCountText(font, text, strlen(text), TEXT_ENCODING_UTF8); 731 glyphsCount = OH_Drawing_FontTextToGlyphs( 732 font, text, strlen(text), OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8, glyphs, count); 733 EXPECT_EQ(OH_Drawing_FontGetWidthsBounds(font, glyphs, glyphsCount, brush, nullptr, widths, outRectarr), 734 OH_DRAWING_SUCCESS); 735 OH_Drawing_RectDestroyArray(outRectarr); 736 OH_Drawing_BrushDestroy(brush); 737 OH_Drawing_PenDestroy(pen); 738 OH_Drawing_FontDestroy(font); 739 } 740 741 /* 742 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_FONT_2701 743 * @tc.name: testFontGetWidthsBoundsNormal2 744 * @tc.desc: test for testFontGetWidthsBoundsNormal2 745 * @tc.size : SmallTest 746 * @tc.type : Function 747 * @tc.level : Level 0 748 */ 749 HWTEST_F(DrawingNativeFontPart2Test, testFontGetWidthsBoundsNormal2, Function | SmallTest | Level0) { 750 OH_Drawing_Font *font = OH_Drawing_FontCreate(); 751 OH_Drawing_FontSetTextSize(font, 50.0f); 752 OH_Drawing_Brush* brush = OH_Drawing_BrushCreate(); 753 OH_Drawing_Pen* pen = OH_Drawing_PenCreate(); 754 const char* text = "你好世界"; 755 uint32_t count = 0; 756 count = OH_Drawing_FontCountText(font, text, strlen(text), TEXT_ENCODING_UTF8); 757 uint16_t glyphs[count]; 758 int glyphsCount = 0; 759 glyphsCount = OH_Drawing_FontTextToGlyphs( 760 font, text, strlen(text), OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8, glyphs, count); 761 float widths[50] = {0.f}; // 50 means widths array number 762 OH_Drawing_Array *outRectarr = OH_Drawing_RectCreateArray(count); 763 std::vector<int> widthArr = {50, 50, 50, 50}; // num of four to font 764 OH_Drawing_ErrorCode errorCode = OH_Drawing_FontGetWidthsBounds( 765 font, glyphs, glyphsCount, brush, nullptr, widths, nullptr); 766 EXPECT_EQ(errorCode, OH_DRAWING_SUCCESS); 767 for (int i = 0; i < count; i++) { 768 EXPECT_EQ((int)widths[i], widthArr[i]); 769 } 770 errorCode = OH_Drawing_FontGetWidthsBounds(font, glyphs, glyphsCount, nullptr, pen, nullptr, outRectarr); 771 EXPECT_EQ(errorCode, OH_DRAWING_SUCCESS); 772 std::vector<std::array<int, 4>> arr = { { 0, -42, 48, 3 }, { 1, -42, 48, 3 }, { 2, -42, 47, 2 }, { 1, -40, 48, 3 }}; 773 for (int i = 0; i < count; i++) { 774 OH_Drawing_Rect* iter = nullptr; 775 EXPECT_EQ(OH_Drawing_RectGetArrayElement(outRectarr, i, &iter), OH_DRAWING_SUCCESS); 776 ASSERT_NE(iter, nullptr); 777 EXPECT_EQ((int)OH_Drawing_RectGetLeft(iter), arr[i][0]); 778 EXPECT_EQ((int)OH_Drawing_RectGetTop(iter), arr[i][1]); 779 EXPECT_EQ((int)OH_Drawing_RectGetRight(iter), arr[i][2]); 780 EXPECT_EQ((int)OH_Drawing_RectGetBottom(iter), arr[i][3]); 781 EXPECT_EQ(OH_Drawing_RectGetBottom(iter) - OH_Drawing_RectGetTop(iter), OH_Drawing_RectGetHeight(iter)); 782 EXPECT_EQ(OH_Drawing_RectGetRight(iter) - OH_Drawing_RectGetLeft(iter), OH_Drawing_RectGetWidth(iter)); 783 } 784 OH_Drawing_BrushSetColor(brush, 0xFF00FFFF); 785 OH_Drawing_BrushSetAlpha(brush, 100); // Alpha 100 786 OH_Drawing_BrushSetAntiAlias(brush, true); 787 EXPECT_EQ(OH_Drawing_FontGetWidthsBounds(font, glyphs, glyphsCount, brush, nullptr, widths, outRectarr), 788 OH_DRAWING_SUCCESS); 789 OH_Drawing_PenSetWidth(pen, 10.0f); 790 OH_Drawing_PenSetColor(pen, 0xFF00FFFF); 791 OH_Drawing_PenSetAlpha(pen, 100); // Alpha 100 792 OH_Drawing_PenSetAntiAlias(pen, true); 793 EXPECT_EQ(OH_Drawing_FontGetWidthsBounds(font, glyphs, glyphsCount, nullptr, pen, widths, outRectarr), 794 OH_DRAWING_SUCCESS); 795 OH_Drawing_RectDestroyArray(outRectarr); 796 OH_Drawing_BrushDestroy(brush); 797 OH_Drawing_PenDestroy(pen); 798 OH_Drawing_FontDestroy(font); 799 } 800 801 /* 802 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_FONT_2702 803 * @tc.name: testFontGetWidthsBoundsNull 804 * @tc.desc: test for testFontGetWidthsBoundsNull 805 * @tc.size : SmallTest 806 * @tc.type : Function 807 * @tc.level : Level 3 808 */ 809 HWTEST_F(DrawingNativeFontPart2Test, testFontGetWidthsBoundsNull, Function | SmallTest | Level3) { 810 OH_Drawing_Font *font = OH_Drawing_FontCreate(); 811 OH_Drawing_FontSetTextSize(font, 50.0f); 812 OH_Drawing_Brush* brush = OH_Drawing_BrushCreate(); 813 OH_Drawing_Pen* pen = OH_Drawing_PenCreate(); 814 const char* text = "你好世界"; 815 uint32_t count = 0; 816 count = OH_Drawing_FontCountText(font, text, strlen(text), TEXT_ENCODING_UTF8); 817 uint16_t glyphs[count]; 818 int glyphsCount = 0; 819 glyphsCount = OH_Drawing_FontTextToGlyphs( 820 font, text, strlen(text), OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8, glyphs, count); 821 float widths[50] = {0.f}; // 50 means widths array number 822 OH_Drawing_Array *outRectarr = OH_Drawing_RectCreateArray(count); 823 // Font passes to nullptr 824 EXPECT_EQ(OH_Drawing_FontGetWidthsBounds(nullptr, glyphs, glyphsCount, nullptr, pen, widths, outRectarr), 825 OH_DRAWING_ERROR_INVALID_PARAMETER); 826 // Glyphs passes to nullptr 827 EXPECT_EQ(OH_Drawing_FontGetWidthsBounds(font, nullptr, glyphsCount, nullptr, pen, widths, outRectarr), 828 OH_DRAWING_ERROR_INVALID_PARAMETER); 829 // Both brush and pen pass to nullptr 830 EXPECT_EQ(OH_Drawing_FontGetWidthsBounds(font, glyphs, glyphsCount, nullptr, nullptr, widths, outRectarr), 831 OH_DRAWING_SUCCESS); 832 // Widths pass to nullptr 833 EXPECT_EQ(OH_Drawing_FontGetWidthsBounds(font, glyphs, glyphsCount, nullptr, pen, nullptr, outRectarr), 834 OH_DRAWING_SUCCESS); 835 // Bounds pass to nullptr 836 EXPECT_EQ(OH_Drawing_FontGetWidthsBounds(font, glyphs, glyphsCount, nullptr, pen, widths, nullptr), 837 OH_DRAWING_SUCCESS); 838 // Widths and Bounds pass to nullptr 839 EXPECT_EQ(OH_Drawing_FontGetWidthsBounds(font, glyphs, glyphsCount, nullptr, pen, nullptr, nullptr), 840 OH_DRAWING_ERROR_INVALID_PARAMETER); 841 OH_Drawing_RectDestroyArray(outRectarr); 842 OH_Drawing_BrushDestroy(brush); 843 OH_Drawing_PenDestroy(pen); 844 OH_Drawing_FontDestroy(font); 845 } 846 847 /* 848 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_FONT_2703 849 * @tc.name: testFontGetWidthsBoundsAbnormal 850 * @tc.desc: test for testFontGetWidthsBoundsAbnormal 851 * @tc.size : SmallTest 852 * @tc.type : Function 853 * @tc.level : Level 3 854 */ 855 HWTEST_F(DrawingNativeFontPart2Test, testFontGetWidthsBoundsAbnormal, Function | SmallTest | Level3) { 856 OH_Drawing_Font *font = OH_Drawing_FontCreate(); 857 OH_Drawing_FontSetTextSize(font, 50.0f); 858 OH_Drawing_Brush* brush = OH_Drawing_BrushCreate(); 859 OH_Drawing_Pen* pen = OH_Drawing_PenCreate(); 860 const char* text = "你好世界"; 861 uint32_t count = 0; 862 count = OH_Drawing_FontCountText(font, text, strlen(text), TEXT_ENCODING_UTF8); 863 uint16_t glyphs[count]; 864 int glyphsCount = 0; 865 glyphsCount = OH_Drawing_FontTextToGlyphs( 866 font, text, strlen(text), OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8, glyphs, count); 867 float widths[50] = {0.f}; // 50 means widths array number 868 OH_Drawing_Array *outRectarr = OH_Drawing_RectCreateArray(count); 869 // count passes to 0 870 EXPECT_EQ(OH_Drawing_FontGetWidthsBounds(font, glyphs, 0, nullptr, pen, widths, outRectarr), 871 OH_DRAWING_ERROR_INVALID_PARAMETER); 872 // count passes to negative number 873 EXPECT_EQ(OH_Drawing_FontGetWidthsBounds(font, glyphs, -1, nullptr, pen, widths, outRectarr), 874 OH_DRAWING_ERROR_INVALID_PARAMETER); 875 // The input parameter of count is less than the length of the glyphs array 876 EXPECT_EQ(OH_Drawing_FontGetWidthsBounds(font, glyphs, sizeof(glyphs)/sizeof(glyphs[0]) - 1, nullptr, 877 pen, widths, nullptr), OH_DRAWING_SUCCESS); 878 // Both brush and pen are not empty 879 EXPECT_EQ(OH_Drawing_FontGetWidthsBounds(font, glyphs, glyphsCount, brush, pen, widths, outRectarr), 880 OH_DRAWING_ERROR_INVALID_PARAMETER); 881 OH_Drawing_RectDestroyArray(outRectarr); 882 OH_Drawing_BrushDestroy(brush); 883 OH_Drawing_PenDestroy(pen); 884 OH_Drawing_FontDestroy(font); 885 } 886 887 /* 888 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_FONT_2704 889 * @tc.name: testFontGetWidthsBoundsMultiCalls 890 * @tc.desc: test for testFontGetWidthsBoundsMultiCalls 891 * @tc.size : SmallTest 892 * @tc.type : Function 893 * @tc.level : Level 3 894 */ 895 HWTEST_F(DrawingNativeFontPart2Test, testFontGetWidthsBoundsMultiCalls, Function | SmallTest | Level3) { 896 OH_Drawing_Font *font = OH_Drawing_FontCreate(); 897 OH_Drawing_FontSetTextSize(font, 50.0f); 898 OH_Drawing_Brush* brush = OH_Drawing_BrushCreate(); 899 OH_Drawing_Pen* pen = OH_Drawing_PenCreate(); 900 const char* text = "你好世界"; 901 uint32_t count = 0; 902 count = OH_Drawing_FontCountText(font, text, strlen(text), TEXT_ENCODING_UTF8); 903 uint16_t glyphs[count]; 904 int glyphsCount = 0; 905 glyphsCount = OH_Drawing_FontTextToGlyphs( 906 font, text, strlen(text), OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8, glyphs, count); 907 float widths[50] = {0.f}; // 50 means widths array number 908 OH_Drawing_Array *outRectarr = OH_Drawing_RectCreateArray(count); 909 // OH_Drawing_FontGetWidthsBounds is called 20 times 910 OH_Drawing_ErrorCode errorCode; 911 for (int i = 0; i < 20; i++) { //Number of cycles: 20 912 errorCode = OH_Drawing_FontGetWidthsBounds(font, glyphs, glyphsCount, brush, nullptr, widths, outRectarr); 913 EXPECT_EQ(errorCode, OH_DRAWING_SUCCESS); 914 } 915 OH_Drawing_RectDestroyArray(outRectarr); 916 OH_Drawing_BrushDestroy(brush); 917 OH_Drawing_PenDestroy(pen); 918 OH_Drawing_FontDestroy(font); 919 } 920 921 /* 922 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_FONT_2800 923 * @tc.name: testFontGePosNormal 924 * @tc.desc: test for testFontGePosNormal 925 * @tc.size : SmallTest 926 * @tc.type : Function 927 * @tc.level : Level 0 928 */ 929 HWTEST_F(DrawingNativeFontPart2Test, testFontGePosNormal, Function | SmallTest | Level0) { 930 OH_Drawing_Font *font = OH_Drawing_FontCreate(); 931 OH_Drawing_FontSetTextSize(font, 50.0f); 932 //font Different words 933 const char* text = "你好世界"; 934 uint32_t count = 0; 935 count = OH_Drawing_FontCountText(font, text, strlen(text), TEXT_ENCODING_UTF8); 936 OH_Drawing_Point *point = OH_Drawing_PointCreate(10.0, 10.0); 937 uint16_t glyphs[count]; 938 int glyphsCount = 0; 939 glyphsCount = OH_Drawing_FontTextToGlyphs( 940 font, text, strlen(text), OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8, glyphs, count); 941 OH_Drawing_Point2D* points = new OH_Drawing_Point2D[count]; 942 //font does not set any attributes 943 OH_Drawing_ErrorCode errorCode = OH_Drawing_FontGetPos(font, glyphs, glyphsCount, point, points); 944 EXPECT_EQ(errorCode, OH_DRAWING_SUCCESS); 945 std::vector<std::array<int, 2>> testPoints = {{10, 10}, {60, 10}, {110, 10}, {160, 10}}; 946 for (int i = 0; i < count; i++) { 947 EXPECT_EQ((int)points[i].x, testPoints[i][0]); 948 EXPECT_EQ((int)points[i].y, testPoints[i][1]); 949 } 950 //length count < glyphs 951 OH_Drawing_ErrorCode errorCode2 = OH_Drawing_FontGetPos(font, glyphs, sizeof(glyphs)/sizeof(glyphs[0])-1, 952 point, points); 953 EXPECT_EQ(errorCode2, OH_DRAWING_SUCCESS); 954 OH_Drawing_Typeface* typeface = OH_Drawing_TypefaceCreateDefault(); 955 OH_Drawing_FontSetTypeface(font, typeface); 956 OH_Drawing_FontSetFakeBoldText(font, true); 957 OH_Drawing_FontSetScaleX(font, 0.5f); 958 OH_Drawing_FontSetHinting(font, FONT_HINTING_SLIGHT); 959 //font set some attributes 960 OH_Drawing_ErrorCode errorCode1 = OH_Drawing_FontGetPos(font, glyphs, glyphsCount, point, points); 961 EXPECT_EQ(errorCode1, OH_DRAWING_SUCCESS); 962 OH_Drawing_PointDestroy(point); 963 if (points != nullptr) { 964 delete[] points; 965 } 966 OH_Drawing_FontDestroy(font); 967 } 968 969 /* 970 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_FONT_2801 971 * @tc.name: testFontGetPosNormal1 972 * @tc.desc: test for testFontGetPosNormal1 973 * @tc.size : SmallTest 974 * @tc.type : Function 975 * @tc.level : Level 0 976 */ 977 HWTEST_F(DrawingNativeFontPart2Test, testFontGetPosNormal1, Function | SmallTest | Level0) { 978 OH_Drawing_Font *font = OH_Drawing_FontCreate(); 979 OH_Drawing_FontSetTextSize(font, 50.0f); 980 const char* text = "1234"; 981 uint32_t count1 = 0; 982 count1 = OH_Drawing_FontCountText(font, text, strlen(text), TEXT_ENCODING_UTF8); 983 OH_Drawing_Point *point1 = OH_Drawing_PointCreate(100.0, 0.0); 984 std::vector<std::array<int, 2>> testPoints1 = {{100, 0}, {129, 0}, {158, 0}, {187, 0}}; 985 uint16_t glyphs1[count1]; 986 int glyphsCount1 = 0; 987 glyphsCount1 = OH_Drawing_FontTextToGlyphs( 988 font, text, strlen(text), OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8, glyphs1, count1); 989 OH_Drawing_Point2D* points1 = new OH_Drawing_Point2D[count1]; 990 OH_Drawing_ErrorCode errorCode1 = OH_Drawing_FontGetPos(font, glyphs1, glyphsCount1, point1, points1); 991 EXPECT_EQ(errorCode1, OH_DRAWING_SUCCESS); 992 for (int i = 0; i < count1; i++) { 993 EXPECT_EQ((int)points1[i].x, testPoints1[i][0]); 994 EXPECT_EQ((int)points1[i].y, testPoints1[i][1]); 995 } 996 uint32_t count2 = 0; 997 count2 = OH_Drawing_FontCountText(font, text, strlen(text), TEXT_ENCODING_UTF8); 998 OH_Drawing_Point *point2 = OH_Drawing_PointCreate(0.0, 100.0); 999 std::vector<std::array<int, 2>> testPoints2 = {{0, 100}, {29, 100}, {58, 100}, {87, 100}}; 1000 uint16_t glyphs2[count2]; 1001 int glyphsCount2 = 0; 1002 glyphsCount2 = OH_Drawing_FontTextToGlyphs( 1003 font, text, strlen(text), OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8, glyphs2, count2); 1004 OH_Drawing_Point2D* points2 = new OH_Drawing_Point2D[count2]; 1005 OH_Drawing_ErrorCode errorCode2 = OH_Drawing_FontGetPos(font, glyphs2, glyphsCount2, point2, points2); 1006 EXPECT_EQ(errorCode2, OH_DRAWING_SUCCESS); 1007 for (int i = 0; i < count2; i++) { 1008 EXPECT_EQ((int)points2[i].x, testPoints2[i][0]); 1009 EXPECT_EQ((int)points2[i].y, testPoints2[i][1]); 1010 } 1011 OH_Drawing_PointDestroy(point1); 1012 OH_Drawing_PointDestroy(point2); 1013 if (points1 != nullptr || points2 != nullptr) { 1014 delete[] points1; 1015 delete[] points2; 1016 } 1017 OH_Drawing_FontDestroy(font); 1018 } 1019 1020 /* 1021 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_FONT_2802 1022 * @tc.name: testFontGePosNormal2 1023 * @tc.desc: test for testFontGePosNormal2 1024 * @tc.size : SmallTest 1025 * @tc.type : Function 1026 * @tc.level : Level 0 1027 */ 1028 HWTEST_F(DrawingNativeFontPart2Test, testFontGePosNormal2, Function | SmallTest | Level0) { 1029 OH_Drawing_Font *font = OH_Drawing_FontCreate(); 1030 OH_Drawing_FontSetTextSize(font, 50.0f); 1031 const char* text = "1234"; 1032 uint32_t count1 = 0; 1033 count1 = OH_Drawing_FontCountText(font, text, strlen(text), TEXT_ENCODING_UTF8); 1034 OH_Drawing_Point *point1 = OH_Drawing_PointCreate(100.25, 200.585); 1035 std::vector<std::array<float, 2>> testPoints1 = {{100.25, 200.585007}, {129.25, 200.585007}, 1036 {158.25, 200.585007}, {187.25, 200.585007}}; 1037 uint16_t glyphs1[count1]; 1038 int glyphsCount1 = 0; 1039 glyphsCount1 = OH_Drawing_FontTextToGlyphs( 1040 font, text, strlen(text), OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8, glyphs1, count1); 1041 OH_Drawing_Point2D* points1 = new OH_Drawing_Point2D[count1]; 1042 OH_Drawing_ErrorCode errorCode1 = OH_Drawing_FontGetPos(font, glyphs1, glyphsCount1, point1, points1); 1043 EXPECT_EQ(errorCode1, OH_DRAWING_SUCCESS); 1044 for (int i = 0; i < count1; i++) { 1045 EXPECT_EQ(points1[i].x, testPoints1[i][0]); 1046 EXPECT_EQ(points1[i].y, testPoints1[i][1]); 1047 } 1048 uint32_t count2 = 0; 1049 count2 = OH_Drawing_FontCountText(font, text, strlen(text), TEXT_ENCODING_UTF8); 1050 OH_Drawing_Point *point2 = OH_Drawing_PointCreate(-100.0, -100.0); 1051 std::vector<std::array<int, 2>> testPoints2 = {{-100, -100}, {-71, -100}, {-42, -100}, {-13, -100}}; 1052 uint16_t glyphs2[count2]; 1053 int glyphsCount2 = 0; 1054 glyphsCount2 = OH_Drawing_FontTextToGlyphs( 1055 font, text, strlen(text), OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8, glyphs2, count2); 1056 OH_Drawing_Point2D* points2 = new OH_Drawing_Point2D[count2]; 1057 OH_Drawing_ErrorCode errorCode2 = OH_Drawing_FontGetPos(font, glyphs2, glyphsCount2, point2, points2); 1058 EXPECT_EQ(errorCode2, OH_DRAWING_SUCCESS); 1059 for (int i = 0; i < count2; i++) { 1060 EXPECT_EQ((int)points2[i].x, testPoints2[i][0]); 1061 EXPECT_EQ((int)points2[i].y, testPoints2[i][1]); 1062 } 1063 OH_Drawing_PointDestroy(point1); 1064 OH_Drawing_PointDestroy(point2); 1065 if (points1 != nullptr || points2 != nullptr) { 1066 delete[] points1; 1067 delete[] points2; 1068 } 1069 OH_Drawing_FontDestroy(font); 1070 } 1071 /* 1072 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_FONT_2803 1073 * @tc.name: testFontGePosNull 1074 * @tc.desc: test for testFontGePosNull 1075 * @tc.size : SmallTest 1076 * @tc.type : Function 1077 * @tc.level : Level 3 1078 */ 1079 HWTEST_F(DrawingNativeFontPart2Test, testFontGePosNull, Function | SmallTest | Level3) { 1080 OH_Drawing_Font *font = OH_Drawing_FontCreate(); 1081 OH_Drawing_FontSetTextSize(font, 50.0f); 1082 const char* text = "你好"; 1083 uint32_t count = 0; 1084 count = OH_Drawing_FontCountText(font, text, strlen(text), TEXT_ENCODING_UTF8); 1085 OH_Drawing_Point *point = OH_Drawing_PointCreate(10.0, 10.0); 1086 uint16_t glyphs[count]; 1087 int glyphsCount = 0; 1088 glyphsCount = OH_Drawing_FontTextToGlyphs( 1089 font, text, strlen(text), OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8, glyphs, count); 1090 OH_Drawing_Point2D* points = new OH_Drawing_Point2D[count]; 1091 EXPECT_EQ(OH_Drawing_FontGetPos(nullptr, glyphs, glyphsCount, point, points), OH_DRAWING_ERROR_INVALID_PARAMETER); 1092 EXPECT_EQ(OH_Drawing_FontGetPos(font, nullptr, glyphsCount, point, points), OH_DRAWING_ERROR_INVALID_PARAMETER); 1093 EXPECT_EQ(OH_Drawing_FontGetPos(font, glyphs, glyphsCount, nullptr, nullptr), OH_DRAWING_ERROR_INVALID_PARAMETER); 1094 OH_Drawing_Point *point1 = OH_Drawing_PointCreate(0.0, 0.0); 1095 EXPECT_EQ(OH_Drawing_FontGetPos(font, glyphs, glyphsCount, point1, points), OH_DRAWING_SUCCESS); 1096 OH_Drawing_PointDestroy(point); 1097 OH_Drawing_PointDestroy(point1); 1098 if (points != nullptr) { 1099 delete[] points; 1100 } 1101 OH_Drawing_FontDestroy(font); 1102 } 1103 1104 /* 1105 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_FONT_2804 1106 * @tc.name: testFontGePosMultiplieCalls 1107 * @tc.desc: test for testFontGePosMultiplieCalls 1108 * @tc.size : SmallTest 1109 * @tc.type : Function 1110 * @tc.level : Level 3 1111 */ 1112 HWTEST_F(DrawingNativeFontPart2Test, testFontGePosMultiplieCalls, Function | SmallTest | Level3) { 1113 OH_Drawing_Font *font = OH_Drawing_FontCreate(); 1114 OH_Drawing_FontSetTextSize(font, 50.0f); 1115 const char* text = "你好"; 1116 uint32_t count = 0; 1117 count = OH_Drawing_FontCountText(font, text, strlen(text), TEXT_ENCODING_UTF8); 1118 OH_Drawing_Point *point = OH_Drawing_PointCreate(10.0, 10.0); 1119 uint16_t glyphs[count]; 1120 int glyphsCount = 0; 1121 glyphsCount = OH_Drawing_FontTextToGlyphs( 1122 font, text, strlen(text), OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8, glyphs, count); 1123 OH_Drawing_Point2D* points = new OH_Drawing_Point2D[count]; 1124 for (int i = 0; i < 20; i++) { //Number of cycles: 20 1125 EXPECT_EQ(OH_Drawing_FontGetPos(font, glyphs, glyphsCount, point, points), OH_DRAWING_SUCCESS); 1126 } 1127 OH_Drawing_FontDestroy(font); 1128 OH_Drawing_PointDestroy(point); 1129 if (points != nullptr) { 1130 delete[] points; 1131 } 1132 } 1133 1134 /* 1135 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_FONT_2805 1136 * @tc.name: testFontGePosAbnormal 1137 * @tc.desc: test for testFontGePosAbnormal. 1138 * @tc.size : SmallTest 1139 * @tc.type : Function 1140 * @tc.level : Level 3 1141 */ 1142 HWTEST_F(DrawingNativeFontPart2Test, testFontGePosAbnormal, Function | SmallTest | Level3) { 1143 OH_Drawing_Font *font = OH_Drawing_FontCreate(); 1144 OH_Drawing_FontSetTextSize(font, 50.0f); 1145 const char* text = "你好"; 1146 uint32_t count = 0; 1147 count = OH_Drawing_FontCountText(font, text, strlen(text), TEXT_ENCODING_UTF8); 1148 OH_Drawing_Point *point = OH_Drawing_PointCreate(10.0, 10.0); 1149 uint16_t glyphs[count]; 1150 int glyphsCount = 0; 1151 glyphsCount = OH_Drawing_FontTextToGlyphs( 1152 font, text, strlen(text), OH_Drawing_TextEncoding::TEXT_ENCODING_UTF8, glyphs, count); 1153 OH_Drawing_Point2D* points = new OH_Drawing_Point2D[count]; 1154 EXPECT_EQ(OH_Drawing_FontGetPos(font, glyphs, 0, point, points), OH_DRAWING_ERROR_INVALID_PARAMETER); 1155 EXPECT_EQ(OH_Drawing_FontGetPos(font, glyphs, -1, point, points), OH_DRAWING_ERROR_INVALID_PARAMETER); 1156 OH_Drawing_FontDestroy(font); 1157 OH_Drawing_PointDestroy(point); 1158 if (points != nullptr) { 1159 delete[] points; 1160 } 1161 } 1162 /* 1163 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_FONT_2900 1164 * @tc.name: testFontGeSpacingNormal 1165 * @tc.desc: test for testFontGeSpacingNormal. 1166 * @tc.size : SmallTest 1167 * @tc.type : Function 1168 * @tc.level : Level 0 1169 */ 1170 HWTEST_F(DrawingNativeFontPart2Test, testFontGeSpacingNormal, Function | SmallTest | Level0) { 1171 OH_Drawing_Font *font = OH_Drawing_FontCreate(); 1172 float spacing = 0.0f; 1173 OH_Drawing_ErrorCode errorCode = OH_Drawing_FontGetSpacing(font, &spacing); 1174 EXPECT_EQ(errorCode, OH_DRAWING_SUCCESS); 1175 OH_Drawing_Typeface* typeface = OH_Drawing_TypefaceCreateDefault(); 1176 OH_Drawing_FontSetTypeface(font, typeface); 1177 OH_Drawing_FontSetTextSize(font, 30.0f); 1178 OH_Drawing_FontSetFakeBoldText(font, true); 1179 OH_Drawing_FontSetScaleX(font, 0.5f); 1180 OH_Drawing_FontSetHinting(font, FONT_HINTING_SLIGHT); 1181 OH_Drawing_ErrorCode errorCode1 = OH_Drawing_FontGetSpacing(font, &spacing); 1182 EXPECT_EQ(errorCode1, OH_DRAWING_SUCCESS); 1183 EXPECT_EQ(std::fabs(spacing - 35.16) < 1e-6, true); 1184 OH_Drawing_FontDestroy(font); 1185 } 1186 1187 /* 1188 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_FONT_2901 1189 * @tc.name: testFontGeSpacingMultiplieCalls 1190 * @tc.desc: test for testFontGeSpacingMultiplieCalls. 1191 * @tc.size : SmallTest 1192 * @tc.type : Function 1193 * @tc.level : Level 3 1194 */ 1195 HWTEST_F(DrawingNativeFontPart2Test, testFontGeSpacingMultiplieCalls, Function | SmallTest | Level3) { 1196 OH_Drawing_Font *font = OH_Drawing_FontCreate(); 1197 OH_Drawing_FontSetTextSize(font, 30.0f); 1198 float spacing = 0.0f; 1199 for (int i = 0; i < 20; i++) { //Number of cycles: 20 1200 EXPECT_EQ(OH_Drawing_FontGetSpacing(font, &spacing), OH_DRAWING_SUCCESS); 1201 } 1202 EXPECT_EQ(std::fabs(spacing - 35.16) < 1e-6, true); 1203 OH_Drawing_FontDestroy(font); 1204 } 1205 1206 /* 1207 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_FONT_2902 1208 * @tc.name: testFontGeSpacingNull 1209 * @tc.desc: test for testFontGeSpacingNull 1210 * @tc.size : SmallTest 1211 * @tc.type : Function 1212 * @tc.level : Level 3 1213 */ 1214 HWTEST_F(DrawingNativeFontPart2Test, testFontGeSpacingNull, Function | SmallTest | Level3) { 1215 OH_Drawing_Font *font = OH_Drawing_FontCreate(); 1216 OH_Drawing_FontSetTextSize(font, 30.0f); 1217 float spacing = 0.0f; 1218 EXPECT_EQ(OH_Drawing_FontGetSpacing(nullptr, &spacing), OH_DRAWING_ERROR_INVALID_PARAMETER); 1219 EXPECT_EQ(OH_Drawing_FontGetSpacing(font, nullptr), OH_DRAWING_ERROR_INVALID_PARAMETER); 1220 OH_Drawing_FontDestroy(font); 1221 } 1222 1223 /* 1224 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_FONT_3000 1225 * @tc.name: testFontMeasureSingleChaWithFeaturesNormal 1226 * @tc.desc: test for testFontMeasureSingleChaWithFeaturesNormal 1227 * @tc.size : SmallTest 1228 * @tc.type : Function 1229 * @tc.level : Level 0 1230 */ 1231 HWTEST_F(DrawingNativeFontPart2Test, testFontMeasureSingleChaWithFeaturesNormal, Function | SmallTest | Level0) { 1232 const char *str = "H"; 1233 OH_Drawing_Canvas* canvas = OH_Drawing_CanvasCreate(); 1234 OH_Drawing_Font *font = OH_Drawing_FontCreate(); 1235 OH_Drawing_Typeface *fileTypeface = OH_Drawing_TypefaceCreateDefault(); 1236 OH_Drawing_FontSetTextSize(font, 50.0f); 1237 OH_Drawing_FontSetTypeface(font, fileTypeface); 1238 OH_Drawing_FontFeatures* features = OH_Drawing_FontFeaturesCreate(); 1239 float textWidth = 0.0f; 1240 OH_Drawing_ErrorCode code = OH_Drawing_FontMeasureSingleCharacterWithFeatures(font, str, features, &textWidth); 1241 EXPECT_EQ(code, OH_DRAWING_SUCCESS); 1242 EXPECT_EQ(textWidth, 37.0f); 1243 str = "你"; 1244 code = OH_Drawing_FontMeasureSingleCharacterWithFeatures(font, str, features, &textWidth); 1245 EXPECT_EQ(code, OH_DRAWING_SUCCESS); 1246 EXPECT_EQ(textWidth, 50.0f); 1247 str = "（"; 1248 code = OH_Drawing_FontMeasureSingleCharacterWithFeatures(font, str, features, &textWidth); 1249 EXPECT_EQ(code, OH_DRAWING_SUCCESS); 1250 EXPECT_EQ(textWidth, 50.0f); 1251 str = "｛"; 1252 code = OH_Drawing_FontMeasureSingleCharacterWithFeatures(font, str, features, &textWidth); 1253 EXPECT_EQ(code, OH_DRAWING_SUCCESS); 1254 EXPECT_EQ(textWidth, 50.0f); 1255 str = "《"; 1256 code = OH_Drawing_FontMeasureSingleCharacterWithFeatures(font, str, features, &textWidth); 1257 EXPECT_EQ(code, OH_DRAWING_SUCCESS); 1258 EXPECT_EQ(textWidth, 50.0f); 1259 str = "8"; 1260 code = OH_Drawing_FontMeasureSingleCharacterWithFeatures(font, str, features, &textWidth); 1261 EXPECT_EQ(code, OH_DRAWING_SUCCESS); 1262 EXPECT_EQ(textWidth, 29.0f); 1263 str = "乂"; 1264 code = OH_Drawing_FontMeasureSingleCharacterWithFeatures(font, str, features, &textWidth); 1265 EXPECT_EQ(code, OH_DRAWING_SUCCESS); 1266 EXPECT_EQ(textWidth, 50.0f); 1267 str = "飛"; 1268 code = OH_Drawing_FontMeasureSingleCharacterWithFeatures(font, str, features, &textWidth); 1269 EXPECT_EQ(code, OH_DRAWING_SUCCESS); 1270 EXPECT_EQ(textWidth, 50.0f); 1271 OH_Drawing_CanvasRestore(canvas); 1272 OH_Drawing_FontDestroy(font); 1273 OH_Drawing_FontFeaturesDestroy(features); 1274 OH_Drawing_CanvasDestroy(canvas); 1275 } 1276 /* 1277 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_FONT_3001 1278 * @tc.name: testFontMeasureSingleChaWithFeaturesAbNormal 1279 * @tc.desc: test for testFontMeasureSingleChaWithFeaturesAbNormal 1280 * @tc.size : SmallTest 1281 * @tc.type : Function 1282 * @tc.level : Level 3 1283 */ 1284 HWTEST_F(DrawingNativeFontPart2Test, testFontMeasureSingleChaWithFeaturesAbNormal, Function | SmallTest | Level3) { 1285 const char *str = "（"; 1286 OH_Drawing_Font *font = OH_Drawing_FontCreate(); 1287 OH_Drawing_Canvas* canvas = OH_Drawing_CanvasCreate(); 1288 OH_Drawing_Brush *brush = OH_Drawing_BrushCreate(); 1289 OH_Drawing_BrushSetColor(brush, 0xFF0000FF); 1290 OH_Drawing_CanvasAttachBrush(canvas, brush); 1291 OH_Drawing_FontSetTextSize(font, 50.0f); 1292 OH_Drawing_FontFeatures* features = OH_Drawing_FontFeaturesCreate(); 1293 float textWidth = 0.0f; 1294 OH_Drawing_ErrorCode code = OH_Drawing_FontMeasureSingleCharacterWithFeatures(nullptr, str, features, &textWidth); 1295 EXPECT_EQ(code, OH_DRAWING_ERROR_INVALID_PARAMETER); 1296 code = OH_Drawing_FontMeasureSingleCharacterWithFeatures(font, nullptr, features, &textWidth); 1297 EXPECT_EQ(code, OH_DRAWING_ERROR_INVALID_PARAMETER); 1298 code = OH_Drawing_FontMeasureSingleCharacterWithFeatures(font, str, nullptr, &textWidth); 1299 EXPECT_EQ(code, OH_DRAWING_ERROR_INVALID_PARAMETER); 1300 code = OH_Drawing_FontMeasureSingleCharacterWithFeatures(font, str, features, nullptr); 1301 EXPECT_EQ(code, OH_DRAWING_ERROR_INVALID_PARAMETER); 1302 code = OH_Drawing_FontMeasureSingleCharacterWithFeatures(font, "", features, &textWidth); 1303 EXPECT_EQ(code, OH_DRAWING_ERROR_INVALID_PARAMETER); 1304 OH_Drawing_FontDestroy(font); 1305 OH_Drawing_CanvasDetachBrush(canvas); 1306 OH_Drawing_BrushDestroy(brush); 1307 OH_Drawing_FontFeaturesDestroy(features); 1308 OH_Drawing_CanvasDestroy(canvas); 1309 } 1310 /* 1311 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_FONT_3002 1312 * @tc.name: testFontMeasureSingleChaWithFeaturesCalls 1313 * @tc.desc: test for testFontMeasureSingleChaWithFeaturesCalls 1314 * @tc.size : SmallTest 1315 * @tc.type : Function 1316 * @tc.level : Level 2 1317 */ 1318 HWTEST_F(DrawingNativeFontPart2Test, testFontMeasureSingleChaWithFeaturesCalls, Function | SmallTest | Level2) { 1319 const char *str = "H"; 1320 OH_Drawing_Canvas* canvas = OH_Drawing_CanvasCreate(); 1321 OH_Drawing_Font *font = OH_Drawing_FontCreate(); 1322 OH_Drawing_Typeface *fileTypeface = OH_Drawing_TypefaceCreateDefault(); 1323 OH_Drawing_FontSetTextSize(font, 50.0f); 1324 OH_Drawing_FontSetTypeface(font, fileTypeface); 1325 OH_Drawing_FontFeatures* features = OH_Drawing_FontFeaturesCreate(); 1326 float textWidth = 0.0f; 1327 int count = 10; 1328 for (int i = 0; i < count; i++) { 1329 OH_Drawing_ErrorCode code = OH_Drawing_FontMeasureSingleCharacterWithFeatures(font, str, features, &textWidth); 1330 EXPECT_EQ(code, OH_DRAWING_SUCCESS); 1331 } 1332 EXPECT_EQ(textWidth, 37.0f); 1333 OH_Drawing_FontDestroy(font); 1334 OH_Drawing_FontFeaturesDestroy(features); 1335 OH_Drawing_CanvasDestroy(canvas); 1336 } 1337 /* 1338 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_FONT_3100 1339 * @tc.name: testFontFeaturesAddFeatureNormal 1340 * @tc.desc: test for testFontFeaturesAddFeatureNormal 1341 * @tc.size : SmallTest 1342 * @tc.type : Function 1343 * @tc.level : Level 2 1344 */ 1345 HWTEST_F(DrawingNativeFontPart2Test, testFontFeaturesAddFeatureNormal, Function | SmallTest | Level2) { 1346 OH_Drawing_FontFeatures* features = OH_Drawing_FontFeaturesCreate(); 1347 OH_Drawing_ErrorCode code = OH_Drawing_FontFeaturesAddFeature(features, "aaaa", 0.1f); 1348 EXPECT_EQ(code, OH_DRAWING_SUCCESS); 1349 int count = 10; 1350 for (int i = 0; i < count; i++) { 1351 code = OH_Drawing_FontFeaturesAddFeature(features, "aaaa", 0.1f); 1352 EXPECT_EQ(code, OH_DRAWING_SUCCESS); 1353 } 1354 code = OH_Drawing_FontFeaturesAddFeature(features, "aaa", 1.0f); 1355 EXPECT_EQ(code, OH_DRAWING_SUCCESS); 1356 code = OH_Drawing_FontFeaturesAddFeature(features, "aaaaa", 1.0f); 1357 EXPECT_EQ(code, OH_DRAWING_SUCCESS); 1358 OH_Drawing_FontFeaturesDestroy(features); 1359 } 1360 /* 1361 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_FONT_3101 1362 * @tc.name: testFontFeaturesAddFeatureAbNormal 1363 * @tc.desc: test for testFontFeaturesAddFeatureAbNormal 1364 * @tc.size : SmallTest 1365 * @tc.type : Function 1366 * @tc.level : Level 3 1367 */ 1368 HWTEST_F(DrawingNativeFontPart2Test, testFontFeaturesAddFeatureAbNormal, Function | SmallTest | Level3) { 1369 OH_Drawing_FontFeatures* features = OH_Drawing_FontFeaturesCreate(); 1370 OH_Drawing_ErrorCode code = OH_Drawing_FontFeaturesAddFeature(nullptr, "aaaa", 0.1f); 1371 EXPECT_EQ(code, OH_DRAWING_ERROR_INVALID_PARAMETER); 1372 code = OH_Drawing_FontFeaturesAddFeature(features, nullptr, 0.1f); 1373 EXPECT_EQ(code, OH_DRAWING_ERROR_INVALID_PARAMETER); 1374 code = OH_Drawing_FontFeaturesAddFeature(features, "aaaa", 0.0f); 1375 EXPECT_EQ(code, OH_DRAWING_SUCCESS); 1376 OH_Drawing_FontFeaturesDestroy(features); 1377 } 1378 /* 1379 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_FONT_3200 1380 * @tc.name: testFontFeaturesandFeatureDestroyNULL 1381 * @tc.desc: test for testFontFeaturesandFeatureDestroyNULL 1382 * @tc.size : SmallTest 1383 * @tc.type : Function 1384 * @tc.level : Level 3 1385 */ 1386 HWTEST_F(DrawingNativeFontPart2Test, testFontFeaturesandFeatureDestroyNULL, Function | SmallTest | Level3) { 1387 OH_Drawing_FontFeatures* features = OH_Drawing_FontFeaturesCreate(); 1388 OH_Drawing_ErrorCode code = OH_Drawing_FontFeaturesDestroy(nullptr); 1389 EXPECT_EQ(code, OH_DRAWING_ERROR_INVALID_PARAMETER); 1390 int count = 10; 1391 for (int i = 0; i < count; i++) { 1392 OH_Drawing_FontFeatures* features1 = OH_Drawing_FontFeaturesCreate(); 1393 OH_Drawing_ErrorCode code1 = OH_Drawing_FontFeaturesDestroy(features1); 1394 EXPECT_EQ(code1, OH_DRAWING_SUCCESS); 1395 } 1396 OH_Drawing_FontFeaturesDestroy(features); 1397 } 1398 } // namespace Drawing 1399 } // namespace Rosen 1400 } // namespace OHOS