tests/test-striconveha.c

   1 /* Test of character set conversion with error handling and autodetection.
   2    Copyright (C) 2007-2020 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 3 of the License, or
   7    (at your option) 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, see <https://www.gnu.org/licenses/>.  */
  16
  17 /* Written by Bruno Haible <bruno@clisp.org>, 2007.  */
  18
  19 #include <config.h>
  20
  21 #include "striconveha.h"
  22
  23 #if HAVE_ICONV
  24 # include <iconv.h>
  25 #endif
  26
  27 #include <errno.h>
  28 #include <stdlib.h>
  29 #include <string.h>
  30
  31 #include "macros.h"
  32 extern int iconv_supports_encoding (const char *encoding);
  33
  34 /* Magic number for detecting bounds violations.  */
  35 #define MAGIC 0x1983EFF1
  36
  37 static size_t *
  38 new_offsets (size_t n)
  39 {
  40   size_t *offsets = (size_t *) malloc ((n + 1) * sizeof (size_t));
  41   offsets[n] = MAGIC;
  42   return offsets;
  43 }
  44
  45 int
  46 main ()
  47 {
  48 #if HAVE_ICONV
  49   static enum iconv_ilseq_handler handlers[] =
  50     { iconveh_error, iconveh_question_mark, iconveh_escape_sequence };
  51   size_t h;
  52   size_t o;
  53   size_t i;
  54
  55   /* Assume that iconv() supports at least the encodings ASCII, ISO-8859-1,
  56      ISO-8859-2, and UTF-8.  */
  57
  58   /* ------------------------- Test mem_iconveha() ------------------------- */
  59
  60   /* Test conversion from ISO-8859-2 to ISO-8859-1 with no errors.  */
  61   for (h = 0; h < SIZEOF (handlers); h++)
  62     {
  63       enum iconv_ilseq_handler handler = handlers[h];
  64       static const char input[] = "\304rger mit b\366sen B\374bchen ohne Augenma\337";
  65       static const char expected[] = "\304rger mit b\366sen B\374bchen ohne Augenma\337";
  66       for (o = 0; o < 2; o++)
  67         {
  68           size_t *offsets = (o ? new_offsets (strlen (input)) : NULL);
  69           char *result = NULL;
  70           size_t length = 0;
  71           int retval = mem_iconveha (input, strlen (input),
  72                                      "ISO-8859-2", "ISO-8859-1",
  73                                      false, handler,
  74                                      offsets,
  75                                      &result, &length);
  76           ASSERT (retval == 0);
  77           ASSERT (length == strlen (expected));
  78           ASSERT (result != NULL && memcmp (result, expected, strlen (expected)) == 0);
  79           if (o)
  80             {
  81               for (i = 0; i < 37; i++)
  82                 ASSERT (offsets[i] == i);
  83               ASSERT (offsets[37] == MAGIC);
  84               free (offsets);
  85             }
  86           free (result);
  87         }
  88     }
  89
  90   /* Test conversion from ISO-8859-2 to ISO-8859-1 with EILSEQ.  */
  91   for (h = 0; h < SIZEOF (handlers); h++)
  92     {
  93       enum iconv_ilseq_handler handler = handlers[h];
  94       static const char input[] = "Rafa\263 Maszkowski"; /* Rafał Maszkowski */
  95       for (o = 0; o < 2; o++)
  96         {
  97           size_t *offsets = (o ? new_offsets (strlen (input)) : NULL);
  98           char *result = NULL;
  99           size_t length = 0;
 100           int retval = mem_iconveha (input, strlen (input),
 101                                      "ISO-8859-2", "ISO-8859-1",
 102                                      false, handler,
 103                                      offsets,
 104                                      &result, &length);
 105           switch (handler)
 106             {
 107             case iconveh_error:
 108               ASSERT (retval == -1 && errno == EILSEQ);
 109               ASSERT (result == NULL);
 110               if (o)
 111                 free (offsets);
 112               break;
 113             case iconveh_question_mark:
 114               {
 115                 static const char expected[] = "Rafa? Maszkowski";
 116                 ASSERT (retval == 0);
 117                 ASSERT (length == strlen (expected));
 118                 ASSERT (result != NULL && memcmp (result, expected, strlen (expected)) == 0);
 119                 if (o)
 120                   {
 121                     for (i = 0; i < 16; i++)
 122                       ASSERT (offsets[i] == i);
 123                     ASSERT (offsets[16] == MAGIC);
 124                     free (offsets);
 125                   }
 126                 free (result);
 127               }
 128               break;
 129             case iconveh_escape_sequence:
 130               {
 131                 static const char expected[] = "Rafa\\u0142 Maszkowski";
 132                 ASSERT (retval == 0);
 133                 ASSERT (length == strlen (expected));
 134                 ASSERT (result != NULL && memcmp (result, expected, strlen (expected)) == 0);
 135                 if (o)
 136                   {
 137                     for (i = 0; i < 16; i++)
 138                       ASSERT (offsets[i] == (i < 5 ? i :
 139                                              i + 5));
 140                     ASSERT (offsets[16] == MAGIC);
 141                     free (offsets);
 142                   }
 143                 free (result);
 144               }
 145               break;
 146             }
 147         }
 148     }
 149
 150   /* Test conversion from ISO-8859-1 to UTF-8 with no errors.  */
 151   for (h = 0; h < SIZEOF (handlers); h++)
 152     {
 153       enum iconv_ilseq_handler handler = handlers[h];
 154       static const char input[] = "\304rger mit b\366sen B\374bchen ohne Augenma\337";
 155       static const char expected[] = "\303\204rger mit b\303\266sen B\303\274bchen ohne Augenma\303\237";
 156       for (o = 0; o < 2; o++)
 157         {
 158           size_t *offsets = (o ? new_offsets (strlen (input)) : NULL);
 159           char *result = NULL;
 160           size_t length = 0;
 161           int retval = mem_iconveha (input, strlen (input),
 162                                      "ISO-8859-1", "UTF-8",
 163                                      false, handler,
 164                                      offsets,
 165                                      &result, &length);
 166           ASSERT (retval == 0);
 167           ASSERT (length == strlen (expected));
 168           ASSERT (result != NULL && memcmp (result, expected, strlen (expected)) == 0);
 169           if (o)
 170             {
 171               for (i = 0; i < 37; i++)
 172                 ASSERT (offsets[i] == (i < 1 ? i :
 173                                        i < 12 ? i + 1 :
 174                                        i < 18 ? i + 2 :
 175                                        i + 3));
 176               ASSERT (offsets[37] == MAGIC);
 177               free (offsets);
 178             }
 179           free (result);
 180         }
 181     }
 182
 183   /* Test conversion from UTF-8 to ISO-8859-1 with no errors.  */
 184   for (h = 0; h < SIZEOF (handlers); h++)
 185     {
 186       enum iconv_ilseq_handler handler = handlers[h];
 187       static const char input[] = "\303\204rger mit b\303\266sen B\303\274bchen ohne Augenma\303\237";
 188       static const char expected[] = "\304rger mit b\366sen B\374bchen ohne Augenma\337";
 189       for (o = 0; o < 2; o++)
 190         {
 191           size_t *offsets = (o ? new_offsets (strlen (input)) : NULL);
 192           char *result = NULL;
 193           size_t length = 0;
 194           int retval = mem_iconveha (input, strlen (input),
 195                                      "UTF-8", "ISO-8859-1",
 196                                      false, handler,
 197                                      offsets,
 198                                      &result, &length);
 199           ASSERT (retval == 0);
 200           ASSERT (length == strlen (expected));
 201           ASSERT (result != NULL && memcmp (result, expected, strlen (expected)) == 0);
 202           if (o)
 203             {
 204               for (i = 0; i < 41; i++)
 205                 ASSERT (offsets[i] == (i < 1 ? i :
 206                                        i == 1 ? (size_t)(-1) :
 207                                        i < 13 ? i - 1 :
 208                                        i == 13 ? (size_t)(-1) :
 209                                        i < 20 ? i - 2 :
 210                                        i == 20 ? (size_t)(-1) :
 211                                        i < 40 ? i - 3 :
 212                                        (size_t)(-1)));
 213               ASSERT (offsets[41] == MAGIC);
 214               free (offsets);
 215             }
 216           free (result);
 217         }
 218     }
 219
 220   /* Test conversion from UTF-8 to ISO-8859-1 with EILSEQ.  */
 221   for (h = 0; h < SIZEOF (handlers); h++)
 222     {
 223       enum iconv_ilseq_handler handler = handlers[h];
 224       static const char input[] = "Rafa\305\202 Maszkowski"; /* Rafał Maszkowski */
 225       for (o = 0; o < 2; o++)
 226         {
 227           size_t *offsets = (o ? new_offsets (strlen (input)) : NULL);
 228           char *result = NULL;
 229           size_t length = 0;
 230           int retval = mem_iconveha (input, strlen (input),
 231                                      "UTF-8", "ISO-8859-1",
 232                                      false, handler,
 233                                      offsets,
 234                                      &result, &length);
 235           switch (handler)
 236             {
 237             case iconveh_error:
 238               ASSERT (retval == -1 && errno == EILSEQ);
 239               ASSERT (result == NULL);
 240               if (o)
 241                 free (offsets);
 242               break;
 243             case iconveh_question_mark:
 244               {
 245                 static const char expected[] = "Rafa? Maszkowski";
 246                 ASSERT (retval == 0);
 247                 ASSERT (length == strlen (expected));
 248                 ASSERT (result != NULL && memcmp (result, expected, strlen (expected)) == 0);
 249                 if (o)
 250                   {
 251                     for (i = 0; i < 17; i++)
 252                       ASSERT (offsets[i] == (i < 5 ? i :
 253                                              i == 5 ? (size_t)(-1) :
 254                                              i - 1));
 255                     ASSERT (offsets[17] == MAGIC);
 256                     free (offsets);
 257                   }
 258                 free (result);
 259               }
 260               break;
 261             case iconveh_escape_sequence:
 262               {
 263                 static const char expected[] = "Rafa\\u0142 Maszkowski";
 264                 ASSERT (retval == 0);
 265                 ASSERT (length == strlen (expected));
 266                 ASSERT (result != NULL && memcmp (result, expected, strlen (expected)) == 0);
 267                 if (o)
 268                   {
 269                     for (i = 0; i < 17; i++)
 270                       ASSERT (offsets[i] == (i < 5 ? i :
 271                                              i == 5 ? (size_t)(-1) :
 272                                              i + 4));
 273                     ASSERT (offsets[17] == MAGIC);
 274                     free (offsets);
 275                   }
 276                 free (result);
 277               }
 278               break;
 279             }
 280         }
 281     }
 282
 283   /* Test conversion from UTF-8 to ISO-8859-1 with EINVAL.  */
 284   for (h = 0; h < SIZEOF (handlers); h++)
 285     {
 286       enum iconv_ilseq_handler handler = handlers[h];
 287       static const char input[] = "\342";
 288       for (o = 0; o < 2; o++)
 289         {
 290           size_t *offsets = (o ? new_offsets (strlen (input)) : NULL);
 291           char *result = NULL;
 292           size_t length = 0;
 293           int retval = mem_iconveha (input, strlen (input),
 294                                      "UTF-8", "ISO-8859-1",
 295                                      false, handler,
 296                                      offsets,
 297                                      &result, &length);
 298           ASSERT (retval == 0);
 299           ASSERT (length == 0);
 300           if (o)
 301             {
 302               ASSERT (offsets[0] == 0);
 303               ASSERT (offsets[1] == MAGIC);
 304               free (offsets);
 305             }
 306           free (result);
 307         }
 308     }
 309
 310   /* autodetect_jp is only supported when iconv() support ISO-2022-JP-2.  */
 311 # if defined _LIBICONV_VERSION || !(defined _AIX || defined __sgi || defined __hpux || defined __osf__ || defined __sun)
 312   if (iconv_supports_encoding ("ISO-2022-JP-2"))
 313     {
 314       /* Test conversions from autodetect_jp to UTF-8.  */
 315       for (h = 0; h < SIZEOF (handlers); h++)
 316         {
 317           enum iconv_ilseq_handler handler = handlers[h];
 318           static const char input[] = "\244\263\244\363\244\313\244\301\244\317"; /* こんにちは in EUC-JP */
 319           static const char expected[] = "\343\201\223\343\202\223\343\201\253\343\201\241\343\201\257"; /* こんにちは */
 320           for (o = 0; o < 2; o++)
 321             {
 322               size_t *offsets = (o ? new_offsets (strlen (input)) : NULL);
 323               char *result = NULL;
 324               size_t length = 0;
 325               int retval = mem_iconveha (input, strlen (input),
 326                                          "autodetect_jp", "UTF-8",
 327                                          false, handler,
 328                                          offsets,
 329                                          &result, &length);
 330               ASSERT (retval == 0);
 331               ASSERT (length == strlen (expected));
 332               ASSERT (result != NULL && memcmp (result, expected, strlen (expected)) == 0);
 333               if (o)
 334                 {
 335                   for (i = 0; i < 10; i++)
 336                     ASSERT (offsets[i] == ((i % 2) == 0 ? (i / 2) * 3 : (size_t)(-1)));
 337                   ASSERT (offsets[10] == MAGIC);
 338                   free (offsets);
 339                 }
 340               free (result);
 341             }
 342         }
 343       for (h = 0; h < SIZEOF (handlers); h++)
 344         {
 345           enum iconv_ilseq_handler handler = handlers[h];
 346           static const char input[] = "\202\261\202\361\202\311\202\277\202\315"; /* こんにちは in Shift_JIS */
 347           static const char expected[] = "\343\201\223\343\202\223\343\201\253\343\201\241\343\201\257"; /* こんにちは */
 348           for (o = 0; o < 2; o++)
 349             {
 350               size_t *offsets = (o ? new_offsets (strlen (input)) : NULL);
 351               char *result = NULL;
 352               size_t length = 0;
 353               int retval = mem_iconveha (input, strlen (input),
 354                                          "autodetect_jp", "UTF-8",
 355                                          false, handler,
 356                                          offsets,
 357                                          &result, &length);
 358               ASSERT (retval == 0);
 359               ASSERT (length == strlen (expected));
 360               ASSERT (result != NULL && memcmp (result, expected, strlen (expected)) == 0);
 361               if (o)
 362                 {
 363                   for (i = 0; i < 10; i++)
 364                     ASSERT (offsets[i] == ((i % 2) == 0 ? (i / 2) * 3 : (size_t)(-1)));
 365                   ASSERT (offsets[10] == MAGIC);
 366                   free (offsets);
 367                 }
 368               free (result);
 369             }
 370         }
 371       for (h = 0; h < SIZEOF (handlers); h++)
 372         {
 373           enum iconv_ilseq_handler handler = handlers[h];
 374           static const char input[] = "\033$B$3$s$K$A$O\033(B"; /* こんにちは in ISO-2022-JP-2 */
 375           static const char expected[] = "\343\201\223\343\202\223\343\201\253\343\201\241\343\201\257"; /* こんにちは */
 376           for (o = 0; o < 2; o++)
 377             {
 378               size_t *offsets = (o ? new_offsets (strlen (input)) : NULL);
 379               char *result = NULL;
 380               size_t length = 0;
 381               int retval = mem_iconveha (input, strlen (input),
 382                                          "autodetect_jp", "UTF-8",
 383                                          false, handler,
 384                                          offsets,
 385                                          &result, &length);
 386               ASSERT (retval == 0);
 387               ASSERT (length == strlen (expected));
 388               ASSERT (result != NULL && memcmp (result, expected, strlen (expected)) == 0);
 389               if (o)
 390                 {
 391                   for (i = 0; i < 16; i++)
 392                     ASSERT (offsets[i] == (i == 0 ? 0 :
 393                                            i == 5 ? 3 :
 394                                            i == 7 ? 6 :
 395                                            i == 9 ? 9 :
 396                                            i == 11 ? 12 :
 397                                            i == 13 ? 15 :
 398                                            (size_t)(-1)));
 399                   ASSERT (offsets[16] == MAGIC);
 400                   free (offsets);
 401                 }
 402               free (result);
 403             }
 404         }
 405     }
 406 # endif
 407
 408 # if (((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 2) || __GLIBC__ > 2) && !defined __UCLIBC__) || _LIBICONV_VERSION >= 0x0105
 409   /* Test conversion from UTF-8 to ISO-8859-1 with transliteration.  */
 410   for (h = 0; h < SIZEOF (handlers); h++)
 411     {
 412       enum iconv_ilseq_handler handler = handlers[h];
 413       static const char input[] = "Costs: 27 \342\202\254"; /* EURO SIGN */
 414       static const char expected[] = "Costs: 27 EUR";
 415       for (o = 0; o < 2; o++)
 416         {
 417           size_t *offsets = (o ? new_offsets (strlen (input)) : NULL);
 418           char *result = NULL;
 419           size_t length = 0;
 420           int retval = mem_iconveha (input, strlen (input),
 421                                      "UTF-8", "ISO-8859-1",
 422                                      true, handler,
 423                                      offsets,
 424                                      &result, &length);
 425           ASSERT (retval == 0);
 426           ASSERT (length == strlen (expected));
 427           ASSERT (result != NULL && memcmp (result, expected, strlen (expected)) == 0);
 428           if (o)
 429             {
 430               for (i = 0; i < 13; i++)
 431                 ASSERT (offsets[i] == (i < 11 ? i : (size_t)(-1)));
 432               ASSERT (offsets[13] == MAGIC);
 433               free (offsets);
 434             }
 435           free (result);
 436         }
 437     }
 438 # endif
 439
 440   /* ------------------------- Test str_iconveha() ------------------------- */
 441
 442   /* Test conversion from ISO-8859-2 to ISO-8859-1 with no errors.  */
 443   for (h = 0; h < SIZEOF (handlers); h++)
 444     {
 445       enum iconv_ilseq_handler handler = handlers[h];
 446       static const char input[] = "\304rger mit b\366sen B\374bchen ohne Augenma\337";
 447       static const char expected[] = "\304rger mit b\366sen B\374bchen ohne Augenma\337";
 448       char *result = str_iconveha (input, "ISO-8859-2", "ISO-8859-1", false, handler);
 449       ASSERT (result != NULL);
 450       ASSERT (strcmp (result, expected) == 0);
 451       free (result);
 452     }
 453
 454   /* Test conversion from ISO-8859-2 to ISO-8859-1 with EILSEQ.  */
 455   for (h = 0; h < SIZEOF (handlers); h++)
 456     {
 457       enum iconv_ilseq_handler handler = handlers[h];
 458       static const char input[] = "Rafa\263 Maszkowski"; /* Rafał Maszkowski */
 459       char *result = str_iconveha (input, "ISO-8859-2", "ISO-8859-1", false, handler);
 460       switch (handler)
 461         {
 462         case iconveh_error:
 463           ASSERT (result == NULL && errno == EILSEQ);
 464           break;
 465         case iconveh_question_mark:
 466           {
 467             static const char expected[] = "Rafa? Maszkowski";
 468             ASSERT (result != NULL);
 469             ASSERT (strcmp (result, expected) == 0);
 470             free (result);
 471           }
 472           break;
 473         case iconveh_escape_sequence:
 474           {
 475             static const char expected[] = "Rafa\\u0142 Maszkowski";
 476             ASSERT (result != NULL);
 477             ASSERT (strcmp (result, expected) == 0);
 478             free (result);
 479           }
 480           break;
 481         }
 482     }
 483
 484   /* Test conversion from ISO-8859-1 to UTF-8 with no errors.  */
 485   for (h = 0; h < SIZEOF (handlers); h++)
 486     {
 487       enum iconv_ilseq_handler handler = handlers[h];
 488       static const char input[] = "\304rger mit b\366sen B\374bchen ohne Augenma\337";
 489       static const char expected[] = "\303\204rger mit b\303\266sen B\303\274bchen ohne Augenma\303\237";
 490       char *result = str_iconveha (input, "ISO-8859-1", "UTF-8", false, handler);
 491       ASSERT (result != NULL);
 492       ASSERT (strcmp (result, expected) == 0);
 493       free (result);
 494     }
 495
 496   /* Test conversion from UTF-8 to ISO-8859-1 with no errors.  */
 497   for (h = 0; h < SIZEOF (handlers); h++)
 498     {
 499       enum iconv_ilseq_handler handler = handlers[h];
 500       static const char input[] = "\303\204rger mit b\303\266sen B\303\274bchen ohne Augenma\303\237";
 501       static const char expected[] = "\304rger mit b\366sen B\374bchen ohne Augenma\337";
 502       char *result = str_iconveha (input, "UTF-8", "ISO-8859-1", false, handler);
 503       ASSERT (result != NULL);
 504       ASSERT (strcmp (result, expected) == 0);
 505       free (result);
 506     }
 507
 508   /* Test conversion from UTF-8 to ISO-8859-1 with EILSEQ.  */
 509   for (h = 0; h < SIZEOF (handlers); h++)
 510     {
 511       enum iconv_ilseq_handler handler = handlers[h];
 512       static const char input[] = "Costs: 27 \342\202\254"; /* EURO SIGN */
 513       char *result = str_iconveha (input, "UTF-8", "ISO-8859-1", false, handler);
 514       switch (handler)
 515         {
 516         case iconveh_error:
 517           ASSERT (result == NULL && errno == EILSEQ);
 518           break;
 519         case iconveh_question_mark:
 520           {
 521             static const char expected[] = "Costs: 27 ?";
 522             ASSERT (result != NULL);
 523             ASSERT (strcmp (result, expected) == 0);
 524             free (result);
 525           }
 526           break;
 527         case iconveh_escape_sequence:
 528           {
 529             static const char expected[] = "Costs: 27 \\u20AC";
 530             ASSERT (result != NULL);
 531             ASSERT (strcmp (result, expected) == 0);
 532             free (result);
 533           }
 534           break;
 535         }
 536     }
 537
 538   /* Test conversion from UTF-8 to ISO-8859-1 with EINVAL.  */
 539   for (h = 0; h < SIZEOF (handlers); h++)
 540     {
 541       enum iconv_ilseq_handler handler = handlers[h];
 542       static const char input[] = "\342";
 543       char *result = str_iconveha (input, "UTF-8", "ISO-8859-1", false, handler);
 544       ASSERT (result != NULL);
 545       ASSERT (strcmp (result, "") == 0);
 546       free (result);
 547     }
 548
 549   /* autodetect_jp is only supported when iconv() support ISO-2022-JP-2.  */
 550 # if defined _LIBICONV_VERSION || !(defined _AIX || defined __sgi || defined __hpux || defined __osf__ || defined __sun)
 551   if (iconv_supports_encoding ("ISO-2022-JP-2"))
 552     {
 553       /* Test conversions from autodetect_jp to UTF-8.  */
 554       for (h = 0; h < SIZEOF (handlers); h++)
 555         {
 556           enum iconv_ilseq_handler handler = handlers[h];
 557           static const char input[] = "\244\263\244\363\244\313\244\301\244\317"; /* こんにちは in EUC-JP */
 558           static const char expected[] = "\343\201\223\343\202\223\343\201\253\343\201\241\343\201\257"; /* こんにちは */
 559           char *result = str_iconveha (input, "autodetect_jp", "UTF-8", false, handler);
 560           ASSERT (result != NULL);
 561           ASSERT (strcmp (result, expected) == 0);
 562           free (result);
 563         }
 564       for (h = 0; h < SIZEOF (handlers); h++)
 565         {
 566           enum iconv_ilseq_handler handler = handlers[h];
 567           static const char input[] = "\202\261\202\361\202\311\202\277\202\315"; /* こんにちは in Shift_JIS */
 568           static const char expected[] = "\343\201\223\343\202\223\343\201\253\343\201\241\343\201\257"; /* こんにちは */
 569           char *result = str_iconveha (input, "autodetect_jp", "UTF-8", false, handler);
 570           ASSERT (result != NULL);
 571           ASSERT (strcmp (result, expected) == 0);
 572           free (result);
 573         }
 574       for (h = 0; h < SIZEOF (handlers); h++)
 575         {
 576           enum iconv_ilseq_handler handler = handlers[h];
 577           static const char input[] = "\033$B$3$s$K$A$O\033(B"; /* こんにちは in ISO-2022-JP-2 */
 578           static const char expected[] = "\343\201\223\343\202\223\343\201\253\343\201\241\343\201\257"; /* こんにちは */
 579           char *result = str_iconveha (input, "autodetect_jp", "UTF-8", false, handler);
 580           ASSERT (result != NULL);
 581           ASSERT (strcmp (result, expected) == 0);
 582           free (result);
 583         }
 584     }
 585 # endif
 586
 587 # if (((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 2) || __GLIBC__ > 2) && !defined __UCLIBC__) || _LIBICONV_VERSION >= 0x0105
 588   /* Test conversion from UTF-8 to ISO-8859-1 with transliteration.  */
 589   for (h = 0; h < SIZEOF (handlers); h++)
 590     {
 591       enum iconv_ilseq_handler handler = handlers[h];
 592       static const char input[] = "Costs: 27 \342\202\254"; /* EURO SIGN */
 593       static const char expected[] = "Costs: 27 EUR";
 594       char *result = str_iconveha (input, "UTF-8", "ISO-8859-1", true, handler);
 595       ASSERT (result != NULL);
 596       ASSERT (strcmp (result, expected) == 0);
 597       free (result);
 598     }
 599 # endif
 600
 601 #endif
 602
 603   return 0;
 604 }