1 /* 2 * Copyright (c) 2024 Huawei Device 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 #include "gtest/hwext/gtest-ext.h" 18 #include "gtest/hwext/gtest-tag.h" 19 #include "unicode/unistr.h" 20 21 #include "base/utils/utf_helper.h" 22 23 using namespace testing; 24 using namespace testing::ext; 25 namespace { 26 const std::u16string TEST_INPUT_U16_STRING = u"THIS IS A STRING"; 27 const std::u16string TEST_INPUT_U16_EMOJI = u"��������������������������������������������"; 28 const std::u32string TEST_INPUT_U32_STRING = U"THIS IS A STRING"; 29 const std::u32string TEST_INPUT_U32_EMOJI = U"��������������������������������������������"; 30 } 31 namespace OHOS::Ace::UtfUtils { 32 class UtfHelperTestOneNg : public Test { SetUp()33 void SetUp() override 34 { 35 index = 0; 36 } 37 38 public: 39 size_t index; 40 }; 41 42 /** 43 * @tc.name: DebuggerConvertRegionUtf16ToUtf8_001 44 * @tc.desc: test DebuggerConvertRegionUtf16ToUtf8 45 * @tc.type: FUNC 46 */ 47 HWTEST_F(UtfHelperTestOneNg, DebuggerConvertRegionUtf16ToUtf8_001, TestSize.Level1) 48 { 49 uint16_t utf16String[] = { 0x0048, 0x0065, 0x006C, 0x006C, 0x006F, 0x002C, 0x0020, 0x4E16, 0x754C }; 50 size_t utf16Len = sizeof(utf16String) / sizeof(utf16String[0]); 51 uint8_t utf8Buffer[100]; 52 size_t res = DebuggerConvertRegionUtf16ToUtf8(utf16String, utf8Buffer, utf16Len, sizeof(utf8Buffer), 0); 53 EXPECT_NE(res, 0); 54 } 55 56 /** 57 * @tc.name: DebuggerConvertRegionUtf16ToUtf8_002 58 * @tc.desc: test DebuggerConvertRegionUtf16ToUtf8 59 * @tc.type: FUNC 60 */ 61 HWTEST_F(UtfHelperTestOneNg, DebuggerConvertRegionUtf16ToUtf8_002, TestSize.Level1) 62 { 63 uint16_t utf16String[] = { 0x0048, 0x0065, 0x006C, 0x006C, 0x006F }; 64 size_t utf16Len = sizeof(utf16String) / sizeof(utf16String[0]); 65 uint8_t utf8Buffer[1]; 66 size_t utf8Len = 0; 67 size_t res = DebuggerConvertRegionUtf16ToUtf8(utf16String, utf8Buffer, utf16Len, utf8Len, 0); 68 EXPECT_EQ(res, 0); 69 } 70 71 /** 72 * @tc.name: DebuggerConvertRegionUtf16ToUtf8_003 73 * @tc.desc: test DebuggerConvertRegionUtf16ToUtf8 74 * @tc.type: FUNC 75 */ 76 HWTEST_F(UtfHelperTestOneNg, DebuggerConvertRegionUtf16ToUtf8_003, TestSize.Level1) 77 { 78 uint16_t utf16String[] = { 0x0048, 0x0065, 0x006C, 0x006C, 0x006F }; 79 size_t utf16Len = sizeof(utf16String) / sizeof(utf16String[0]); 80 uint8_t* utf8Buffer = nullptr; 81 size_t utf8Len = 100; 82 size_t res = DebuggerConvertRegionUtf16ToUtf8(utf16String, utf8Buffer, utf16Len, utf8Len, 0); 83 EXPECT_EQ(res, 0); 84 } 85 86 /** 87 * @tc.name: DebuggerConvertRegionUtf16ToUtf8_004 88 * @tc.desc: test DebuggerConvertRegionUtf16ToUtf8 89 * @tc.type: FUNC 90 */ 91 HWTEST_F(UtfHelperTestOneNg, DebuggerConvertRegionUtf16ToUtf8_004, TestSize.Level1) 92 { 93 const uint16_t* utf16String = nullptr; 94 uint8_t utf8Buffer[100]; 95 size_t utf8Len = 100; 96 size_t utf16Len = 5; 97 size_t res = DebuggerConvertRegionUtf16ToUtf8(utf16String, utf8Buffer, utf16Len, utf8Len, 0); 98 EXPECT_EQ(res, 0); 99 } 100 101 /** 102 * @tc.name: DebuggerConvertRegionUtf16ToUtf8_005 103 * @tc.desc: null string 104 * @tc.type: FUNC 105 */ 106 HWTEST_F(UtfHelperTestOneNg, DebuggerConvertRegionUtf16ToUtf8_005, TestSize.Level1) 107 { 108 const uint16_t* emptyInput = nullptr; 109 uint8_t output[10] = { 0 }; 110 size_t result = DebuggerConvertRegionUtf16ToUtf8(emptyInput, output, 0, 10, 0); 111 EXPECT_EQ(result, 0); 112 } 113 114 /** 115 * @tc.name: DebuggerConvertRegionUtf16ToUtf8_006 116 * @tc.desc: singlebyte string 117 * @tc.type: FUNC 118 */ 119 HWTEST_F(UtfHelperTestOneNg, DebuggerConvertRegionUtf16ToUtf8_006, TestSize.Level1) 120 { 121 const uint16_t input[] = { 0x0061 }; 122 uint8_t output[10] = { 0 }; 123 size_t result = DebuggerConvertRegionUtf16ToUtf8(input, output, 1, 10, 0); 124 EXPECT_EQ(result, 1); 125 EXPECT_EQ(output[0], 0x61); 126 } 127 128 /** 129 * @tc.name: DebuggerConvertRegionUtf16ToUtf8_007 130 * @tc.desc: twobyte string 131 * @tc.type: FUNC 132 */ 133 HWTEST_F(UtfHelperTestOneNg, DebuggerConvertRegionUtf16ToUtf8_007, TestSize.Level1) 134 { 135 const uint16_t input[] = { 0xD800, 0xDC00 }; 136 uint8_t output[10] = { 0 }; 137 size_t result = DebuggerConvertRegionUtf16ToUtf8(input, output, 2, 10, 0); 138 EXPECT_EQ(result, 4); 139 } 140 141 /** 142 * @tc.name: DebuggerConvertRegionUtf16ToUtf8_008 143 * @tc.desc: twobyte string 144 * @tc.type: FUNC 145 */ 146 HWTEST_F(UtfHelperTestOneNg, DebuggerConvertRegionUtf16ToUtf8_008, TestSize.Level1) 147 { 148 const uint16_t input[] = { 0xD800, 0xD800 }; 149 uint8_t output[10] = { 0 }; 150 size_t result = DebuggerConvertRegionUtf16ToUtf8(input, output, 2, 10, 0); 151 EXPECT_EQ(result, 6); 152 } 153 154 /** 155 * @tc.name: Str8DebugToStr16_001 156 * @tc.desc: test Str8DebugToStr16 157 * @tc.type: FUNC 158 */ 159 HWTEST_F(UtfHelperTestOneNg, Str8DebugToStr16_001, TestSize.Level1) 160 { 161 std::string emptyStr = ""; 162 std::u16string result = Str8DebugToStr16(emptyStr); 163 EXPECT_EQ(result, u""); 164 } 165 166 /** 167 * @tc.name: Str8DebugToStr16_002 168 * @tc.desc: test Str8DebugToStr16 169 * @tc.type: FUNC 170 */ 171 HWTEST_F(UtfHelperTestOneNg, Str8DebugToStr16_002, TestSize.Level1) 172 { 173 std::string str = "Hello"; 174 std::u16string result = Str8DebugToStr16(str); 175 EXPECT_EQ(result, u"Hello"); 176 } 177 178 /** 179 * @tc.name: Str8DebugToStr16_003 180 * @tc.desc: test Str8DebugToStr16 181 * @tc.type: FUNC 182 */ 183 HWTEST_F(UtfHelperTestOneNg, Str8DebugToStr16_003, TestSize.Level1) 184 { 185 std::string str = DEFAULT_STR; 186 std::u16string result = Str8DebugToStr16(str); 187 EXPECT_EQ(result, DEFAULT_U16STR); 188 } 189 190 /** 191 * @tc.name: Str8DebugToStr16_004 192 * @tc.desc: test Str8DebugToStr16 193 * @tc.type: FUNC 194 */ 195 HWTEST_F(UtfHelperTestOneNg, Str8DebugToStr16_004, TestSize.Level1) 196 { 197 std::string str = "Word"; 198 std::u16string result = Str8DebugToStr16(str); 199 EXPECT_NE(result, DEFAULT_U16STR); 200 } 201 202 /** 203 * @tc.name: Str16DebugToStr8_001 204 * @tc.desc: test Str16DebugToStr8 205 * @tc.type: FUNC 206 */ 207 HWTEST_F(UtfHelperTestOneNg, Str16DebugToStr8_001, TestSize.Level1) 208 { 209 std::u16string emptyStr = u""; 210 std::string result = Str16DebugToStr8(emptyStr); 211 EXPECT_EQ(result, ""); 212 } 213 214 /** 215 * @tc.name: Str16DebugToStr8_002 216 * @tc.desc: test Str16DebugToStr8 217 * @tc.type: FUNC 218 */ 219 HWTEST_F(UtfHelperTestOneNg, Str16DebugToStr8_002, TestSize.Level1) 220 { 221 std::u16string str = u"Hello"; 222 std::string result = Str16DebugToStr8(str); 223 EXPECT_EQ(result, "Hello"); 224 } 225 226 /** 227 * @tc.name: Str16DebugToStr8_003 228 * @tc.desc: test Str16DebugToStr8 229 * @tc.type: FUNC 230 */ 231 HWTEST_F(UtfHelperTestOneNg, Str16DebugToStr8_003, TestSize.Level1) 232 { 233 std::u16string str = DEFAULT_U16STR; 234 std::string result = Str16DebugToStr8(str); 235 EXPECT_EQ(result, DEFAULT_STR); 236 } 237 238 /** 239 * @tc.name: Str16DebugToStr8_004 240 * @tc.desc: test Str16DebugToStr8 241 * @tc.type: FUNC 242 */ 243 HWTEST_F(UtfHelperTestOneNg, Str16DebugToStr8_004, TestSize.Level1) 244 { 245 std::u16string str = u"Word"; 246 std::string result = Str16DebugToStr8(str); 247 EXPECT_NE(result, DEFAULT_STR); 248 } 249 250 /** 251 * @tc.name: Str16DebugToStr8_005 252 * @tc.desc: test Str16DebugToStr8 253 * @tc.type: FUNC 254 */ 255 HWTEST_F(UtfHelperTestOneNg, Str16DebugToStr8_005, TestSize.Level1) 256 { 257 std::u16string str = u"Word"; 258 std::string result = Str16DebugToStr8(str); 259 EXPECT_EQ(result, "Word"); 260 } 261 262 /** 263 * @tc.name: Utf8ToUtf16Size_001 264 * @tc.desc: test Utf8ToUtf16Size 265 * @tc.type: FUNC 266 */ 267 HWTEST_F(UtfHelperTestOneNg, Utf8ToUtf16Size_001, TestSize.Level1) 268 { 269 uint8_t utf8[] = { 0xF0, 0x9F, 0x98, 0x80 }; 270 size_t utf8Len = sizeof(utf8) / sizeof(uint8_t); 271 size_t result = Utf8ToUtf16Size(utf8, utf8Len); 272 EXPECT_EQ(result, 2); 273 } 274 275 /** 276 * @tc.name: Utf8ToUtf16Size_002 277 * @tc.desc: test Utf8ToUtf16Size 278 * @tc.type: FUNC 279 */ 280 HWTEST_F(UtfHelperTestOneNg, Utf8ToUtf16Size_002, TestSize.Level1) 281 { 282 uint8_t utf8[] = { 0xF0, 0x80, 0x80, 0x80 }; 283 size_t utf8Len = sizeof(utf8) / sizeof(uint8_t); 284 size_t result = Utf8ToUtf16Size(utf8, utf8Len); 285 EXPECT_EQ(result, 1); 286 } 287 288 /** 289 * @tc.name: Utf8ToUtf16Size_003 290 * @tc.desc: test Utf8ToUtf16Size 291 * @tc.type: FUNC 292 */ 293 HWTEST_F(UtfHelperTestOneNg, Utf8ToUtf16Size_003, TestSize.Level1) 294 { 295 uint8_t utf8[] = { 0xC3, 0x82 }; 296 size_t utf8Len = sizeof(utf8) / sizeof(uint8_t); 297 size_t result = Utf8ToUtf16Size(utf8, utf8Len); 298 EXPECT_EQ(result, 1); 299 } 300 301 /** 302 * @tc.name: ConvertRegionUtf8ToUtf16_001 303 * @tc.desc: test ConvertRegionUtf8ToUtf16 304 * @tc.type: FUNC 305 */ 306 HWTEST_F(UtfHelperTestOneNg, ConvertRegionUtf8ToUtf16_001, TestSize.Level1) 307 { 308 uint8_t utf8[] = { 0xF0, 0x9F, 0x98, 0x80 }; 309 size_t utf8Len = sizeof(utf8) / sizeof(uint8_t); 310 uint16_t utf16[2]; 311 size_t utf16Len = sizeof(utf16) / sizeof(uint16_t); 312 size_t result = ConvertRegionUtf8ToUtf16(utf8, utf16, utf8Len, utf16Len); 313 EXPECT_EQ(result, 2); 314 } 315 316 /** 317 * @tc.name: ConvertRegionUtf8ToUtf16_002 318 * @tc.desc: test ConvertRegionUtf8ToUtf16 319 * @tc.type: FUNC 320 */ 321 HWTEST_F(UtfHelperTestOneNg, ConvertRegionUtf8ToUtf16_002, TestSize.Level1) 322 { 323 uint8_t utf8[] = { 0xF0, 0x80, 0x80, 0x80 }; 324 size_t utf8Len = sizeof(utf8) / sizeof(uint8_t); 325 uint16_t utf16[1]; 326 size_t utf16Len = sizeof(utf16) / sizeof(uint16_t); 327 size_t result = ConvertRegionUtf8ToUtf16(utf8, utf16, utf8Len, utf16Len); 328 EXPECT_EQ(result, 1); 329 } 330 331 /** 332 * @tc.name: ConvertRegionUtf8ToUtf16_003 333 * @tc.desc: test ConvertRegionUtf8ToUtf16 334 * @tc.type: FUNC 335 */ 336 HWTEST_F(UtfHelperTestOneNg, ConvertRegionUtf8ToUtf16_003, TestSize.Level1) 337 { 338 uint8_t utf8[] = { 0xC3, 0x81 }; 339 size_t utf8Len = sizeof(utf8) / sizeof(uint8_t); 340 uint16_t utf16[1]; 341 size_t utf16Len = sizeof(utf16) / sizeof(uint16_t); 342 size_t result = ConvertRegionUtf8ToUtf16(utf8, utf16, utf8Len, utf16Len); 343 EXPECT_EQ(result, 1); 344 } 345 346 /** 347 * @tc.name: ConvertRegionUtf8ToUtf16_004 348 * @tc.desc: test ConvertRegionUtf8ToUtf16 349 * @tc.type: FUNC 350 */ 351 HWTEST_F(UtfHelperTestOneNg, ConvertRegionUtf8ToUtf16_004, TestSize.Level1) 352 { 353 const uint8_t utf8Data[] = { 0xF0, 0x90 }; 354 size_t utf8Len = sizeof(utf8Data) / sizeof(utf8Data[0]); 355 uint16_t utf16Data[10] = { 0 }; 356 size_t utf16Len = sizeof(utf16Data) / sizeof(utf16Data[0]); 357 size_t result = ConvertRegionUtf8ToUtf16(utf8Data, utf16Data, utf8Len, utf16Len); 358 EXPECT_EQ(result, 2); 359 } 360 361 /** 362 * @tc.name: ConvertRegionUtf8ToUtf16_005 363 * @tc.desc: test ConvertRegionUtf8ToUtf16 364 * @tc.type: FUNC 365 */ 366 HWTEST_F(UtfHelperTestOneNg, ConvertRegionUtf8ToUtf16_005, TestSize.Level1) 367 { 368 uint8_t utf8[] = {}; 369 size_t utf8Len = sizeof(utf8) / sizeof(uint8_t); 370 uint16_t utf16[10]; 371 size_t utf16Len = sizeof(utf16) / sizeof(uint16_t); 372 size_t result = ConvertRegionUtf8ToUtf16(utf8, utf16, utf8Len, utf16Len); 373 EXPECT_EQ(result, 0); 374 } 375 376 /** 377 * @tc.name: FixUtf8Len_001 378 * @tc.desc: test FixUtf8Len 379 * @tc.type: FUNC 380 */ 381 HWTEST_F(UtfHelperTestOneNg, FixUtf8Len_001, TestSize.Level1) 382 { 383 const uint8_t utf8Data[] = { 0xC2 }; 384 size_t utf8Len = sizeof(utf8Data) / sizeof(utf8Data[0]); 385 uint16_t utf16Data[10] = { 0 }; 386 size_t utf16Len = sizeof(utf16Data) / sizeof(utf16Data[0]); 387 size_t result = ConvertRegionUtf8ToUtf16(utf8Data, utf16Data, utf8Len, utf16Len); 388 EXPECT_EQ(result, 1); 389 } 390 391 /** 392 * @tc.name: FixUtf8Len_002 393 * @tc.desc: test FixUtf8Len 394 * @tc.type: FUNC 395 */ 396 HWTEST_F(UtfHelperTestOneNg, FixUtf8Len_002, TestSize.Level1) 397 { 398 const uint8_t utf8Data[] = { 0xF0, 0x90 }; 399 size_t utf8Len = sizeof(utf8Data) / sizeof(utf8Data[0]); 400 uint16_t utf16Data[10] = { 0 }; 401 size_t utf16Len = sizeof(utf16Data) / sizeof(utf16Data[0]); 402 size_t result = ConvertRegionUtf8ToUtf16(utf8Data, utf16Data, utf8Len, utf16Len); 403 EXPECT_EQ(result, 2); 404 } 405 406 /** 407 * @tc.name: FixUtf8Len_003 408 * @tc.desc: test FixUtf8Len 409 * @tc.type: FUNC 410 */ 411 HWTEST_F(UtfHelperTestOneNg, FixUtf8Len_003, TestSize.Level1) 412 { 413 const uint8_t utf8Data[] = { 0xF0, 0x90, 0x80 }; 414 size_t utf8Len = sizeof(utf8Data) / sizeof(utf8Data[0]); 415 uint16_t utf16Data[10] = { 0 }; 416 size_t utf16Len = sizeof(utf16Data) / sizeof(utf16Data[0]); 417 size_t result = ConvertRegionUtf8ToUtf16(utf8Data, utf16Data, utf8Len, utf16Len); 418 EXPECT_EQ(result, 3); 419 } 420 421 /** 422 * @tc.name: FixUtf8Len_004 423 * @tc.desc: test FixUtf8Len 424 * @tc.type: FUNC 425 */ 426 HWTEST_F(UtfHelperTestOneNg, FixUtf8Len_004, TestSize.Level1) 427 { 428 const uint8_t utf8Data[] = { 0x48 }; 429 size_t utf8Len = sizeof(utf8Data) / sizeof(utf8Data[0]); 430 uint16_t utf16Data[10] = { 0 }; 431 size_t utf16Len = sizeof(utf16Data) / sizeof(utf16Data[0]); 432 size_t result = ConvertRegionUtf8ToUtf16(utf8Data, utf16Data, utf8Len, utf16Len); 433 EXPECT_EQ(result, 1); 434 } 435 436 /** 437 * @tc.name: FixUtf8Len_005 438 * @tc.desc: test FixUtf8Len 439 * @tc.type: FUNC 440 */ 441 HWTEST_F(UtfHelperTestOneNg, FixUtf8Len_005, TestSize.Level1) 442 { 443 const uint8_t utf8Data[] = { 0x48, 0xC2 }; 444 size_t utf8Len = sizeof(utf8Data) / sizeof(utf8Data[0]); 445 uint16_t utf16Data[10] = { 0 }; 446 size_t utf16Len = sizeof(utf16Data) / sizeof(utf16Data[0]); 447 size_t result = ConvertRegionUtf8ToUtf16(utf8Data, utf16Data, utf8Len, utf16Len); 448 EXPECT_NE(result, 1); 449 } 450 451 /** 452 * @tc.name: FixUtf8Len_006 453 * @tc.desc: test FixUtf8Len 454 * @tc.type: FUNC 455 */ 456 HWTEST_F(UtfHelperTestOneNg, FixUtf8Len_006, TestSize.Level1) 457 { 458 const uint8_t utf8Data[] = { 0x48, 0x65, 0xC2 }; 459 size_t utf8Len = sizeof(utf8Data) / sizeof(utf8Data[0]); 460 uint16_t utf16Data[10] = { 0 }; 461 size_t utf16Len = sizeof(utf16Data) / sizeof(utf16Data[0]); 462 size_t result = ConvertRegionUtf8ToUtf16(utf8Data, utf16Data, utf8Len, utf16Len); 463 EXPECT_EQ(result, 3); 464 } 465 466 /** 467 * @tc.name: FixUtf8Len_007 468 * @tc.desc: empty string 469 * @tc.type: FUNC 470 */ 471 HWTEST_F(UtfHelperTestOneNg, FixUtf8Len_007, TestSize.Level1) 472 { 473 const uint8_t* emptyInput = nullptr; 474 uint16_t output[10] = { 0 }; 475 size_t result = ConvertRegionUtf8ToUtf16(emptyInput, output, 0, 10); 476 EXPECT_EQ(result, 0); 477 } 478 479 /** 480 * @tc.name: FixUtf8Len_008 481 * @tc.desc: singleByte string 482 * @tc.type: FUNC 483 */ 484 HWTEST_F(UtfHelperTestOneNg, FixUtf8Len_008, TestSize.Level1) 485 { 486 const uint8_t* input = reinterpret_cast<const uint8_t*>(u8"a"); 487 uint16_t output[10] = { 0 }; 488 size_t result = ConvertRegionUtf8ToUtf16(input, output, 1, 10); 489 EXPECT_EQ(result, 1); 490 EXPECT_EQ(output[0], 'a'); 491 } 492 493 /** 494 * @tc.name: FixUtf8Len_009 495 * @tc.desc: mixed string 496 * @tc.type: FUNC 497 */ 498 HWTEST_F(UtfHelperTestOneNg, FixUtf8Len_009, TestSize.Level1) 499 { 500 const uint8_t* input = reinterpret_cast<const uint8_t*>(u8"Hello, 世界!"); 501 uint16_t output[50] = { 0 }; 502 size_t result = ConvertRegionUtf8ToUtf16(input, output, strlen(reinterpret_cast<const char*>(input)), 50); 503 EXPECT_EQ(result, 10); 504 } 505 506 /** 507 * @tc.name: FixUtf8Len_010 508 * @tc.desc: invalid string 509 * @tc.type: FUNC 510 */ 511 HWTEST_F(UtfHelperTestOneNg, FixUtf8Len_010, TestSize.Level1) 512 { 513 const uint8_t* input = reinterpret_cast<const uint8_t*>(u8"XXXX"); 514 uint16_t output[10] = { 0 }; 515 size_t result = ConvertRegionUtf8ToUtf16(input, output, 4, 10); 516 EXPECT_EQ(result, 4); 517 } 518 519 /** 520 * @tc.name: ConvertRegionUtf16ToUtf8_001 521 * @tc.desc: test ConvertRegionUtf16ToUtf8 522 * @tc.type: FUNC 523 */ 524 HWTEST_F(UtfHelperTestOneNg, ConvertRegionUtf16ToUtf8_001, TestSize.Level1) 525 { 526 uint16_t utf16String[] = { 0x0048, 0x0065, 0x006C, 0x006C, 0x006F }; 527 size_t utf16Len = sizeof(utf16String) / sizeof(utf16String[0]); 528 uint8_t utf8Buffer[1]; 529 size_t utf8Len = 0; 530 size_t res = ConvertRegionUtf16ToUtf8(utf16String, utf8Buffer, utf16Len, utf8Len, 0); 531 EXPECT_EQ(res, 0); 532 } 533 534 /** 535 * @tc.name: Utf16ToUtf8Size001 536 * @tc.desc: Test utf_helper Utf16ToUtf8Size 537 * @tc.type: FUNC 538 */ 539 HWTEST_F(UtfHelperTestOneNg, Utf16ToUtf8Size_001, TestSize.Level1) 540 { 541 uint16_t utf16[1] = { 0xd800 + 1 }; 542 size_t len = sizeof(utf16) / sizeof(utf16[0]); 543 EXPECT_EQ(Utf16ToUtf8Size(utf16, len), 4); 544 } 545 546 /** 547 * @tc.name: Utf16ToUtf8Size_002 548 * @tc.desc: Test utf_helper Utf16ToUtf8Size 549 * @tc.type: FUNC 550 */ 551 HWTEST_F(UtfHelperTestOneNg, Utf16ToUtf8Size_002, TestSize.Level1) 552 { 553 uint16_t utf16[1] = { 0 }; 554 size_t len = sizeof(utf16) / sizeof(utf16[0]); 555 EXPECT_EQ(Utf16ToUtf8Size(utf16, len), 1); 556 } 557 558 /** 559 * @tc.name: Utf16ToUtf8Size_003 560 * @tc.desc: Test utf_helper Utf16ToUtf8Size 561 * @tc.type: FUNC 562 */ 563 HWTEST_F(UtfHelperTestOneNg, Utf16ToUtf8Size_003, TestSize.Level1) 564 { 565 uint16_t utf16[1] = { 0x7ff - 1 }; 566 size_t len = sizeof(utf16) / sizeof(utf16[0]); 567 EXPECT_EQ(Utf16ToUtf8Size(utf16, len), 3); 568 } 569 570 /** 571 * @tc.name: Utf16ToUtf8Size_004 572 * @tc.desc: Test utf_helper Utf16ToUtf8Size 573 * @tc.type: FUNC 574 */ 575 HWTEST_F(UtfHelperTestOneNg, Utf16ToUtf8Size_004, TestSize.Level1) 576 { 577 uint16_t utf16[1] = { 0xd800 + 1 }; 578 size_t len = sizeof(utf16) / sizeof(utf16[0]); 579 EXPECT_EQ(Utf16ToUtf8Size(utf16, len), 4); 580 } 581 582 /** 583 * @tc.name: Utf16ToUtf8Size_005 584 * @tc.desc: Test utf_helper Utf16ToUtf8Size 585 * @tc.type: FUNC 586 */ 587 HWTEST_F(UtfHelperTestOneNg, Utf16ToUtf8Size_005, TestSize.Level1) 588 { 589 uint16_t utf16[2] = { 0xd800 + 1, 0xdc00 + 1 }; 590 size_t len = sizeof(utf16) / sizeof(utf16[0]); 591 EXPECT_EQ(Utf16ToUtf8Size(utf16, len), 5); 592 } 593 594 /** 595 * @tc.name: Utf16ToUtf8Size_006 596 * @tc.desc: Test utf_helper Utf16ToUtf8Size 597 * @tc.type: FUNC 598 */ 599 HWTEST_F(UtfHelperTestOneNg, Utf16ToUtf8Size_006, TestSize.Level1) 600 { 601 uint16_t utf16[2] = { 0xd800 + 1, 0xdc00 - 1 }; 602 size_t len = sizeof(utf16) / sizeof(utf16[0]); 603 EXPECT_EQ(Utf16ToUtf8Size(utf16, len), 7); 604 } 605 606 /** 607 * @tc.name: Utf16ToUtf8Size_007 608 * @tc.desc: Test utf_helper Utf16ToUtf8Size 609 * @tc.type: FUNC 610 */ 611 HWTEST_F(UtfHelperTestOneNg, Utf16ToUtf8Size_007, TestSize.Level1) 612 { 613 uint16_t utf16[2] = { 0xd800 + 1, 0xdfff + 1 }; 614 size_t len = sizeof(utf16) / sizeof(utf16[0]); 615 EXPECT_EQ(Utf16ToUtf8Size(utf16, len), 7); 616 } 617 618 /** 619 * @tc.name: IsIndexInPairedSurrogates_001 620 * @tc.desc: test utf_helper.cpp: justify that index is in paired surrogates 621 * @tc.type: FUNC 622 */ 623 HWTEST_F(UtfHelperTestOneNg, IsIndexInPairedSurrogates_001, TestSize.Level1) 624 { 625 std::u16string emojiStr = u""; 626 ASSERT_EQ(UtfUtils::IsIndexInPairedSurrogates(-1, emojiStr), false); 627 ASSERT_EQ(UtfUtils::IsIndexInPairedSurrogates(0, emojiStr), false); 628 ASSERT_EQ(UtfUtils::IsIndexInPairedSurrogates(1, emojiStr), false); 629 ASSERT_EQ(UtfUtils::IsIndexInPairedSurrogates(2, emojiStr), false); 630 } 631 632 /** 633 * @tc.name: IsIndexInPairedSurrogates_002 634 * @tc.desc: test utf_helper.cpp: justify that index is in paired surrogates 635 * @tc.type: FUNC 636 */ 637 HWTEST_F(UtfHelperTestOneNg, IsIndexInPairedSurrogates_002, TestSize.Level1) 638 { 639 std::u16string emojiStr = u"哈哈��"; 640 int32_t len = static_cast<int32_t>(emojiStr.length()); 641 ASSERT_EQ(UtfUtils::IsIndexInPairedSurrogates(-1, emojiStr), false); 642 ASSERT_EQ(UtfUtils::IsIndexInPairedSurrogates(0, emojiStr), false); 643 ASSERT_EQ(UtfUtils::IsIndexInPairedSurrogates(1, emojiStr), false); 644 ASSERT_EQ(UtfUtils::IsIndexInPairedSurrogates(2, emojiStr), false); 645 ASSERT_EQ(UtfUtils::IsIndexInPairedSurrogates(len - 1, emojiStr), true); 646 ASSERT_EQ(UtfUtils::IsIndexInPairedSurrogates(len, emojiStr), false); 647 ASSERT_EQ(UtfUtils::IsIndexInPairedSurrogates(len + 1, emojiStr), false); 648 } 649 650 /** 651 * @tc.name: IsIndexInPairedSurrogates_003 652 * @tc.desc: test utf_helper.cpp: justify that index is in paired surrogates when a emoji is truncated 653 * @tc.type: FUNC 654 */ 655 HWTEST_F(UtfHelperTestOneNg, IsIndexInPairedSurrogates_003, TestSize.Level1) 656 { 657 std::u16string emojiStr = u"哈哈����"; 658 int32_t len = static_cast<int32_t>(emojiStr.length()); 659 std::u16string subEmojiStr = emojiStr.substr(0, len - 1); 660 ASSERT_EQ(UtfUtils::IsIndexInPairedSurrogates(0, subEmojiStr), false); 661 ASSERT_EQ(UtfUtils::IsIndexInPairedSurrogates(1, subEmojiStr), false); 662 ASSERT_EQ(UtfUtils::IsIndexInPairedSurrogates(2, subEmojiStr), false); 663 ASSERT_EQ(UtfUtils::IsIndexInPairedSurrogates(3, subEmojiStr), true); 664 ASSERT_EQ(UtfUtils::IsIndexInPairedSurrogates(len - 1, subEmojiStr), false); 665 ASSERT_EQ(UtfUtils::IsIndexInPairedSurrogates(len, subEmojiStr), false); 666 ASSERT_EQ(UtfUtils::IsIndexInPairedSurrogates(len + 1, subEmojiStr), false); 667 } 668 669 /** 670 * @tc.name: Str16ToStr32_001 671 * @tc.desc: test utf_helper.cpp: Convert u16string and u32string 672 * @tc.type: FUNC 673 */ 674 HWTEST_F(UtfHelperTestOneNg, Str16ToStr32_001, TestSize.Level1) 675 { 676 ASSERT_EQ(UtfUtils::Str16ToStr32(TEST_INPUT_U16_STRING), TEST_INPUT_U32_STRING); 677 ASSERT_EQ(UtfUtils::Str16ToStr32(TEST_INPUT_U16_EMOJI), TEST_INPUT_U32_EMOJI); 678 ASSERT_EQ(UtfUtils::Str16ToStr32(u""), U""); 679 ASSERT_EQ(UtfUtils::Str16ToStr32(UtfUtils::DEFAULT_U16STR), UtfUtils::DEFAULT_U32STR); 680 } 681 682 /** 683 * @tc.name: Str16ToStr32_002 684 * @tc.desc: test utf_helper.cpp: Convert u16string to u32string reserving truncated emoji string 685 * @tc.type: FUNC 686 */ 687 HWTEST_F(UtfHelperTestOneNg, Str16ToStr32_002, TestSize.Level1) 688 { 689 std::u16string emojiStr = u"��"; 690 std::u16string subEmojiStr = emojiStr.substr(0, 1); 691 std::u32string excpectSubEmojiStr = U"哈"; 692 excpectSubEmojiStr[0] = 0xD83D; /* D83D DC01 is utf-16 encoding for emoji �� */ 693 ASSERT_EQ(UtfUtils::Str16ToStr32(subEmojiStr), excpectSubEmojiStr); 694 } 695 696 /** 697 * @tc.name: Str16ToStr32_003 698 * @tc.desc: test utf_helper.cpp: Convert u16string to u32string reserving truncated emoji string 699 * @tc.type: FUNC 700 */ 701 HWTEST_F(UtfHelperTestOneNg, Str16ToStr32_003, TestSize.Level1) 702 { 703 std::u16string emojiStr = u"哈哈��"; 704 std::u16string subEmojiStr = emojiStr.substr(0, 3); 705 std::u32string excpectSubEmojiStr = U"哈哈哈"; 706 excpectSubEmojiStr[2] = 0xD83D; /* D83D DC01 is utf-16 encoding for emoji �� */ 707 ASSERT_EQ(UtfUtils::Str16ToStr32(subEmojiStr), excpectSubEmojiStr); 708 } 709 710 /** 711 * @tc.name: Str32ToStr16_001 712 * @tc.desc: test utf_helper.cpp: Convert u16string and u32string 713 * @tc.type: FUNC 714 */ 715 HWTEST_F(UtfHelperTestOneNg, Str32ToStr16_001, TestSize.Level1) 716 { 717 ASSERT_EQ(UtfUtils::Str32ToStr16(TEST_INPUT_U32_STRING), TEST_INPUT_U16_STRING); 718 ASSERT_EQ(UtfUtils::Str32ToStr16(TEST_INPUT_U32_EMOJI), TEST_INPUT_U16_EMOJI); 719 ASSERT_EQ(UtfUtils::Str32ToStr16(U""), u""); 720 ASSERT_EQ(UtfUtils::Str32ToStr16(UtfUtils::DEFAULT_U32STR), UtfUtils::DEFAULT_U16STR); 721 } 722 723 /** 724 * @tc.name: Str32ToStr16_002 725 * @tc.desc: test utf_helper.cpp: Convert u16string to u32string reserving truncated emoji string 726 * @tc.type: FUNC 727 */ 728 HWTEST_F(UtfHelperTestOneNg, Str32ToStr16_002, TestSize.Level1) 729 { 730 std::u16string emojiStr = u"��"; 731 std::u16string subEmojiStr = emojiStr.substr(0, 1); 732 std::u32string excpectSubEmojiStr = U"哈"; 733 excpectSubEmojiStr[0] = 0xD83D; /* D83D DC01 is utf-16 encoding for emoji �� */ 734 ASSERT_EQ(UtfUtils::Str32ToStr16(UtfUtils::Str16ToStr32(subEmojiStr)), subEmojiStr); 735 } 736 737 /** 738 * @tc.name: Str32ToStr16_003 739 * @tc.desc: test utf_helper.cpp: Convert u16string to u32string reserving truncated emoji string 740 * @tc.type: FUNC 741 */ 742 HWTEST_F(UtfHelperTestOneNg, Str32ToStr16_003, TestSize.Level1) 743 { 744 std::u16string emojiStr = u"哈哈��"; 745 std::u16string subEmojiStr = emojiStr.substr(0, 3); 746 std::u32string excpectSubEmojiStr = U"哈哈哈"; 747 excpectSubEmojiStr[2] = 0xD83D; /* D83D DC01 is utf-16 encoding for emoji �� */ 748 ASSERT_EQ(UtfUtils::Str32ToStr16(UtfUtils::Str16ToStr32(subEmojiStr)), subEmojiStr); 749 } 750 751 } // namespace OHOS::Ace::UtfUtils