cups/testi18n.c

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