1 /* 2 * Internationalization test for CUPS. 3 * 4 * Copyright 2007-2014 by Apple Inc. 5 * Copyright 1997-2006 by Easy Software Products. 6 * 7 * These coded instructions, statements, and computer programs are the 8 * property of Apple Inc. and are protected by Federal copyright 9 * law. Distribution and use rights are outlined in the file "LICENSE.txt" 10 * which should have been included with this file. If this file is 11 * missing or damaged, see the license at "http://www.cups.org/". 12 * 13 * This file is subject to the Apple OS-Developed Software exception. 14 */ 15 16 /* 17 * Include necessary headers... 18 */ 19 20 #include "string-private.h" 21 #include "language-private.h" 22 #include <stdlib.h> 23 #include <time.h> 24 #include <unistd.h> 25 26 27 /* 28 * Local globals... 29 */ 30 31 static const char * const lang_encodings[] = 32 { /* Encoding strings */ 33 "us-ascii", "iso-8859-1", 34 "iso-8859-2", "iso-8859-3", 35 "iso-8859-4", "iso-8859-5", 36 "iso-8859-6", "iso-8859-7", 37 "iso-8859-8", "iso-8859-9", 38 "iso-8859-10", "utf-8", 39 "iso-8859-13", "iso-8859-14", 40 "iso-8859-15", "windows-874", 41 "windows-1250", "windows-1251", 42 "windows-1252", "windows-1253", 43 "windows-1254", "windows-1255", 44 "windows-1256", "windows-1257", 45 "windows-1258", "koi8-r", 46 "koi8-u", "iso-8859-11", 47 "iso-8859-16", "mac-roman", 48 "unknown", "unknown", 49 "unknown", "unknown", 50 "unknown", "unknown", 51 "unknown", "unknown", 52 "unknown", "unknown", 53 "unknown", "unknown", 54 "unknown", "unknown", 55 "unknown", "unknown", 56 "unknown", "unknown", 57 "unknown", "unknown", 58 "unknown", "unknown", 59 "unknown", "unknown", 60 "unknown", "unknown", 61 "unknown", "unknown", 62 "unknown", "unknown", 63 "unknown", "unknown", 64 "unknown", "unknown", 65 "windows-932", "windows-936", 66 "windows-949", "windows-950", 67 "windows-1361", "unknown", 68 "unknown", "unknown", 69 "unknown", "unknown", 70 "unknown", "unknown", 71 "unknown", "unknown", 72 "unknown", "unknown", 73 "unknown", "unknown", 74 "unknown", "unknown", 75 "unknown", "unknown", 76 "unknown", "unknown", 77 "unknown", "unknown", 78 "unknown", "unknown", 79 "unknown", "unknown", 80 "unknown", "unknown", 81 "unknown", "unknown", 82 "unknown", "unknown", 83 "unknown", "unknown", 84 "unknown", "unknown", 85 "unknown", "unknown", 86 "unknown", "unknown", 87 "unknown", "unknown", 88 "unknown", "unknown", 89 "unknown", "unknown", 90 "unknown", "unknown", 91 "unknown", "unknown", 92 "unknown", "unknown", 93 "unknown", "unknown", 94 "unknown", "unknown", 95 "unknown", "unknown", 96 "unknown", "unknown", 97 "euc-cn", "euc-jp", 98 "euc-kr", "euc-tw", 99 "jis-x0213" 100 }; 101 102 103 /* 104 * Local functions... 105 */ 106 107 static void print_utf8(const char *msg, const cups_utf8_t *src); 108 109 110 /* 111 * 'main()' - Main entry for internationalization test module. 112 */ 113 114 int /* O - Exit code */ 115 main(int argc, /* I - Argument Count */ 116 char *argv[]) /* I - Arguments */ 117 { 118 FILE *fp; /* File pointer */ 119 int count; /* File line counter */ 120 int status, /* Status of current test */ 121 errors; /* Error count */ 122 char line[1024]; /* File line source string */ 123 int len; /* Length (count) of string */ 124 char legsrc[1024], /* Legacy source string */ 125 legdest[1024], /* Legacy destination string */ 126 *legptr; /* Pointer into legacy string */ 127 cups_utf8_t utf8latin[] = /* UTF-8 Latin-1 source */ 128 { 0x41, 0x20, 0x21, 0x3D, 0x20, 0xC3, 0x84, 0x2E, 0x00 }; 129 /* "A != <A WITH DIAERESIS>." - use ISO 8859-1 */ 130 cups_utf8_t utf8repla[] = /* UTF-8 Latin-1 replacement */ 131 { 0x41, 0x20, 0xE2, 0x89, 0xA2, 0x20, 0xC3, 0x84, 0x2E, 0x00 }; 132 /* "A <NOT IDENTICAL TO> <A WITH DIAERESIS>." */ 133 cups_utf8_t utf8greek[] = /* UTF-8 Greek source string */ 134 { 0x41, 0x20, 0x21, 0x3D, 0x20, 0xCE, 0x91, 0x2E, 0x00 }; 135 /* "A != <ALPHA>." - use ISO 8859-7 */ 136 cups_utf8_t utf8japan[] = /* UTF-8 Japanese source */ 137 { 0x41, 0x20, 0x21, 0x3D, 0x20, 0xEE, 0x9C, 0x80, 0x2E, 0x00 }; 138 /* "A != <PRIVATE U+E700>." - use Windows 932 or EUC-JP */ 139 cups_utf8_t utf8taiwan[] = /* UTF-8 Chinese source */ 140 { 0x41, 0x20, 0x21, 0x3D, 0x20, 0xE4, 0xB9, 0x82, 0x2E, 0x00 }; 141 /* "A != <CJK U+4E42>." - use Windows 950 (Big5) or EUC-TW */ 142 cups_utf8_t utf8dest[1024]; /* UTF-8 destination string */ 143 cups_utf32_t utf32dest[1024]; /* UTF-32 destination string */ 144 145 146 if (argc > 1) 147 { 148 int i; /* Looping var */ 149 cups_encoding_t encoding; /* Source encoding */ 150 151 152 if (argc != 3) 153 { 154 puts("Usage: ./testi18n [filename charset]"); 155 return (1); 156 } 157 158 if ((fp = fopen(argv[1], "rb")) == NULL) 159 { 160 perror(argv[1]); 161 return (1); 162 } 163 164 for (i = 0, encoding = CUPS_AUTO_ENCODING; 165 i < (int)(sizeof(lang_encodings) / sizeof(lang_encodings[0])); 166 i ++) 167 if (!_cups_strcasecmp(lang_encodings[i], argv[2])) 168 { 169 encoding = (cups_encoding_t)i; 170 break; 171 } 172 173 if (encoding == CUPS_AUTO_ENCODING) 174 { 175 fprintf(stderr, "%s: Unknown character set!\n", argv[2]); 176 return (1); 177 } 178 179 while (fgets(line, sizeof(line), fp)) 180 { 181 if (cupsCharsetToUTF8(utf8dest, line, sizeof(utf8dest), encoding) < 0) 182 { 183 fprintf(stderr, "%s: Unable to convert line: %s", argv[1], line); 184 return (1); 185 } 186 187 fputs((char *)utf8dest, stdout); 188 } 189 190 fclose(fp); 191 return (0); 192 } 193 194 /* 195 * Start with some conversion tests from a UTF-8 test file. 196 */ 197 198 errors = 0; 199 200 if ((fp = fopen("utf8demo.txt", "rb")) == NULL) 201 { 202 perror("utf8demo.txt"); 203 return (1); 204 } 205 206 /* 207 * cupsUTF8ToUTF32 208 */ 209 210 fputs("cupsUTF8ToUTF32 of utfdemo.txt: ", stdout); 211 212 for (count = 0, status = 0; fgets(line, sizeof(line), fp);) 213 { 214 count ++; 215 216 if (cupsUTF8ToUTF32(utf32dest, (cups_utf8_t *)line, 1024) < 0) 217 { 218 printf("FAIL (UTF-8 to UTF-32 on line %d)\n", count); 219 errors ++; 220 status = 1; 221 break; 222 } 223 } 224 225 if (!status) 226 puts("PASS"); 227 228 /* 229 * cupsUTF8ToCharset(CUPS_EUC_JP) 230 */ 231 232 fputs("cupsUTF8ToCharset(CUPS_EUC_JP) of utfdemo.txt: ", stdout); 233 234 rewind(fp); 235 236 for (count = 0, status = 0; fgets(line, sizeof(line), fp);) 237 { 238 count ++; 239 240 len = cupsUTF8ToCharset(legdest, (cups_utf8_t *)line, 1024, CUPS_EUC_JP); 241 if (len < 0) 242 { 243 printf("FAIL (UTF-8 to EUC-JP on line %d)\n", count); 244 errors ++; 245 status = 1; 246 break; 247 } 248 } 249 250 if (!status) 251 puts("PASS"); 252 253 fclose(fp); 254 255 /* 256 * Test UTF-8 to legacy charset (ISO 8859-1)... 257 */ 258 259 fputs("cupsUTF8ToCharset(CUPS_ISO8859_1): ", stdout); 260 261 legdest[0] = 0; 262 263 len = cupsUTF8ToCharset(legdest, utf8latin, 1024, CUPS_ISO8859_1); 264 if (len < 0) 265 { 266 printf("FAIL (len=%d)\n", len); 267 errors ++; 268 } 269 else 270 puts("PASS"); 271 272 /* 273 * cupsCharsetToUTF8 274 */ 275 276 fputs("cupsCharsetToUTF8(CUPS_ISO8859_1): ", stdout); 277 278 strlcpy(legsrc, legdest, sizeof(legsrc)); 279 280 len = cupsCharsetToUTF8(utf8dest, legsrc, 1024, CUPS_ISO8859_1); 281 if ((size_t)len != strlen((char *)utf8latin)) 282 { 283 printf("FAIL (len=%d, expected %d)\n", len, (int)strlen((char *)utf8latin)); 284 print_utf8(" utf8latin", utf8latin); 285 print_utf8(" utf8dest", utf8dest); 286 errors ++; 287 } 288 else if (memcmp(utf8latin, utf8dest, (size_t)len)) 289 { 290 puts("FAIL (results do not match)"); 291 print_utf8(" utf8latin", utf8latin); 292 print_utf8(" utf8dest", utf8dest); 293 errors ++; 294 } 295 else if (cupsUTF8ToCharset(legdest, utf8repla, 1024, CUPS_ISO8859_1) < 0) 296 { 297 puts("FAIL (replacement characters do not work!)"); 298 errors ++; 299 } 300 else 301 puts("PASS"); 302 303 /* 304 * Test UTF-8 to/from legacy charset (ISO 8859-7)... 305 */ 306 307 fputs("cupsUTF8ToCharset(CUPS_ISO8859_7): ", stdout); 308 309 if (cupsUTF8ToCharset(legdest, utf8greek, 1024, CUPS_ISO8859_7) < 0) 310 { 311 puts("FAIL"); 312 errors ++; 313 } 314 else 315 { 316 for (legptr = legdest; *legptr && *legptr != '?'; legptr ++); 317 318 if (*legptr) 319 { 320 puts("FAIL (unknown character)"); 321 errors ++; 322 } 323 else 324 puts("PASS"); 325 } 326 327 fputs("cupsCharsetToUTF8(CUPS_ISO8859_7): ", stdout); 328 329 strlcpy(legsrc, legdest, sizeof(legsrc)); 330 331 len = cupsCharsetToUTF8(utf8dest, legsrc, 1024, CUPS_ISO8859_7); 332 if ((size_t)len != strlen((char *)utf8greek)) 333 { 334 printf("FAIL (len=%d, expected %d)\n", len, (int)strlen((char *)utf8greek)); 335 print_utf8(" utf8greek", utf8greek); 336 print_utf8(" utf8dest", utf8dest); 337 errors ++; 338 } 339 else if (memcmp(utf8greek, utf8dest, (size_t)len)) 340 { 341 puts("FAIL (results do not match)"); 342 print_utf8(" utf8greek", utf8greek); 343 print_utf8(" utf8dest", utf8dest); 344 errors ++; 345 } 346 else 347 puts("PASS"); 348 349 /* 350 * Test UTF-8 to/from legacy charset (Windows 932)... 351 */ 352 353 fputs("cupsUTF8ToCharset(CUPS_WINDOWS_932): ", stdout); 354 355 if (cupsUTF8ToCharset(legdest, utf8japan, 1024, CUPS_WINDOWS_932) < 0) 356 { 357 puts("FAIL"); 358 errors ++; 359 } 360 else 361 { 362 for (legptr = legdest; *legptr && *legptr != '?'; legptr ++); 363 364 if (*legptr) 365 { 366 puts("FAIL (unknown character)"); 367 errors ++; 368 } 369 else 370 puts("PASS"); 371 } 372 373 fputs("cupsCharsetToUTF8(CUPS_WINDOWS_932): ", stdout); 374 375 strlcpy(legsrc, legdest, sizeof(legsrc)); 376 377 len = cupsCharsetToUTF8(utf8dest, legsrc, 1024, CUPS_WINDOWS_932); 378 if ((size_t)len != strlen((char *)utf8japan)) 379 { 380 printf("FAIL (len=%d, expected %d)\n", len, (int)strlen((char *)utf8japan)); 381 print_utf8(" utf8japan", utf8japan); 382 print_utf8(" utf8dest", utf8dest); 383 errors ++; 384 } 385 else if (memcmp(utf8japan, utf8dest, (size_t)len)) 386 { 387 puts("FAIL (results do not match)"); 388 print_utf8(" utf8japan", utf8japan); 389 print_utf8(" utf8dest", utf8dest); 390 errors ++; 391 } 392 else 393 puts("PASS"); 394 395 /* 396 * Test UTF-8 to/from legacy charset (EUC-JP)... 397 */ 398 399 fputs("cupsUTF8ToCharset(CUPS_EUC_JP): ", stdout); 400 401 if (cupsUTF8ToCharset(legdest, utf8japan, 1024, CUPS_EUC_JP) < 0) 402 { 403 puts("FAIL"); 404 errors ++; 405 } 406 else 407 { 408 for (legptr = legdest; *legptr && *legptr != '?'; legptr ++); 409 410 if (*legptr) 411 { 412 puts("FAIL (unknown character)"); 413 errors ++; 414 } 415 else 416 puts("PASS"); 417 } 418 419 #ifndef __linux 420 fputs("cupsCharsetToUTF8(CUPS_EUC_JP): ", stdout); 421 422 strlcpy(legsrc, legdest, sizeof(legsrc)); 423 424 len = cupsCharsetToUTF8(utf8dest, legsrc, 1024, CUPS_EUC_JP); 425 if ((size_t)len != strlen((char *)utf8japan)) 426 { 427 printf("FAIL (len=%d, expected %d)\n", len, (int)strlen((char *)utf8japan)); 428 print_utf8(" utf8japan", utf8japan); 429 print_utf8(" utf8dest", utf8dest); 430 errors ++; 431 } 432 else if (memcmp(utf8japan, utf8dest, (size_t)len)) 433 { 434 puts("FAIL (results do not match)"); 435 print_utf8(" utf8japan", utf8japan); 436 print_utf8(" utf8dest", utf8dest); 437 errors ++; 438 } 439 else 440 puts("PASS"); 441 #endif /* !__linux */ 442 443 /* 444 * Test UTF-8 to/from legacy charset (Windows 950)... 445 */ 446 447 fputs("cupsUTF8ToCharset(CUPS_WINDOWS_950): ", stdout); 448 449 if (cupsUTF8ToCharset(legdest, utf8taiwan, 1024, CUPS_WINDOWS_950) < 0) 450 { 451 puts("FAIL"); 452 errors ++; 453 } 454 else 455 { 456 for (legptr = legdest; *legptr && *legptr != '?'; legptr ++); 457 458 if (*legptr) 459 { 460 puts("FAIL (unknown character)"); 461 errors ++; 462 } 463 else 464 puts("PASS"); 465 } 466 467 fputs("cupsCharsetToUTF8(CUPS_WINDOWS_950): ", stdout); 468 469 strlcpy(legsrc, legdest, sizeof(legsrc)); 470 471 len = cupsCharsetToUTF8(utf8dest, legsrc, 1024, CUPS_WINDOWS_950); 472 if ((size_t)len != strlen((char *)utf8taiwan)) 473 { 474 printf("FAIL (len=%d, expected %d)\n", len, (int)strlen((char *)utf8taiwan)); 475 print_utf8(" utf8taiwan", utf8taiwan); 476 print_utf8(" utf8dest", utf8dest); 477 errors ++; 478 } 479 else if (memcmp(utf8taiwan, utf8dest, (size_t)len)) 480 { 481 puts("FAIL (results do not match)"); 482 print_utf8(" utf8taiwan", utf8taiwan); 483 print_utf8(" utf8dest", utf8dest); 484 errors ++; 485 } 486 else 487 puts("PASS"); 488 489 /* 490 * Test UTF-8 to/from legacy charset (EUC-TW)... 491 */ 492 493 fputs("cupsUTF8ToCharset(CUPS_EUC_TW): ", stdout); 494 495 if (cupsUTF8ToCharset(legdest, utf8taiwan, 1024, CUPS_EUC_TW) < 0) 496 { 497 puts("FAIL"); 498 errors ++; 499 } 500 else 501 { 502 for (legptr = legdest; *legptr && *legptr != '?'; legptr ++); 503 504 if (*legptr) 505 { 506 puts("FAIL (unknown character)"); 507 errors ++; 508 } 509 else 510 puts("PASS"); 511 } 512 513 fputs("cupsCharsetToUTF8(CUPS_EUC_TW): ", stdout); 514 515 strlcpy(legsrc, legdest, sizeof(legsrc)); 516 517 len = cupsCharsetToUTF8(utf8dest, legsrc, 1024, CUPS_EUC_TW); 518 if ((size_t)len != strlen((char *)utf8taiwan)) 519 { 520 printf("FAIL (len=%d, expected %d)\n", len, (int)strlen((char *)utf8taiwan)); 521 print_utf8(" utf8taiwan", utf8taiwan); 522 print_utf8(" utf8dest", utf8dest); 523 errors ++; 524 } 525 else if (memcmp(utf8taiwan, utf8dest, (size_t)len)) 526 { 527 puts("FAIL (results do not match)"); 528 print_utf8(" utf8taiwan", utf8taiwan); 529 print_utf8(" utf8dest", utf8dest); 530 errors ++; 531 } 532 else 533 puts("PASS"); 534 535 #if 0 536 /* 537 * Test UTF-8 (16-bit) to UTF-32 (w/ BOM)... 538 */ 539 if (verbose) 540 printf("\ntesti18n: Testing UTF-8 to UTF-32 (w/ BOM)...\n"); 541 len = cupsUTF8ToUTF32(utf32dest, utf8good, 1024); 542 if (len < 0) 543 return (1); 544 if (verbose) 545 { 546 print_utf8(" utf8good ", utf8good); 547 print_utf32(" utf32dest", utf32dest); 548 } 549 memcpy(utf32src, utf32dest, (len + 1) * sizeof(cups_utf32_t)); 550 len = cupsUTF32ToUTF8(utf8dest, utf32src, 1024); 551 if (len < 0) 552 return (1); 553 if (len != strlen ((char *) utf8good)) 554 return (1); 555 if (memcmp(utf8good, utf8dest, len) != 0) 556 return (1); 557 558 /* 559 * Test invalid UTF-8 (16-bit) to UTF-32 (w/ BOM)... 560 */ 561 if (verbose) 562 printf("\ntesti18n: Testing UTF-8 bad 16-bit source string...\n"); 563 len = cupsUTF8ToUTF32(utf32dest, utf8bad, 1024); 564 if (len >= 0) 565 return (1); 566 if (verbose) 567 print_utf8(" utf8bad ", utf8bad); 568 569 /* 570 * Test _cupsCharmapFlush()... 571 */ 572 if (verbose) 573 printf("\ntesti18n: Testing _cupsCharmapFlush()...\n"); 574 _cupsCharmapFlush(); 575 return (0); 576 #endif /* 0 */ 577 578 return (errors > 0); 579 } 580 581 582 /* 583 * 'print_utf8()' - Print UTF-8 string with (optional) message. 584 */ 585 586 static void 587 print_utf8(const char *msg, /* I - Message String */ 588 const cups_utf8_t *src) /* I - UTF-8 Source String */ 589 { 590 const char *prefix; /* Prefix string */ 591 592 593 if (msg) 594 printf("%s:", msg); 595 596 for (prefix = " "; *src; src ++) 597 { 598 printf("%s%02x", prefix, *src); 599 600 if ((src[0] & 0x80) && (src[1] & 0x80)) 601 prefix = ""; 602 else 603 prefix = " "; 604 } 605 606 putchar('\n'); 607 } 608
