tests/convert-test.c

   1 /* GLIB - Library of useful routines for C programming
   2  * Copyright (C) 1995-1997  Peter Mattis, Spencer Kimball and Josh MacDonald
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library 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 GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19
  20 /*
  21  * Modified by the GLib Team and others 1997-2000.  See the AUTHORS
  22  * file for a list of people on the GLib Team.  See the ChangeLog
  23  * files for a list of changes.  These files are distributed with
  24  * GLib at ftp://ftp.gtk.org/pub/gtk/.
  25  */
  26
  27 #undef G_DISABLE_ASSERT
  28 #undef G_LOG_DOMAIN
  29
  30 #include <string.h>
  31
  32 #include <glib.h>
  33
  34 /* Bug 311337 */
  35 static void
  36 test_iconv_state (void)
  37 {
  38   gchar *in = "\xf4\xe5\xf8\xe5\xed";
  39   gchar *expected = "\xd7\xa4\xd7\x95\xd7\xa8\xd7\x95\xd7\x9d";
  40   gchar *out;
  41   gsize bytes_read = 0;
  42   gsize bytes_written = 0;
  43   GError *error = NULL;
  44
  45   out = g_convert (in, -1, "UTF-8", "CP1255",
  46                    &bytes_read, &bytes_written, &error);
  47
  48   if (error && error->code == G_CONVERT_ERROR_NO_CONVERSION)
  49     return; /* silently skip if CP1255 is not supported, see bug 467707 */
  50
  51   g_assert_no_error (error);
  52   g_assert (bytes_read == 5);
  53   g_assert (bytes_written == 10);
  54   g_assert (strcmp (out, expected) == 0);
  55   g_free (out);
  56 }
  57
  58 /* some tests involving "vulgar fraction one half" */
  59 static void
  60 test_one_half (void)
  61 {
  62   gchar *in = "\xc2\xbd";
  63   gchar *out;
  64   gsize bytes_read = 0;
  65   gsize bytes_written = 0;
  66   GError *error = NULL;
  67
  68   out = g_convert (in, -1,
  69                    "ISO-8859-1", "UTF-8",
  70                    &bytes_read, &bytes_written,
  71                    &error);
  72
  73   g_assert_no_error (error);
  74   g_assert (bytes_read == 2);
  75   g_assert (bytes_written == 1);
  76   g_assert (strcmp (out, "\xbd") == 0);
  77   g_free (out);
  78
  79   out = g_convert (in, -1,
  80                    "ISO-8859-15", "UTF-8",
  81                    &bytes_read, &bytes_written,
  82                    &error);
  83
  84   g_assert_error (error, G_CONVERT_ERROR, G_CONVERT_ERROR_ILLEGAL_SEQUENCE);
  85   g_assert (bytes_read == 0);
  86   g_assert (bytes_written == 0);
  87   g_assert (out == NULL);
  88   g_clear_error (&error);
  89   g_free (out);
  90
  91   out = g_convert_with_fallback (in, -1,
  92                                  "ISO8859-15", "UTF-8",
  93                                  "a",
  94                                  &bytes_read, &bytes_written,
  95                                  &error);
  96
  97   g_assert_no_error (error);
  98   g_assert (bytes_read == 2);
  99   g_assert (bytes_written == 1);
 100   g_assert (strcmp (out, "a") == 0);
 101   g_free (out);
 102 }
 103
 104 static void
 105 test_byte_order (void)
 106 {
 107   gchar in_be[4] = { 0xfe, 0xff, 0x03, 0x93}; /* capital gamma */
 108   gchar in_le[4] = { 0xff, 0xfe, 0x93, 0x03};
 109   gchar *expected = "\xce\x93";
 110   gchar *out;
 111   gsize bytes_read = 0;
 112   gsize bytes_written = 0;
 113   GError *error = NULL;
 114
 115   out = g_convert (in_be, sizeof (in_be),
 116                    "UTF-8", "UTF-16",
 117                    &bytes_read, &bytes_written,
 118                    &error);
 119
 120   g_assert_no_error (error);
 121   g_assert (bytes_read == 4);
 122   g_assert (bytes_written == 2);
 123   g_assert (strcmp (out, expected) == 0);
 124   g_free (out);
 125
 126   out = g_convert (in_le, sizeof (in_le),
 127                    "UTF-8", "UTF-16",
 128                    &bytes_read, &bytes_written,
 129                    &error);
 130
 131   g_assert_no_error (error);
 132   g_assert (bytes_read == 4);
 133   g_assert (bytes_written == 2);
 134   g_assert (strcmp (out, expected) == 0);
 135   g_free (out);
 136 }
 137
 138 static void
 139 check_utf8_to_ucs4 (const char     *utf8,
 140                     glong           utf8_len,
 141                     const gunichar *ucs4,
 142                     glong           ucs4_len,
 143                     glong           error_pos)
 144 {
 145   gunichar *result, *result2, *result3;
 146   glong items_read, items_read2;
 147   glong items_written, items_written2;
 148   GError *error, *error2, *error3;
 149   gint i;
 150
 151   if (!error_pos)
 152     {
 153       /* check the fast conversion */
 154       result = g_utf8_to_ucs4_fast (utf8, utf8_len, &items_written);
 155
 156       g_assert (items_written == ucs4_len);
 157       g_assert (result);
 158       for (i = 0; i <= items_written; i++)
 159         g_assert (result[i] == ucs4[i]);
 160
 161       g_free (result);
 162     }
 163
 164   error = NULL;
 165   result = g_utf8_to_ucs4 (utf8, utf8_len, &items_read, &items_written, &error);
 166
 167   if (utf8_len == strlen (utf8))
 168     {
 169       /* check that len == -1 yields identical results */
 170       error2 = NULL;
 171       result2 = g_utf8_to_ucs4 (utf8, -1, &items_read2, &items_written2, &error2);
 172       g_assert (error || items_read2 == items_read);
 173       g_assert (error || items_written2 == items_written2);
 174       g_assert (!!result == !!result2);
 175       g_assert (!!error == !!error2);
 176       if (result)
 177         for (i = 0; i <= items_written; i++)
 178           g_assert (result[i] == result2[i]);
 179
 180       g_free (result2);
 181       if (error2)
 182         g_error_free (error2);
 183     }
 184
 185   error3 = NULL;
 186   result3 = g_utf8_to_ucs4 (utf8, utf8_len, NULL, NULL, &error3);
 187
 188   if (error3 && error3->code == G_CONVERT_ERROR_PARTIAL_INPUT)
 189     {
 190       g_assert_no_error (error);
 191       g_assert (items_read == error_pos);
 192       g_assert (items_written == ucs4_len);
 193       g_assert (result);
 194       for (i = 0; i <= items_written; i++)
 195         g_assert (result[i] == ucs4[i]);
 196     }
 197   else if (error_pos)
 198     {
 199       g_assert (error != NULL);
 200       g_assert (result == NULL);
 201       g_assert (items_read == error_pos);
 202       g_error_free (error);
 203
 204       g_assert (error3 != NULL);
 205       g_assert (result3 == NULL);
 206       g_error_free (error3);
 207     }
 208   else
 209     {
 210       g_assert_no_error (error);
 211       g_assert (items_read == utf8_len);
 212       g_assert (items_written == ucs4_len);
 213       g_assert (result);
 214       for (i = 0; i <= items_written; i++)
 215         g_assert (result[i] == ucs4[i]);
 216
 217       g_assert_no_error (error3);
 218       g_assert (result3);
 219       for (i = 0; i <= ucs4_len; i++)
 220         g_assert (result3[i] == ucs4[i]);
 221     }
 222
 223   g_free (result);
 224   g_free (result3);
 225 }
 226
 227 static void
 228 check_ucs4_to_utf8 (const gunichar *ucs4,
 229                     glong           ucs4_len,
 230                     const char     *utf8,
 231                     glong           utf8_len,
 232                     glong           error_pos)
 233 {
 234   gchar *result, *result2, *result3;
 235   glong items_read, items_read2;
 236   glong items_written, items_written2;
 237   GError *error, *error2, *error3;
 238
 239   error = NULL;
 240   result = g_ucs4_to_utf8 (ucs4, ucs4_len, &items_read, &items_written, &error);
 241
 242   if (ucs4[ucs4_len] == 0)
 243     {
 244       /* check that len == -1 yields identical results */
 245       error2 = NULL;
 246       result2 = g_ucs4_to_utf8 (ucs4, -1, &items_read2, &items_written2, &error2);
 247
 248       g_assert (error || items_read2 == items_read);
 249       g_assert (error || items_written2 == items_written);
 250       g_assert (!!result == !!result2);
 251       g_assert (!!error == !!error2);
 252       if (result)
 253         g_assert (strcmp (result, result2) == 0);
 254
 255       g_free (result2);
 256       if (error2)
 257         g_error_free (error2);
 258     }
 259
 260   error3 = NULL;
 261   result3 = g_ucs4_to_utf8 (ucs4, ucs4_len, NULL, NULL, &error3);
 262
 263   if (error_pos)
 264     {
 265       g_assert (error != NULL);
 266       g_assert (result == NULL);
 267       g_assert (items_read == error_pos);
 268       g_error_free (error);
 269
 270       g_assert (error3 != NULL);
 271       g_assert (result3 == NULL);
 272       g_error_free (error3);
 273     }
 274   else
 275     {
 276       g_assert_no_error (error);
 277       g_assert (items_read == ucs4_len);
 278       g_assert (items_written == utf8_len);
 279       g_assert (result);
 280       g_assert (strcmp (result, utf8) == 0);
 281
 282       g_assert_no_error (error3);
 283       g_assert (result3);
 284       g_assert (strcmp (result3, utf8) == 0);
 285     }
 286
 287   g_free (result);
 288   g_free (result3);
 289 }
 290
 291 static void
 292 check_utf8_to_utf16 (const char      *utf8,
 293                      glong            utf8_len,
 294                      const gunichar2 *utf16,
 295                      glong            utf16_len,
 296                      glong            error_pos)
 297 {
 298   gunichar2 *result, *result2, *result3;
 299   glong items_read, items_read2;
 300   glong items_written, items_written2;
 301   GError *error, *error2, *error3;
 302   gint i;
 303
 304   error = NULL;
 305   result = g_utf8_to_utf16 (utf8, utf8_len, &items_read, &items_written, &error);
 306
 307   if (utf8_len == strlen (utf8))
 308     {
 309       /* check that len == -1 yields identical results */
 310       error2 = NULL;
 311       result2 = g_utf8_to_utf16 (utf8, -1, &items_read2, &items_written2, &error2);
 312       g_assert (error || items_read2 == items_read);
 313       g_assert (error || items_written2 == items_written2);
 314       g_assert (!!result == !!result2);
 315       g_assert (!!error == !!error2);
 316       if (result)
 317         for (i = 0; i <= items_written; i++)
 318           g_assert (result[i] == result2[i]);
 319
 320       g_free (result2);
 321       if (error2)
 322         g_error_free (error2);
 323     }
 324
 325   error3 = NULL;
 326   result3 = g_utf8_to_utf16 (utf8, utf8_len, NULL, NULL, &error3);
 327
 328   if (error3 && error3->code == G_CONVERT_ERROR_PARTIAL_INPUT)
 329     {
 330       g_assert_no_error (error);
 331       g_assert (items_read == error_pos);
 332       g_assert (items_written == utf16_len);
 333       g_assert (result);
 334       for (i = 0; i <= items_written; i++)
 335         g_assert (result[i] == utf16[i]);
 336     }
 337   else if (error_pos)
 338     {
 339       g_assert (error != NULL);
 340       g_assert (result == NULL);
 341       g_assert (items_read == error_pos);
 342       g_error_free (error);
 343
 344       g_assert (error3 != NULL);
 345       g_assert (result3 == NULL);
 346       g_error_free (error3);
 347     }
 348   else
 349     {
 350       g_assert_no_error (error);
 351       g_assert (items_read == utf8_len);
 352       g_assert (items_written == utf16_len);
 353       g_assert (result);
 354       for (i = 0; i <= items_written; i++)
 355         g_assert (result[i] == utf16[i]);
 356
 357       g_assert_no_error (error3);
 358       g_assert (result3);
 359       for (i = 0; i <= utf16_len; i++)
 360         g_assert (result3[i] == utf16[i]);
 361     }
 362
 363   g_free (result);
 364   g_free (result3);
 365 }
 366
 367 static void
 368 check_utf16_to_utf8 (const gunichar2 *utf16,
 369                      glong            utf16_len,
 370                      const char      *utf8,
 371                      glong            utf8_len,
 372                      glong            error_pos)
 373 {
 374   gchar *result, *result2, *result3;
 375   glong items_read, items_read2;
 376   glong items_written, items_written2;
 377   GError *error, *error2, *error3;
 378
 379   error = NULL;
 380   result = g_utf16_to_utf8 (utf16, utf16_len, &items_read, &items_written, &error);
 381   if (utf16[utf16_len] == 0)
 382     {
 383       /* check that len == -1 yields identical results */
 384       error2 = NULL;
 385       result2 = g_utf16_to_utf8 (utf16, -1, &items_read2, &items_written2, &error2);
 386
 387       g_assert (error || items_read2 == items_read);
 388       g_assert (error || items_written2 == items_written);
 389       g_assert (!!result == !!result2);
 390       g_assert (!!error == !!error2);
 391       if (result)
 392         g_assert (strcmp (result, result2) == 0);
 393
 394       g_free (result2);
 395       if (error2)
 396         g_error_free (error2);
 397     }
 398
 399   error3 = NULL;
 400   result3 = g_utf16_to_utf8 (utf16, utf16_len, NULL, NULL, &error3);
 401
 402   if (error3 && error3->code == G_CONVERT_ERROR_PARTIAL_INPUT)
 403     {
 404       g_assert_no_error (error);
 405       g_assert (items_read == error_pos);
 406       g_assert (items_read + 1 == utf16_len);
 407       g_assert (items_written == utf8_len);
 408       g_assert (result);
 409       g_assert (strcmp (result, utf8) == 0);
 410     }
 411   else if (error_pos)
 412     {
 413       g_assert (error != NULL);
 414       g_assert (result == NULL);
 415       g_assert (items_read == error_pos);
 416       g_error_free (error);
 417
 418       g_assert (error3 != NULL);
 419       g_assert (result3 == NULL);
 420       g_error_free (error3);
 421     }
 422   else
 423     {
 424       g_assert_no_error (error);
 425       g_assert (items_read == utf16_len);
 426       g_assert (items_written == utf8_len);
 427       g_assert (result);
 428       g_assert (strcmp (result, utf8) == 0);
 429
 430       g_assert_no_error (error3);
 431       g_assert (result3);
 432       g_assert (strcmp (result3, utf8) == 0);
 433     }
 434
 435   g_free (result);
 436   g_free (result3);
 437 }
 438
 439 static void
 440 check_ucs4_to_utf16 (const gunichar  *ucs4,
 441                      glong            ucs4_len,
 442                      const gunichar2 *utf16,
 443                      glong            utf16_len,
 444                      glong            error_pos)
 445 {
 446   gunichar2 *result, *result2, *result3;
 447   glong items_read, items_read2;
 448   glong items_written, items_written2;
 449   GError *error, *error2, *error3;
 450   gint i;
 451
 452   error = NULL;
 453   result = g_ucs4_to_utf16 (ucs4, ucs4_len, &items_read, &items_written, &error);
 454
 455   if (ucs4[ucs4_len] == 0)
 456     {
 457       /* check that len == -1 yields identical results */
 458       error2 = NULL;
 459       result2 = g_ucs4_to_utf16 (ucs4, -1, &items_read2, &items_written2, &error2);
 460
 461       g_assert (error || items_read2 == items_read);
 462       g_assert (error || items_written2 == items_written);
 463       g_assert (!!result == !!result2);
 464       g_assert (!!error == !!error2);
 465       if (result)
 466       for (i = 0; i <= utf16_len; i++)
 467         g_assert (result[i] == result2[i]);
 468
 469       g_free (result2);
 470       if (error2)
 471         g_error_free (error2);
 472     }
 473
 474   error3 = NULL;
 475   result3 = g_ucs4_to_utf16 (ucs4, -1, NULL, NULL, &error3);
 476
 477   if (error_pos)
 478     {
 479       g_assert (error != NULL);
 480       g_assert (result == NULL);
 481       g_assert (items_read == error_pos);
 482       g_error_free (error);
 483
 484       g_assert (error3 != NULL);
 485       g_assert (result3 == NULL);
 486       g_error_free (error3);
 487     }
 488   else
 489     {
 490       g_assert_no_error (error);
 491       g_assert (items_read == ucs4_len);
 492       g_assert (items_written == utf16_len);
 493       g_assert (result);
 494       for (i = 0; i <= utf16_len; i++)
 495         g_assert (result[i] == utf16[i]);
 496
 497       g_assert_no_error (error3);
 498       g_assert (result3);
 499       for (i = 0; i <= utf16_len; i++)
 500         g_assert (result3[i] == utf16[i]);
 501     }
 502
 503   g_free (result);
 504   g_free (result3);
 505 }
 506
 507 static void
 508 check_utf16_to_ucs4 (const gunichar2 *utf16,
 509                      glong            utf16_len,
 510                      const gunichar  *ucs4,
 511                      glong            ucs4_len,
 512                      glong            error_pos)
 513 {
 514   gunichar *result, *result2, *result3;
 515   glong items_read, items_read2;
 516   glong items_written, items_written2;
 517   GError *error, *error2, *error3;
 518   gint i;
 519
 520   error = NULL;
 521   result = g_utf16_to_ucs4 (utf16, utf16_len, &items_read, &items_written, &error);
 522   if (utf16[utf16_len] == 0)
 523     {
 524       /* check that len == -1 yields identical results */
 525       error2 = NULL;
 526       result2 = g_utf16_to_ucs4 (utf16, -1, &items_read2, &items_written2, &error2);
 527       g_assert (error || items_read2 == items_read);
 528       g_assert (error || items_written2 == items_written2);
 529       g_assert (!!result == !!result2);
 530       g_assert (!!error == !!error2);
 531       if (result)
 532         for (i = 0; i <= items_written; i++)
 533           g_assert (result[i] == result2[i]);
 534
 535       g_free (result2);
 536       if (error2)
 537         g_error_free (error2);
 538     }
 539
 540   error3 = NULL;
 541   result3 = g_utf16_to_ucs4 (utf16, utf16_len, NULL, NULL, &error3);
 542
 543   if (error3 && error3->code == G_CONVERT_ERROR_PARTIAL_INPUT)
 544     {
 545       g_assert_no_error (error);
 546       g_assert (items_read == error_pos);
 547       g_assert (items_read + 1 == utf16_len);
 548       g_assert (items_written == ucs4_len);
 549       g_assert (result);
 550       for (i = 0; i <= items_written; i++)
 551         g_assert (result[i] == ucs4[i]);
 552     }
 553   else if (error_pos)
 554     {
 555       g_assert (error != NULL);
 556       g_assert (result == NULL);
 557       g_assert (items_read == error_pos);
 558       g_error_free (error);
 559
 560       g_assert (error3 != NULL);
 561       g_assert (result3 == NULL);
 562       g_error_free (error3);
 563     }
 564   else
 565     {
 566       g_assert_no_error (error);
 567       g_assert (items_read == utf16_len);
 568       g_assert (items_written == ucs4_len);
 569       g_assert (result);
 570       for (i = 0; i <= ucs4_len; i++)
 571         g_assert (result[i] == ucs4[i]);
 572
 573       g_assert_no_error (error3);
 574       g_assert (result3);
 575       for (i = 0; i <= ucs4_len; i++)
 576         g_assert (result3[i] == ucs4[i]);
 577     }
 578
 579   g_free (result);
 580   g_free (result3);
 581 }
 582
 583 static void
 584 test_unicode_conversions (void)
 585 {
 586   char *utf8;
 587   gunichar ucs4[100];
 588   gunichar2 utf16[100];
 589
 590   utf8 = "abc";
 591   ucs4[0] = 0x61; ucs4[1] = 0x62; ucs4[2] = 0x63; ucs4[3] = 0;
 592   utf16[0] = 0x61; utf16[1] = 0x62; utf16[2] = 0x63; utf16[3] = 0;
 593
 594   check_utf8_to_ucs4 (utf8, 3, ucs4, 3, 0);
 595   check_ucs4_to_utf8 (ucs4, 3, utf8, 3, 0);
 596   check_utf8_to_utf16 (utf8, 3, utf16, 3, 0);
 597   check_utf16_to_utf8 (utf16, 3, utf8, 3, 0);
 598   check_ucs4_to_utf16 (ucs4, 3, utf16, 3, 0);
 599   check_utf16_to_ucs4 (utf16, 3, ucs4, 3, 0);
 600
 601   utf8 = "\316\261\316\262\316\263";
 602   ucs4[0] = 0x03b1; ucs4[1] = 0x03b2; ucs4[2] = 0x03b3; ucs4[3] = 0;
 603   utf16[0] = 0x03b1; utf16[1] = 0x03b2; utf16[2] = 0x03b3; utf16[3] = 0;
 604
 605   check_utf8_to_ucs4 (utf8, 6, ucs4, 3, 0);
 606   check_ucs4_to_utf8 (ucs4, 3, utf8, 6, 0);
 607   check_utf8_to_utf16 (utf8, 6, utf16, 3, 0);
 608   check_utf16_to_utf8 (utf16, 3, utf8, 6, 0);
 609   check_ucs4_to_utf16 (ucs4, 3, utf16, 3, 0);
 610   check_utf16_to_ucs4 (utf16, 3, ucs4, 3, 0);
 611
 612   /* partial utf8 character */
 613   utf8 = "abc\316";
 614   ucs4[0] = 0x61; ucs4[1] = 0x62; ucs4[2] = 0x63; ucs4[3] = 0;
 615   utf16[0] = 0x61; utf16[1] = 0x62; utf16[2] = 0x63; utf16[3] = 0;
 616
 617   check_utf8_to_ucs4 (utf8, 4, ucs4, 3, 3);
 618   check_utf8_to_utf16 (utf8, 4, utf16, 3, 3);
 619
 620   /* invalid utf8 */
 621   utf8 = "abc\316\316";
 622   ucs4[0] = 0;
 623   utf16[0] = 0;
 624
 625   check_utf8_to_ucs4 (utf8, 5, ucs4, 0, 3);
 626   check_utf8_to_utf16 (utf8, 5, utf16, 0, 3);
 627
 628   /* partial utf16 character */
 629   utf8 = "ab";
 630   ucs4[0] = 0x61; ucs4[1] = 0x62; ucs4[2] = 0;
 631   utf16[0] = 0x61; utf16[1] = 0x62; utf16[2] = 0xd801; utf16[3] = 0;
 632
 633   check_utf16_to_utf8 (utf16, 3, utf8, 2, 2);
 634   check_utf16_to_ucs4 (utf16, 3, ucs4, 2, 2);
 635
 636   /* invalid utf16 */
 637   utf8 = NULL;
 638   ucs4[0] = 0;
 639   utf16[0] = 0x61; utf16[1] = 0x62; utf16[2] = 0xdc01; utf16[3] = 0;
 640
 641   check_utf16_to_utf8 (utf16, 3, utf8, 0, 2);
 642   check_utf16_to_ucs4 (utf16, 3, ucs4, 0, 2);
 643
 644   /* invalid ucs4 */
 645   utf8 = NULL;
 646   ucs4[0] = 0x61; ucs4[1] = 0x62; ucs4[2] = 0x80000000; ucs4[3] = 0;
 647   utf16[0] = 0;
 648
 649   check_ucs4_to_utf8 (ucs4, 3, utf8, 0, 2);
 650   check_ucs4_to_utf16 (ucs4, 3, utf16, 0, 2);
 651 }
 652
 653 int
 654 main (int argc, char *argv[])
 655 {
 656   test_iconv_state ();
 657   test_one_half ();
 658   test_byte_order ();
 659   test_unicode_conversions ();
 660
 661   return 0;
 662 }