tests/uniconv/test-u16-conv-from-enc.c

   1 /* Test of conversion to UTF-16 from legacy encodings.
   2    Copyright (C) 2007 Free Software Foundation, Inc.
   3
   4    This program is free software; you can redistribute it and/or modify
   5    it under the terms of the GNU General Public License as published by
   6    the Free Software Foundation; either version 2, or (at your option)
   7    any later version.
   8
   9    This program is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12    GNU General Public License for more details.
  13
  14    You should have received a copy of the GNU General Public License
  15    along with this program; if not, write to the Free Software Foundation,
  16    Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.  */
  17
  18 /* Written by Bruno Haible <bruno@clisp.org>, 2007.  */
  19
  20 #ifdef HAVE_CONFIG_H
  21 # include <config.h>
  22 #endif
  23
  24 #include "uniconv.h"
  25
  26 #include <stdio.h>
  27 #include <stdlib.h>
  28 #include <string.h>
  29
  30 #include "unistr.h"
  31
  32 #define SIZEOF(array) (sizeof (array) / sizeof (array[0]))
  33 #define ASSERT(expr) \
  34   do                                                                         \
  35     {                                                                        \
  36       if (!(expr))                                                           \
  37         {                                                                    \
  38           fprintf (stderr, "%s:%d: assertion failed\n", __FILE__, __LINE__); \
  39           abort ();                                                          \
  40         }                                                                    \
  41     }                                                                        \
  42   while (0)
  43
  44 /* Magic number for detecting bounds violations.  */
  45 #define MAGIC 0x1983EFF1
  46
  47 static size_t *
  48 new_offsets (size_t n)
  49 {
  50   size_t *offsets = (size_t *) malloc ((n + 1) * sizeof (size_t));
  51   offsets[n] = MAGIC;
  52   return offsets;
  53 }
  54
  55 int
  56 main ()
  57 {
  58   static enum iconv_ilseq_handler handlers[] =
  59     { iconveh_error, iconveh_question_mark, iconveh_escape_sequence };
  60   size_t h;
  61   size_t o;
  62   size_t i;
  63
  64 #if HAVE_ICONV
  65   /* Assume that iconv() supports at least the encodings ASCII, ISO-8859-1,
  66      ISO-8859-2, and UTF-8.  */
  67
  68   /* Test conversion from ISO-8859-1 to UTF-16 with no errors.  */
  69   for (h = 0; h < SIZEOF (handlers); h++)
  70     {
  71       enum iconv_ilseq_handler handler = handlers[h];
  72       static const char input[] = "\304rger mit b\366sen B\374bchen ohne Augenma\337";
  73       static const uint16_t expected[] = /* Ärger mit bösen Bübchen ohne Augenmaß */
  74         {
  75           0xC4, 'r', 'g', 'e', 'r', ' ', 'm', 'i', 't', ' ', 'b', 0xF6, 's',
  76           'e', 'n', ' ', 'B', 0xFC, 'b', 'c', 'h', 'e', 'n', ' ', 'o', 'h',
  77           'n', 'e', ' ', 'A', 'u', 'g', 'e', 'n', 'm', 'a', 0xDF
  78         };
  79       for (o = 0; o < 2; o++)
  80         {
  81           size_t *offsets = (o ? new_offsets (strlen (input)) : NULL);
  82           uint16_t *result = NULL;
  83           size_t length = 0;
  84           int retval = u16_conv_from_encoding ("ISO-8859-1", handler,
  85                                                input, strlen (input),
  86                                                offsets,
  87                                                &result, &length);
  88           ASSERT (retval == 0);
  89           ASSERT (length == SIZEOF (expected));
  90           ASSERT (result != NULL && u16_cmp (result, expected, SIZEOF (expected)) == 0);
  91           if (o)
  92             {
  93               for (i = 0; i < 37; i++)
  94                 ASSERT (offsets[i] == i);
  95               ASSERT (offsets[37] == MAGIC);
  96               free (offsets);
  97             }
  98           free (result);
  99         }
 100     }
 101
 102   /* Test conversion from ISO-8859-2 to UTF-16 with no errors.  */
 103   for (h = 0; h < SIZEOF (handlers); h++)
 104     {
 105       enum iconv_ilseq_handler handler = handlers[h];
 106       static const char input[] = "Rafa\263 Maszkowski"; /* Rafał Maszkowski */
 107       static const uint16_t expected[] =
 108         {
 109           'R', 'a', 'f', 'a', 0x0142, ' ', 'M', 'a', 's', 'z', 'k', 'o', 'w',
 110           's', 'k', 'i'
 111         };
 112       for (o = 0; o < 2; o++)
 113         {
 114           size_t *offsets = (o ? new_offsets (strlen (input)) : NULL);
 115           uint16_t *result = NULL;
 116           size_t length = 0;
 117           int retval = u16_conv_from_encoding ("ISO-8859-2", handler,
 118                                                input, strlen (input),
 119                                                offsets,
 120                                                &result, &length);
 121           ASSERT (retval == 0);
 122           ASSERT (length == SIZEOF (expected));
 123           ASSERT (result != NULL && u16_cmp (result, expected, SIZEOF (expected)) == 0);
 124           if (o)
 125             {
 126               for (i = 0; i < 16; i++)
 127                 ASSERT (offsets[i] == i);
 128               ASSERT (offsets[16] == MAGIC);
 129               free (offsets);
 130             }
 131           free (result);
 132         }
 133     }
 134
 135   /* autodetect_jp is only supported when iconv() support ISO-2022-JP-2.  */
 136 # if defined _LIBICONV_VERSION || !(defined _AIX || defined __sgi || defined __hpux || defined __osf__)
 137   /* Test conversions from autodetect_jp to UTF-16.  */
 138   for (h = 0; h < SIZEOF (handlers); h++)
 139     {
 140       enum iconv_ilseq_handler handler = handlers[h];
 141       static const char input[] = "\244\263\244\363\244\313\244\301\244\317"; /* こんにちは in EUC-JP */
 142       static const uint16_t expected[] = /* こんにちは */
 143         {
 144           0x3053, 0x3093, 0x306B, 0x3061, 0x306F
 145         };
 146       for (o = 0; o < 2; o++)
 147         {
 148           size_t *offsets = (o ? new_offsets (strlen (input)) : NULL);
 149           uint16_t *result = NULL;
 150           size_t length = 0;
 151           int retval = u16_conv_from_encoding ("autodetect_jp", handler,
 152                                                input, strlen (input),
 153                                                offsets,
 154                                                &result, &length);
 155           ASSERT (retval == 0);
 156           ASSERT (length == SIZEOF (expected));
 157           ASSERT (result != NULL && u16_cmp (result, expected, SIZEOF (expected)) == 0);
 158           if (o)
 159             {
 160               for (i = 0; i < 10; i++)
 161                 ASSERT (offsets[i] == ((i % 2) == 0 ? i / 2 : (size_t)(-1)));
 162               ASSERT (offsets[10] == MAGIC);
 163               free (offsets);
 164             }
 165           free (result);
 166         }
 167     }
 168   for (h = 0; h < SIZEOF (handlers); h++)
 169     {
 170       enum iconv_ilseq_handler handler = handlers[h];
 171       static const char input[] = "\202\261\202\361\202\311\202\277\202\315"; /* こんにちは in Shift_JIS */
 172       static const uint16_t expected[] = /* こんにちは */
 173         {
 174           0x3053, 0x3093, 0x306B, 0x3061, 0x306F
 175         };
 176       for (o = 0; o < 2; o++)
 177         {
 178           size_t *offsets = (o ? new_offsets (strlen (input)) : NULL);
 179           uint16_t *result = NULL;
 180           size_t length = 0;
 181           int retval = u16_conv_from_encoding ("autodetect_jp", handler,
 182                                                input, strlen (input),
 183                                                offsets,
 184                                                &result, &length);
 185           ASSERT (retval == 0);
 186           ASSERT (length == SIZEOF (expected));
 187           ASSERT (result != NULL && u16_cmp (result, expected, SIZEOF (expected)) == 0);
 188           if (o)
 189             {
 190               for (i = 0; i < 10; i++)
 191                 ASSERT (offsets[i] == ((i % 2) == 0 ? i / 2 : (size_t)(-1)));
 192               ASSERT (offsets[10] == MAGIC);
 193               free (offsets);
 194             }
 195           free (result);
 196         }
 197     }
 198   for (h = 0; h < SIZEOF (handlers); h++)
 199     {
 200       enum iconv_ilseq_handler handler = handlers[h];
 201       static const char input[] = "\033$B$3$s$K$A$O\033(B"; /* こんにちは in ISO-2022-JP-2 */
 202       static const uint16_t expected[] = /* こんにちは */
 203         {
 204           0x3053, 0x3093, 0x306B, 0x3061, 0x306F
 205         };
 206       for (o = 0; o < 2; o++)
 207         {
 208           size_t *offsets = (o ? new_offsets (strlen (input)) : NULL);
 209           uint16_t *result = NULL;
 210           size_t length = 0;
 211           int retval = u16_conv_from_encoding ("autodetect_jp", handler,
 212                                                input, strlen (input),
 213                                                offsets,
 214                                                &result, &length);
 215           ASSERT (retval == 0);
 216           ASSERT (length == SIZEOF (expected));
 217           ASSERT (result != NULL && u16_cmp (result, expected, SIZEOF (expected)) == 0);
 218           if (o)
 219             {
 220               for (i = 0; i < 16; i++)
 221                 ASSERT (offsets[i] == (i == 0 ? 0 :
 222                                        i == 5 ? 1 :
 223                                        i == 7 ? 2 :
 224                                        i == 9 ? 3 :
 225                                        i == 11 ? 4 :
 226                                        i == 13 ? 5 :
 227                                        (size_t)(-1)));
 228               ASSERT (offsets[16] == MAGIC);
 229               free (offsets);
 230             }
 231           free (result);
 232         }
 233     }
 234 # endif
 235
 236 #endif
 237
 238   return 0;
 239 }