[thirdparty/cups.git] / cups / testi18n.c

/*
 * Internationalization test for CUPS.
 *
 * Copyright 2007-2014 by Apple Inc.
 * Copyright 1997-2006 by Easy Software Products.
 *
 * Licensed under Apache License v2.0.  See the file "LICENSE" for more information.
 */

/*
 * Include necessary headers...
 */

#include "string-private.h"
#include "language-private.h"
#include <stdlib.h>
#include <time.h>
#include <unistd.h>


/*
 * Local globals...
 */

static const char * const lang_encodings[] =
			{		/* Encoding strings */
			  "us-ascii",		"iso-8859-1",
			  "iso-8859-2",		"iso-8859-3",
			  "iso-8859-4",		"iso-8859-5",
			  "iso-8859-6",		"iso-8859-7",
			  "iso-8859-8",		"iso-8859-9",
			  "iso-8859-10",	"utf-8",
			  "iso-8859-13",	"iso-8859-14",
			  "iso-8859-15",	"windows-874",
			  "windows-1250",	"windows-1251",
			  "windows-1252",	"windows-1253",
			  "windows-1254",	"windows-1255",
			  "windows-1256",	"windows-1257",
			  "windows-1258",	"koi8-r",
			  "koi8-u",		"iso-8859-11",
			  "iso-8859-16",	"mac-roman",
			  "unknown",		"unknown",
			  "unknown",		"unknown",
			  "unknown",		"unknown",
			  "unknown",		"unknown",
			  "unknown",		"unknown",
			  "unknown",		"unknown",
			  "unknown",		"unknown",
			  "unknown",		"unknown",
			  "unknown",		"unknown",
			  "unknown",		"unknown",
			  "unknown",		"unknown",
			  "unknown",		"unknown",
			  "unknown",		"unknown",
			  "unknown",		"unknown",
			  "unknown",		"unknown",
			  "unknown",		"unknown",
			  "unknown",		"unknown",
			  "windows-932",	"windows-936",
			  "windows-949",	"windows-950",
			  "windows-1361",	"unknown",
			  "unknown",		"unknown",
			  "unknown",		"unknown",
			  "unknown",		"unknown",
			  "unknown",		"unknown",
			  "unknown",		"unknown",
			  "unknown",		"unknown",
			  "unknown",		"unknown",
			  "unknown",		"unknown",
			  "unknown",		"unknown",
			  "unknown",		"unknown",
			  "unknown",		"unknown",
			  "unknown",		"unknown",
			  "unknown",		"unknown",
			  "unknown",		"unknown",
			  "unknown",		"unknown",
			  "unknown",		"unknown",
			  "unknown",		"unknown",
			  "unknown",		"unknown",
			  "unknown",		"unknown",
			  "unknown",		"unknown",
			  "unknown",		"unknown",
			  "unknown",		"unknown",
			  "unknown",		"unknown",
			  "unknown",		"unknown",
			  "unknown",		"unknown",
			  "unknown",		"unknown",
			  "unknown",		"unknown",
			  "unknown",		"unknown",
			  "unknown",		"unknown",
			  "euc-cn",		"euc-jp",
			  "euc-kr",		"euc-tw",
			  "jis-x0213"
			};


/*
 * Local functions...
 */

static void	print_utf8(const char *msg, const cups_utf8_t *src);


/*
 * 'main()' - Main entry for internationalization test module.
 */

int					/* O - Exit code */
main(int  argc,				/* I - Argument Count */
     char *argv[])			/* I - Arguments */
{
  FILE		*fp;			/* File pointer */
  int		count;			/* File line counter */
  int		status,			/* Status of current test */
		errors;			/* Error count */
  char		line[1024];		/* File line source string */
  int		len;			/* Length (count) of string */
  char		legsrc[1024],		/* Legacy source string */
		legdest[1024],		/* Legacy destination string */
		*legptr;		/* Pointer into legacy string */
  cups_utf8_t	utf8latin[] =		/* UTF-8 Latin-1 source */
    { 0x41, 0x20, 0x21, 0x3D, 0x20, 0xC3, 0x84, 0x2E, 0x00 };
    /* "A != <A WITH DIAERESIS>." - use ISO 8859-1 */
  cups_utf8_t	utf8repla[] =		/* UTF-8 Latin-1 replacement */
    { 0x41, 0x20, 0xE2, 0x89, 0xA2, 0x20, 0xC3, 0x84, 0x2E, 0x00 };
    /* "A <NOT IDENTICAL TO> <A WITH DIAERESIS>." */
  cups_utf8_t	utf8greek[] =		/* UTF-8 Greek source string */
    { 0x41, 0x20, 0x21, 0x3D, 0x20, 0xCE, 0x91, 0x2E, 0x00 };
    /* "A != <ALPHA>." - use ISO 8859-7 */
  cups_utf8_t	utf8japan[] =		/* UTF-8 Japanese source */
    { 0x41, 0x20, 0x21, 0x3D, 0x20, 0xEE, 0x9C, 0x80, 0x2E, 0x00 };
    /* "A != <PRIVATE U+E700>." - use Windows 932 or EUC-JP */
  cups_utf8_t	utf8taiwan[] =		/* UTF-8 Chinese source */
    { 0x41, 0x20, 0x21, 0x3D, 0x20, 0xE4, 0xB9, 0x82, 0x2E, 0x00 };
    /* "A != <CJK U+4E42>." - use Windows 950 (Big5) or EUC-TW */
  cups_utf8_t	utf8dest[1024];		/* UTF-8 destination string */
  cups_utf32_t	utf32dest[1024];	/* UTF-32 destination string */


  if (argc > 1)
  {
    int			i;		/* Looping var */
    cups_encoding_t	encoding;	/* Source encoding */


    if (argc != 3)
    {
      puts("Usage: ./testi18n [filename charset]");
      return (1);
    }

    if ((fp = fopen(argv[1], "rb")) == NULL)
    {
      perror(argv[1]);
      return (1);
    }

    for (i = 0, encoding = CUPS_AUTO_ENCODING;
         i < (int)(sizeof(lang_encodings) / sizeof(lang_encodings[0]));
	 i ++)
      if (!_cups_strcasecmp(lang_encodings[i], argv[2]))
      {
        encoding = (cups_encoding_t)i;
	break;
      }

    if (encoding == CUPS_AUTO_ENCODING)
    {
      fprintf(stderr, "%s: Unknown character set!\n", argv[2]);
      return (1);
    }

    while (fgets(line, sizeof(line), fp))
    {
      if (cupsCharsetToUTF8(utf8dest, line, sizeof(utf8dest), encoding) < 0)
      {
        fprintf(stderr, "%s: Unable to convert line: %s", argv[1], line);
	return (1);
      }

      fputs((char *)utf8dest, stdout);
    }

    fclose(fp);
    return (0);
  }

 /*
  * Start with some conversion tests from a UTF-8 test file.
  */

  errors = 0;

  if ((fp = fopen("utf8demo.txt", "rb")) == NULL)
  {
    perror("utf8demo.txt");
    return (1);
  }

 /*
  * cupsUTF8ToUTF32
  */

  fputs("cupsUTF8ToUTF32 of utfdemo.txt: ", stdout);

  for (count = 0, status = 0; fgets(line, sizeof(line), fp);)
  {
    count ++;

    if (cupsUTF8ToUTF32(utf32dest, (cups_utf8_t *)line, 1024) < 0)
    {
      printf("FAIL (UTF-8 to UTF-32 on line %d)\n", count);
      errors ++;
      status = 1;
      break;
    }
  }

  if (!status)
    puts("PASS");

 /*
  * cupsUTF8ToCharset(CUPS_EUC_JP)
  */

  fputs("cupsUTF8ToCharset(CUPS_EUC_JP) of utfdemo.txt: ", stdout);

  rewind(fp);

  for (count = 0, status = 0; fgets(line, sizeof(line), fp);)
  {
    count ++;

    len = cupsUTF8ToCharset(legdest, (cups_utf8_t *)line, 1024, CUPS_EUC_JP);
    if (len < 0)
    {
      printf("FAIL (UTF-8 to EUC-JP on line %d)\n", count);
      errors ++;
      status = 1;
      break;
    }
  }

  if (!status)
    puts("PASS");

  fclose(fp);

 /*
  * Test UTF-8 to legacy charset (ISO 8859-1)...
  */

  fputs("cupsUTF8ToCharset(CUPS_ISO8859_1): ", stdout);

  legdest[0] = 0;

  len = cupsUTF8ToCharset(legdest, utf8latin, 1024, CUPS_ISO8859_1);
  if (len < 0)
  {
    printf("FAIL (len=%d)\n", len);
    errors ++;
  }
  else
    puts("PASS");

 /*
  * cupsCharsetToUTF8
  */

  fputs("cupsCharsetToUTF8(CUPS_ISO8859_1): ", stdout);

  strlcpy(legsrc, legdest, sizeof(legsrc));

  len = cupsCharsetToUTF8(utf8dest, legsrc, 1024, CUPS_ISO8859_1);
  if ((size_t)len != strlen((char *)utf8latin))
  {
    printf("FAIL (len=%d, expected %d)\n", len, (int)strlen((char *)utf8latin));
    print_utf8("    utf8latin", utf8latin);
    print_utf8("    utf8dest", utf8dest);
    errors ++;
  }
  else if (memcmp(utf8latin, utf8dest, (size_t)len))
  {
    puts("FAIL (results do not match)");
    print_utf8("    utf8latin", utf8latin);
    print_utf8("    utf8dest", utf8dest);
    errors ++;
  }
  else if (cupsUTF8ToCharset(legdest, utf8repla, 1024, CUPS_ISO8859_1) < 0)
  {
    puts("FAIL (replacement characters do not work!)");
    errors ++;
  }
  else
    puts("PASS");

 /*
  * Test UTF-8 to/from legacy charset (ISO 8859-7)...
  */

  fputs("cupsUTF8ToCharset(CUPS_ISO8859_7): ", stdout);

  if (cupsUTF8ToCharset(legdest, utf8greek, 1024, CUPS_ISO8859_7) < 0)
  {
    puts("FAIL");
    errors ++;
  }
  else
  {
    for (legptr = legdest; *legptr && *legptr != '?'; legptr ++);

    if (*legptr)
    {
      puts("FAIL (unknown character)");
      errors ++;
    }
    else
      puts("PASS");
  }

  fputs("cupsCharsetToUTF8(CUPS_ISO8859_7): ", stdout);

  strlcpy(legsrc, legdest, sizeof(legsrc));

  len = cupsCharsetToUTF8(utf8dest, legsrc, 1024, CUPS_ISO8859_7);
  if ((size_t)len != strlen((char *)utf8greek))
  {
    printf("FAIL (len=%d, expected %d)\n", len, (int)strlen((char *)utf8greek));
    print_utf8("    utf8greek", utf8greek);
    print_utf8("    utf8dest", utf8dest);
    errors ++;
  }
  else if (memcmp(utf8greek, utf8dest, (size_t)len))
  {
    puts("FAIL (results do not match)");
    print_utf8("    utf8greek", utf8greek);
    print_utf8("    utf8dest", utf8dest);
    errors ++;
  }
  else
    puts("PASS");

 /*
  * Test UTF-8 to/from legacy charset (Windows 932)...
  */

  fputs("cupsUTF8ToCharset(CUPS_WINDOWS_932): ", stdout);

  if (cupsUTF8ToCharset(legdest, utf8japan, 1024, CUPS_WINDOWS_932) < 0)
  {
    puts("FAIL");
    errors ++;
  }
  else
  {
    for (legptr = legdest; *legptr && *legptr != '?'; legptr ++);

    if (*legptr)
    {
      puts("FAIL (unknown character)");
      errors ++;
    }
    else
      puts("PASS");
  }

  fputs("cupsCharsetToUTF8(CUPS_WINDOWS_932): ", stdout);

  strlcpy(legsrc, legdest, sizeof(legsrc));

  len = cupsCharsetToUTF8(utf8dest, legsrc, 1024, CUPS_WINDOWS_932);
  if ((size_t)len != strlen((char *)utf8japan))
  {
    printf("FAIL (len=%d, expected %d)\n", len, (int)strlen((char *)utf8japan));
    print_utf8("    utf8japan", utf8japan);
    print_utf8("    utf8dest", utf8dest);
    errors ++;
  }
  else if (memcmp(utf8japan, utf8dest, (size_t)len))
  {
    puts("FAIL (results do not match)");
    print_utf8("    utf8japan", utf8japan);
    print_utf8("    utf8dest", utf8dest);
    errors ++;
  }
  else
    puts("PASS");

 /*
  * Test UTF-8 to/from legacy charset (EUC-JP)...
  */

  fputs("cupsUTF8ToCharset(CUPS_EUC_JP): ", stdout);

  if (cupsUTF8ToCharset(legdest, utf8japan, 1024, CUPS_EUC_JP) < 0)
  {
    puts("FAIL");
    errors ++;
  }
  else
  {
    for (legptr = legdest; *legptr && *legptr != '?'; legptr ++);

    if (*legptr)
    {
      puts("FAIL (unknown character)");
      errors ++;
    }
    else
      puts("PASS");
  }

#ifndef __linux
  fputs("cupsCharsetToUTF8(CUPS_EUC_JP): ", stdout);

  strlcpy(legsrc, legdest, sizeof(legsrc));

  len = cupsCharsetToUTF8(utf8dest, legsrc, 1024, CUPS_EUC_JP);
  if ((size_t)len != strlen((char *)utf8japan))
  {
    printf("FAIL (len=%d, expected %d)\n", len, (int)strlen((char *)utf8japan));
    print_utf8("    utf8japan", utf8japan);
    print_utf8("    utf8dest", utf8dest);
    errors ++;
  }
  else if (memcmp(utf8japan, utf8dest, (size_t)len))
  {
    puts("FAIL (results do not match)");
    print_utf8("    utf8japan", utf8japan);
    print_utf8("    utf8dest", utf8dest);
    errors ++;
  }
  else
    puts("PASS");
#endif /* !__linux */

 /*
  * Test UTF-8 to/from legacy charset (Windows 950)...
  */

  fputs("cupsUTF8ToCharset(CUPS_WINDOWS_950): ", stdout);

  if (cupsUTF8ToCharset(legdest, utf8taiwan, 1024, CUPS_WINDOWS_950) < 0)
  {
    puts("FAIL");
    errors ++;
  }
  else
  {
    for (legptr = legdest; *legptr && *legptr != '?'; legptr ++);

    if (*legptr)
    {
      puts("FAIL (unknown character)");
      errors ++;
    }
    else
      puts("PASS");
  }

  fputs("cupsCharsetToUTF8(CUPS_WINDOWS_950): ", stdout);

  strlcpy(legsrc, legdest, sizeof(legsrc));

  len = cupsCharsetToUTF8(utf8dest, legsrc, 1024, CUPS_WINDOWS_950);
  if ((size_t)len != strlen((char *)utf8taiwan))
  {
    printf("FAIL (len=%d, expected %d)\n", len, (int)strlen((char *)utf8taiwan));
    print_utf8("    utf8taiwan", utf8taiwan);
    print_utf8("    utf8dest", utf8dest);
    errors ++;
  }
  else if (memcmp(utf8taiwan, utf8dest, (size_t)len))
  {
    puts("FAIL (results do not match)");
    print_utf8("    utf8taiwan", utf8taiwan);
    print_utf8("    utf8dest", utf8dest);
    errors ++;
  }
  else
    puts("PASS");

 /*
  * Test UTF-8 to/from legacy charset (EUC-TW)...
  */

  fputs("cupsUTF8ToCharset(CUPS_EUC_TW): ", stdout);

  if (cupsUTF8ToCharset(legdest, utf8taiwan, 1024, CUPS_EUC_TW) < 0)
  {
    puts("FAIL");
    errors ++;
  }
  else
  {
    for (legptr = legdest; *legptr && *legptr != '?'; legptr ++);

    if (*legptr)
    {
      puts("FAIL (unknown character)");
      errors ++;
    }
    else
      puts("PASS");
  }

  fputs("cupsCharsetToUTF8(CUPS_EUC_TW): ", stdout);

  strlcpy(legsrc, legdest, sizeof(legsrc));

  len = cupsCharsetToUTF8(utf8dest, legsrc, 1024, CUPS_EUC_TW);
  if ((size_t)len != strlen((char *)utf8taiwan))
  {
    printf("FAIL (len=%d, expected %d)\n", len, (int)strlen((char *)utf8taiwan));
    print_utf8("    utf8taiwan", utf8taiwan);
    print_utf8("    utf8dest", utf8dest);
    errors ++;
  }
  else if (memcmp(utf8taiwan, utf8dest, (size_t)len))
  {
    puts("FAIL (results do not match)");
    print_utf8("    utf8taiwan", utf8taiwan);
    print_utf8("    utf8dest", utf8dest);
    errors ++;
  }
  else
    puts("PASS");

#if 0
 /*
  * Test UTF-8 (16-bit) to UTF-32 (w/ BOM)...
  */
  if (verbose)
    printf("\ntesti18n: Testing UTF-8 to UTF-32 (w/ BOM)...\n");
  len = cupsUTF8ToUTF32(utf32dest, utf8good, 1024);
  if (len < 0)
    return (1);
  if (verbose)
  {
    print_utf8(" utf8good ", utf8good);
    print_utf32(" utf32dest", utf32dest);
  }
  memcpy(utf32src, utf32dest, (len + 1) * sizeof(cups_utf32_t));
  len = cupsUTF32ToUTF8(utf8dest, utf32src, 1024);
  if (len < 0)
    return (1);
  if (len != strlen ((char *) utf8good))
    return (1);
  if (memcmp(utf8good, utf8dest, len) != 0)
    return (1);

 /*
  * Test invalid UTF-8 (16-bit) to UTF-32 (w/ BOM)...
  */
  if (verbose)
    printf("\ntesti18n: Testing UTF-8 bad 16-bit source string...\n");
  len = cupsUTF8ToUTF32(utf32dest, utf8bad, 1024);
  if (len >= 0)
    return (1);
  if (verbose)
    print_utf8(" utf8bad  ", utf8bad);

 /*
  * Test _cupsCharmapFlush()...
  */
  if (verbose)
    printf("\ntesti18n: Testing _cupsCharmapFlush()...\n");
  _cupsCharmapFlush();
  return (0);
#endif /* 0 */

  return (errors > 0);
}


/*
 * 'print_utf8()' - Print UTF-8 string with (optional) message.
 */

static void
print_utf8(const char	     *msg,	/* I - Message String */
	   const cups_utf8_t *src)	/* I - UTF-8 Source String */
{
  const char	*prefix;		/* Prefix string */


  if (msg)
    printf("%s:", msg);

  for (prefix = " "; *src; src ++)
  {
    printf("%s%02x", prefix, *src);

    if ((src[0] & 0x80) && (src[1] & 0x80))
      prefix = "";
    else
      prefix = " ";
  }

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