1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * Unit tests for Unicode functions 4 * 5 * Copyright (c) 2018 Heinrich Schuchardt <xypron.glpk@gmx.de> 6 */ 7 8 #include <common.h> 9 #include <charset.h> 10 #include <command.h> 11 #include <errno.h> 12 #include <test/test.h> 13 #include <test/suites.h> 14 #include <test/ut.h> 15 16 /* Linker list entry for a Unicode test */ 17 #define UNICODE_TEST(_name) UNIT_TEST(_name, 0, unicode_test) 18 19 /* Constants c1-c4 and d1-d4 encode the same letters */ 20 21 /* Six characters translating to one utf-8 byte each. */ 22 static const u16 c1[] = {0x55, 0x2d, 0x42, 0x6f, 0x6f, 0x74, 0x00}; 23 /* One character translating to two utf-8 bytes */ 24 static const u16 c2[] = {0x6b, 0x61, 0x66, 0x62, 0xe1, 0x74, 0x75, 0x72, 0x00}; 25 /* Three characters translating to three utf-8 bytes each */ 26 static const u16 c3[] = {0x6f5c, 0x6c34, 0x8266, 0x00}; 27 /* Three letters translating to four utf-8 bytes each */ 28 static const u16 c4[] = {0xd801, 0xdc8d, 0xd801, 0xdc96, 0xd801, 0xdc87, 29 0x0000}; 30 31 /* Illegal utf-16 strings */ 32 static const u16 i1[] = {0x69, 0x31, 0xdc87, 0x6c, 0x00}; 33 static const u16 i2[] = {0x69, 0x32, 0xd801, 0xd801, 0x6c, 0x00}; 34 static const u16 i3[] = {0x69, 0x33, 0xd801, 0x00}; 35 36 /* Six characters translating to one utf-16 word each. */ 37 static const char d1[] = {0x55, 0x2d, 0x42, 0x6f, 0x6f, 0x74, 0x00}; 38 /* Eight characters translating to one utf-16 word each */ 39 static const char d2[] = {0x6b, 0x61, 0x66, 0x62, 0xc3, 0xa1, 0x74, 0x75, 40 0x72, 0x00}; 41 /* Three characters translating to one utf-16 word each */ 42 static const char d3[] = {0xe6, 0xbd, 0x9c, 0xe6, 0xb0, 0xb4, 0xe8, 0x89, 43 0xa6, 0x00}; 44 /* Three letters translating to two utf-16 word each */ 45 static const char d4[] = {0xf0, 0x90, 0x92, 0x8d, 0xf0, 0x90, 0x92, 0x96, 46 0xf0, 0x90, 0x92, 0x87, 0x00}; 47 48 /* Illegal utf-8 strings */ 49 static const char j1[] = {0x6a, 0x31, 0xa1, 0x6c, 0x00}; 50 static const char j2[] = {0x6a, 0x32, 0xc3, 0xc3, 0x6c, 0x00}; 51 static const char j3[] = {0x6a, 0x33, 0xf0, 0x90, 0xf0, 0x00}; 52 53 static int unicode_test_u16_strdup(struct unit_test_state *uts) 54 { 55 u16 *copy = u16_strdup(c4); 56 57 ut_assert(copy != c4); 58 ut_assert(!memcmp(copy, c4, sizeof(c4))); 59 free(copy); 60 return 0; 61 } 62 UNICODE_TEST(unicode_test_u16_strdup); 63 64 static int unicode_test_u16_strcpy(struct unit_test_state *uts) 65 { 66 u16 *r; 67 u16 copy[10]; 68 69 r = u16_strcpy(copy, c1); 70 ut_assert(r == copy); 71 ut_assert(!memcmp(copy, c1, sizeof(c1))); 72 return 0; 73 } 74 UNICODE_TEST(unicode_test_u16_strcpy); 75 76 /* U-Boot uses UTF-16 strings in the EFI context only. */ 77 #if CONFIG_IS_ENABLED(EFI_LOADER) && !defined(API_BUILD) 78 static int unicode_test_string16(struct unit_test_state *uts) 79 { 80 char buf[20]; 81 82 /* Test length and precision */ 83 memset(buf, 0xff, sizeof(buf)); 84 sprintf(buf, "%8.6ls", c2); 85 ut_asserteq(' ', buf[1]); 86 ut_assert(!strncmp(&buf[2], d2, 7)); 87 ut_assert(!buf[9]); 88 89 memset(buf, 0xff, sizeof(buf)); 90 sprintf(buf, "%8.6ls", c4); 91 ut_asserteq(' ', buf[4]); 92 ut_assert(!strncmp(&buf[5], d4, 12)); 93 ut_assert(!buf[17]); 94 95 memset(buf, 0xff, sizeof(buf)); 96 sprintf(buf, "%-8.2ls", c4); 97 ut_asserteq(' ', buf[8]); 98 ut_assert(!strncmp(buf, d4, 8)); 99 ut_assert(!buf[14]); 100 101 /* Test handling of illegal utf-16 sequences */ 102 memset(buf, 0xff, sizeof(buf)); 103 sprintf(buf, "%ls", i1); 104 ut_asserteq_str("i1?l", buf); 105 106 memset(buf, 0xff, sizeof(buf)); 107 sprintf(buf, "%ls", i2); 108 ut_asserteq_str("i2?l", buf); 109 110 memset(buf, 0xff, sizeof(buf)); 111 sprintf(buf, "%ls", i3); 112 ut_asserteq_str("i3?", buf); 113 114 return 0; 115 } 116 UNICODE_TEST(unicode_test_string16); 117 #endif 118 119 static int unicode_test_utf8_get(struct unit_test_state *uts) 120 { 121 const char *s; 122 s32 code; 123 int i; 124 125 /* Check characters less than 0x800 */ 126 s = d2; 127 for (i = 0; i < 8; ++i) { 128 code = utf8_get((const char **)&s); 129 /* c2 is the utf-8 encoding of d2 */ 130 ut_asserteq(c2[i], code); 131 if (!code) 132 break; 133 } 134 ut_asserteq_ptr(s, d2 + 9) 135 136 /* Check characters less than 0x10000 */ 137 s = d3; 138 for (i = 0; i < 4; ++i) { 139 code = utf8_get((const char **)&s); 140 /* c3 is the utf-8 encoding of d3 */ 141 ut_asserteq(c3[i], code); 142 if (!code) 143 break; 144 } 145 ut_asserteq_ptr(s, d3 + 9) 146 147 /* Check character greater 0xffff */ 148 s = d4; 149 code = utf8_get((const char **)&s); 150 ut_asserteq(0x0001048d, code); 151 ut_asserteq_ptr(s, d4 + 4); 152 153 return 0; 154 } 155 UNICODE_TEST(unicode_test_utf8_get); 156 157 static int unicode_test_utf8_put(struct unit_test_state *uts) 158 { 159 char buffer[8] = { 0, }; 160 char *pos; 161 162 /* Commercial at, translates to one character */ 163 pos = buffer; 164 ut_assert(!utf8_put('@', &pos)) 165 ut_asserteq(1, pos - buffer); 166 ut_asserteq('@', buffer[0]); 167 ut_assert(!buffer[1]); 168 169 /* Latin letter G with acute, translates to two charactes */ 170 pos = buffer; 171 ut_assert(!utf8_put(0x1f4, &pos)); 172 ut_asserteq(2, pos - buffer); 173 ut_asserteq_str("\xc7\xb4", buffer); 174 175 /* Tagalog letter i, translates to three characters */ 176 pos = buffer; 177 ut_assert(!utf8_put(0x1701, &pos)); 178 ut_asserteq(3, pos - buffer); 179 ut_asserteq_str("\xe1\x9c\x81", buffer); 180 181 /* Hamster face, translates to four characters */ 182 pos = buffer; 183 ut_assert(!utf8_put(0x1f439, &pos)); 184 ut_asserteq(4, pos - buffer); 185 ut_asserteq_str("\xf0\x9f\x90\xb9", buffer); 186 187 /* Illegal code */ 188 pos = buffer; 189 ut_asserteq(-1, utf8_put(0xd888, &pos)); 190 191 return 0; 192 } 193 UNICODE_TEST(unicode_test_utf8_put); 194 195 static int unicode_test_utf8_utf16_strlen(struct unit_test_state *uts) 196 { 197 ut_asserteq(6, utf8_utf16_strlen(d1)); 198 ut_asserteq(8, utf8_utf16_strlen(d2)); 199 ut_asserteq(3, utf8_utf16_strlen(d3)); 200 ut_asserteq(6, utf8_utf16_strlen(d4)); 201 202 /* illegal utf-8 sequences */ 203 ut_asserteq(4, utf8_utf16_strlen(j1)); 204 ut_asserteq(4, utf8_utf16_strlen(j2)); 205 ut_asserteq(3, utf8_utf16_strlen(j3)); 206 207 return 0; 208 } 209 UNICODE_TEST(unicode_test_utf8_utf16_strlen); 210 211 static int unicode_test_utf8_utf16_strnlen(struct unit_test_state *uts) 212 { 213 ut_asserteq(3, utf8_utf16_strnlen(d1, 3)); 214 ut_asserteq(6, utf8_utf16_strnlen(d1, 13)); 215 ut_asserteq(6, utf8_utf16_strnlen(d2, 6)); 216 ut_asserteq(2, utf8_utf16_strnlen(d3, 2)); 217 ut_asserteq(4, utf8_utf16_strnlen(d4, 2)); 218 ut_asserteq(6, utf8_utf16_strnlen(d4, 3)); 219 220 /* illegal utf-8 sequences */ 221 ut_asserteq(4, utf8_utf16_strnlen(j1, 16)); 222 ut_asserteq(4, utf8_utf16_strnlen(j2, 16)); 223 ut_asserteq(3, utf8_utf16_strnlen(j3, 16)); 224 225 return 0; 226 } 227 UNICODE_TEST(unicode_test_utf8_utf16_strnlen); 228 229 /** 230 * ut_u16_strcmp() - Compare to u16 strings. 231 * 232 * @a1: first string 233 * @a2: second string 234 * @count: number of u16 to compare 235 * Return: -1 if a1 < a2, 0 if a1 == a2, 1 if a1 > a2 236 */ 237 static int unicode_test_u16_strcmp(const u16 *a1, const u16 *a2, size_t count) 238 { 239 for (; (*a1 || *a2) && count; ++a1, ++a2, --count) { 240 if (*a1 < *a2) 241 return -1; 242 if (*a1 > *a2) 243 return 1; 244 } 245 return 0; 246 } 247 248 static int unicode_test_utf8_utf16_strcpy(struct unit_test_state *uts) 249 { 250 u16 buf[16]; 251 u16 *pos; 252 253 pos = buf; 254 utf8_utf16_strcpy(&pos, d1); 255 ut_asserteq(6, pos - buf); 256 ut_assert(!unicode_test_u16_strcmp(buf, c1, SIZE_MAX)); 257 258 pos = buf; 259 utf8_utf16_strcpy(&pos, d2); 260 ut_asserteq(8, pos - buf); 261 ut_assert(!unicode_test_u16_strcmp(buf, c2, SIZE_MAX)); 262 263 pos = buf; 264 utf8_utf16_strcpy(&pos, d3); 265 ut_asserteq(3, pos - buf); 266 ut_assert(!unicode_test_u16_strcmp(buf, c3, SIZE_MAX)); 267 268 pos = buf; 269 utf8_utf16_strcpy(&pos, d4); 270 ut_asserteq(6, pos - buf); 271 ut_assert(!unicode_test_u16_strcmp(buf, c4, SIZE_MAX)); 272 273 /* Illegal utf-8 strings */ 274 pos = buf; 275 utf8_utf16_strcpy(&pos, j1); 276 ut_asserteq(4, pos - buf); 277 ut_assert(!unicode_test_u16_strcmp(buf, L"j1?l", SIZE_MAX)); 278 279 pos = buf; 280 utf8_utf16_strcpy(&pos, j2); 281 ut_asserteq(4, pos - buf); 282 ut_assert(!unicode_test_u16_strcmp(buf, L"j2?l", SIZE_MAX)); 283 284 pos = buf; 285 utf8_utf16_strcpy(&pos, j3); 286 ut_asserteq(3, pos - buf); 287 ut_assert(!unicode_test_u16_strcmp(buf, L"j3?", SIZE_MAX)); 288 289 return 0; 290 } 291 UNICODE_TEST(unicode_test_utf8_utf16_strcpy); 292 293 static int unicode_test_utf8_utf16_strncpy(struct unit_test_state *uts) 294 { 295 u16 buf[16]; 296 u16 *pos; 297 298 pos = buf; 299 memset(buf, 0, sizeof(buf)); 300 utf8_utf16_strncpy(&pos, d1, 4); 301 ut_asserteq(4, pos - buf); 302 ut_assert(!buf[4]); 303 ut_assert(!unicode_test_u16_strcmp(buf, c1, 4)); 304 305 pos = buf; 306 memset(buf, 0, sizeof(buf)); 307 utf8_utf16_strncpy(&pos, d2, 10); 308 ut_asserteq(8, pos - buf); 309 ut_assert(buf[4]); 310 ut_assert(!unicode_test_u16_strcmp(buf, c2, SIZE_MAX)); 311 312 pos = buf; 313 memset(buf, 0, sizeof(buf)); 314 utf8_utf16_strncpy(&pos, d3, 2); 315 ut_asserteq(2, pos - buf); 316 ut_assert(!buf[2]); 317 ut_assert(!unicode_test_u16_strcmp(buf, c3, 2)); 318 319 pos = buf; 320 memset(buf, 0, sizeof(buf)); 321 utf8_utf16_strncpy(&pos, d4, 2); 322 ut_asserteq(4, pos - buf); 323 ut_assert(!buf[4]); 324 ut_assert(!unicode_test_u16_strcmp(buf, c4, 4)); 325 326 pos = buf; 327 memset(buf, 0, sizeof(buf)); 328 utf8_utf16_strncpy(&pos, d4, 10); 329 ut_asserteq(6, pos - buf); 330 ut_assert(buf[5]); 331 ut_assert(!unicode_test_u16_strcmp(buf, c4, SIZE_MAX)); 332 333 return 0; 334 } 335 UNICODE_TEST(unicode_test_utf8_utf16_strncpy); 336 337 static int unicode_test_utf16_get(struct unit_test_state *uts) 338 { 339 const u16 *s; 340 s32 code; 341 int i; 342 343 /* Check characters less than 0x10000 */ 344 s = c2; 345 for (i = 0; i < 9; ++i) { 346 code = utf16_get((const u16 **)&s); 347 ut_asserteq(c2[i], code); 348 if (!code) 349 break; 350 } 351 ut_asserteq_ptr(c2 + 8, s); 352 353 /* Check character greater 0xffff */ 354 s = c4; 355 code = utf16_get((const u16 **)&s); 356 ut_asserteq(0x0001048d, code); 357 ut_asserteq_ptr(c4 + 2, s); 358 359 return 0; 360 } 361 UNICODE_TEST(unicode_test_utf16_get); 362 363 static int unicode_test_utf16_put(struct unit_test_state *uts) 364 { 365 u16 buffer[4] = { 0, }; 366 u16 *pos; 367 368 /* Commercial at, translates to one word */ 369 pos = buffer; 370 ut_assert(!utf16_put('@', &pos)); 371 ut_asserteq(1, pos - buffer); 372 ut_asserteq((u16)'@', buffer[0]); 373 ut_assert(!buffer[1]); 374 375 /* Hamster face, translates to two words */ 376 pos = buffer; 377 ut_assert(!utf16_put(0x1f439, &pos)); 378 ut_asserteq(2, pos - buffer); 379 ut_asserteq((u16)0xd83d, buffer[0]); 380 ut_asserteq((u16)0xdc39, buffer[1]); 381 ut_assert(!buffer[2]); 382 383 /* Illegal code */ 384 pos = buffer; 385 ut_asserteq(-1, utf16_put(0xd888, &pos)); 386 387 return 0; 388 } 389 UNICODE_TEST(unicode_test_utf16_put); 390 391 static int unicode_test_utf16_strnlen(struct unit_test_state *uts) 392 { 393 ut_asserteq(3, utf16_strnlen(c1, 3)); 394 ut_asserteq(6, utf16_strnlen(c1, 13)); 395 ut_asserteq(6, utf16_strnlen(c2, 6)); 396 ut_asserteq(2, utf16_strnlen(c3, 2)); 397 ut_asserteq(2, utf16_strnlen(c4, 2)); 398 ut_asserteq(3, utf16_strnlen(c4, 3)); 399 400 /* illegal utf-16 word sequences */ 401 ut_asserteq(4, utf16_strnlen(i1, 16)); 402 ut_asserteq(4, utf16_strnlen(i2, 16)); 403 ut_asserteq(3, utf16_strnlen(i3, 16)); 404 405 return 0; 406 } 407 UNICODE_TEST(unicode_test_utf16_strnlen); 408 409 static int unicode_test_utf16_utf8_strlen(struct unit_test_state *uts) 410 { 411 ut_asserteq(6, utf16_utf8_strlen(c1)); 412 ut_asserteq(9, utf16_utf8_strlen(c2)); 413 ut_asserteq(9, utf16_utf8_strlen(c3)); 414 ut_asserteq(12, utf16_utf8_strlen(c4)); 415 416 /* illegal utf-16 word sequences */ 417 ut_asserteq(4, utf16_utf8_strlen(i1)); 418 ut_asserteq(4, utf16_utf8_strlen(i2)); 419 ut_asserteq(3, utf16_utf8_strlen(i3)); 420 421 return 0; 422 } 423 UNICODE_TEST(unicode_test_utf16_utf8_strlen); 424 425 static int unicode_test_utf16_utf8_strnlen(struct unit_test_state *uts) 426 { 427 ut_asserteq(3, utf16_utf8_strnlen(c1, 3)); 428 ut_asserteq(6, utf16_utf8_strnlen(c1, 13)); 429 ut_asserteq(7, utf16_utf8_strnlen(c2, 6)); 430 ut_asserteq(6, utf16_utf8_strnlen(c3, 2)); 431 ut_asserteq(8, utf16_utf8_strnlen(c4, 2)); 432 ut_asserteq(12, utf16_utf8_strnlen(c4, 3)); 433 return 0; 434 } 435 UNICODE_TEST(unicode_test_utf16_utf8_strnlen); 436 437 static int unicode_test_utf16_utf8_strcpy(struct unit_test_state *uts) 438 { 439 char buf[16]; 440 char *pos; 441 442 pos = buf; 443 utf16_utf8_strcpy(&pos, c1); 444 ut_asserteq(6, pos - buf); 445 ut_asserteq_str(d1, buf); 446 447 pos = buf; 448 utf16_utf8_strcpy(&pos, c2); 449 ut_asserteq(9, pos - buf); 450 ut_asserteq_str(d2, buf); 451 452 pos = buf; 453 utf16_utf8_strcpy(&pos, c3); 454 ut_asserteq(9, pos - buf); 455 ut_asserteq_str(d3, buf); 456 457 pos = buf; 458 utf16_utf8_strcpy(&pos, c4); 459 ut_asserteq(12, pos - buf); 460 ut_asserteq_str(d4, buf); 461 462 /* Illegal utf-16 strings */ 463 pos = buf; 464 utf16_utf8_strcpy(&pos, i1); 465 ut_asserteq(4, pos - buf); 466 ut_asserteq_str("i1?l", buf); 467 468 pos = buf; 469 utf16_utf8_strcpy(&pos, i2); 470 ut_asserteq(4, pos - buf); 471 ut_asserteq_str("i2?l", buf); 472 473 pos = buf; 474 utf16_utf8_strcpy(&pos, i3); 475 ut_asserteq(3, pos - buf); 476 ut_asserteq_str("i3?", buf); 477 478 return 0; 479 } 480 UNICODE_TEST(unicode_test_utf16_utf8_strcpy); 481 482 static int unicode_test_utf16_utf8_strncpy(struct unit_test_state *uts) 483 { 484 char buf[16]; 485 char *pos; 486 487 pos = buf; 488 memset(buf, 0, sizeof(buf)); 489 utf16_utf8_strncpy(&pos, c1, 4); 490 ut_asserteq(4, pos - buf); 491 ut_assert(!buf[4]); 492 ut_assert(!strncmp(buf, d1, 4)); 493 494 pos = buf; 495 memset(buf, 0, sizeof(buf)); 496 utf16_utf8_strncpy(&pos, c2, 10); 497 ut_asserteq(9, pos - buf); 498 ut_assert(buf[4]); 499 ut_assert(!strncmp(buf, d2, SIZE_MAX)); 500 501 pos = buf; 502 memset(buf, 0, sizeof(buf)); 503 utf16_utf8_strncpy(&pos, c3, 2); 504 ut_asserteq(6, pos - buf); 505 ut_assert(!buf[6]); 506 ut_assert(!strncmp(buf, d3, 6)); 507 508 pos = buf; 509 memset(buf, 0, sizeof(buf)); 510 utf16_utf8_strncpy(&pos, c4, 2); 511 ut_asserteq(8, pos - buf); 512 ut_assert(!buf[8]); 513 ut_assert(!strncmp(buf, d4, 8)); 514 515 pos = buf; 516 memset(buf, 0, sizeof(buf)); 517 utf16_utf8_strncpy(&pos, c4, 10); 518 ut_asserteq(12, pos - buf); 519 ut_assert(buf[5]); 520 ut_assert(!strncmp(buf, d4, SIZE_MAX)); 521 522 return 0; 523 } 524 UNICODE_TEST(unicode_test_utf16_utf8_strncpy); 525 526 static int unicode_test_utf_to_lower(struct unit_test_state *uts) 527 { 528 ut_asserteq('@', utf_to_lower('@')); 529 ut_asserteq('a', utf_to_lower('A')); 530 ut_asserteq('z', utf_to_lower('Z')); 531 ut_asserteq('[', utf_to_lower('[')); 532 ut_asserteq('m', utf_to_lower('m')); 533 /* Latin letter O with diaresis (umlaut) */ 534 ut_asserteq(0x00f6, utf_to_lower(0x00d6)); 535 #ifdef CONFIG_EFI_UNICODE_CAPITALIZATION 536 /* Cyrillic letter I*/ 537 ut_asserteq(0x0438, utf_to_lower(0x0418)); 538 #endif 539 return 0; 540 } 541 UNICODE_TEST(unicode_test_utf_to_lower); 542 543 static int unicode_test_utf_to_upper(struct unit_test_state *uts) 544 { 545 ut_asserteq('`', utf_to_upper('`')); 546 ut_asserteq('A', utf_to_upper('a')); 547 ut_asserteq('Z', utf_to_upper('z')); 548 ut_asserteq('{', utf_to_upper('{')); 549 ut_asserteq('M', utf_to_upper('M')); 550 /* Latin letter O with diaresis (umlaut) */ 551 ut_asserteq(0x00d6, utf_to_upper(0x00f6)); 552 #ifdef CONFIG_EFI_UNICODE_CAPITALIZATION 553 /* Cyrillic letter I */ 554 ut_asserteq(0x0418, utf_to_upper(0x0438)); 555 #endif 556 return 0; 557 } 558 UNICODE_TEST(unicode_test_utf_to_upper); 559 560 int do_ut_unicode(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) 561 { 562 struct unit_test *tests = ll_entry_start(struct unit_test, unicode_test); 563 const int n_ents = ll_entry_count(struct unit_test, unicode_test); 564 565 return cmd_ut_category("Unicode", tests, n_ents, argc, argv); 566 } 567