glib/tests/strfuncs.c

   1 /* Unit tests for gstrfuncs
   2  * Copyright (C) 1995-1997  Peter Mattis, Spencer Kimball and Josh MacDonald
   3  *
   4  * This work is provided "as is"; redistribution and modification
   5  * in whole or in part, in any medium, physical or electronic is
   6  * permitted without restriction.
   7  *
   8  * This work is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  11  *
  12  * In no event shall the authors or contributors be liable for any
  13  * direct, indirect, incidental, special, exemplary, or consequential
  14  * damages (including, but not limited to, procurement of substitute
  15  * goods or services; loss of use, data, or profits; or business
  16  * interruption) however caused and on any theory of liability, whether
  17  * in contract, strict liability, or tort (including negligence or
  18  * otherwise) arising in any way out of the use of this software, even
  19  * if advised of the possibility of such damage.
  20  */
  21
  22 #define GLIB_DISABLE_DEPRECATION_WARNINGS
  23
  24 #define _XOPEN_SOURCE 600
  25 #include <ctype.h>
  26 #include <errno.h>
  27 #include <locale.h>
  28 #include <math.h>
  29 #include <stdarg.h>
  30 #include <stdio.h>
  31 #include <stdlib.h>
  32 #include <string.h>
  33 #include "glib.h"
  34
  35 #if defined (_MSC_VER) && (_MSC_VER <= 1800)
  36 #define isnan(x) _isnan(x)
  37
  38 #ifndef NAN
  39 static const unsigned long __nan[2] = {0xffffffff, 0x7fffffff};
  40 #define NAN (*(const float *) __nan)
  41 #endif
  42
  43 #ifndef INFINITY
  44 #define INFINITY HUGE_VAL
  45 #endif
  46
  47 #endif
  48
  49 #define GLIB_TEST_STRING "el dorado "
  50
  51 #define FOR_ALL_CTYPE(macro)    \
  52         macro(isalnum)          \
  53         macro(isalpha)          \
  54         macro(iscntrl)          \
  55         macro(isdigit)          \
  56         macro(isgraph)          \
  57         macro(islower)          \
  58         macro(isprint)          \
  59         macro(ispunct)          \
  60         macro(isspace)          \
  61         macro(isupper)          \
  62         macro(isxdigit)
  63
  64 #define DEFINE_CALL_CTYPE(function)             \
  65         static int                              \
  66         call_##function (int c)                 \
  67         {                                       \
  68                 return function (c);            \
  69         }
  70
  71 #define DEFINE_CALL_G_ASCII_CTYPE(function)     \
  72         static gboolean                         \
  73         call_g_ascii_##function (gchar c)       \
  74         {                                       \
  75                 return g_ascii_##function (c);  \
  76         }
  77
  78 FOR_ALL_CTYPE (DEFINE_CALL_CTYPE)
  79 FOR_ALL_CTYPE (DEFINE_CALL_G_ASCII_CTYPE)
  80
  81 static void
  82 test_is_function (const char *name,
  83                   gboolean (* ascii_function) (gchar),
  84                   int (* c_library_function) (int),
  85                   gboolean (* unicode_function) (gunichar))
  86 {
  87   int c;
  88
  89   for (c = 0; c <= 0x7F; c++)
  90     {
  91       gboolean ascii_result = ascii_function ((gchar)c);
  92       gboolean c_library_result = c_library_function (c) != 0;
  93       gboolean unicode_result = unicode_function ((gunichar) c);
  94       if (ascii_result != c_library_result && c != '\v')
  95         {
  96           g_error ("g_ascii_%s returned %d and %s returned %d for 0x%X",
  97                    name, ascii_result, name, c_library_result, c);
  98         }
  99       if (ascii_result != unicode_result)
 100         {
 101           g_error ("g_ascii_%s returned %d and g_unichar_%s returned %d for 0x%X",
 102                    name, ascii_result, name, unicode_result, c);
 103         }
 104     }
 105   for (c = 0x80; c <= 0xFF; c++)
 106     {
 107       gboolean ascii_result = ascii_function ((gchar)c);
 108       if (ascii_result)
 109         {
 110           g_error ("g_ascii_%s returned TRUE for 0x%X", name, c);
 111         }
 112     }
 113 }
 114
 115 static void
 116 test_to_function (const char *name,
 117                   gchar (* ascii_function) (gchar),
 118                   int (* c_library_function) (int),
 119                   gunichar (* unicode_function) (gunichar))
 120 {
 121   int c;
 122
 123   for (c = 0; c <= 0x7F; c++)
 124     {
 125       int ascii_result = (guchar) ascii_function ((gchar) c);
 126       int c_library_result = c_library_function (c);
 127       int unicode_result = unicode_function ((gunichar) c);
 128       if (ascii_result != c_library_result)
 129         {
 130           g_error ("g_ascii_%s returned 0x%X and %s returned 0x%X for 0x%X",
 131                    name, ascii_result, name, c_library_result, c);
 132         }
 133       if (ascii_result != unicode_result)
 134         {
 135           g_error ("g_ascii_%s returned 0x%X and g_unichar_%s returned 0x%X for 0x%X",
 136                    name, ascii_result, name, unicode_result, c);
 137         }
 138     }
 139   for (c = 0x80; c <= 0xFF; c++)
 140     {
 141       int ascii_result = (guchar) ascii_function ((gchar) c);
 142       if (ascii_result != c)
 143         {
 144           g_error ("g_ascii_%s returned 0x%X for 0x%X",
 145                    name, ascii_result, c);
 146         }
 147     }
 148 }
 149
 150 static void
 151 test_digit_function (const char *name,
 152                      int (* ascii_function) (gchar),
 153                      int (* unicode_function) (gunichar))
 154 {
 155   int c;
 156
 157   for (c = 0; c <= 0x7F; c++)
 158     {
 159       int ascii_result = ascii_function ((gchar) c);
 160       int unicode_result = unicode_function ((gunichar) c);
 161       if (ascii_result != unicode_result)
 162         {
 163           g_error ("g_ascii_%s_value returned %d and g_unichar_%s_value returned %d for 0x%X",
 164                    name, ascii_result, name, unicode_result, c);
 165         }
 166     }
 167   for (c = 0x80; c <= 0xFF; c++)
 168     {
 169       int ascii_result = ascii_function ((gchar) c);
 170       if (ascii_result != -1)
 171         {
 172           g_error ("g_ascii_%s_value returned %d for 0x%X",
 173                    name, ascii_result, c);
 174         }
 175     }
 176 }
 177
 178 static void
 179 test_is_to_digit (void)
 180 {
 181   #define TEST_IS(name) test_is_function (#name, call_g_ascii_##name, call_##name, g_unichar_##name);
 182
 183   FOR_ALL_CTYPE(TEST_IS)
 184
 185   #undef TEST_IS
 186
 187   #define TEST_TO(name) test_to_function (#name, g_ascii_##name, name, g_unichar_##name)
 188
 189   TEST_TO (tolower);
 190   TEST_TO (toupper);
 191
 192   #undef TEST_TO
 193
 194   #define TEST_DIGIT(name) test_digit_function (#name, g_ascii_##name##_value, g_unichar_##name##_value)
 195
 196   TEST_DIGIT (digit);
 197   TEST_DIGIT (xdigit);
 198
 199   #undef TEST_DIGIT
 200 }
 201
 202 static void
 203 test_strdup (void)
 204 {
 205   gchar *str;
 206
 207   str = g_strdup (NULL);
 208   g_assert (str == NULL);
 209
 210   str = g_strdup (GLIB_TEST_STRING);
 211   g_assert (str != NULL);
 212   g_assert_cmpstr (str, ==, GLIB_TEST_STRING);
 213   g_free (str);
 214 }
 215
 216 static void
 217 test_strndup (void)
 218 {
 219   gchar *str;
 220
 221   str = g_strndup (NULL, 3);
 222   g_assert (str == NULL);
 223
 224   str = g_strndup ("aaaa", 5);
 225   g_assert (str != NULL);
 226   g_assert_cmpstr (str, ==, "aaaa");
 227   g_free (str);
 228
 229   str = g_strndup ("aaaa", 2);
 230   g_assert (str != NULL);
 231   g_assert_cmpstr (str, ==, "aa");
 232   g_free (str);
 233 }
 234
 235 static void
 236 test_strdup_printf (void)
 237 {
 238   gchar *str;
 239
 240   str = g_strdup_printf ("%05d %-5s", 21, "test");
 241   g_assert (str != NULL);
 242   g_assert_cmpstr (str, ==, "00021 test ");
 243   g_free (str);
 244 }
 245
 246 static void
 247 test_strdupv (void)
 248 {
 249   gchar *vec[] = { "Foo", "Bar", NULL };
 250   gchar **copy;
 251
 252   copy = g_strdupv (NULL);
 253   g_assert (copy == NULL);
 254
 255   copy = g_strdupv (vec);
 256   g_assert (copy != NULL);
 257   g_assert_cmpstr (copy[0], ==, "Foo");
 258   g_assert_cmpstr (copy[1], ==, "Bar");
 259   g_assert (copy[2] == NULL);
 260   g_strfreev (copy);
 261 }
 262
 263 static void
 264 test_strnfill (void)
 265 {
 266   gchar *str;
 267
 268   str = g_strnfill (0, 'a');
 269   g_assert (str != NULL);
 270   g_assert (*str == '\0');
 271   g_free (str);
 272
 273   str = g_strnfill (5, 'a');
 274   g_assert (str != NULL);
 275   g_assert_cmpstr (str, ==, "aaaaa");
 276   g_free (str);
 277 }
 278
 279 static void
 280 test_strconcat (void)
 281 {
 282   gchar *str;
 283
 284   str = g_strconcat (GLIB_TEST_STRING, NULL);
 285   g_assert (str != NULL);
 286   g_assert_cmpstr (str, ==, GLIB_TEST_STRING);
 287   g_free (str);
 288
 289   str = g_strconcat (GLIB_TEST_STRING,
 290                      GLIB_TEST_STRING,
 291                      GLIB_TEST_STRING,
 292                      NULL);
 293   g_assert (str != NULL);
 294   g_assert_cmpstr (str, ==, GLIB_TEST_STRING GLIB_TEST_STRING GLIB_TEST_STRING);
 295   g_free (str);
 296
 297   g_assert (g_strconcat (NULL, "bla", NULL) == NULL);
 298 }
 299
 300 static void
 301 test_strjoin (void)
 302 {
 303   gchar *str;
 304
 305   str = g_strjoin (NULL, NULL);
 306   g_assert (str != NULL);
 307   g_assert (*str == '\0');
 308   g_free (str);
 309
 310   str = g_strjoin (":", NULL);
 311   g_assert (str != NULL);
 312   g_assert (*str == '\0');
 313   g_free (str);
 314
 315   str = g_strjoin (NULL, GLIB_TEST_STRING, NULL);
 316   g_assert (str != NULL);
 317   g_assert_cmpstr (str, ==, GLIB_TEST_STRING);
 318   g_free (str);
 319
 320   str = g_strjoin (NULL,
 321                    GLIB_TEST_STRING,
 322                    GLIB_TEST_STRING,
 323                    GLIB_TEST_STRING,
 324                    NULL);
 325   g_assert (str != NULL);
 326   g_assert_cmpstr (str, ==, GLIB_TEST_STRING GLIB_TEST_STRING GLIB_TEST_STRING);
 327   g_free (str);
 328
 329   str = g_strjoin (":",
 330                    GLIB_TEST_STRING,
 331                    GLIB_TEST_STRING,
 332                    GLIB_TEST_STRING,
 333                    NULL);
 334   g_assert (str != NULL);
 335   g_assert_cmpstr (str, ==, GLIB_TEST_STRING ":" GLIB_TEST_STRING ":" GLIB_TEST_STRING);
 336   g_free (str);
 337 }
 338
 339 static void
 340 test_strcanon (void)
 341 {
 342   gchar *str;
 343
 344   if (g_test_undefined ())
 345     {
 346       gchar *ret;
 347
 348       g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
 349                              "*assertion*!= NULL*");
 350       str = g_strcanon (NULL, "ab", 'y');
 351       g_test_assert_expected_messages ();
 352       g_assert (str == NULL);
 353
 354       str = g_strdup ("abxabxab");
 355       g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
 356                              "*assertion*!= NULL*");
 357       ret = g_strcanon (str, NULL, 'y');
 358       g_test_assert_expected_messages ();
 359       g_assert (ret == NULL);
 360       g_free (str);
 361     }
 362
 363   str = g_strdup ("abxabxab");
 364   str = g_strcanon (str, "ab", 'y');
 365   g_assert (str != NULL);
 366   g_assert_cmpstr (str, ==, "abyabyab");
 367   g_free (str);
 368 }
 369
 370 static void
 371 test_strcompress_strescape (void)
 372 {
 373   gchar *str;
 374   gchar *tmp;
 375
 376   /* test compress */
 377   if (g_test_undefined ())
 378     {
 379       g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
 380                              "*assertion*!= NULL*");
 381       str = g_strcompress (NULL);
 382       g_test_assert_expected_messages ();
 383       g_assert (str == NULL);
 384
 385       /* trailing slashes are not allowed */
 386       g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_WARNING,
 387                              "*trailing \\*");
 388       str = g_strcompress ("abc\\");
 389       g_test_assert_expected_messages ();
 390       g_assert_cmpstr (str, ==, "abc");
 391       g_free (str);
 392     }
 393
 394   str = g_strcompress ("abc\\\\\\\"\\b\\f\\n\\r\\t\\v\\003\\177\\234\\313\\12345z");
 395   g_assert (str != NULL);
 396   g_assert_cmpstr (str, ==, "abc\\\"\b\f\n\r\t\v\003\177\234\313\12345z");
 397   g_free (str);
 398
 399   /* test escape */
 400   if (g_test_undefined ())
 401     {
 402       g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
 403                              "*assertion*!= NULL*");
 404       str = g_strescape (NULL, NULL);
 405       g_test_assert_expected_messages ();
 406       g_assert (str == NULL);
 407     }
 408
 409   str = g_strescape ("abc\\\"\b\f\n\r\t\v\003\177\234\313", NULL);
 410   g_assert (str != NULL);
 411   g_assert_cmpstr (str, ==, "abc\\\\\\\"\\b\\f\\n\\r\\t\\v\\003\\177\\234\\313");
 412   g_free (str);
 413
 414   str = g_strescape ("abc\\\"\b\f\n\r\t\v\003\177\234\313",
 415                      "\b\f\001\002\003\004");
 416   g_assert (str != NULL);
 417   g_assert_cmpstr (str, ==, "abc\\\\\\\"\b\f\\n\\r\\t\\v\003\\177\\234\\313");
 418   g_free (str);
 419
 420   /* round trip */
 421   tmp = g_strescape ("abc\\\"\b\f\n\r\t\v\003\177\234\313", NULL);
 422   str = g_strcompress (tmp);
 423   g_assert (str != NULL);
 424   g_assert_cmpstr (str, ==, "abc\\\"\b\f\n\r\t\v\003\177\234\313");
 425   g_free (str);
 426   g_free (tmp);
 427 }
 428
 429 static void
 430 test_ascii_strcasecmp (void)
 431 {
 432   gboolean res;
 433
 434   if (g_test_undefined ())
 435     {
 436       g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
 437                              "*assertion*!= NULL*");
 438       res = g_ascii_strcasecmp ("foo", NULL);
 439       g_test_assert_expected_messages ();
 440       g_assert (res == FALSE);
 441
 442       g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
 443                              "*assertion*!= NULL*");
 444       res = g_ascii_strcasecmp (NULL, "foo");
 445       g_test_assert_expected_messages ();
 446       g_assert (res == FALSE);
 447     }
 448
 449   res = g_ascii_strcasecmp ("FroboZZ", "frobozz");
 450   g_assert_cmpint (res, ==, 0);
 451
 452   res = g_ascii_strcasecmp ("frobozz", "frobozz");
 453   g_assert_cmpint (res, ==, 0);
 454
 455   res = g_ascii_strcasecmp ("frobozz", "FROBOZZ");
 456   g_assert_cmpint (res, ==, 0);
 457
 458   res = g_ascii_strcasecmp ("FROBOZZ", "froboz");
 459   g_assert_cmpint (res, !=, 0);
 460
 461   res = g_ascii_strcasecmp ("", "");
 462   g_assert_cmpint (res, ==, 0);
 463
 464   res = g_ascii_strcasecmp ("!#%&/()", "!#%&/()");
 465   g_assert_cmpint (res, ==, 0);
 466
 467   res = g_ascii_strcasecmp ("a", "b");
 468   g_assert_cmpint (res, <, 0);
 469
 470   res = g_ascii_strcasecmp ("a", "B");
 471   g_assert_cmpint (res, <, 0);
 472
 473   res = g_ascii_strcasecmp ("A", "b");
 474   g_assert_cmpint (res, <, 0);
 475
 476   res = g_ascii_strcasecmp ("A", "B");
 477   g_assert_cmpint (res, <, 0);
 478
 479   res = g_ascii_strcasecmp ("b", "a");
 480   g_assert_cmpint (res, >, 0);
 481
 482   res = g_ascii_strcasecmp ("b", "A");
 483   g_assert_cmpint (res, >, 0);
 484
 485   res = g_ascii_strcasecmp ("B", "a");
 486   g_assert_cmpint (res, >, 0);
 487
 488   res = g_ascii_strcasecmp ("B", "A");
 489   g_assert_cmpint (res, >, 0);
 490 }
 491
 492 static void
 493 do_test_strchug (const gchar *str, const gchar *expected)
 494 {
 495   gchar *tmp;
 496   gboolean res;
 497
 498   tmp = g_strdup (str);
 499
 500   g_strchug (tmp);
 501   res = (strcmp (tmp, expected) == 0);
 502   g_free (tmp);
 503
 504   g_assert_cmpint (res, ==, TRUE);
 505 }
 506
 507 static void
 508 test_strchug (void)
 509 {
 510   if (g_test_undefined ())
 511     {
 512       g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
 513                              "*assertion*!= NULL*");
 514       g_strchug (NULL);
 515       g_test_assert_expected_messages ();
 516     }
 517
 518   do_test_strchug ("", "");
 519   do_test_strchug (" ", "");
 520   do_test_strchug ("\t\r\n ", "");
 521   do_test_strchug (" a", "a");
 522   do_test_strchug ("  a", "a");
 523   do_test_strchug ("a a", "a a");
 524   do_test_strchug (" a a", "a a");
 525 }
 526
 527 static void
 528 do_test_strchomp (const gchar *str, const gchar *expected)
 529 {
 530   gchar *tmp;
 531   gboolean res;
 532
 533   tmp = g_strdup (str);
 534
 535   g_strchomp (tmp);
 536   res = (strcmp (tmp, expected) == 0);
 537   g_free (tmp);
 538
 539   g_assert_cmpint (res, ==, TRUE);
 540 }
 541
 542 static void
 543 test_strchomp (void)
 544 {
 545   if (g_test_undefined ())
 546     {
 547       g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
 548                              "*assertion*!= NULL*");
 549       g_strchomp (NULL);
 550       g_test_assert_expected_messages ();
 551     }
 552
 553   do_test_strchomp ("", "");
 554   do_test_strchomp (" ", "");
 555   do_test_strchomp (" \t\r\n", "");
 556   do_test_strchomp ("a ", "a");
 557   do_test_strchomp ("a  ", "a");
 558   do_test_strchomp ("a a", "a a");
 559   do_test_strchomp ("a a ", "a a");
 560 }
 561
 562 static void
 563 test_strreverse (void)
 564 {
 565   gchar *str;
 566   gchar *p;
 567
 568   if (g_test_undefined ())
 569     {
 570       g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
 571                              "*assertion*!= NULL*");
 572       str = g_strreverse (NULL);
 573       g_test_assert_expected_messages ();
 574       g_assert (str == NULL);
 575     }
 576
 577   str = p = g_strdup ("abcde");
 578   str = g_strreverse (str);
 579   g_assert (str != NULL);
 580   g_assert (p == str);
 581   g_assert_cmpstr (str, ==, "edcba");
 582   g_free (str);
 583 }
 584
 585 static void
 586 test_strncasecmp (void)
 587 {
 588   g_assert (g_strncasecmp ("abc1", "ABC2", 3) == 0);
 589   g_assert (g_strncasecmp ("abc1", "ABC2", 4) != 0);
 590 }
 591
 592 static void
 593 test_strstr (void)
 594 {
 595   gchar *haystack;
 596   gchar *res;
 597
 598   haystack = g_strdup ("FooBarFooBarFoo");
 599
 600   /* strstr_len */
 601   res = g_strstr_len (haystack, 6, "xxx");
 602   g_assert (res == NULL);
 603
 604   res = g_strstr_len (haystack, 6, "FooBarFooBarFooBar");
 605   g_assert (res == NULL);
 606
 607   res = g_strstr_len (haystack, 3, "Bar");
 608   g_assert (res == NULL);
 609
 610   res = g_strstr_len (haystack, 6, "");
 611   g_assert (res == haystack);
 612   g_assert_cmpstr (res, ==, "FooBarFooBarFoo");
 613
 614   res = g_strstr_len (haystack, 6, "Bar");
 615   g_assert (res == haystack + 3);
 616   g_assert_cmpstr (res, ==, "BarFooBarFoo");
 617
 618   res = g_strstr_len (haystack, -1, "Bar");
 619   g_assert (res == haystack + 3);
 620   g_assert_cmpstr (res, ==, "BarFooBarFoo");
 621
 622   /* strrstr */
 623   res = g_strrstr (haystack, "xxx");
 624   g_assert (res == NULL);
 625
 626   res = g_strrstr (haystack, "FooBarFooBarFooBar");
 627   g_assert (res == NULL);
 628
 629   res = g_strrstr (haystack, "");
 630   g_assert (res == haystack);
 631   g_assert_cmpstr (res, ==, "FooBarFooBarFoo");
 632
 633   res = g_strrstr (haystack, "Bar");
 634   g_assert (res == haystack + 9);
 635   g_assert_cmpstr (res, ==, "BarFoo");
 636
 637   /* strrstr_len */
 638   res = g_strrstr_len (haystack, 14, "xxx");
 639   g_assert (res == NULL);
 640
 641   res = g_strrstr_len (haystack, 14, "FooBarFooBarFooBar");
 642   g_assert (res == NULL);
 643
 644   res = g_strrstr_len (haystack, 3, "Bar");
 645   g_assert (res == NULL);
 646
 647   res = g_strrstr_len (haystack, 14, "BarFoo");
 648   g_assert (res == haystack + 3);
 649   g_assert_cmpstr (res, ==, "BarFooBarFoo");
 650
 651   res = g_strrstr_len (haystack, 15, "BarFoo");
 652   g_assert (res == haystack + 9);
 653   g_assert_cmpstr (res, ==, "BarFoo");
 654
 655   res = g_strrstr_len (haystack, -1, "BarFoo");
 656   g_assert (res == haystack + 9);
 657   g_assert_cmpstr (res, ==, "BarFoo");
 658
 659   /* test case for strings with \0 in the middle */
 660   *(haystack + 7) = '\0';
 661   res = g_strstr_len (haystack, 15, "BarFoo");
 662   g_assert (res == NULL);
 663
 664   g_free (haystack);
 665 }
 666
 667 static void
 668 test_has_prefix (void)
 669 {
 670   gboolean res;
 671
 672   if (g_test_undefined ())
 673     {
 674       g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
 675                              "*assertion*!= NULL*");
 676       res = g_str_has_prefix ("foo", NULL);
 677       g_test_assert_expected_messages ();
 678       g_assert (res == FALSE);
 679
 680       g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
 681                              "*assertion*!= NULL*");
 682       res = g_str_has_prefix (NULL, "foo");
 683       g_test_assert_expected_messages ();
 684       g_assert (res == FALSE);
 685     }
 686
 687   res = g_str_has_prefix ("foo", "bar");
 688   g_assert_cmpint (res, ==, FALSE);
 689
 690   res = g_str_has_prefix ("foo", "foobar");
 691   g_assert_cmpint (res, ==, FALSE);
 692
 693   res = g_str_has_prefix ("foobar", "bar");
 694   g_assert_cmpint (res, ==, FALSE);
 695
 696   res = g_str_has_prefix ("foobar", "foo");
 697   g_assert_cmpint (res, ==, TRUE);
 698
 699   res = g_str_has_prefix ("foo", "");
 700   g_assert_cmpint (res, ==, TRUE);
 701
 702   res = g_str_has_prefix ("foo", "foo");
 703   g_assert_cmpint (res, ==, TRUE);
 704
 705   res = g_str_has_prefix ("", "");
 706   g_assert_cmpint (res, ==, TRUE);
 707 }
 708
 709 static void
 710 test_has_suffix (void)
 711 {
 712   gboolean res;
 713
 714   if (g_test_undefined ())
 715     {
 716       g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
 717                              "*assertion*!= NULL*");
 718       res = g_str_has_suffix ("foo", NULL);
 719       g_test_assert_expected_messages ();
 720       g_assert (res == FALSE);
 721
 722       g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
 723                              "*assertion*!= NULL*");
 724       res = g_str_has_suffix (NULL, "foo");
 725       g_test_assert_expected_messages ();
 726       g_assert (res == FALSE);
 727     }
 728
 729   res = g_str_has_suffix ("foo", "bar");
 730   g_assert_cmpint (res, ==, FALSE);
 731
 732   res = g_str_has_suffix ("bar", "foobar");
 733   g_assert_cmpint (res, ==, FALSE);
 734
 735   res = g_str_has_suffix ("foobar", "foo");
 736   g_assert_cmpint (res, ==, FALSE);
 737
 738   res = g_str_has_suffix ("foobar", "bar");
 739   g_assert_cmpint (res, ==, TRUE);
 740
 741   res = g_str_has_suffix ("foo", "");
 742   g_assert_cmpint (res, ==, TRUE);
 743
 744   res = g_str_has_suffix ("foo", "foo");
 745   g_assert_cmpint (res, ==, TRUE);
 746
 747   res = g_str_has_suffix ("", "");
 748   g_assert_cmpint (res, ==, TRUE);
 749 }
 750
 751 static void
 752 strv_check (gchar **strv, ...)
 753 {
 754   gboolean ok = TRUE;
 755   gint i = 0;
 756   va_list list;
 757
 758   va_start (list, strv);
 759   while (ok)
 760     {
 761       const gchar *str = va_arg (list, const char *);
 762       if (strv[i] == NULL)
 763         {
 764           g_assert (str == NULL);
 765           break;
 766         }
 767       if (str == NULL)
 768         {
 769           ok = FALSE;
 770         }
 771       else
 772         {
 773           g_assert_cmpstr (strv[i], ==, str);
 774         }
 775       i++;
 776     }
 777   va_end (list);
 778
 779   g_strfreev (strv);
 780 }
 781
 782 static void
 783 test_strsplit (void)
 784 {
 785   strv_check (g_strsplit ("", ",", 0), NULL);
 786   strv_check (g_strsplit ("x", ",", 0), "x", NULL);
 787   strv_check (g_strsplit ("x,y", ",", 0), "x", "y", NULL);
 788   strv_check (g_strsplit ("x,y,", ",", 0), "x", "y", "", NULL);
 789   strv_check (g_strsplit (",x,y", ",", 0), "", "x", "y", NULL);
 790   strv_check (g_strsplit (",x,y,", ",", 0), "", "x", "y", "", NULL);
 791   strv_check (g_strsplit ("x,y,z", ",", 0), "x", "y", "z", NULL);
 792   strv_check (g_strsplit ("x,y,z,", ",", 0), "x", "y", "z", "", NULL);
 793   strv_check (g_strsplit (",x,y,z", ",", 0), "", "x", "y", "z", NULL);
 794   strv_check (g_strsplit (",x,y,z,", ",", 0), "", "x", "y", "z", "", NULL);
 795   strv_check (g_strsplit (",,x,,y,,z,,", ",", 0), "", "", "x", "", "y", "", "z", "", "", NULL);
 796   strv_check (g_strsplit (",,x,,y,,z,,", ",,", 0), "", "x", "y", "z", "", NULL);
 797
 798   strv_check (g_strsplit ("", ",", 1), NULL);
 799   strv_check (g_strsplit ("x", ",", 1), "x", NULL);
 800   strv_check (g_strsplit ("x,y", ",", 1), "x,y", NULL);
 801   strv_check (g_strsplit ("x,y,", ",", 1), "x,y,", NULL);
 802   strv_check (g_strsplit (",x,y", ",", 1), ",x,y", NULL);
 803   strv_check (g_strsplit (",x,y,", ",", 1), ",x,y,", NULL);
 804   strv_check (g_strsplit ("x,y,z", ",", 1), "x,y,z", NULL);
 805   strv_check (g_strsplit ("x,y,z,", ",", 1), "x,y,z,", NULL);
 806   strv_check (g_strsplit (",x,y,z", ",", 1), ",x,y,z", NULL);
 807   strv_check (g_strsplit (",x,y,z,", ",", 1), ",x,y,z,", NULL);
 808   strv_check (g_strsplit (",,x,,y,,z,,", ",", 1), ",,x,,y,,z,,", NULL);
 809   strv_check (g_strsplit (",,x,,y,,z,,", ",,", 1), ",,x,,y,,z,,", NULL);
 810
 811   strv_check (g_strsplit ("", ",", 2), NULL);
 812   strv_check (g_strsplit ("x", ",", 2), "x", NULL);
 813   strv_check (g_strsplit ("x,y", ",", 2), "x", "y", NULL);
 814   strv_check (g_strsplit ("x,y,", ",", 2), "x", "y,", NULL);
 815   strv_check (g_strsplit (",x,y", ",", 2), "", "x,y", NULL);
 816   strv_check (g_strsplit (",x,y,", ",", 2), "", "x,y,", NULL);
 817   strv_check (g_strsplit ("x,y,z", ",", 2), "x", "y,z", NULL);
 818   strv_check (g_strsplit ("x,y,z,", ",", 2), "x", "y,z,", NULL);
 819   strv_check (g_strsplit (",x,y,z", ",", 2), "", "x,y,z", NULL);
 820   strv_check (g_strsplit (",x,y,z,", ",", 2), "", "x,y,z,", NULL);
 821   strv_check (g_strsplit (",,x,,y,,z,,", ",", 2), "", ",x,,y,,z,,", NULL);
 822   strv_check (g_strsplit (",,x,,y,,z,,", ",,", 2), "", "x,,y,,z,,", NULL);
 823 }
 824
 825 static void
 826 test_strsplit_set (void)
 827 {
 828   strv_check (g_strsplit_set ("", ",/", 0), NULL);
 829   strv_check (g_strsplit_set (":def/ghi:", ":/", -1), "", "def", "ghi", "", NULL);
 830   strv_check (g_strsplit_set ("abc:def/ghi", ":/", -1), "abc", "def", "ghi", NULL);
 831   strv_check (g_strsplit_set (",;,;,;,;", ",;", -1), "", "", "", "", "", "", "", "", "", NULL);
 832   strv_check (g_strsplit_set (",,abc.def", ".,", -1), "", "", "abc", "def", NULL);
 833
 834   strv_check (g_strsplit_set (",x.y", ",.", 0), "", "x", "y", NULL);
 835   strv_check (g_strsplit_set (".x,y,", ",.", 0), "", "x", "y", "", NULL);
 836   strv_check (g_strsplit_set ("x,y.z", ",.", 0), "x", "y", "z", NULL);
 837   strv_check (g_strsplit_set ("x.y,z,", ",.", 0), "x", "y", "z", "", NULL);
 838   strv_check (g_strsplit_set (",x.y,z", ",.", 0), "", "x", "y", "z", NULL);
 839   strv_check (g_strsplit_set (",x,y,z,", ",.", 0), "", "x", "y", "z", "", NULL);
 840   strv_check (g_strsplit_set (",.x,,y,;z..", ".,;", 0), "", "", "x", "", "y", "", "z", "", "", NULL);
 841   strv_check (g_strsplit_set (",,x,,y,,z,,", ",,", 0), "", "", "x", "", "y", "", "z", "", "", NULL);
 842
 843   strv_check (g_strsplit_set ("x,y.z", ",.", 1), "x,y.z", NULL);
 844   strv_check (g_strsplit_set ("x.y,z,", ",.", 1), "x.y,z,", NULL);
 845   strv_check (g_strsplit_set (",x,y,z", ",.", 1), ",x,y,z", NULL);
 846   strv_check (g_strsplit_set (",x,y.z,", ",.", 1), ",x,y.z,", NULL);
 847   strv_check (g_strsplit_set (",,x,.y,,z,,", ",.", 1), ",,x,.y,,z,,", NULL);
 848   strv_check (g_strsplit_set (",.x,,y,,z,,", ",,..", 1), ",.x,,y,,z,,", NULL);
 849
 850   strv_check (g_strsplit_set ("", ",", 0), NULL);
 851   strv_check (g_strsplit_set ("x", ",", 0), "x", NULL);
 852   strv_check (g_strsplit_set ("x,y", ",", 0), "x", "y", NULL);
 853   strv_check (g_strsplit_set ("x,y,", ",", 0), "x", "y", "", NULL);
 854   strv_check (g_strsplit_set (",x,y", ",", 0), "", "x", "y", NULL);
 855   strv_check (g_strsplit_set (",x,y,", ",", 0), "", "x", "y", "", NULL);
 856   strv_check (g_strsplit_set ("x,y,z", ",", 0), "x", "y", "z", NULL);
 857   strv_check (g_strsplit_set ("x,y,z,", ",", 0), "x", "y", "z", "", NULL);
 858   strv_check (g_strsplit_set (",x,y,z", ",", 0), "", "x", "y", "z", NULL);
 859   strv_check (g_strsplit_set (",x,y,z,", ",", 0), "", "x", "y", "z", "", NULL);
 860   strv_check (g_strsplit_set (",,x,,y,,z,,", ",", 0), "", "", "x", "", "y", "", "z", "", "", NULL);
 861
 862   strv_check (g_strsplit_set ("", ",", 1), NULL);
 863   strv_check (g_strsplit_set ("x", ",", 1), "x", NULL);
 864   strv_check (g_strsplit_set ("x,y", ",", 1), "x,y", NULL);
 865   strv_check (g_strsplit_set ("x,y,", ",", 1), "x,y,", NULL);
 866   strv_check (g_strsplit_set (",x,y", ",", 1), ",x,y", NULL);
 867   strv_check (g_strsplit_set (",x,y,", ",", 1), ",x,y,", NULL);
 868   strv_check (g_strsplit_set ("x,y,z", ",", 1), "x,y,z", NULL);
 869   strv_check (g_strsplit_set ("x,y,z,", ",", 1), "x,y,z,", NULL);
 870   strv_check (g_strsplit_set (",x,y,z", ",", 1), ",x,y,z", NULL);
 871   strv_check (g_strsplit_set (",x,y,z,", ",", 1), ",x,y,z,", NULL);
 872   strv_check (g_strsplit_set (",,x,,y,,z,,", ",", 1), ",,x,,y,,z,,", NULL);
 873   strv_check (g_strsplit_set (",,x,,y,,z,,", ",,", 1), ",,x,,y,,z,,", NULL);
 874
 875   strv_check (g_strsplit_set ("", ",", 2), NULL);
 876   strv_check (g_strsplit_set ("x", ",", 2), "x", NULL);
 877   strv_check (g_strsplit_set ("x,y", ",", 2), "x", "y", NULL);
 878   strv_check (g_strsplit_set ("x,y,", ",", 2), "x", "y,", NULL);
 879   strv_check (g_strsplit_set (",x,y", ",", 2), "", "x,y", NULL);
 880   strv_check (g_strsplit_set (",x,y,", ",", 2), "", "x,y,", NULL);
 881   strv_check (g_strsplit_set ("x,y,z", ",", 2), "x", "y,z", NULL);
 882   strv_check (g_strsplit_set ("x,y,z,", ",", 2), "x", "y,z,", NULL);
 883   strv_check (g_strsplit_set (",x,y,z", ",", 2), "", "x,y,z", NULL);
 884   strv_check (g_strsplit_set (",x,y,z,", ",", 2), "", "x,y,z,", NULL);
 885   strv_check (g_strsplit_set (",,x,,y,,z,,", ",", 2), "", ",x,,y,,z,,", NULL);
 886
 887   strv_check (g_strsplit_set (",,x,.y,..z,,", ",.", 3), "", "", "x,.y,..z,,", NULL);
 888 }
 889
 890 static void
 891 test_strv_length (void)
 892 {
 893   gchar **strv;
 894   guint l;
 895
 896   if (g_test_undefined ())
 897     {
 898       g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
 899                              "*assertion*!= NULL*");
 900       l = g_strv_length (NULL);
 901       g_test_assert_expected_messages ();
 902       g_assert_cmpint (l, ==, 0);
 903     }
 904
 905   strv = g_strsplit ("1,2,3,4", ",", -1);
 906   l = g_strv_length (strv);
 907   g_assert_cmpuint (l, ==, 4);
 908   g_strfreev (strv);
 909 }
 910
 911 static char *locales[] = {"sv_SE", "en_US", "fa_IR", "C", "ru_RU"};
 912
 913 static void
 914 check_strtod_string (gchar    *number,
 915                      double    res,
 916                      gboolean  check_end,
 917                      gint      correct_len)
 918 {
 919   double d;
 920   gint l;
 921   gchar *dummy;
 922
 923   /* we try a copy of number, with some free space for malloc before that.
 924    * This is supposed to smash the some wrong pointer calculations. */
 925
 926   dummy = g_malloc (100000);
 927   number = g_strdup (number);
 928   g_free (dummy);
 929
 930   for (l = 0; l < G_N_ELEMENTS (locales); l++)
 931     {
 932       gchar *end = "(unset)";
 933
 934       setlocale (LC_NUMERIC, locales[l]);
 935       d = g_ascii_strtod (number, &end);
 936       g_assert (isnan (res) ? isnan (d) : (d == res));
 937       g_assert ((end - number) == (check_end ? correct_len : strlen (number)));
 938     }
 939
 940   g_free (number);
 941 }
 942
 943 static void
 944 check_strtod_number (gdouble num, gchar *fmt, gchar *str)
 945 {
 946   int l;
 947   gchar buf[G_ASCII_DTOSTR_BUF_SIZE];
 948
 949   for (l = 0; l < G_N_ELEMENTS (locales); l++)
 950     {
 951       setlocale (LC_ALL, locales[l]);
 952       g_ascii_formatd (buf, G_ASCII_DTOSTR_BUF_SIZE, fmt, num);
 953       g_assert_cmpstr (buf, ==, str);
 954     }
 955 }
 956
 957 static void
 958 test_strtod (void)
 959 {
 960   gdouble d, our_nan, our_inf;
 961   char buffer[G_ASCII_DTOSTR_BUF_SIZE];
 962
 963 #ifdef NAN
 964   our_nan = NAN;
 965 #else
 966   /* Do this before any call to setlocale.  */
 967   our_nan = atof ("NaN");
 968 #endif
 969   g_assert (isnan (our_nan));
 970
 971 #ifdef INFINITY
 972   our_inf = INFINITY;
 973 #else
 974   our_inf = atof ("Infinity");
 975 #endif
 976   g_assert (our_inf > 1 && our_inf == our_inf / 2);
 977
 978   check_strtod_string ("123.123", 123.123, FALSE, 0);
 979   check_strtod_string ("123.123e2", 123.123e2, FALSE, 0);
 980   check_strtod_string ("123.123e-2", 123.123e-2, FALSE, 0);
 981   check_strtod_string ("-123.123", -123.123, FALSE, 0);
 982   check_strtod_string ("-123.123e2", -123.123e2, FALSE, 0);
 983   check_strtod_string ("-123.123e-2", -123.123e-2, FALSE, 0);
 984   check_strtod_string ("5.4", 5.4, TRUE, 3);
 985   check_strtod_string ("5.4,5.5", 5.4, TRUE, 3);
 986   check_strtod_string ("5,4", 5.0, TRUE, 1);
 987 #ifndef _MSC_VER
 988   /* hex strings for strtod() is a C99 feature which Visual C++ does not support */
 989   check_strtod_string ("0xa.b", 10.6875, TRUE, 5);
 990   check_strtod_string ("0xa.bP3", 85.5, TRUE, 7);
 991   check_strtod_string ("0xa.bp+3", 85.5, TRUE, 8);
 992   check_strtod_string ("0xa.bp-2", 2.671875, TRUE, 8);
 993   check_strtod_string ("0xA.BG", 10.6875, TRUE, 5);
 994 #endif
 995   /* the following are for #156421 */
 996   check_strtod_string ("1e1", 1e1, FALSE, 0);
 997 #ifndef _MSC_VER
 998   /* NAN/-nan/INF/-infinity strings for strtod() are C99 features which Visual C++ does not support */
 999   check_strtod_string ("NAN", our_nan, FALSE, 0);
1000   check_strtod_string ("-nan", -our_nan, FALSE, 0);
1001   check_strtod_string ("INF", our_inf, FALSE, 0);
1002   check_strtod_string ("-infinity", -our_inf, FALSE, 0);
1003 #endif
1004   check_strtod_string ("-.75,0", -0.75, TRUE, 4);
1005
1006 #ifndef _MSC_VER
1007   /* the values of d in the following 2 tests generate a C1064 compiler limit error */
1008   d = 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.0;
1009   g_assert (d == g_ascii_strtod (g_ascii_dtostr (buffer, sizeof (buffer), d), NULL));
1010
1011   d = -179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.0;
1012   g_assert (d == g_ascii_strtod (g_ascii_dtostr (buffer, sizeof (buffer), d), NULL));
1013 #endif
1014
1015   d = pow (2.0, -1024.1);
1016   g_assert (d == g_ascii_strtod (g_ascii_dtostr (buffer, sizeof (buffer), d), NULL));
1017
1018   d = -pow (2.0, -1024.1);
1019   g_assert (d == g_ascii_strtod (g_ascii_dtostr (buffer, sizeof (buffer), d), NULL));
1020
1021   /* for #343899 */
1022   check_strtod_string (" 0.75", 0.75, FALSE, 0);
1023   check_strtod_string (" +0.75", 0.75, FALSE, 0);
1024   check_strtod_string (" -0.75", -0.75, FALSE, 0);
1025   check_strtod_string ("\f0.75", 0.75, FALSE, 0);
1026   check_strtod_string ("\n0.75", 0.75, FALSE, 0);
1027   check_strtod_string ("\r0.75", 0.75, FALSE, 0);
1028   check_strtod_string ("\t0.75", 0.75, FALSE, 0);
1029
1030 #if 0
1031   /* g_ascii_isspace() returns FALSE for vertical tab, see #59388 */
1032   check_strtod_string ("\v0.75", 0.75, FALSE, 0);
1033 #endif
1034
1035   /* for #343899 */
1036   check_strtod_number (0.75, "%0.2f", "0.75");
1037   check_strtod_number (0.75, "%5.2f", " 0.75");
1038   check_strtod_number (-0.75, "%0.2f", "-0.75");
1039   check_strtod_number (-0.75, "%5.2f", "-0.75");
1040 #ifdef _MSC_VER
1041   check_strtod_number (1e99, "%0.e", "1e+099");
1042 #else
1043   check_strtod_number (1e99, "%.0e", "1e+99");
1044 #endif
1045 }
1046
1047 static void
1048 check_uint64 (const gchar *str,
1049               const gchar *end,
1050               gint         base,
1051               guint64      result,
1052               gint         error)
1053 {
1054   guint64 actual;
1055   gchar *endptr = NULL;
1056   gint err;
1057
1058   errno = 0;
1059   actual = g_ascii_strtoull (str, &endptr, base);
1060   err = errno;
1061
1062   g_assert (actual == result);
1063   g_assert_cmpstr (end, ==, endptr);
1064   g_assert (err == error);
1065 }
1066
1067 static void
1068 check_int64 (const gchar *str,
1069              const gchar *end,
1070              gint         base,
1071              gint64       result,
1072              gint         error)
1073 {
1074   gint64 actual;
1075   gchar *endptr = NULL;
1076   gint err;
1077
1078   errno = 0;
1079   actual = g_ascii_strtoll (str, &endptr, base);
1080   err = errno;
1081
1082   g_assert (actual == result);
1083   g_assert_cmpstr (end, ==, endptr);
1084   g_assert (err == error);
1085 }
1086
1087 static void
1088 test_strtoll (void)
1089 {
1090   check_uint64 ("0", "", 10, 0, 0);
1091   check_uint64 ("+0", "", 10, 0, 0);
1092   check_uint64 ("-0", "", 10, 0, 0);
1093   check_uint64 ("18446744073709551615", "", 10, G_MAXUINT64, 0);
1094   check_uint64 ("18446744073709551616", "", 10, G_MAXUINT64, ERANGE);
1095   check_uint64 ("20xyz", "xyz", 10, 20, 0);
1096   check_uint64 ("-1", "", 10, G_MAXUINT64, 0);
1097
1098   check_int64 ("0", "", 10, 0, 0);
1099   check_int64 ("9223372036854775807", "", 10, G_MAXINT64, 0);
1100   check_int64 ("9223372036854775808", "", 10, G_MAXINT64, ERANGE);
1101   check_int64 ("-9223372036854775808", "", 10, G_MININT64, 0);
1102   check_int64 ("-9223372036854775809", "", 10, G_MININT64, ERANGE);
1103   check_int64 ("32768", "", 10, 32768, 0);
1104   check_int64 ("-32768", "", 10, -32768, 0);
1105   check_int64 ("001", "", 10, 1, 0);
1106   check_int64 ("-001", "", 10, -1, 0);
1107 }
1108
1109 static void
1110 test_bounds (void)
1111 {
1112   GMappedFile *file, *before, *after;
1113   char buffer[4097];
1114   char *tmp, *tmp2;
1115   char **array;
1116   char *string;
1117
1118   /* if we allocate the file between two others and then free those
1119    * other two, then hopefully we end up with unmapped memory on either
1120    * side.
1121    */
1122   before = g_mapped_file_new ("4096-random-bytes", TRUE, NULL);
1123
1124   /* quick workaround until #549783 can be fixed */
1125   if (before == NULL)
1126     return;
1127
1128   file = g_mapped_file_new ("4096-random-bytes", TRUE, NULL);
1129   after = g_mapped_file_new ("4096-random-bytes", TRUE, NULL);
1130   g_mapped_file_unref (before);
1131   g_mapped_file_unref (after);
1132
1133   g_assert (file != NULL);
1134   g_assert_cmpint (g_mapped_file_get_length (file), ==, 4096);
1135   string = g_mapped_file_get_contents (file);
1136
1137   /* ensure they're all non-nul */
1138   g_assert (memchr (string, '\0', 4096) == NULL);
1139
1140   /* test set 1: ensure that nothing goes past its maximum length, even in
1141    *             light of a missing nul terminator.
1142    *
1143    * we try to test all of the 'n' functions here.
1144    */
1145   tmp = g_strndup (string, 4096);
1146   g_assert_cmpint (strlen (tmp), ==, 4096);
1147   g_free (tmp);
1148
1149   /* found no bugs in gnome, i hope :) */
1150   g_assert (g_strstr_len (string, 4096, "BUGS") == NULL);
1151   g_strstr_len (string, 4096, "B");
1152   g_strstr_len (string, 4096, ".");
1153   g_strstr_len (string, 4096, "");
1154
1155   g_strrstr_len (string, 4096, "BUGS");
1156   g_strrstr_len (string, 4096, "B");
1157   g_strrstr_len (string, 4096, ".");
1158   g_strrstr_len (string, 4096, "");
1159
1160   tmp = g_ascii_strup (string, 4096);
1161   tmp2 = g_ascii_strup (tmp, 4096);
1162   g_assert_cmpint (g_ascii_strncasecmp (string, tmp, 4096), ==, 0);
1163   g_assert_cmpint (g_ascii_strncasecmp (string, tmp2, 4096), ==, 0);
1164   g_assert_cmpint (g_ascii_strncasecmp (tmp, tmp2, 4096), ==, 0);
1165   g_free (tmp);
1166   g_free (tmp2);
1167
1168   tmp = g_ascii_strdown (string, 4096);
1169   tmp2 = g_ascii_strdown (tmp, 4096);
1170   g_assert_cmpint (g_ascii_strncasecmp (string, tmp, 4096), ==, 0);
1171   g_assert_cmpint (g_ascii_strncasecmp (string, tmp2, 4096), ==, 0);
1172   g_assert_cmpint (g_ascii_strncasecmp (tmp, tmp2, 4096), ==, 0);
1173   g_free (tmp);
1174   g_free (tmp2);
1175
1176   tmp = g_markup_escape_text (string, 4096);
1177   g_free (tmp);
1178
1179   /* test set 2: ensure that nothing reads even one byte past a '\0'.
1180    */
1181   g_assert_cmpint (string[4095], ==, '\n');
1182   string[4095] = '\0';
1183
1184   tmp = g_strdup (string);
1185   g_assert_cmpint (strlen (tmp), ==, 4095);
1186   g_free (tmp);
1187
1188   tmp = g_strndup (string, 10000);
1189   g_assert_cmpint (strlen (tmp), ==, 4095);
1190   g_free (tmp);
1191
1192   g_stpcpy (buffer, string);
1193   g_assert_cmpint (strlen (buffer), ==, 4095);
1194
1195   g_strstr_len (string, 10000, "BUGS");
1196   g_strstr_len (string, 10000, "B");
1197   g_strstr_len (string, 10000, ".");
1198   g_strstr_len (string, 10000, "");
1199
1200   g_strrstr (string, "BUGS");
1201   g_strrstr (string, "B");
1202   g_strrstr (string, ".");
1203   g_strrstr (string, "");
1204
1205   g_strrstr_len (string, 10000, "BUGS");
1206   g_strrstr_len (string, 10000, "B");
1207   g_strrstr_len (string, 10000, ".");
1208   g_strrstr_len (string, 10000, "");
1209
1210   g_str_has_prefix (string, "this won't do very much...");
1211   g_str_has_suffix (string, "but maybe this will...");
1212   g_str_has_suffix (string, "HMMMM.");
1213   g_str_has_suffix (string, "MMMM.");
1214   g_str_has_suffix (string, "M.");
1215
1216   g_strlcpy (buffer, string, sizeof buffer);
1217   g_assert_cmpint (strlen (buffer), ==, 4095);
1218   g_strlcpy (buffer, string, sizeof buffer);
1219   buffer[0] = '\0';
1220   g_strlcat (buffer, string, sizeof buffer);
1221   g_assert_cmpint (strlen (buffer), ==, 4095);
1222
1223   tmp = g_strdup_printf ("<%s>", string);
1224   g_assert_cmpint (strlen (tmp), ==, 4095 + 2);
1225   g_free (tmp);
1226
1227   tmp = g_ascii_strdown (string, -1);
1228   tmp2 = g_ascii_strdown (tmp, -1);
1229   g_assert_cmpint (strlen(tmp), ==, strlen(tmp2));
1230   g_assert_cmpint (strlen(string), ==, strlen(tmp));
1231   g_assert_cmpint (g_ascii_strncasecmp (string, tmp, -1), ==, 0);
1232   g_assert_cmpint (g_ascii_strncasecmp (string, tmp2, -1), ==, 0);
1233   g_assert_cmpint (g_ascii_strncasecmp (tmp, tmp2, -1), ==, 0);
1234   g_free (tmp);
1235   g_free (tmp2);
1236
1237   tmp = g_ascii_strup (string, -1);
1238   tmp2 = g_ascii_strup (string, -1);
1239   g_assert_cmpint (strlen(tmp), ==, strlen(tmp2));
1240   g_assert_cmpint (strlen(string), ==, strlen(tmp));
1241   g_assert_cmpint (g_ascii_strncasecmp (string, tmp, -1), ==, 0);
1242   g_assert_cmpint (g_ascii_strncasecmp (string, tmp2, -1), ==, 0);
1243   g_assert_cmpint (g_ascii_strncasecmp (tmp, tmp2, -1), ==, 0);
1244   g_free (tmp);
1245   g_free (tmp2);
1246
1247   g_ascii_strcasecmp (string, string);
1248   g_ascii_strncasecmp (string, string, 10000);
1249
1250   g_strreverse (string);
1251   g_strreverse (string);
1252   g_strchug (string);
1253   g_strchomp (string);
1254   g_strstrip (string);
1255   g_assert_cmpint (strlen (string), ==, 4095);
1256
1257   g_strdelimit (string, "M", 'N');
1258   g_strcanon (string, " N.", ':');
1259   g_assert_cmpint (strlen (string), ==, 4095);
1260
1261   array = g_strsplit (string, ".", -1);
1262   tmp = g_strjoinv (".", array);
1263   g_strfreev (array);
1264
1265   g_assert_cmpint (strlen (tmp), ==, 4095);
1266   g_assert (memcmp (tmp, string, 4095) == 0);
1267   g_free (tmp);
1268
1269   tmp = g_strconcat (string, string, string, NULL);
1270   g_assert_cmpint (strlen (tmp), ==, 4095 * 3);
1271   g_free (tmp);
1272
1273   tmp = g_strjoin ("!", string, string, NULL);
1274   g_assert_cmpint (strlen (tmp), ==, 4095 + 1 + 4095);
1275   g_free (tmp);
1276
1277   tmp = g_markup_escape_text (string, -1);
1278   g_free (tmp);
1279
1280   tmp = g_markup_printf_escaped ("%s", string);
1281   g_free (tmp);
1282
1283   tmp = g_strescape (string, NULL);
1284   tmp2 = g_strcompress (tmp);
1285   g_assert_cmpstr (string, ==, tmp2);
1286   g_free (tmp2);
1287   g_free (tmp);
1288
1289   g_mapped_file_unref (file);
1290 }
1291
1292 static void
1293 test_strip_context (void)
1294 {
1295   const gchar *msgid;
1296   const gchar *msgval;
1297   const gchar *s;
1298
1299
1300   msgid = "blabla";
1301   msgval = "bla";
1302   s = g_strip_context (msgid, msgval);
1303   g_assert (s == msgval);
1304
1305   msgid = msgval = "blabla";
1306   s = g_strip_context (msgid, msgval);
1307   g_assert (s == msgval);
1308
1309   msgid = msgval = "blabla|foo";
1310   s = g_strip_context (msgid, msgval);
1311   g_assert (s == msgval + 7);
1312
1313   msgid = msgval = "blabla||bar";
1314   s = g_strip_context (msgid, msgval);
1315   g_assert (s == msgval + 7);
1316 }
1317
1318 static void
1319 test_strerror (void)
1320 {
1321   gint i;
1322   const gchar *str;
1323
1324   for (i = 1; i < 100; i++)
1325     {
1326       str = g_strerror (i);
1327       g_assert (str != NULL);
1328       g_assert (g_utf8_validate (str, -1, NULL));
1329     }
1330 }
1331
1332 static void
1333 test_strsignal (void)
1334 {
1335   gint i;
1336   const gchar *str;
1337
1338   for (i = 1; i < 20; i++)
1339     {
1340       str = g_strsignal (i);
1341       g_assert (str != NULL);
1342       g_assert (g_utf8_validate (str, -1, NULL));
1343     }
1344 }
1345
1346 static void
1347 test_strup (void)
1348 {
1349   gchar *s;
1350
1351   s = g_strdup ("lower");
1352   g_assert_cmpstr (g_strup (s), ==, "LOWER");
1353   g_assert_cmpstr (g_strdown (s), ==, "lower");
1354   g_assert (g_strcasecmp ("lower", "LOWER") == 0);
1355   g_free (s);
1356 }
1357
1358 int
1359 main (int   argc,
1360       char *argv[])
1361 {
1362   g_test_init (&argc, &argv, NULL);
1363
1364   g_test_add_func ("/strfuncs/test-is-to-digit", test_is_to_digit);
1365   g_test_add_func ("/strfuncs/strdup", test_strdup);
1366   g_test_add_func ("/strfuncs/strndup", test_strndup);
1367   g_test_add_func ("/strfuncs/strdup-printf", test_strdup_printf);
1368   g_test_add_func ("/strfuncs/strdupv", test_strdupv);
1369   g_test_add_func ("/strfuncs/strnfill", test_strnfill);
1370   g_test_add_func ("/strfuncs/strconcat", test_strconcat);
1371   g_test_add_func ("/strfuncs/strjoin", test_strjoin);
1372   g_test_add_func ("/strfuncs/strcanon", test_strcanon);
1373   g_test_add_func ("/strfuncs/strcompress-strescape", test_strcompress_strescape);
1374   g_test_add_func ("/strfuncs/ascii-strcasecmp", test_ascii_strcasecmp);
1375   g_test_add_func ("/strfuncs/strchug", test_strchug);
1376   g_test_add_func ("/strfuncs/strchomp", test_strchomp);
1377   g_test_add_func ("/strfuncs/strreverse", test_strreverse);
1378   g_test_add_func ("/strfuncs/strncasecmp", test_strncasecmp);
1379   g_test_add_func ("/strfuncs/strstr", test_strstr);
1380   g_test_add_func ("/strfuncs/has-prefix", test_has_prefix);
1381   g_test_add_func ("/strfuncs/has-suffix", test_has_suffix);
1382   g_test_add_func ("/strfuncs/strsplit", test_strsplit);
1383   g_test_add_func ("/strfuncs/strsplit-set", test_strsplit_set);
1384   g_test_add_func ("/strfuncs/strv-length", test_strv_length);
1385   g_test_add_func ("/strfuncs/strtod", test_strtod);
1386   g_test_add_func ("/strfuncs/strtoull-strtoll", test_strtoll);
1387   g_test_add_func ("/strfuncs/bounds-check", test_bounds);
1388   g_test_add_func ("/strfuncs/strip-context", test_strip_context);
1389   g_test_add_func ("/strfuncs/strerror", test_strerror);
1390   g_test_add_func ("/strfuncs/strsignal", test_strsignal);
1391   g_test_add_func ("/strfuncs/strup", test_strup);
1392
1393   return g_test_run();
1394 }