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

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