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 #ifndef GLIB_DISABLE_DEPRECATION_WARNINGS
  23 #define GLIB_DISABLE_DEPRECATION_WARNINGS
  24 #endif
  25
  26 #define _XOPEN_SOURCE 600
  27 #include <ctype.h>
  28 #include <errno.h>
  29 #include <locale.h>
  30 #include <math.h>
  31 #include <stdarg.h>
  32 #include <stdio.h>
  33 #include <stdlib.h>
  34 #include <string.h>
  35 #include "glib.h"
  36
  37 #if defined (_MSC_VER) && (_MSC_VER <= 1800)
  38 #define isnan(x) _isnan(x)
  39
  40 #ifndef NAN
  41 static const unsigned long __nan[2] = {0xffffffff, 0x7fffffff};
  42 #define NAN (*(const float *) __nan)
  43 #endif
  44
  45 #ifndef INFINITY
  46 #define INFINITY HUGE_VAL
  47 #endif
  48
  49 #endif
  50
  51 #define GLIB_TEST_STRING "el dorado "
  52
  53 #define FOR_ALL_CTYPE(macro)    \
  54         macro(isalnum)          \
  55         macro(isalpha)          \
  56         macro(iscntrl)          \
  57         macro(isdigit)          \
  58         macro(isgraph)          \
  59         macro(islower)          \
  60         macro(isprint)          \
  61         macro(ispunct)          \
  62         macro(isspace)          \
  63         macro(isupper)          \
  64         macro(isxdigit)
  65
  66 #define DEFINE_CALL_CTYPE(function)             \
  67         static int                              \
  68         call_##function (int c)                 \
  69         {                                       \
  70                 return function (c);            \
  71         }
  72
  73 #define DEFINE_CALL_G_ASCII_CTYPE(function)     \
  74         static gboolean                         \
  75         call_g_ascii_##function (gchar c)       \
  76         {                                       \
  77                 return g_ascii_##function (c);  \
  78         }
  79
  80 FOR_ALL_CTYPE (DEFINE_CALL_CTYPE)
  81 FOR_ALL_CTYPE (DEFINE_CALL_G_ASCII_CTYPE)
  82
  83 static void
  84 test_is_function (const char *name,
  85                   gboolean (* ascii_function) (gchar),
  86                   int (* c_library_function) (int),
  87                   gboolean (* unicode_function) (gunichar))
  88 {
  89   int c;
  90
  91   for (c = 0; c <= 0x7F; c++)
  92     {
  93       gboolean ascii_result = ascii_function ((gchar)c);
  94       gboolean c_library_result = c_library_function (c) != 0;
  95       gboolean unicode_result = unicode_function ((gunichar) c);
  96       if (ascii_result != c_library_result && c != '\v')
  97         {
  98           g_error ("g_ascii_%s returned %d and %s returned %d for 0x%X",
  99                    name, ascii_result, name, c_library_result, c);
 100         }
 101       if (ascii_result != unicode_result)
 102         {
 103           g_error ("g_ascii_%s returned %d and g_unichar_%s returned %d for 0x%X",
 104                    name, ascii_result, name, unicode_result, c);
 105         }
 106     }
 107   for (c = 0x80; c <= 0xFF; c++)
 108     {
 109       gboolean ascii_result = ascii_function ((gchar)c);
 110       if (ascii_result)
 111         {
 112           g_error ("g_ascii_%s returned TRUE for 0x%X", name, c);
 113         }
 114     }
 115 }
 116
 117 static void
 118 test_to_function (const char *name,
 119                   gchar (* ascii_function) (gchar),
 120                   int (* c_library_function) (int),
 121                   gunichar (* unicode_function) (gunichar))
 122 {
 123   int c;
 124
 125   for (c = 0; c <= 0x7F; c++)
 126     {
 127       int ascii_result = (guchar) ascii_function ((gchar) c);
 128       int c_library_result = c_library_function (c);
 129       int unicode_result = unicode_function ((gunichar) c);
 130       if (ascii_result != c_library_result)
 131         {
 132           g_error ("g_ascii_%s returned 0x%X and %s returned 0x%X for 0x%X",
 133                    name, ascii_result, name, c_library_result, c);
 134         }
 135       if (ascii_result != unicode_result)
 136         {
 137           g_error ("g_ascii_%s returned 0x%X and g_unichar_%s returned 0x%X for 0x%X",
 138                    name, ascii_result, name, unicode_result, c);
 139         }
 140     }
 141   for (c = 0x80; c <= 0xFF; c++)
 142     {
 143       int ascii_result = (guchar) ascii_function ((gchar) c);
 144       if (ascii_result != c)
 145         {
 146           g_error ("g_ascii_%s returned 0x%X for 0x%X",
 147                    name, ascii_result, c);
 148         }
 149     }
 150 }
 151
 152 static void
 153 test_digit_function (const char *name,
 154                      int (* ascii_function) (gchar),
 155                      int (* unicode_function) (gunichar))
 156 {
 157   int c;
 158
 159   for (c = 0; c <= 0x7F; c++)
 160     {
 161       int ascii_result = ascii_function ((gchar) c);
 162       int unicode_result = unicode_function ((gunichar) c);
 163       if (ascii_result != unicode_result)
 164         {
 165           g_error ("g_ascii_%s_value returned %d and g_unichar_%s_value returned %d for 0x%X",
 166                    name, ascii_result, name, unicode_result, c);
 167         }
 168     }
 169   for (c = 0x80; c <= 0xFF; c++)
 170     {
 171       int ascii_result = ascii_function ((gchar) c);
 172       if (ascii_result != -1)
 173         {
 174           g_error ("g_ascii_%s_value returned %d for 0x%X",
 175                    name, ascii_result, c);
 176         }
 177     }
 178 }
 179
 180 static void
 181 test_is_to_digit (void)
 182 {
 183   #define TEST_IS(name) test_is_function (#name, call_g_ascii_##name, call_##name, g_unichar_##name);
 184
 185   FOR_ALL_CTYPE(TEST_IS)
 186
 187   #undef TEST_IS
 188
 189   #define TEST_TO(name) test_to_function (#name, g_ascii_##name, name, g_unichar_##name)
 190
 191   TEST_TO (tolower);
 192   TEST_TO (toupper);
 193
 194   #undef TEST_TO
 195
 196   #define TEST_DIGIT(name) test_digit_function (#name, g_ascii_##name##_value, g_unichar_##name##_value)
 197
 198   TEST_DIGIT (digit);
 199   TEST_DIGIT (xdigit);
 200
 201   #undef TEST_DIGIT
 202 }
 203
 204 /* Testing g_memdup() function with various positive and negative cases */
 205 static void
 206 test_memdup (void)
 207 {
 208   G_GNUC_BEGIN_IGNORE_DEPRECATIONS
 209
 210   gchar *str_dup = NULL;
 211   const gchar *str = "The quick brown fox jumps over the lazy dog";
 212
 213   /* Testing negative cases */
 214   g_assert_null (g_memdup (NULL, 1024));
 215   g_assert_null (g_memdup (str, 0));
 216   g_assert_null (g_memdup (NULL, 0));
 217
 218   /* Testing normal usage cases */
 219   str_dup = g_memdup (str, strlen (str) + 1);
 220   g_assert_nonnull (str_dup);
 221   g_assert_cmpstr (str, ==, str_dup);
 222
 223   g_free (str_dup);
 224
 225   G_GNUC_END_IGNORE_DEPRECATIONS
 226 }
 227
 228 /* Testing g_memdup2() function with various positive and negative cases */
 229 static void
 230 test_memdup2 (void)
 231 {
 232   gchar *str_dup = NULL;
 233   const gchar *str = "The quick brown fox jumps over the lazy dog";
 234
 235   /* Testing negative cases */
 236   g_assert_null (g_memdup2 (NULL, 1024));
 237   g_assert_null (g_memdup2 (str, 0));
 238   g_assert_null (g_memdup2 (NULL, 0));
 239
 240   /* Testing normal usage cases */
 241   str_dup = g_memdup2 (str, strlen (str) + 1);
 242   g_assert_nonnull (str_dup);
 243   g_assert_cmpstr (str, ==, str_dup);
 244
 245   g_free (str_dup);
 246 }
 247
 248 /* Testing g_strpcpy() function with various positive and negative cases */
 249 static void
 250 test_stpcpy (void)
 251 {
 252   gchar *str = "The quick brown fox jumps over the lazy dog";
 253   gchar str_cpy[45], *str_cpy_end = NULL;
 254
 255   if (g_test_undefined ())
 256     {
 257       /* Testing degenerated cases */
 258       g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
 259                              "*assertion*!= NULL*");
 260       str_cpy_end = g_stpcpy (str_cpy, NULL);
 261       g_test_assert_expected_messages ();
 262
 263       g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
 264                              "*assertion*!= NULL*");
 265       str_cpy_end = g_stpcpy (NULL, str);
 266       g_test_assert_expected_messages ();
 267     }
 268
 269   /* Testing normal usage cases */
 270   str_cpy_end = g_stpcpy (str_cpy, str);
 271   g_assert_nonnull (str_cpy);
 272   g_assert_true (str_cpy + strlen (str) == str_cpy_end);
 273   g_assert_cmpstr (str, ==, str_cpy);
 274   g_assert_cmpstr (str, ==, str_cpy_end - strlen (str));
 275 }
 276
 277 /* Testing g_strlcpy() function with various positive and negative cases */
 278 static void
 279 test_strlcpy (void)
 280 {
 281   gchar *str = "The quick brown fox jumps over the lazy dog";
 282   gchar str_cpy[45];
 283   gsize str_cpy_size = 0;
 284
 285   if (g_test_undefined ())
 286     {
 287       /* Testing degenerated cases */
 288       g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
 289                              "*assertion*!= NULL*");
 290       str_cpy_size = g_strlcpy (str_cpy, NULL, 0);
 291       g_test_assert_expected_messages ();
 292       /* Returned 0 because g_strlcpy() failed */
 293       g_assert_cmpint (str_cpy_size, ==, 0);
 294
 295       g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
 296                              "*assertion*!= NULL*");
 297       str_cpy_size = g_strlcpy (NULL, str, 0);
 298       g_test_assert_expected_messages ();
 299       /* Returned 0 because g_strlcpy() failed */
 300       g_assert_cmpint (str_cpy_size, ==, 0);
 301     }
 302
 303   str_cpy_size = g_strlcpy (str_cpy, "", 0);
 304   g_assert_cmpint (str_cpy_size, ==, strlen (""));
 305
 306   /* Testing normal usage cases.
 307    * Note that the @dest_size argument to g_strlcpy() is normally meant to be
 308    * set to `sizeof (dest)`. We set it to various values `≤ sizeof (str_cpy)`
 309    * for testing purposes.  */
 310   str_cpy_size = g_strlcpy (str_cpy, str, strlen (str) + 1);
 311   g_assert_nonnull (str_cpy);
 312   g_assert_cmpstr (str, ==, str_cpy);
 313   g_assert_cmpint (str_cpy_size, ==, strlen (str));
 314
 315   str_cpy_size = g_strlcpy (str_cpy, str, strlen (str));
 316   g_assert_nonnull (str_cpy);
 317   g_assert_cmpstr ("The quick brown fox jumps over the lazy do", ==, str_cpy);
 318   g_assert_cmpint (str_cpy_size, ==, strlen (str));
 319
 320   str_cpy_size = g_strlcpy (str_cpy, str, strlen (str) - 15);
 321   g_assert_nonnull (str_cpy);
 322   g_assert_cmpstr ("The quick brown fox jumps o", ==, str_cpy);
 323   g_assert_cmpint (str_cpy_size, ==, strlen (str));
 324
 325   str_cpy_size = g_strlcpy (str_cpy, str, 0);
 326   g_assert_nonnull (str_cpy);
 327   g_assert_cmpstr ("The quick brown fox jumps o", ==, str_cpy);
 328   g_assert_cmpint (str_cpy_size, ==, strlen (str));
 329
 330   str_cpy_size = g_strlcpy (str_cpy, str, strlen (str) + 15);
 331   g_assert_nonnull (str_cpy);
 332   g_assert_cmpstr (str, ==, str_cpy);
 333   g_assert_cmpint (str_cpy_size, ==, strlen (str));
 334 }
 335
 336 /* Testing g_strlcat() function with various positive and negative cases */
 337 static void
 338 test_strlcat (void)
 339 {
 340   gchar *str = "The quick brown fox jumps over the lazy dog";
 341   gchar str_cpy[60] = { 0 };
 342   gsize str_cpy_size = 0;
 343
 344   if (g_test_undefined ())
 345     {
 346       /* Testing degenerated cases */
 347       g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
 348                              "*assertion*!= NULL*");
 349       str_cpy_size = g_strlcat (str_cpy, NULL, 0);
 350       g_test_assert_expected_messages ();
 351       /* Returned 0 because g_strlcpy() failed */
 352       g_assert_cmpint (str_cpy_size, ==, 0);
 353
 354       g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
 355                              "*assertion*!= NULL*");
 356       str_cpy_size = g_strlcat (NULL, str, 0);
 357       g_test_assert_expected_messages ();
 358       /* Returned 0 because g_strlcpy() failed */
 359       g_assert_cmpint (str_cpy_size, ==, 0);
 360     }
 361
 362   str_cpy_size = g_strlcat (str_cpy, "", 0);
 363   g_assert_cmpint (str_cpy_size, ==, strlen (""));
 364
 365   /* Testing normal usage cases.
 366    * Note that the @dest_size argument to g_strlcat() is normally meant to be
 367    * set to `sizeof (dest)`. We set it to various values `≤ sizeof (str_cpy)`
 368    * for testing purposes. */
 369   g_assert_cmpuint (strlen (str) + 1, <=, sizeof (str_cpy));
 370   str_cpy_size = g_strlcat (str_cpy, str, strlen (str) + 1);
 371   g_assert_cmpstr (str, ==, str_cpy);
 372   g_assert_cmpint (str_cpy_size, ==, strlen (str));
 373
 374   g_assert_cmpuint (strlen (str), <=, sizeof (str_cpy));
 375   str_cpy_size = g_strlcat (str_cpy, str, strlen (str));
 376   g_assert_cmpstr (str, ==, str_cpy);
 377   g_assert_cmpint (str_cpy_size, ==, 2 * strlen (str));
 378
 379   g_assert_cmpuint (strlen (str) - 15, <=, sizeof (str_cpy));
 380   str_cpy_size = g_strlcat (str_cpy, str, strlen (str) - 15);
 381   g_assert_cmpstr (str, ==, str_cpy);
 382   g_assert_cmpint (str_cpy_size, ==, 2 * strlen (str) - 15);
 383
 384   g_assert_cmpuint (0, <=, sizeof (str_cpy));
 385   str_cpy_size = g_strlcat (str_cpy, str, 0);
 386   g_assert_cmpstr (str, ==, str_cpy);
 387   g_assert_cmpint (str_cpy_size, ==, strlen (str));
 388
 389   g_assert_cmpuint (strlen (str) + 15, <=, sizeof (str_cpy));
 390   str_cpy_size = g_strlcat (str_cpy, str, strlen (str) + 15);
 391   g_assert_cmpstr ("The quick brown fox jumps over the lazy dogThe quick brow",
 392                    ==, str_cpy);
 393   g_assert_cmpint (str_cpy_size, ==, 2 * strlen (str));
 394 }
 395
 396 /* Testing g_ascii_strdown() function with various positive and negative cases */
 397 static void
 398 test_ascii_strdown (void)
 399 {
 400   const gchar *str_down = "the quick brown fox jumps over the lazy dog.";
 401   const gchar *str_up = "THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG.";
 402   gchar* str;
 403
 404   if (g_test_undefined ())
 405     {
 406   /* Testing degenerated cases */
 407       g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
 408                              "*assertion*!= NULL*");
 409       str = g_ascii_strdown (NULL, 0);
 410       g_test_assert_expected_messages ();
 411     }
 412
 413   str = g_ascii_strdown ("", 0);
 414   g_assert_nonnull (str);
 415   g_assert_cmpstr (str, ==, "");
 416   g_free (str);
 417
 418   str = g_ascii_strdown ("", -1);
 419   g_assert_nonnull (str);
 420   g_assert_cmpstr (str, ==, "");
 421   g_free (str);
 422
 423   /* Testing normal usage cases */
 424   str = g_ascii_strdown (str_down, strlen (str_down));
 425   g_assert_nonnull (str);
 426   g_assert_cmpstr (str, ==, str_down);
 427   g_free (str);
 428
 429   str = g_ascii_strdown (str_up, strlen (str_up));
 430   g_assert_nonnull (str);
 431   g_assert_cmpstr (str, ==, str_down);
 432   g_free (str);
 433
 434   str = g_ascii_strdown (str_up, -1);
 435   g_assert_nonnull (str);
 436   g_assert_cmpstr (str, ==, str_down);
 437   g_free (str);
 438
 439   str = g_ascii_strdown (str_up, 0);
 440   g_assert_nonnull (str);
 441   g_assert_cmpstr (str, ==, "");
 442   g_free (str);
 443 }
 444
 445 /* Testing g_ascii_strup() function with various positive and negative cases */
 446 static void
 447 test_ascii_strup (void)
 448 {
 449   const gchar *str_down = "the quick brown fox jumps over the lazy dog.";
 450   const gchar *str_up = "THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG.";
 451   gchar* str;
 452
 453   if (g_test_undefined ())
 454     {
 455       /* Testing degenerated cases */
 456       g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
 457                              "*assertion*!= NULL*");
 458       str = g_ascii_strup (NULL, 0);
 459       g_test_assert_expected_messages ();
 460     }
 461
 462   str = g_ascii_strup ("", 0);
 463   g_assert_nonnull (str);
 464   g_assert_cmpstr (str, ==, "");
 465   g_free (str);
 466
 467   str = g_ascii_strup ("", -1);
 468   g_assert_nonnull (str);
 469   g_assert_cmpstr (str, ==, "");
 470   g_free (str);
 471
 472   /* Testing normal usage cases */
 473   str = g_ascii_strup (str_up, strlen (str_up));
 474   g_assert_nonnull (str);
 475   g_assert_cmpstr (str, ==, str_up);
 476   g_free (str);
 477
 478   str = g_ascii_strup (str_down, strlen (str_down));
 479   g_assert_nonnull (str);
 480   g_assert_cmpstr (str, ==, str_up);
 481   g_free (str);
 482
 483   str = g_ascii_strup (str_down, -1);
 484   g_assert_nonnull (str);
 485   g_assert_cmpstr (str, ==, str_up);
 486   g_free (str);
 487
 488   str = g_ascii_strup (str_down, 0);
 489   g_assert_nonnull (str);
 490   g_assert_cmpstr (str, ==, "");
 491   g_free (str);
 492 }
 493
 494 /* Testing g_strdup() function with various positive and negative cases */
 495 static void
 496 test_strdup (void)
 497 {
 498   gchar *str;
 499
 500   g_assert_null (g_strdup (NULL));
 501
 502   str = g_strdup (GLIB_TEST_STRING);
 503   g_assert_nonnull (str);
 504   g_assert_cmpstr (str, ==, GLIB_TEST_STRING);
 505   g_free (str);
 506 }
 507
 508 /* Testing g_strndup() function with various positive and negative cases */
 509 static void
 510 test_strndup (void)
 511 {
 512   gchar *str;
 513
 514   str = g_strndup (NULL, 3);
 515   g_assert_null (str);
 516
 517   str = g_strndup ("aaaa", 5);
 518   g_assert_nonnull (str);
 519   g_assert_cmpstr (str, ==, "aaaa");
 520   g_free (str);
 521
 522   str = g_strndup ("aaaa", 2);
 523   g_assert_nonnull (str);
 524   g_assert_cmpstr (str, ==, "aa");
 525   g_free (str);
 526 }
 527
 528 /* Testing g_strdup_printf() function with various positive and negative cases */
 529 static void
 530 test_strdup_printf (void)
 531 {
 532   gchar *str;
 533
 534   str = g_strdup_printf ("%05d %-5s", 21, "test");
 535   g_assert_nonnull (str);
 536   g_assert_cmpstr (str, ==, "00021 test ");
 537   g_free (str);
 538 }
 539
 540 /* Testing g_strdupv() function with various positive and negative cases */
 541 static void
 542 test_strdupv (void)
 543 {
 544   gchar *vec[] = { "Foo", "Bar", NULL };
 545   gchar **copy;
 546
 547   copy = g_strdupv (NULL);
 548   g_assert_null (copy);
 549
 550   copy = g_strdupv (vec);
 551   g_assert_nonnull (copy);
 552   g_assert_cmpstrv (copy, vec);
 553   g_strfreev (copy);
 554 }
 555
 556 /* Testing g_strfill() function with various positive and negative cases */
 557 static void
 558 test_strnfill (void)
 559 {
 560   gchar *str;
 561
 562   str = g_strnfill (0, 'a');
 563   g_assert_nonnull (str);
 564   g_assert_true (*str == '\0');
 565   g_free (str);
 566
 567   str = g_strnfill (5, 'a');
 568   g_assert_nonnull (str);
 569   g_assert_cmpstr (str, ==, "aaaaa");
 570   g_free (str);
 571 }
 572
 573 /* Testing g_strconcat() function with various positive and negative cases */
 574 static void
 575 test_strconcat (void)
 576 {
 577   gchar *str;
 578
 579   str = g_strconcat (GLIB_TEST_STRING, NULL);
 580   g_assert_nonnull (str);
 581   g_assert_cmpstr (str, ==, GLIB_TEST_STRING);
 582   g_free (str);
 583
 584   str = g_strconcat (GLIB_TEST_STRING,
 585                      GLIB_TEST_STRING,
 586                      GLIB_TEST_STRING,
 587                      NULL);
 588   g_assert_nonnull (str);
 589   g_assert_cmpstr (str, ==, GLIB_TEST_STRING GLIB_TEST_STRING GLIB_TEST_STRING);
 590   g_free (str);
 591
 592   g_assert_null (g_strconcat (NULL, "bla", NULL));
 593 }
 594
 595 /* Testing g_strjoinv() function with various positive and negative cases */
 596 static void
 597 test_strjoinv (void)
 598 {
 599   gchar *strings[] = { "string1", "string2", NULL };
 600   gchar *empty_strings[] = { NULL };
 601   gchar *str;
 602
 603   if (g_test_undefined ())
 604     {
 605       /* Testing degenerated cases */
 606       g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
 607                              "*assertion*!= NULL*");
 608       str = g_strjoinv (NULL, NULL);
 609       g_test_assert_expected_messages ();
 610     }
 611
 612   str = g_strjoinv (":", strings);
 613   g_assert_nonnull (str);
 614   g_assert_cmpstr (str, ==, "string1:string2");
 615   g_free (str);
 616
 617   str = g_strjoinv (NULL, strings);
 618   g_assert_nonnull (str);
 619   g_assert_cmpstr (str, ==, "string1string2");
 620   g_free (str);
 621
 622   str = g_strjoinv (NULL, empty_strings);
 623   g_assert_nonnull (str);
 624   g_assert_cmpstr (str, ==, "");
 625   g_free (str);
 626 }
 627
 628 /* Testing g_strjoin() function with various positive and negative cases */
 629 static void
 630 test_strjoin (void)
 631 {
 632   gchar *str;
 633
 634   str = g_strjoin (NULL, NULL);
 635   g_assert_nonnull (str);
 636   g_assert_true (*str == '\0');
 637   g_free (str);
 638
 639   str = g_strjoin (":", NULL);
 640   g_assert_nonnull (str);
 641   g_assert_true (*str == '\0');
 642   g_free (str);
 643
 644   str = g_strjoin (NULL, GLIB_TEST_STRING, NULL);
 645   g_assert_nonnull (str);
 646   g_assert_cmpstr (str, ==, GLIB_TEST_STRING);
 647   g_free (str);
 648
 649   str = g_strjoin (NULL,
 650                    GLIB_TEST_STRING,
 651                    GLIB_TEST_STRING,
 652                    GLIB_TEST_STRING,
 653                    NULL);
 654   g_assert_nonnull (str);
 655   g_assert_cmpstr (str, ==, GLIB_TEST_STRING GLIB_TEST_STRING GLIB_TEST_STRING);
 656   g_free (str);
 657
 658   str = g_strjoin (":",
 659                    GLIB_TEST_STRING,
 660                    GLIB_TEST_STRING,
 661                    GLIB_TEST_STRING,
 662                    NULL);
 663   g_assert_nonnull (str);
 664   g_assert_cmpstr (str, ==, GLIB_TEST_STRING ":" GLIB_TEST_STRING ":" GLIB_TEST_STRING);
 665   g_free (str);
 666 }
 667
 668 /* Testing g_strcanon() function with various positive and negative cases */
 669 static void
 670 test_strcanon (void)
 671 {
 672   gchar *str;
 673
 674   if (g_test_undefined ())
 675     {
 676       gchar *ret;
 677
 678       g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
 679                              "*assertion*!= NULL*");
 680       str = g_strcanon (NULL, "ab", 'y');
 681       g_test_assert_expected_messages ();
 682       g_assert_null (str);
 683
 684       str = g_strdup ("abxabxab");
 685       g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
 686                              "*assertion*!= NULL*");
 687       ret = g_strcanon (str, NULL, 'y');
 688       g_test_assert_expected_messages ();
 689       g_assert_null (ret);
 690       g_free (str);
 691     }
 692
 693   str = g_strdup ("abxabxab");
 694   str = g_strcanon (str, "ab", 'y');
 695   g_assert_nonnull (str);
 696   g_assert_cmpstr (str, ==, "abyabyab");
 697   g_free (str);
 698 }
 699
 700 /* Testing g_strcompress() and g_strescape() functions with various cases */
 701 static void
 702 test_strcompress_strescape (void)
 703 {
 704   gchar *str;
 705   gchar *tmp;
 706
 707   /* test compress */
 708   if (g_test_undefined ())
 709     {
 710       g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
 711                              "*assertion*!= NULL*");
 712       str = g_strcompress (NULL);
 713       g_test_assert_expected_messages ();
 714       g_assert_null (str);
 715
 716       /* trailing slashes are not allowed */
 717       g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_WARNING,
 718                              "*trailing \\*");
 719       str = g_strcompress ("abc\\");
 720       g_test_assert_expected_messages ();
 721       g_assert_cmpstr (str, ==, "abc");
 722       g_free (str);
 723     }
 724
 725   str = g_strcompress ("abc\\\\\\\"\\b\\f\\n\\r\\t\\v\\003\\177\\234\\313\\12345z");
 726   g_assert_nonnull (str);
 727   g_assert_cmpstr (str, ==, "abc\\\"\b\f\n\r\t\v\003\177\234\313\12345z");
 728   g_free (str);
 729
 730   /* test escape */
 731   if (g_test_undefined ())
 732     {
 733       g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
 734                              "*assertion*!= NULL*");
 735       str = g_strescape (NULL, NULL);
 736       g_test_assert_expected_messages ();
 737       g_assert_null (str);
 738     }
 739
 740   str = g_strescape ("abc\\\"\b\f\n\r\t\v\003\177\234\313", NULL);
 741   g_assert_nonnull (str);
 742   g_assert_cmpstr (str, ==, "abc\\\\\\\"\\b\\f\\n\\r\\t\\v\\003\\177\\234\\313");
 743   g_free (str);
 744
 745   str = g_strescape ("abc\\\"\b\f\n\r\t\v\003\177\234\313",
 746                      "\b\f\001\002\003\004");
 747   g_assert_nonnull (str);
 748   g_assert_cmpstr (str, ==, "abc\\\\\\\"\b\f\\n\\r\\t\\v\003\\177\\234\\313");
 749   g_free (str);
 750
 751   /* round trip */
 752   tmp = g_strescape ("abc\\\"\b\f\n\r\t\v\003\177\234\313", NULL);
 753   str = g_strcompress (tmp);
 754   g_assert_nonnull (str);
 755   g_assert_cmpstr (str, ==, "abc\\\"\b\f\n\r\t\v\003\177\234\313");
 756   g_free (str);
 757   g_free (tmp);
 758
 759   /* Unicode round trip */
 760   str = g_strescape ("héllø there⸘", NULL);
 761   g_assert_nonnull (str);
 762   g_assert_cmpstr (str, ==, "h\\303\\251ll\\303\\270 there\\342\\270\\230");
 763   tmp = g_strcompress (str);
 764   g_assert_nonnull (tmp);
 765   g_assert_cmpstr (tmp, ==, "héllø there⸘");
 766   g_free (tmp);
 767   g_free (str);
 768
 769   /* Test expanding invalid escapes */
 770   str = g_strcompress ("\\11/ \\118 \\8aa \\19");
 771   g_assert_nonnull (str);
 772   g_assert_cmpstr (str, ==, "\t/ \t8 8aa \0019");
 773   g_free (str);
 774 }
 775
 776 /* Testing g_ascii_strcasecmp() and g_ascii_strncasecmp() */
 777 static void
 778 test_ascii_strcasecmp (void)
 779 {
 780   gboolean res;
 781
 782   if (g_test_undefined ())
 783     {
 784       g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
 785                              "*assertion*!= NULL*");
 786       res = g_ascii_strcasecmp ("foo", NULL);
 787       g_test_assert_expected_messages ();
 788       g_assert_false (res);
 789
 790       g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
 791                              "*assertion*!= NULL*");
 792       res = g_ascii_strcasecmp (NULL, "foo");
 793       g_test_assert_expected_messages ();
 794       g_assert_false (res);
 795
 796       g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
 797                              "*assertion*!= NULL*");
 798       res = g_ascii_strncasecmp ("foo", NULL, 0);
 799       g_test_assert_expected_messages ();
 800       g_assert_false (res);
 801
 802       g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
 803                              "*assertion*!= NULL*");
 804       res = g_ascii_strncasecmp (NULL, "foo", 0);
 805       g_test_assert_expected_messages ();
 806       g_assert_false (res);
 807     }
 808
 809   res = g_ascii_strcasecmp ("FroboZZ", "frobozz");
 810   g_assert_cmpint (res, ==, 0);
 811
 812   res = g_ascii_strcasecmp ("frobozz", "frobozz");
 813   g_assert_cmpint (res, ==, 0);
 814
 815   res = g_ascii_strcasecmp ("frobozz", "FROBOZZ");
 816   g_assert_cmpint (res, ==, 0);
 817
 818   res = g_ascii_strcasecmp ("FROBOZZ", "froboz");
 819   g_assert_cmpint (res, !=, 0);
 820
 821   res = g_ascii_strcasecmp ("", "");
 822   g_assert_cmpint (res, ==, 0);
 823
 824   res = g_ascii_strcasecmp ("!#%&/()", "!#%&/()");
 825   g_assert_cmpint (res, ==, 0);
 826
 827   res = g_ascii_strcasecmp ("a", "b");
 828   g_assert_cmpint (res, <, 0);
 829
 830   res = g_ascii_strcasecmp ("a", "B");
 831   g_assert_cmpint (res, <, 0);
 832
 833   res = g_ascii_strcasecmp ("A", "b");
 834   g_assert_cmpint (res, <, 0);
 835
 836   res = g_ascii_strcasecmp ("A", "B");
 837   g_assert_cmpint (res, <, 0);
 838
 839   res = g_ascii_strcasecmp ("b", "a");
 840   g_assert_cmpint (res, >, 0);
 841
 842   res = g_ascii_strcasecmp ("b", "A");
 843   g_assert_cmpint (res, >, 0);
 844
 845   res = g_ascii_strcasecmp ("B", "a");
 846   g_assert_cmpint (res, >, 0);
 847
 848   res = g_ascii_strcasecmp ("B", "A");
 849   g_assert_cmpint (res, >, 0);
 850
 851   /* g_ascii_strncasecmp() */
 852   res = g_ascii_strncasecmp ("", "", 10);
 853   g_assert_cmpint (res, ==, 0);
 854
 855   res = g_ascii_strncasecmp ("Frob0ZZ", "frob0zz", strlen ("frobozz"));
 856   g_assert_cmpint (res, ==, 0);
 857
 858   res = g_ascii_strncasecmp ("Frob0ZZ", "frobozz", strlen ("frobozz"));
 859   g_assert_cmpint (res, !=, 0);
 860
 861   res = g_ascii_strncasecmp ("frob0ZZ", "FroB0zz", strlen ("frobozz"));
 862   g_assert_cmpint (res, ==, 0);
 863
 864   res = g_ascii_strncasecmp ("Frob0ZZ", "froB0zz", strlen ("frobozz") - 5);
 865   g_assert_cmpint (res, ==, 0);
 866
 867   res = g_ascii_strncasecmp ("Frob0ZZ", "froB0zz", strlen ("frobozz") + 5);
 868   g_assert_cmpint (res, ==, 0);
 869 }
 870
 871 static void
 872 do_test_strchug (const gchar *str, const gchar *expected)
 873 {
 874   gchar *tmp;
 875   gboolean res;
 876
 877   tmp = g_strdup (str);
 878
 879   g_strchug (tmp);
 880   res = (strcmp (tmp, expected) == 0);
 881   g_free (tmp);
 882
 883   g_assert_cmpint (res, ==, TRUE);
 884 }
 885
 886 /* Testing g_strchug() function with various positive and negative cases */
 887 static void
 888 test_strchug (void)
 889 {
 890   if (g_test_undefined ())
 891     {
 892       g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
 893                              "*assertion*!= NULL*");
 894       g_strchug (NULL);
 895       g_test_assert_expected_messages ();
 896     }
 897
 898   do_test_strchug ("", "");
 899   do_test_strchug (" ", "");
 900   do_test_strchug ("\t\r\n ", "");
 901   do_test_strchug (" a", "a");
 902   do_test_strchug ("  a", "a");
 903   do_test_strchug ("a a", "a a");
 904   do_test_strchug (" a a", "a a");
 905 }
 906
 907 static void
 908 do_test_strchomp (const gchar *str, const gchar *expected)
 909 {
 910   gchar *tmp;
 911   gboolean res;
 912
 913   tmp = g_strdup (str);
 914
 915   g_strchomp (tmp);
 916   res = (strcmp (tmp, expected) == 0);
 917   g_free (tmp);
 918
 919   g_assert_cmpint (res, ==, TRUE);
 920 }
 921
 922 /* Testing g_strchomp() function with various positive and negative cases */
 923 static void
 924 test_strchomp (void)
 925 {
 926   if (g_test_undefined ())
 927     {
 928       g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
 929                              "*assertion*!= NULL*");
 930       g_strchomp (NULL);
 931       g_test_assert_expected_messages ();
 932     }
 933
 934   do_test_strchomp ("", "");
 935   do_test_strchomp (" ", "");
 936   do_test_strchomp (" \t\r\n", "");
 937   do_test_strchomp ("a ", "a");
 938   do_test_strchomp ("a  ", "a");
 939   do_test_strchomp ("a a", "a a");
 940   do_test_strchomp ("a a ", "a a");
 941 }
 942
 943 /* Testing g_str_tokenize_and_fold() functions */
 944 static void
 945 test_str_tokenize_and_fold (void)
 946 {
 947   const gchar *local_str = "en_GB";
 948   const gchar *sample  = "The quick brown fox¸ jumps over the lazy dog.";
 949   const gchar *special_cases = "quıck QUİCK QUİı QUıİ İıck ıİCK àìøş";
 950   gchar **tokens, **alternates;
 951   gchar
 952     *expected_tokens[] =     \
 953     {"the", "quick", "brown", "fox", "jumps", "over", "the", "lazy", "dog", NULL},
 954     *expected_tokens_alt[] = \
 955     { "quick", "quick", "quii", "quii", "iick", "iick", "àìøş", NULL};
 956
 957   if (g_test_undefined ())
 958     {
 959       /* Testing degenerated cases */
 960       g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
 961                              "*assertion*!= NULL*");
 962       tokens = g_str_tokenize_and_fold (NULL, local_str, NULL);
 963       g_test_assert_expected_messages ();
 964     }
 965
 966   tokens = g_str_tokenize_and_fold (special_cases, local_str, &alternates);
 967   g_assert_cmpint (g_strv_length (tokens), ==,
 968                    g_strv_length (expected_tokens_alt));
 969   g_assert_true (g_strv_equal ((const gchar * const *) tokens,
 970                                (const gchar * const *) expected_tokens_alt));
 971   g_strfreev (tokens);
 972   g_strfreev (alternates);
 973
 974   tokens = g_str_tokenize_and_fold (sample, local_str, &alternates);
 975   g_assert_cmpint (g_strv_length (tokens), ==, g_strv_length (expected_tokens));
 976   g_assert_true (g_strv_equal ((const gchar * const *) tokens,
 977                                (const gchar * const *) expected_tokens));
 978   g_strfreev (tokens);
 979   g_strfreev (alternates);
 980
 981   tokens = g_str_tokenize_and_fold (sample, local_str, NULL);
 982   g_assert_cmpint (g_strv_length (tokens), ==, g_strv_length (expected_tokens));
 983   g_assert_true (g_strv_equal ((const gchar * const *) tokens,
 984                                (const gchar * const *) expected_tokens));
 985   g_strfreev (tokens);
 986
 987   tokens = g_str_tokenize_and_fold (sample, NULL, &alternates);
 988   g_assert_cmpint (g_strv_length (tokens), ==, g_strv_length (expected_tokens));
 989   g_assert_true (g_strv_equal ((const gchar * const *) tokens,
 990                                (const gchar * const *) expected_tokens));
 991   g_strfreev (tokens);
 992   g_strfreev (alternates);
 993 }
 994
 995 /* Testing g_strreverse() function with various positive and negative cases */
 996 static void
 997 test_strreverse (void)
 998 {
 999   gchar *str;
1000   gchar *p;
1001
1002   if (g_test_undefined ())
1003     {
1004       g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
1005                              "*assertion*!= NULL*");
1006       str = g_strreverse (NULL);
1007       g_test_assert_expected_messages ();
1008       g_assert_null (str);
1009     }
1010
1011   str = p = g_strdup ("abcde");
1012   str = g_strreverse (str);
1013   g_assert_nonnull (str);
1014   g_assert_true (p == str);
1015   g_assert_cmpstr (str, ==, "edcba");
1016   g_free (str);
1017 }
1018
1019 /* Testing g_strncasecmp() functions */
1020 static void
1021 test_strncasecmp (void)
1022 {
1023   g_assert_cmpint (g_strncasecmp ("abc1", "ABC2", 3), ==, 0);
1024   g_assert_cmpint (g_strncasecmp ("abc1", "ABC2", 4), !=, 0);
1025 }
1026
1027 static void
1028 test_strstr (void)
1029 {
1030   gchar *haystack;
1031   gchar *res;
1032
1033   haystack = g_strdup ("FooBarFooBarFoo");
1034
1035   if (g_test_undefined ())
1036     {
1037       /* Testing degenerated cases */
1038       g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
1039                              "*assertion*!= NULL*");
1040       res = g_strstr_len (NULL, 0, "xxx");
1041       g_test_assert_expected_messages ();
1042
1043       g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
1044                              "*assertion*!= NULL*");
1045       res = g_strstr_len ("xxx", 0, NULL);
1046       g_test_assert_expected_messages ();
1047     }
1048
1049   /* strstr_len */
1050   res = g_strstr_len (haystack, 6, "xxx");
1051   g_assert_null (res);
1052
1053   res = g_strstr_len (haystack, 6, "FooBarFooBarFooBar");
1054   g_assert_null (res);
1055
1056   res = g_strstr_len (haystack, 3, "Bar");
1057   g_assert_null (res);
1058
1059   res = g_strstr_len (haystack, 6, "");
1060   g_assert_true (res == haystack);
1061   g_assert_cmpstr (res, ==, "FooBarFooBarFoo");
1062
1063   res = g_strstr_len (haystack, 6, "Bar");
1064   g_assert_true (res == haystack + 3);
1065   g_assert_cmpstr (res, ==, "BarFooBarFoo");
1066
1067   res = g_strstr_len (haystack, -1, "Bar");
1068   g_assert_true (res == haystack + 3);
1069   g_assert_cmpstr (res, ==, "BarFooBarFoo");
1070
1071   /* strrstr */
1072   if (g_test_undefined ())
1073     {
1074       g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
1075                              "*assertion*!= NULL*");
1076       res = g_strrstr (NULL, "xxx");
1077       g_test_assert_expected_messages ();
1078
1079       g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
1080                              "*assertion*!= NULL*");
1081       res = g_strrstr ("xxx", NULL);
1082       g_test_assert_expected_messages ();
1083     }
1084
1085   res = g_strrstr (haystack, "xxx");
1086   g_assert_null (res);
1087
1088   res = g_strrstr (haystack, "FooBarFooBarFooBar");
1089   g_assert_null (res);
1090
1091   res = g_strrstr (haystack, "");
1092   g_assert_true (res == haystack);
1093   g_assert_cmpstr (res, ==, "FooBarFooBarFoo");
1094
1095   res = g_strrstr (haystack, "Bar");
1096   g_assert_true (res == haystack + 9);
1097   g_assert_cmpstr (res, ==, "BarFoo");
1098
1099   /* strrstr_len */
1100   if (g_test_undefined ())
1101     {
1102       g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
1103                              "*assertion*!= NULL*");
1104       res = g_strrstr_len (NULL, 14, "xxx");
1105       g_test_assert_expected_messages ();
1106
1107       g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
1108                              "*assertion*!= NULL*");
1109       res = g_strrstr_len ("xxx", 14, NULL);
1110       g_test_assert_expected_messages ();
1111     }
1112
1113   res = g_strrstr_len (haystack, 14, "xxx");
1114   g_assert_null (res);
1115
1116   res = g_strrstr_len (haystack, 14, "FooBarFooBarFooBar");
1117   g_assert_null (res);
1118
1119   res = g_strrstr_len (haystack, 3, "Bar");
1120   g_assert_null (res);
1121
1122   res = g_strrstr_len (haystack, 14, "BarFoo");
1123   g_assert_true (res == haystack + 3);
1124   g_assert_cmpstr (res, ==, "BarFooBarFoo");
1125
1126   res = g_strrstr_len (haystack, 15, "BarFoo");
1127   g_assert_true (res == haystack + 9);
1128   g_assert_cmpstr (res, ==, "BarFoo");
1129
1130   res = g_strrstr_len (haystack, -1, "BarFoo");
1131   g_assert_true (res == haystack + 9);
1132   g_assert_cmpstr (res, ==, "BarFoo");
1133
1134   /* test case for strings with \0 in the middle */
1135   *(haystack + 7) = '\0';
1136   res = g_strstr_len (haystack, 15, "BarFoo");
1137   g_assert_null (res);
1138
1139   g_free (haystack);
1140 }
1141
1142 /* Testing g_strtod() function with various positive and negative cases */
1143 static void
1144 test_strtod (void)
1145 {
1146   gchar *str_end = NULL;
1147   double value = 0.0;
1148   const double gold_ratio = 1.61803398874989484;
1149   const gchar *gold_ratio_str = "1.61803398874989484";
1150   const gchar *minus_gold_ratio_str = "-1.61803398874989484";
1151
1152   if (g_test_undefined ())
1153     {
1154       /* Testing degenerated cases */
1155       g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
1156                              "*assertion*!= NULL*");
1157       value = g_strtod (NULL, NULL);
1158       g_test_assert_expected_messages ();
1159       g_assert_cmpfloat (value, ==, 0.0);
1160     }
1161
1162   g_assert_cmpfloat (g_strtod ("\x00\x00\x00\x00", NULL), ==, 0.0);
1163   g_assert_cmpfloat (g_strtod ("\x00\x00\x00\x00", &str_end), ==, 0.0);
1164   g_assert_cmpstr (str_end, ==, "");
1165   g_assert_cmpfloat (g_strtod ("\xff\xff\xff\xff", NULL), ==, 0.0);
1166   g_assert_cmpfloat (g_strtod ("\xff\xff\xff\xff", &str_end), ==, 0.0);
1167   g_assert_cmpstr (str_end, ==, "\xff\xff\xff\xff");
1168
1169   /* Testing normal usage cases */
1170   g_assert_cmpfloat (g_strtod (gold_ratio_str, NULL), ==, gold_ratio);
1171   g_assert_cmpfloat (g_strtod (gold_ratio_str, &str_end), ==, gold_ratio);
1172   g_assert_true (str_end == gold_ratio_str + strlen (gold_ratio_str));
1173   g_assert_cmpfloat (g_strtod (minus_gold_ratio_str, NULL), ==, -gold_ratio);
1174   g_assert_cmpfloat (g_strtod (minus_gold_ratio_str, &str_end), ==, -gold_ratio);
1175   g_assert_true (str_end == minus_gold_ratio_str + strlen (minus_gold_ratio_str));
1176 }
1177
1178 /* Testing g_strdelimit() function */
1179 static void
1180 test_strdelimit (void)
1181 {
1182   const gchar *const_string = "ABCDE<*>Q";
1183   gchar *string;
1184
1185   if (g_test_undefined ())
1186     {
1187       /* Testing degenerated cases */
1188       g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
1189                              "*assertion*!= NULL*");
1190       string = g_strdelimit (NULL, "ABCDE", 'N');
1191       g_test_assert_expected_messages ();
1192     }
1193
1194   string = g_strdelimit (g_strdup (const_string), "<>", '?');
1195   g_assert_cmpstr (string, ==, "ABCDE?*?Q");
1196   g_free (string);
1197
1198   string = g_strdelimit (g_strdup (const_string), NULL, '?');
1199   g_assert_cmpstr (string, ==, "ABCDE?*?Q");
1200   g_free (string);
1201 }
1202
1203 /* Testing g_str_has_prefix() */
1204 static void
1205 test_has_prefix (void)
1206 {
1207   gboolean res;
1208
1209   if (g_test_undefined ())
1210     {
1211       g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
1212                              "*assertion*!= NULL*");
1213       res = g_str_has_prefix ("foo", NULL);
1214       g_test_assert_expected_messages ();
1215       g_assert_false (res);
1216
1217       g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
1218                              "*assertion*!= NULL*");
1219       res = g_str_has_prefix (NULL, "foo");
1220       g_test_assert_expected_messages ();
1221       g_assert_false (res);
1222     }
1223
1224   res = g_str_has_prefix ("foo", "bar");
1225   g_assert_cmpint (res, ==, FALSE);
1226
1227   res = g_str_has_prefix ("foo", "foobar");
1228   g_assert_cmpint (res, ==, FALSE);
1229
1230   res = g_str_has_prefix ("foobar", "bar");
1231   g_assert_cmpint (res, ==, FALSE);
1232
1233   res = g_str_has_prefix ("foobar", "foo");
1234   g_assert_cmpint (res, ==, TRUE);
1235
1236   res = g_str_has_prefix ("foo", "");
1237   g_assert_cmpint (res, ==, TRUE);
1238
1239   res = g_str_has_prefix ("foo", "foo");
1240   g_assert_cmpint (res, ==, TRUE);
1241
1242   res = g_str_has_prefix ("", "");
1243   g_assert_cmpint (res, ==, TRUE);
1244 }
1245
1246 static void
1247 test_has_suffix (void)
1248 {
1249   gboolean res;
1250
1251   if (g_test_undefined ())
1252     {
1253       g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
1254                              "*assertion*!= NULL*");
1255       res = g_str_has_suffix ("foo", NULL);
1256       g_test_assert_expected_messages ();
1257       g_assert_false (res);
1258
1259       g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
1260                              "*assertion*!= NULL*");
1261       res = g_str_has_suffix (NULL, "foo");
1262       g_test_assert_expected_messages ();
1263       g_assert_false (res);
1264     }
1265
1266   res = g_str_has_suffix ("foo", "bar");
1267   g_assert_false (res);
1268
1269   res = g_str_has_suffix ("bar", "foobar");
1270   g_assert_false (res);
1271
1272   res = g_str_has_suffix ("foobar", "foo");
1273   g_assert_false (res);
1274
1275   res = g_str_has_suffix ("foobar", "bar");
1276   g_assert_true (res);
1277
1278   res = g_str_has_suffix ("foo", "");
1279   g_assert_true (res);
1280
1281   res = g_str_has_suffix ("foo", "foo");
1282   g_assert_true (res);
1283
1284   res = g_str_has_suffix ("", "");
1285   g_assert_true (res);
1286 }
1287
1288 static void
1289 strv_check (gchar **strv, ...)
1290 {
1291   gboolean ok = TRUE;
1292   gint i = 0;
1293   va_list list;
1294
1295   va_start (list, strv);
1296   while (ok)
1297     {
1298       const gchar *str = va_arg (list, const char *);
1299       if (strv[i] == NULL)
1300         {
1301           g_assert_null (str);
1302           break;
1303         }
1304       if (str == NULL)
1305         {
1306           ok = FALSE;
1307         }
1308       else
1309         {
1310           g_assert_cmpstr (strv[i], ==, str);
1311         }
1312       i++;
1313     }
1314   va_end (list);
1315
1316   g_strfreev (strv);
1317 }
1318
1319 /* Testing g_strsplit() function with various positive and negative cases */
1320 static void
1321 test_strsplit (void)
1322 {
1323   gchar **string = NULL;
1324
1325   if (g_test_undefined ())
1326     {
1327       /* Testing degenerated cases */
1328       g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
1329                              "*assertion*!= NULL*");
1330       string = g_strsplit (NULL, ",", 0);
1331       g_test_assert_expected_messages ();
1332       g_assert_null (string);
1333
1334       g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
1335                              "*assertion*!= NULL*");
1336       string = g_strsplit ("x", NULL, 0);
1337       g_test_assert_expected_messages ();
1338       g_assert_null (string);
1339
1340       g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
1341                              "*assertion \'delimiter[0] != \'\\0\'*");
1342       string = g_strsplit ("x", "", 0);
1343       g_test_assert_expected_messages ();
1344       g_assert_null (string);
1345     }
1346
1347   strv_check (g_strsplit ("", ",", 0), NULL);
1348   strv_check (g_strsplit ("x", ",", 0), "x", NULL);
1349   strv_check (g_strsplit ("x,y", ",", 0), "x", "y", NULL);
1350   strv_check (g_strsplit ("x,y,", ",", 0), "x", "y", "", NULL);
1351   strv_check (g_strsplit (",x,y", ",", 0), "", "x", "y", NULL);
1352   strv_check (g_strsplit (",x,y,", ",", 0), "", "x", "y", "", NULL);
1353   strv_check (g_strsplit ("x,y,z", ",", 0), "x", "y", "z", NULL);
1354   strv_check (g_strsplit ("x,y,z,", ",", 0), "x", "y", "z", "", NULL);
1355   strv_check (g_strsplit (",x,y,z", ",", 0), "", "x", "y", "z", NULL);
1356   strv_check (g_strsplit (",x,y,z,", ",", 0), "", "x", "y", "z", "", NULL);
1357   strv_check (g_strsplit (",,x,,y,,z,,", ",", 0), "", "", "x", "", "y", "", "z", "", "", NULL);
1358   strv_check (g_strsplit (",,x,,y,,z,,", ",,", 0), "", "x", "y", "z", "", NULL);
1359
1360   strv_check (g_strsplit ("", ",", 1), NULL);
1361   strv_check (g_strsplit ("x", ",", 1), "x", NULL);
1362   strv_check (g_strsplit ("x,y", ",", 1), "x,y", NULL);
1363   strv_check (g_strsplit ("x,y,", ",", 1), "x,y,", NULL);
1364   strv_check (g_strsplit (",x,y", ",", 1), ",x,y", NULL);
1365   strv_check (g_strsplit (",x,y,", ",", 1), ",x,y,", NULL);
1366   strv_check (g_strsplit ("x,y,z", ",", 1), "x,y,z", NULL);
1367   strv_check (g_strsplit ("x,y,z,", ",", 1), "x,y,z,", NULL);
1368   strv_check (g_strsplit (",x,y,z", ",", 1), ",x,y,z", NULL);
1369   strv_check (g_strsplit (",x,y,z,", ",", 1), ",x,y,z,", NULL);
1370   strv_check (g_strsplit (",,x,,y,,z,,", ",", 1), ",,x,,y,,z,,", NULL);
1371   strv_check (g_strsplit (",,x,,y,,z,,", ",,", 1), ",,x,,y,,z,,", NULL);
1372
1373   strv_check (g_strsplit ("", ",", 2), NULL);
1374   strv_check (g_strsplit ("x", ",", 2), "x", NULL);
1375   strv_check (g_strsplit ("x,y", ",", 2), "x", "y", NULL);
1376   strv_check (g_strsplit ("x,y,", ",", 2), "x", "y,", NULL);
1377   strv_check (g_strsplit (",x,y", ",", 2), "", "x,y", NULL);
1378   strv_check (g_strsplit (",x,y,", ",", 2), "", "x,y,", NULL);
1379   strv_check (g_strsplit ("x,y,z", ",", 2), "x", "y,z", NULL);
1380   strv_check (g_strsplit ("x,y,z,", ",", 2), "x", "y,z,", NULL);
1381   strv_check (g_strsplit (",x,y,z", ",", 2), "", "x,y,z", NULL);
1382   strv_check (g_strsplit (",x,y,z,", ",", 2), "", "x,y,z,", NULL);
1383   strv_check (g_strsplit (",,x,,y,,z,,", ",", 2), "", ",x,,y,,z,,", NULL);
1384   strv_check (g_strsplit (",,x,,y,,z,,", ",,", 2), "", "x,,y,,z,,", NULL);
1385 }
1386
1387 /* Testing function g_strsplit_set() */
1388 static void
1389 test_strsplit_set (void)
1390 {
1391   gchar **string = NULL;
1392
1393   if (g_test_undefined ())
1394     {
1395       /* Testing degenerated cases */
1396       g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
1397                              "*assertion*!= NULL*");
1398       string = g_strsplit_set (NULL, ",/", 0);
1399       g_test_assert_expected_messages ();
1400       g_assert_null (string);
1401
1402       g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
1403                              "*assertion*!= NULL*");
1404       string = g_strsplit_set ("", NULL, 0);
1405       g_test_assert_expected_messages ();
1406       g_assert_null (string);
1407     }
1408
1409   strv_check (g_strsplit_set ("", ",/", 0), NULL);
1410   strv_check (g_strsplit_set (":def/ghi:", ":/", -1), "", "def", "ghi", "", NULL);
1411   strv_check (g_strsplit_set ("abc:def/ghi", ":/", -1), "abc", "def", "ghi", NULL);
1412   strv_check (g_strsplit_set (",;,;,;,;", ",;", -1), "", "", "", "", "", "", "", "", "", NULL);
1413   strv_check (g_strsplit_set (",,abc.def", ".,", -1), "", "", "abc", "def", NULL);
1414
1415   strv_check (g_strsplit_set (",x.y", ",.", 0), "", "x", "y", NULL);
1416   strv_check (g_strsplit_set (".x,y,", ",.", 0), "", "x", "y", "", NULL);
1417   strv_check (g_strsplit_set ("x,y.z", ",.", 0), "x", "y", "z", NULL);
1418   strv_check (g_strsplit_set ("x.y,z,", ",.", 0), "x", "y", "z", "", NULL);
1419   strv_check (g_strsplit_set (",x.y,z", ",.", 0), "", "x", "y", "z", NULL);
1420   strv_check (g_strsplit_set (",x,y,z,", ",.", 0), "", "x", "y", "z", "", NULL);
1421   strv_check (g_strsplit_set (",.x,,y,;z..", ".,;", 0), "", "", "x", "", "y", "", "z", "", "", NULL);
1422   strv_check (g_strsplit_set (",,x,,y,,z,,", ",,", 0), "", "", "x", "", "y", "", "z", "", "", NULL);
1423
1424   strv_check (g_strsplit_set ("x,y.z", ",.", 1), "x,y.z", NULL);
1425   strv_check (g_strsplit_set ("x.y,z,", ",.", 1), "x.y,z,", NULL);
1426   strv_check (g_strsplit_set (",x,y,z", ",.", 1), ",x,y,z", NULL);
1427   strv_check (g_strsplit_set (",x,y.z,", ",.", 1), ",x,y.z,", NULL);
1428   strv_check (g_strsplit_set (",,x,.y,,z,,", ",.", 1), ",,x,.y,,z,,", NULL);
1429   strv_check (g_strsplit_set (",.x,,y,,z,,", ",,..", 1), ",.x,,y,,z,,", NULL);
1430
1431   strv_check (g_strsplit_set ("", ",", 0), NULL);
1432   strv_check (g_strsplit_set ("x", ",", 0), "x", NULL);
1433   strv_check (g_strsplit_set ("x,y", ",", 0), "x", "y", NULL);
1434   strv_check (g_strsplit_set ("x,y,", ",", 0), "x", "y", "", NULL);
1435   strv_check (g_strsplit_set (",x,y", ",", 0), "", "x", "y", NULL);
1436   strv_check (g_strsplit_set (",x,y,", ",", 0), "", "x", "y", "", NULL);
1437   strv_check (g_strsplit_set ("x,y,z", ",", 0), "x", "y", "z", NULL);
1438   strv_check (g_strsplit_set ("x,y,z,", ",", 0), "x", "y", "z", "", NULL);
1439   strv_check (g_strsplit_set (",x,y,z", ",", 0), "", "x", "y", "z", NULL);
1440   strv_check (g_strsplit_set (",x,y,z,", ",", 0), "", "x", "y", "z", "", NULL);
1441   strv_check (g_strsplit_set (",,x,,y,,z,,", ",", 0), "", "", "x", "", "y", "", "z", "", "", NULL);
1442
1443   strv_check (g_strsplit_set ("", ",", 1), NULL);
1444   strv_check (g_strsplit_set ("x", ",", 1), "x", NULL);
1445   strv_check (g_strsplit_set ("x,y", ",", 1), "x,y", NULL);
1446   strv_check (g_strsplit_set ("x,y,", ",", 1), "x,y,", NULL);
1447   strv_check (g_strsplit_set (",x,y", ",", 1), ",x,y", NULL);
1448   strv_check (g_strsplit_set (",x,y,", ",", 1), ",x,y,", NULL);
1449   strv_check (g_strsplit_set ("x,y,z", ",", 1), "x,y,z", NULL);
1450   strv_check (g_strsplit_set ("x,y,z,", ",", 1), "x,y,z,", NULL);
1451   strv_check (g_strsplit_set (",x,y,z", ",", 1), ",x,y,z", NULL);
1452   strv_check (g_strsplit_set (",x,y,z,", ",", 1), ",x,y,z,", NULL);
1453   strv_check (g_strsplit_set (",,x,,y,,z,,", ",", 1), ",,x,,y,,z,,", NULL);
1454   strv_check (g_strsplit_set (",,x,,y,,z,,", ",,", 1), ",,x,,y,,z,,", NULL);
1455
1456   strv_check (g_strsplit_set ("", ",", 2), NULL);
1457   strv_check (g_strsplit_set ("x", ",", 2), "x", NULL);
1458   strv_check (g_strsplit_set ("x,y", ",", 2), "x", "y", NULL);
1459   strv_check (g_strsplit_set ("x,y,", ",", 2), "x", "y,", NULL);
1460   strv_check (g_strsplit_set (",x,y", ",", 2), "", "x,y", NULL);
1461   strv_check (g_strsplit_set (",x,y,", ",", 2), "", "x,y,", NULL);
1462   strv_check (g_strsplit_set ("x,y,z", ",", 2), "x", "y,z", NULL);
1463   strv_check (g_strsplit_set ("x,y,z,", ",", 2), "x", "y,z,", NULL);
1464   strv_check (g_strsplit_set (",x,y,z", ",", 2), "", "x,y,z", NULL);
1465   strv_check (g_strsplit_set (",x,y,z,", ",", 2), "", "x,y,z,", NULL);
1466   strv_check (g_strsplit_set (",,x,,y,,z,,", ",", 2), "", ",x,,y,,z,,", NULL);
1467
1468   strv_check (g_strsplit_set (",,x,.y,..z,,", ",.", 3), "", "", "x,.y,..z,,", NULL);
1469 }
1470
1471 /* Testing g_strv_length() function with various positive and negative cases */
1472 static void
1473 test_strv_length (void)
1474 {
1475   gchar **strv;
1476   guint l;
1477
1478   if (g_test_undefined ())
1479     {
1480       g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
1481                              "*assertion*!= NULL*");
1482       l = g_strv_length (NULL);
1483       g_test_assert_expected_messages ();
1484       g_assert_cmpint (l, ==, 0);
1485     }
1486
1487   strv = g_strsplit ("1,2,3,4", ",", -1);
1488   l = g_strv_length (strv);
1489   g_assert_cmpuint (l, ==, 4);
1490   g_strfreev (strv);
1491 }
1492
1493 static char *locales[] = {"sv_SE", "en_US", "fa_IR", "C", "ru_RU"};
1494
1495 static void
1496 check_strtod_string (gchar    *number,
1497                      double    res,
1498                      gboolean  check_end,
1499                      gsize      correct_len)
1500 {
1501   double d;
1502   gsize l;
1503   gchar *dummy;
1504
1505   /* we try a copy of number, with some free space for malloc before that.
1506    * This is supposed to smash the some wrong pointer calculations. */
1507
1508   dummy = g_malloc (100000);
1509   number = g_strdup (number);
1510   g_free (dummy);
1511
1512   for (l = 0; l < G_N_ELEMENTS (locales); l++)
1513     {
1514       gchar *end = "(unset)";
1515
1516       setlocale (LC_NUMERIC, locales[l]);
1517       d = g_ascii_strtod (number, &end);
1518       g_assert_true (isnan (res) ? isnan (d) : (d == res));
1519       g_assert_true ((gsize) (end - number) ==
1520                      (check_end ? correct_len : strlen (number)));
1521     }
1522
1523   g_free (number);
1524 }
1525
1526 static void
1527 check_strtod_number (gdouble num, gchar *fmt, gchar *str)
1528 {
1529   gsize l;
1530   gchar buf[G_ASCII_DTOSTR_BUF_SIZE];
1531
1532   for (l = 0; l < G_N_ELEMENTS (locales); l++)
1533     {
1534       setlocale (LC_ALL, locales[l]);
1535       g_ascii_formatd (buf, G_ASCII_DTOSTR_BUF_SIZE, fmt, num);
1536       g_assert_cmpstr (buf, ==, str);
1537     }
1538 }
1539
1540 /* Testing g_ascii_strtod() function with various positive and negative cases */
1541 static void
1542 test_ascii_strtod (void)
1543 {
1544   gdouble d, our_nan, our_inf;
1545   char buffer[G_ASCII_DTOSTR_BUF_SIZE];
1546
1547 #ifdef NAN
1548   our_nan = NAN;
1549 #else
1550   /* Do this before any call to setlocale.  */
1551   our_nan = atof ("NaN");
1552 #endif
1553   g_assert_true (isnan (our_nan));
1554
1555 #ifdef INFINITY
1556   our_inf = INFINITY;
1557 #else
1558   our_inf = atof ("Infinity");
1559 #endif
1560   g_assert_true (our_inf > 1 && our_inf == our_inf / 2);
1561
1562   /* Testing degenerated cases */
1563   if (g_test_undefined ())
1564     {
1565       g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
1566                              "*assertion*!= NULL*");
1567       d = g_ascii_strtod (NULL, NULL);
1568       g_test_assert_expected_messages ();
1569     }
1570
1571   /* Testing normal cases */
1572   check_strtod_string ("123.123", 123.123, FALSE, 0);
1573   check_strtod_string ("123.123e2", 123.123e2, FALSE, 0);
1574   check_strtod_string ("123.123e-2", 123.123e-2, FALSE, 0);
1575   check_strtod_string ("-123.123", -123.123, FALSE, 0);
1576   check_strtod_string ("-123.123e2", -123.123e2, FALSE, 0);
1577   check_strtod_string ("-123.123e-2", -123.123e-2, FALSE, 0);
1578   check_strtod_string ("5.4", 5.4, TRUE, 3);
1579   check_strtod_string ("5.4,5.5", 5.4, TRUE, 3);
1580   check_strtod_string ("5,4", 5.0, TRUE, 1);
1581 #ifndef _MSC_VER
1582   /* hex strings for strtod() is a C99 feature which Visual C++ does not support */
1583   check_strtod_string ("0xa.b", 10.6875, TRUE, 5);
1584   check_strtod_string ("0xa.bP3", 85.5, TRUE, 7);
1585   check_strtod_string ("0xa.bp+3", 85.5, TRUE, 8);
1586   check_strtod_string ("0xa.bp-2", 2.671875, TRUE, 8);
1587   check_strtod_string ("0xA.BG", 10.6875, TRUE, 5);
1588 #endif
1589   /* the following are for #156421 */
1590   check_strtod_string ("1e1", 1e1, FALSE, 0);
1591 #ifndef _MSC_VER
1592   /* NAN/-nan/INF/-infinity strings for strtod() are C99 features which Visual C++ does not support */
1593   check_strtod_string ("NAN", our_nan, FALSE, 0);
1594   check_strtod_string ("-nan", -our_nan, FALSE, 0);
1595   check_strtod_string ("INF", our_inf, FALSE, 0);
1596   check_strtod_string ("-infinity", -our_inf, FALSE, 0);
1597 #endif
1598   check_strtod_string ("-.75,0", -0.75, TRUE, 4);
1599
1600 #ifndef _MSC_VER
1601   /* the values of d in the following 2 tests generate a C1064 compiler limit error */
1602   d = 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.0;
1603   g_assert_true (d == g_ascii_strtod (g_ascii_dtostr (buffer, sizeof (buffer), d), NULL));
1604
1605   d = -179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.0;
1606   g_assert_true (d == g_ascii_strtod (g_ascii_dtostr (buffer, sizeof (buffer), d), NULL));
1607 #endif
1608
1609   d = pow (2.0, -1024.1);
1610   g_assert_true (d == g_ascii_strtod (g_ascii_dtostr (buffer, sizeof (buffer), d), NULL));
1611
1612   d = -pow (2.0, -1024.1);
1613   g_assert_true (d == g_ascii_strtod (g_ascii_dtostr (buffer, sizeof (buffer), d), NULL));
1614
1615   /* for #343899 */
1616   check_strtod_string (" 0.75", 0.75, FALSE, 0);
1617   check_strtod_string (" +0.75", 0.75, FALSE, 0);
1618   check_strtod_string (" -0.75", -0.75, FALSE, 0);
1619   check_strtod_string ("\f0.75", 0.75, FALSE, 0);
1620   check_strtod_string ("\n0.75", 0.75, FALSE, 0);
1621   check_strtod_string ("\r0.75", 0.75, FALSE, 0);
1622   check_strtod_string ("\t0.75", 0.75, FALSE, 0);
1623
1624 #if 0
1625   /* g_ascii_isspace() returns FALSE for vertical tab, see #59388 */
1626   check_strtod_string ("\v0.75", 0.75, FALSE, 0);
1627 #endif
1628
1629   /* for #343899 */
1630   check_strtod_number (0.75, "%0.2f", "0.75");
1631   check_strtod_number (0.75, "%5.2f", " 0.75");
1632   check_strtod_number (-0.75, "%0.2f", "-0.75");
1633   check_strtod_number (-0.75, "%5.2f", "-0.75");
1634   check_strtod_number (1e99, "%.0e", "1e+99");
1635 }
1636
1637 static void
1638 check_uint64 (const gchar *str,
1639               const gchar *end,
1640               gint         base,
1641               guint64      result,
1642               gint         error)
1643 {
1644   guint64 actual;
1645   gchar *endptr = NULL;
1646   gint err;
1647
1648   errno = 0;
1649   actual = g_ascii_strtoull (str, &endptr, base);
1650   err = errno;
1651
1652   g_assert_true (actual == result);
1653   g_assert_cmpstr (end, ==, endptr);
1654   g_assert_true (err == error);
1655 }
1656
1657 static void
1658 check_int64 (const gchar *str,
1659              const gchar *end,
1660              gint         base,
1661              gint64       result,
1662              gint         error)
1663 {
1664   gint64 actual;
1665   gchar *endptr = NULL;
1666   gint err;
1667
1668   errno = 0;
1669   actual = g_ascii_strtoll (str, &endptr, base);
1670   err = errno;
1671
1672   g_assert_true (actual == result);
1673   g_assert_cmpstr (end, ==, endptr);
1674   g_assert_true (err == error);
1675 }
1676
1677 static void
1678 test_strtoll (void)
1679 {
1680   check_uint64 ("0", "", 10, 0, 0);
1681   check_uint64 ("+0", "", 10, 0, 0);
1682   check_uint64 ("-0", "", 10, 0, 0);
1683   check_uint64 ("18446744073709551615", "", 10, G_MAXUINT64, 0);
1684   check_uint64 ("18446744073709551616", "", 10, G_MAXUINT64, ERANGE);
1685   check_uint64 ("20xyz", "xyz", 10, 20, 0);
1686   check_uint64 ("-1", "", 10, G_MAXUINT64, 0);
1687   check_uint64 ("-FF4", "", 16, -((guint64) 0xFF4), 0);
1688
1689   check_int64 ("0", "", 10, 0, 0);
1690   check_int64 ("9223372036854775807", "", 10, G_MAXINT64, 0);
1691   check_int64 ("9223372036854775808", "", 10, G_MAXINT64, ERANGE);
1692   check_int64 ("-9223372036854775808", "", 10, G_MININT64, 0);
1693   check_int64 ("-9223372036854775809", "", 10, G_MININT64, ERANGE);
1694   check_int64 ("32768", "", 10, 32768, 0);
1695   check_int64 ("-32768", "", 10, -32768, 0);
1696   check_int64 ("001", "", 10, 1, 0);
1697   check_int64 ("-001", "", 10, -1, 0);
1698 }
1699
1700 /* Testing g_str_match_string() function with various cases */
1701 static void
1702 test_str_match_string (void)
1703 {
1704   gboolean result = TRUE;
1705   const gchar *str = "The quick brown fox¸ jumps over the lazy dog.";
1706
1707   if (g_test_undefined ())
1708     {
1709       /* Testing degenerated cases */
1710       g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
1711                              "*assertion*!= NULL*");
1712       result = g_str_match_string (NULL, "AAA", TRUE);
1713       g_test_assert_expected_messages ();
1714       g_assert_false (result);
1715
1716       g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
1717                              "*assertion*!= NULL*");
1718       result = g_str_match_string (str, NULL, TRUE);
1719       g_test_assert_expected_messages ();
1720       g_assert_false (result);
1721     }
1722
1723   g_assert_false (g_str_match_string (str, "AAA", TRUE));
1724   g_assert_false (g_str_match_string (str, "AAA", FALSE));
1725 }
1726
1727 /* Testing functions bounds */
1728 static void
1729 test_bounds (void)
1730 {
1731   GMappedFile *file, *before, *after;
1732   char buffer[4097];
1733   char *tmp, *tmp2;
1734   char **array;
1735   char *string;
1736   const char * const strjoinv_0[] = { NULL };
1737   const char * const strjoinv_1[] = { "foo", NULL };
1738
1739   /* if we allocate the file between two others and then free those
1740    * other two, then hopefully we end up with unmapped memory on either
1741    * side.
1742    */
1743   before = g_mapped_file_new ("4096-random-bytes", TRUE, NULL);
1744
1745   /* quick workaround until #549783 can be fixed */
1746   if (before == NULL)
1747     return;
1748
1749   file = g_mapped_file_new ("4096-random-bytes", TRUE, NULL);
1750   after = g_mapped_file_new ("4096-random-bytes", TRUE, NULL);
1751   g_mapped_file_unref (before);
1752   g_mapped_file_unref (after);
1753
1754   g_assert_nonnull (file);
1755   g_assert_cmpint (g_mapped_file_get_length (file), ==, 4096);
1756   string = g_mapped_file_get_contents (file);
1757
1758   /* ensure they're all non-nul */
1759   g_assert_null (memchr (string, '\0', 4096));
1760
1761   /* test set 1: ensure that nothing goes past its maximum length, even in
1762    *             light of a missing nul terminator.
1763    *
1764    * we try to test all of the 'n' functions here.
1765    */
1766   tmp = g_strndup (string, 4096);
1767   g_assert_cmpint (strlen (tmp), ==, 4096);
1768   g_free (tmp);
1769
1770   /* found no bugs in gnome, i hope :) */
1771   g_assert_null (g_strstr_len (string, 4096, "BUGS"));
1772   g_strstr_len (string, 4096, "B");
1773   g_strstr_len (string, 4096, ".");
1774   g_strstr_len (string, 4096, "");
1775
1776   g_strrstr_len (string, 4096, "BUGS");
1777   g_strrstr_len (string, 4096, "B");
1778   g_strrstr_len (string, 4096, ".");
1779   g_strrstr_len (string, 4096, "");
1780
1781   tmp = g_ascii_strup (string, 4096);
1782   tmp2 = g_ascii_strup (tmp, 4096);
1783   g_assert_cmpint (g_ascii_strncasecmp (string, tmp, 4096), ==, 0);
1784   g_assert_cmpint (g_ascii_strncasecmp (string, tmp2, 4096), ==, 0);
1785   g_assert_cmpint (g_ascii_strncasecmp (tmp, tmp2, 4096), ==, 0);
1786   g_free (tmp);
1787   g_free (tmp2);
1788
1789   tmp = g_ascii_strdown (string, 4096);
1790   tmp2 = g_ascii_strdown (tmp, 4096);
1791   g_assert_cmpint (g_ascii_strncasecmp (string, tmp, 4096), ==, 0);
1792   g_assert_cmpint (g_ascii_strncasecmp (string, tmp2, 4096), ==, 0);
1793   g_assert_cmpint (g_ascii_strncasecmp (tmp, tmp2, 4096), ==, 0);
1794   g_free (tmp);
1795   g_free (tmp2);
1796
1797   tmp = g_markup_escape_text (string, 4096);
1798   g_free (tmp);
1799
1800   /* test set 2: ensure that nothing reads even one byte past a '\0'.
1801    */
1802   g_assert_cmpint (string[4095], ==, '\n');
1803   string[4095] = '\0';
1804
1805   tmp = g_strdup (string);
1806   g_assert_cmpint (strlen (tmp), ==, 4095);
1807   g_free (tmp);
1808
1809   tmp = g_strndup (string, 10000);
1810   g_assert_cmpint (strlen (tmp), ==, 4095);
1811   g_free (tmp);
1812
1813   g_stpcpy (buffer, string);
1814   g_assert_cmpint (strlen (buffer), ==, 4095);
1815
1816   g_strstr_len (string, 10000, "BUGS");
1817   g_strstr_len (string, 10000, "B");
1818   g_strstr_len (string, 10000, ".");
1819   g_strstr_len (string, 10000, "");
1820
1821   g_strrstr (string, "BUGS");
1822   g_strrstr (string, "B");
1823   g_strrstr (string, ".");
1824   g_strrstr (string, "");
1825
1826   g_strrstr_len (string, 10000, "BUGS");
1827   g_strrstr_len (string, 10000, "B");
1828   g_strrstr_len (string, 10000, ".");
1829   g_strrstr_len (string, 10000, "");
1830
1831   g_str_has_prefix (string, "this won't do very much...");
1832   g_str_has_suffix (string, "but maybe this will...");
1833   g_str_has_suffix (string, "HMMMM.");
1834   g_str_has_suffix (string, "MMMM.");
1835   g_str_has_suffix (string, "M.");
1836
1837   g_strlcpy (buffer, string, sizeof buffer);
1838   g_assert_cmpint (strlen (buffer), ==, 4095);
1839   g_strlcpy (buffer, string, sizeof buffer);
1840   buffer[0] = '\0';
1841   g_strlcat (buffer, string, sizeof buffer);
1842   g_assert_cmpint (strlen (buffer), ==, 4095);
1843
1844   tmp = g_strdup_printf ("<%s>", string);
1845   g_assert_cmpint (strlen (tmp), ==, 4095 + 2);
1846   g_free (tmp);
1847
1848   tmp = g_ascii_strdown (string, -1);
1849   tmp2 = g_ascii_strdown (tmp, -1);
1850   g_assert_cmpint (strlen (tmp), ==, strlen (tmp2));
1851   g_assert_cmpint (strlen (string), ==, strlen (tmp));
1852   g_assert_cmpint (g_ascii_strncasecmp (string, tmp, -1), ==, 0);
1853   g_assert_cmpint (g_ascii_strncasecmp (string, tmp2, -1), ==, 0);
1854   g_assert_cmpint (g_ascii_strncasecmp (tmp, tmp2, -1), ==, 0);
1855   g_free (tmp);
1856   g_free (tmp2);
1857
1858   tmp = g_ascii_strup (string, -1);
1859   tmp2 = g_ascii_strup (string, -1);
1860   g_assert_cmpint (strlen (tmp), ==, strlen (tmp2));
1861   g_assert_cmpint (strlen (string), ==, strlen (tmp));
1862   g_assert_cmpint (g_ascii_strncasecmp (string, tmp, -1), ==, 0);
1863   g_assert_cmpint (g_ascii_strncasecmp (string, tmp2, -1), ==, 0);
1864   g_assert_cmpint (g_ascii_strncasecmp (tmp, tmp2, -1), ==, 0);
1865   g_free (tmp);
1866   g_free (tmp2);
1867
1868   g_ascii_strcasecmp (string, string);
1869   g_ascii_strncasecmp (string, string, 10000);
1870
1871   g_strreverse (string);
1872   g_strreverse (string);
1873   g_strchug (string);
1874   g_strchomp (string);
1875   g_strstrip (string);
1876   g_assert_cmpint (strlen (string), ==, 4095);
1877
1878   g_strdelimit (string, "M", 'N');
1879   g_strcanon (string, " N.", ':');
1880   g_assert_cmpint (strlen (string), ==, 4095);
1881
1882   array = g_strsplit (string, ".", -1);
1883   tmp = g_strjoinv (".", array);
1884   g_strfreev (array);
1885
1886   g_assert_cmpmem (tmp, strlen (tmp), string, 4095);
1887   g_free (tmp);
1888
1889   tmp = g_strjoinv ("/", (char **) strjoinv_0);
1890   g_assert_cmpstr (tmp, ==, "");
1891   g_free (tmp);
1892
1893   tmp = g_strjoinv ("/", (char **) strjoinv_1);
1894   g_assert_cmpstr (tmp, ==, "foo");
1895   g_free (tmp);
1896
1897   tmp = g_strconcat (string, string, string, NULL);
1898   g_assert_cmpint (strlen (tmp), ==, 4095 * 3);
1899   g_free (tmp);
1900
1901   tmp = g_strjoin ("!", string, string, NULL);
1902   g_assert_cmpint (strlen (tmp), ==, 4095 + 1 + 4095);
1903   g_free (tmp);
1904
1905   tmp = g_markup_escape_text (string, -1);
1906   g_free (tmp);
1907
1908   tmp = g_markup_printf_escaped ("%s", string);
1909   g_free (tmp);
1910
1911   tmp = g_strescape (string, NULL);
1912   tmp2 = g_strcompress (tmp);
1913   g_assert_cmpstr (string, ==, tmp2);
1914   g_free (tmp2);
1915   g_free (tmp);
1916
1917   g_mapped_file_unref (file);
1918 }
1919
1920 /* Testing g_strip_context() function with various cases */
1921 static void
1922 test_strip_context (void)
1923 {
1924   const gchar *msgid;
1925   const gchar *msgval;
1926   const gchar *s;
1927
1928   msgid = "blabla";
1929   msgval = "bla";
1930   s = g_strip_context (msgid, msgval);
1931   g_assert_true (s == msgval);
1932
1933   msgid = msgval = "blabla";
1934   s = g_strip_context (msgid, msgval);
1935   g_assert_true (s == msgval);
1936
1937   msgid = msgval = "blabla|foo";
1938   s = g_strip_context (msgid, msgval);
1939   g_assert_true (s == msgval + 7);
1940
1941   msgid = msgval = "blabla||bar";
1942   s = g_strip_context (msgid, msgval);
1943   g_assert_true (s == msgval + 7);
1944 }
1945
1946 /* Test the strings returned by g_strerror() are valid and unique. On Windows,
1947  * fewer than 200 error numbers are used, so we expect some strings to
1948  * return a generic ‘unknown error code’ message. */
1949 static void
1950 test_strerror (void)
1951 {
1952   GHashTable *strs;
1953   gint i;
1954   const gchar *str, *unknown_str;
1955
1956   setlocale (LC_ALL, "C");
1957
1958   unknown_str = g_strerror (-1);
1959   strs = g_hash_table_new (g_str_hash, g_str_equal);
1960   for (i = 1; i < 200; i++)
1961     {
1962       gboolean is_unknown;
1963       str = g_strerror (i);
1964       is_unknown = (strcmp (str, unknown_str) == 0);
1965       g_assert_nonnull (str);
1966       g_assert_true (g_utf8_validate (str, -1, NULL));
1967       g_assert_true (!g_hash_table_contains (strs, str) || is_unknown);
1968       g_hash_table_add (strs, (gpointer) str);
1969     }
1970
1971   g_hash_table_unref (strs);
1972 }
1973
1974 /* Testing g_strsignal() function with various cases */
1975 static void
1976 test_strsignal (void)
1977 {
1978   gint i;
1979   const gchar *str;
1980
1981   for (i = 1; i < 20; i++)
1982     {
1983       str = g_strsignal (i);
1984       g_assert_nonnull (str);
1985       g_assert_true (g_utf8_validate (str, -1, NULL));
1986     }
1987 }
1988
1989 /* Testing g_strup(), g_strdown() and g_strcasecmp() */
1990 static void
1991 test_strup (void)
1992 {
1993   gchar *s = NULL;
1994
1995   if (g_test_undefined ())
1996     {
1997       /* Testing degenerated cases */
1998       g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
1999                              "*assertion*!= NULL*");
2000       s = g_strup (NULL);
2001       g_test_assert_expected_messages ();
2002
2003       g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
2004                              "*assertion*!= NULL*");
2005       s = g_strdown (NULL);
2006       g_test_assert_expected_messages ();
2007
2008       g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
2009                              "*assertion*!= NULL*");
2010       g_strcasecmp (NULL, "ABCD");
2011       g_test_assert_expected_messages ();
2012
2013       g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
2014                              "*assertion*!= NULL*");
2015       g_strcasecmp ("abcd", NULL);
2016       g_test_assert_expected_messages ();
2017     }
2018
2019   s = g_strdup ("lower UPPER");
2020   g_assert_cmpstr (g_strup (s), ==, "LOWER UPPER");
2021   g_assert_cmpstr (g_strdown (s), ==, "lower upper");
2022   g_assert_true (g_strcasecmp ("lower", "LOWER") == 0);
2023   g_free (s);
2024 }
2025
2026 /* Testing g_str_to_ascii() function with various cases */
2027 static void
2028 test_transliteration (void)
2029 {
2030   gchar *out;
2031
2032   /* ...to test the defaults */
2033   setlocale (LC_ALL, "C");
2034
2035   /* Test something trivial */
2036   out = g_str_to_ascii ("hello", NULL);
2037   g_assert_cmpstr (out, ==, "hello");
2038   g_free (out);
2039
2040   /* Test something above 0xffff */
2041   out = g_str_to_ascii ("𝐀𝐀𝐀", NULL);
2042   g_assert_cmpstr (out, ==, "AAA");
2043   g_free (out);
2044
2045   /* Test something with no good match */
2046   out = g_str_to_ascii ("a ∧ ¬a", NULL);
2047   g_assert_cmpstr (out, ==, "a ? ?a");
2048   g_free (out);
2049
2050   /* Make sure 'ö' is handled differently per locale */
2051   out = g_str_to_ascii ("ö", NULL);
2052   g_assert_cmpstr (out, ==, "o");
2053   g_free (out);
2054
2055   out = g_str_to_ascii ("ö", "sv");
2056   g_assert_cmpstr (out, ==, "o");
2057   g_free (out);
2058
2059   out = g_str_to_ascii ("ö", "de");
2060   g_assert_cmpstr (out, ==, "oe");
2061   g_free (out);
2062
2063   /* Make sure we can find a locale by a wide range of names */
2064   out = g_str_to_ascii ("ö", "de_DE");
2065   g_assert_cmpstr (out, ==, "oe");
2066   g_free (out);
2067
2068   out = g_str_to_ascii ("ö", "de_DE.UTF-8");
2069   g_assert_cmpstr (out, ==, "oe");
2070   g_free (out);
2071
2072   out = g_str_to_ascii ("ö", "de_DE.UTF-8@euro");
2073   g_assert_cmpstr (out, ==, "oe");
2074   g_free (out);
2075
2076   out = g_str_to_ascii ("ö", "de@euro");
2077   g_assert_cmpstr (out, ==, "oe");
2078   g_free (out);
2079
2080   /* Test some invalid locale names */
2081   out = g_str_to_ascii ("ö", "de_DE@euro.UTF-8");
2082   g_assert_cmpstr (out, ==, "o");
2083   g_free (out);
2084
2085   out = g_str_to_ascii ("ö", "de@DE@euro");
2086   g_assert_cmpstr (out, ==, "o");
2087   g_free (out);
2088
2089   out = g_str_to_ascii ("ö", "doesnotexist");
2090   g_assert_cmpstr (out, ==, "o");
2091   g_free (out);
2092
2093   out = g_str_to_ascii ("ö", "thislocalenameistoolong");
2094   g_assert_cmpstr (out, ==, "o");
2095   g_free (out);
2096
2097   /* Try a lookup of a locale with a variant */
2098   out = g_str_to_ascii ("б", "sr_RS");
2099   g_assert_cmpstr (out, ==, "b");
2100   g_free (out);
2101
2102   out = g_str_to_ascii ("б", "sr_RS@latin");
2103   g_assert_cmpstr (out, ==, "?");
2104   g_free (out);
2105
2106   /* Ukrainian contains the only multi-character mappings.
2107    * Try a string that contains one ('зг') along with a partial
2108    * sequence ('з') at the end.
2109    */
2110   out = g_str_to_ascii ("Зліва направо, згори вниз", "uk");
2111   g_assert_cmpstr (out, ==, "Zliva napravo, zghory vnyz");
2112   g_free (out);
2113
2114   /* Try out the other combinations */
2115   out = g_str_to_ascii ("Зг", "uk");
2116   g_assert_cmpstr (out, ==, "Zgh");
2117   g_free (out);
2118
2119   out = g_str_to_ascii ("зГ", "uk");
2120   g_assert_cmpstr (out, ==, "zGH");
2121   g_free (out);
2122
2123   out = g_str_to_ascii ("ЗГ", "uk");
2124   g_assert_cmpstr (out, ==, "ZGH");
2125   g_free (out);
2126
2127   /* And a non-combination */
2128   out = g_str_to_ascii ("зя", "uk");
2129   g_assert_cmpstr (out, ==, "zya");
2130   g_free (out);
2131 }
2132
2133 /* Testing g_strv_contains() function with various cases */
2134 static void
2135 test_strv_contains (void)
2136 {
2137   gboolean result = TRUE;
2138   const gchar *strv_simple[] = { "hello", "there", NULL };
2139   const gchar *strv_dupe[] = { "dupe", "dupe", NULL };
2140   const gchar *strv_empty[] = { NULL };
2141
2142   if (g_test_undefined ())
2143     {
2144       /* Testing degenerated cases */
2145       g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
2146                              "*assertion*!= NULL*");
2147       result = g_strv_contains (NULL, "hello");
2148       g_test_assert_expected_messages ();
2149       g_assert_false (result);
2150
2151       g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
2152                              "*assertion*!= NULL*");
2153       result = g_strv_contains (strv_simple, NULL);
2154       g_test_assert_expected_messages ();
2155       g_assert_false (result);
2156     }
2157
2158   g_assert_true (g_strv_contains (strv_simple, "hello"));
2159   g_assert_true (g_strv_contains (strv_simple, "there"));
2160   g_assert_false (g_strv_contains (strv_simple, "non-existent"));
2161   g_assert_false (g_strv_contains (strv_simple, ""));
2162
2163   g_assert_true (g_strv_contains (strv_dupe, "dupe"));
2164
2165   g_assert_false (g_strv_contains (strv_empty, "empty!"));
2166   g_assert_false (g_strv_contains (strv_empty, ""));
2167 }
2168
2169 /* Test g_strv_equal() works for various inputs. */
2170 static void
2171 test_strv_equal (void)
2172 {
2173   gboolean result = TRUE;
2174   const gchar *strv_empty[] = { NULL };
2175   const gchar *strv_empty2[] = { NULL };
2176   const gchar *strv_simple[] = { "hello", "you", NULL };
2177   const gchar *strv_simple2[] = { "hello", "you", NULL };
2178   const gchar *strv_simple_reordered[] = { "you", "hello", NULL };
2179   const gchar *strv_simple_superset[] = { "hello", "you", "again", NULL };
2180   const gchar *strv_another[] = { "not", "a", "coded", "message", NULL };
2181
2182   if (g_test_undefined ())
2183     {
2184       /* Testing degenerated cases */
2185       g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
2186                              "*assertion*!= NULL*");
2187       result = g_strv_equal (NULL, strv_simple2);
2188       g_test_assert_expected_messages ();
2189       g_assert_false (result);
2190
2191       g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
2192                              "*assertion*!= NULL*");
2193       result = g_strv_equal (strv_simple, NULL);
2194       g_test_assert_expected_messages ();
2195       g_assert_false (result);
2196     }
2197
2198   g_assert_true (g_strv_equal (strv_empty, strv_empty));
2199   g_assert_true (g_strv_equal (strv_empty, strv_empty2));
2200   g_assert_true (g_strv_equal (strv_empty2, strv_empty));
2201   g_assert_false (g_strv_equal (strv_empty, strv_simple));
2202   g_assert_false (g_strv_equal (strv_simple, strv_empty));
2203   g_assert_true (g_strv_equal (strv_simple, strv_simple));
2204   g_assert_true (g_strv_equal (strv_simple, strv_simple2));
2205   g_assert_true (g_strv_equal (strv_simple2, strv_simple));
2206   g_assert_false (g_strv_equal (strv_simple, strv_simple_reordered));
2207   g_assert_false (g_strv_equal (strv_simple_reordered, strv_simple));
2208   g_assert_false (g_strv_equal (strv_simple, strv_simple_superset));
2209   g_assert_false (g_strv_equal (strv_simple_superset, strv_simple));
2210   g_assert_false (g_strv_equal (strv_simple, strv_another));
2211   g_assert_false (g_strv_equal (strv_another, strv_simple));
2212 }
2213
2214 typedef enum
2215   {
2216     SIGNED,
2217     UNSIGNED
2218   } SignType;
2219
2220 typedef struct
2221 {
2222   const gchar *str;
2223   SignType sign_type;
2224   guint base;
2225   gint min;
2226   gint max;
2227   gint expected;
2228   gboolean should_fail;
2229   GNumberParserError error_code;
2230 } TestData;
2231
2232 const TestData test_data[] = {
2233   /* typical cases for signed */
2234   { "0",  SIGNED, 10, -2,  2,  0, FALSE, 0                                   },
2235   { "+0", SIGNED, 10, -2,  2,  0, FALSE, 0                                   },
2236   { "-0", SIGNED, 10, -2,  2,  0, FALSE, 0                                   },
2237   { "-2", SIGNED, 10, -2,  2, -2, FALSE, 0                                   },
2238   {"-02", SIGNED, 10, -2,  2, -2, FALSE, 0                                   },
2239   { "2",  SIGNED, 10, -2,  2,  2, FALSE, 0                                   },
2240   { "02", SIGNED, 10, -2,  2,  2, FALSE, 0                                   },
2241   { "+2", SIGNED, 10, -2,  2,  2, FALSE, 0                                   },
2242   {"+02", SIGNED, 10, -2,  2,  2, FALSE, 0                                   },
2243   { "3",  SIGNED, 10, -2,  2,  0, TRUE,  G_NUMBER_PARSER_ERROR_OUT_OF_BOUNDS },
2244   { "+3", SIGNED, 10, -2,  2,  0, TRUE,  G_NUMBER_PARSER_ERROR_OUT_OF_BOUNDS },
2245   { "-3", SIGNED, 10, -2,  2,  0, TRUE,  G_NUMBER_PARSER_ERROR_OUT_OF_BOUNDS },
2246
2247   /* typical cases for unsigned */
2248   { "-1", UNSIGNED, 10, 0, 2, 0, TRUE,  G_NUMBER_PARSER_ERROR_INVALID       },
2249   { "1",  UNSIGNED, 10, 0, 2, 1, FALSE, 0                                   },
2250   { "+1", UNSIGNED, 10, 0, 2, 0, TRUE,  G_NUMBER_PARSER_ERROR_INVALID       },
2251   { "0",  UNSIGNED, 10, 0, 2, 0, FALSE, 0                                   },
2252   { "+0", UNSIGNED, 10, 0, 2, 0, TRUE,  G_NUMBER_PARSER_ERROR_INVALID       },
2253   { "-0", UNSIGNED, 10, 0, 2, 0, TRUE,  G_NUMBER_PARSER_ERROR_INVALID       },
2254   { "2",  UNSIGNED, 10, 0, 2, 2, FALSE, 0                                   },
2255   { "+2", UNSIGNED, 10, 0, 2, 0, TRUE,  G_NUMBER_PARSER_ERROR_INVALID       },
2256   { "3",  UNSIGNED, 10, 0, 2, 0, TRUE,  G_NUMBER_PARSER_ERROR_OUT_OF_BOUNDS },
2257   { "+3", UNSIGNED, 10, 0, 2, 0, TRUE,  G_NUMBER_PARSER_ERROR_INVALID       },
2258
2259   /* min == max cases for signed */
2260   { "-2", SIGNED, 10, -2, -2, -2, FALSE, 0                                   },
2261   { "-1", SIGNED, 10, -2, -2,  0, TRUE,  G_NUMBER_PARSER_ERROR_OUT_OF_BOUNDS },
2262   { "-3", SIGNED, 10, -2, -2,  0, TRUE,  G_NUMBER_PARSER_ERROR_OUT_OF_BOUNDS },
2263
2264   /* min == max cases for unsigned */
2265   { "2", UNSIGNED, 10, 2, 2, 2, FALSE, 0                                   },
2266   { "3", UNSIGNED, 10, 2, 2, 0, TRUE,  G_NUMBER_PARSER_ERROR_OUT_OF_BOUNDS },
2267   { "1", UNSIGNED, 10, 2, 2, 0, TRUE,  G_NUMBER_PARSER_ERROR_OUT_OF_BOUNDS },
2268
2269   /* invalid inputs */
2270   { "",    SIGNED,   10, -2,  2,  0, TRUE,  G_NUMBER_PARSER_ERROR_INVALID },
2271   { "",    UNSIGNED, 10,  0,  2,  0, TRUE,  G_NUMBER_PARSER_ERROR_INVALID },
2272   { "a",   SIGNED,   10, -2,  2,  0, TRUE,  G_NUMBER_PARSER_ERROR_INVALID },
2273   { "a",   UNSIGNED, 10,  0,  2,  0, TRUE,  G_NUMBER_PARSER_ERROR_INVALID },
2274   { "1a",  SIGNED,   10, -2,  2,  0, TRUE,  G_NUMBER_PARSER_ERROR_INVALID },
2275   { "1a",  UNSIGNED, 10,  0,  2,  0, TRUE,  G_NUMBER_PARSER_ERROR_INVALID },
2276   { "- 1", SIGNED,   10, -2,  2,  0, TRUE,  G_NUMBER_PARSER_ERROR_INVALID },
2277
2278   /* leading/trailing whitespace */
2279   { " 1", SIGNED,   10, -2,  2,  0, TRUE,  G_NUMBER_PARSER_ERROR_INVALID },
2280   { " 1", UNSIGNED, 10,  0,  2,  0, TRUE,  G_NUMBER_PARSER_ERROR_INVALID },
2281   { "1 ", SIGNED,   10, -2,  2,  0, TRUE,  G_NUMBER_PARSER_ERROR_INVALID },
2282   { "1 ", UNSIGNED, 10,  0,  2,  0, TRUE,  G_NUMBER_PARSER_ERROR_INVALID },
2283
2284   /* hexadecimal numbers */
2285   { "a",     SIGNED,   16,   0, 15, 10, FALSE, 0                             },
2286   { "a",     UNSIGNED, 16,   0, 15, 10, FALSE, 0                             },
2287   { "0a",    UNSIGNED, 16,   0, 15, 10, FALSE, 0                             },
2288   { "0xa",   SIGNED,   16,   0, 15,  0, TRUE,  G_NUMBER_PARSER_ERROR_INVALID },
2289   { "0xa",   UNSIGNED, 16,   0, 15,  0, TRUE,  G_NUMBER_PARSER_ERROR_INVALID },
2290   { "-0xa",  SIGNED,   16, -15, 15,  0, TRUE,  G_NUMBER_PARSER_ERROR_INVALID },
2291   { "-0xa",  UNSIGNED, 16,   0, 15,  0, TRUE,  G_NUMBER_PARSER_ERROR_INVALID },
2292   { "+0xa",  SIGNED,   16,   0, 15,  0, TRUE,  G_NUMBER_PARSER_ERROR_INVALID },
2293   { "+0xa",  UNSIGNED, 16,   0, 15,  0, TRUE,  G_NUMBER_PARSER_ERROR_INVALID },
2294   { "- 0xa", SIGNED,   16, -15, 15,  0, TRUE,  G_NUMBER_PARSER_ERROR_INVALID },
2295   { "- 0xa", UNSIGNED, 16,   0, 15,  0, TRUE,  G_NUMBER_PARSER_ERROR_INVALID },
2296   { "+ 0xa", SIGNED,   16, -15, 15,  0, TRUE,  G_NUMBER_PARSER_ERROR_INVALID },
2297   { "+ 0xa", UNSIGNED, 16,   0, 15,  0, TRUE,  G_NUMBER_PARSER_ERROR_INVALID },
2298 };
2299
2300 /* Testing g_ascii_string_to_signed() and g_ascii_string_to_unsigned() functions */
2301 static void
2302 test_ascii_string_to_number_usual (void)
2303 {
2304   gsize idx;
2305   gboolean result;
2306   GError *error = NULL;
2307   const TestData *data;
2308   gint value;
2309   gint64 value64 = 0;
2310   guint64 valueu64 = 0;
2311
2312   /*** g_ascii_string_to_signed() ***/
2313   data = &test_data[0]; /* Setting data to signed data */
2314
2315   if (g_test_undefined ())
2316     {
2317       /* Testing degenerated cases */
2318       g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
2319                              "*assertion*!= NULL*");
2320       result = g_ascii_string_to_signed (NULL,
2321                                          data->base,
2322                                          data->min,
2323                                          data->max,
2324                                          &value64,
2325                                          &error);
2326       g_test_assert_expected_messages ();
2327
2328       g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
2329                              "*assertion \'base >= 2 && base <= 36\'*");
2330       result = g_ascii_string_to_signed (data->str,
2331                                          1,
2332                                          data->min,
2333                                          data->max,
2334                                          &value64,
2335                                          &error);
2336       g_test_assert_expected_messages ();
2337
2338       g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
2339                              "*assertion \'base >= 2 && base <= 36\'*");
2340       result = g_ascii_string_to_signed (data->str,
2341                                          40,
2342                                          data->min,
2343                                          data->max,
2344                                          &value64,
2345                                          &error);
2346       g_test_assert_expected_messages ();
2347
2348       g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
2349                              "*assertion \'min <= max\'*");
2350       result = g_ascii_string_to_signed (data->str,
2351                                          data->base,
2352                                          data->max,
2353                                          data->min,
2354                                          &value64,
2355                                          &error);
2356       g_test_assert_expected_messages ();
2357     }
2358
2359   /* Catching first part of (error == NULL || *error == NULL) */
2360   result = g_ascii_string_to_signed (data->str,
2361                                      data->base,
2362                                      data->min,
2363                                      data->max,
2364                                      &value64,
2365                                      NULL);
2366
2367   /*** g_ascii_string_to_unsigned() ***/
2368   data = &test_data[12]; /* Setting data to unsigned data */
2369
2370   if (g_test_undefined ())
2371     {
2372       g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
2373                              "*assertion*!= NULL*");
2374       result = g_ascii_string_to_unsigned (NULL,
2375                                            data->base,
2376                                            data->min,
2377                                            data->max,
2378                                            &valueu64,
2379                                            &error);
2380       g_test_assert_expected_messages ();
2381
2382       g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
2383                              "*assertion \'base >= 2 && base <= 36\'*");
2384       result = g_ascii_string_to_unsigned (data->str,
2385                                            1,
2386                                            data->min,
2387                                            data->max,
2388                                            &valueu64,
2389                                            &error);
2390       g_test_assert_expected_messages ();
2391
2392       g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
2393                              "*assertion \'base >= 2 && base <= 36\'*");
2394       result = g_ascii_string_to_unsigned (data->str,
2395                                            40,
2396                                            data->min,
2397                                            data->max,
2398                                            &valueu64,
2399                                            &error);
2400       g_test_assert_expected_messages ();
2401
2402       g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
2403                              "*assertion \'min <= max\'*");
2404       result = g_ascii_string_to_unsigned (data->str,
2405                                            data->base,
2406                                            data->max,
2407                                            data->min,
2408                                            &valueu64,
2409                                            &error);
2410       g_test_assert_expected_messages ();
2411     }
2412
2413   /* Catching first part of (error == NULL || *error == NULL) */
2414   result = g_ascii_string_to_unsigned (data->str,
2415                                        data->base,
2416                                        data->min,
2417                                        data->max,
2418                                        &valueu64,
2419                                        NULL);
2420
2421   /* Testing usual cases */
2422   for (idx = 0; idx < G_N_ELEMENTS (test_data); ++idx)
2423     {
2424       data = &test_data[idx];
2425
2426       switch (data->sign_type)
2427         {
2428         case SIGNED:
2429           {
2430             result = g_ascii_string_to_signed (data->str,
2431                                                data->base,
2432                                                data->min,
2433                                                data->max,
2434                                                &value64,
2435                                                &error);
2436             value = value64;
2437             g_assert_cmpint (value, ==, value64);
2438             break;
2439           }
2440
2441         case UNSIGNED:
2442           {
2443             guint64 value64 = 0;
2444             result = g_ascii_string_to_unsigned (data->str,
2445                                                  data->base,
2446                                                  data->min,
2447                                                  data->max,
2448                                                  &value64,
2449                                                  &error);
2450             value = value64;
2451             g_assert_cmpint (value, ==, value64);
2452             break;
2453           }
2454
2455         default:
2456           g_assert_not_reached ();
2457         }
2458
2459       if (data->should_fail)
2460         {
2461           g_assert_false (result);
2462           g_assert_error (error, G_NUMBER_PARSER_ERROR, (gint) data->error_code);
2463           g_clear_error (&error);
2464         }
2465       else
2466         {
2467           g_assert_true (result);
2468           g_assert_no_error (error);
2469           g_assert_cmpint (value, ==, data->expected);
2470         }
2471     }
2472 }
2473
2474 /* Testing pathological cases for g_ascii_string_to_(un)signed()  */
2475 static void
2476 test_ascii_string_to_number_pathological (void)
2477 {
2478   GError *error = NULL;
2479   const gchar *crazy_high = "999999999999999999999999999999999999";
2480   const gchar *crazy_low = "-999999999999999999999999999999999999";
2481   const gchar *max_uint64 = "18446744073709551615";
2482   const gchar *max_int64 = "9223372036854775807";
2483   const gchar *min_int64 = "-9223372036854775808";
2484   guint64 uvalue = 0;
2485   gint64 svalue = 0;
2486
2487   g_assert_false (g_ascii_string_to_unsigned (crazy_high,
2488                                               10,
2489                                               0,
2490                                               G_MAXUINT64,
2491                                               NULL,
2492                                               &error));
2493   g_assert_error (error, G_NUMBER_PARSER_ERROR, G_NUMBER_PARSER_ERROR_OUT_OF_BOUNDS);
2494   g_clear_error (&error);
2495   g_assert_false (g_ascii_string_to_unsigned (crazy_low,
2496                                               10,
2497                                               0,
2498                                               G_MAXUINT64,
2499                                               NULL,
2500                                               &error));
2501   // crazy_low is a signed number so it is not a valid unsigned number
2502   g_assert_error (error, G_NUMBER_PARSER_ERROR, G_NUMBER_PARSER_ERROR_INVALID);
2503   g_clear_error (&error);
2504
2505   g_assert_false (g_ascii_string_to_signed (crazy_high,
2506                                             10,
2507                                             G_MININT64,
2508                                             G_MAXINT64,
2509                                             NULL,
2510                                             &error));
2511   g_assert_error (error, G_NUMBER_PARSER_ERROR, G_NUMBER_PARSER_ERROR_OUT_OF_BOUNDS);
2512   g_clear_error (&error);
2513   g_assert_false (g_ascii_string_to_signed (crazy_low,
2514                                             10,
2515                                             G_MININT64,
2516                                             G_MAXINT64,
2517                                             NULL,
2518                                             &error));
2519   g_assert_error (error, G_NUMBER_PARSER_ERROR, G_NUMBER_PARSER_ERROR_OUT_OF_BOUNDS);
2520   g_clear_error (&error);
2521
2522   g_assert_true (g_ascii_string_to_unsigned (max_uint64,
2523                                              10,
2524                                              0,
2525                                              G_MAXUINT64,
2526                                              &uvalue,
2527                                              &error));
2528   g_assert_no_error (error);
2529   g_assert_cmpint (uvalue, ==, G_MAXUINT64);
2530
2531   g_assert_true (g_ascii_string_to_signed (max_int64,
2532                                            10,
2533                                            G_MININT64,
2534                                            G_MAXINT64,
2535                                            &svalue,
2536                                            &error));
2537   g_assert_no_error (error);
2538   g_assert_cmpint (svalue, ==, G_MAXINT64);
2539
2540   g_assert_true (g_ascii_string_to_signed (min_int64,
2541                                            10,
2542                                            G_MININT64,
2543                                            G_MAXINT64,
2544                                            &svalue,
2545                                            &error));
2546   g_assert_no_error (error);
2547   g_assert_cmpint (svalue, ==, G_MININT64);
2548 }
2549
2550 int
2551 main (int   argc,
2552       char *argv[])
2553 {
2554   g_test_init (&argc, &argv, NULL);
2555
2556   g_test_add_func ("/strfuncs/ascii-strcasecmp", test_ascii_strcasecmp);
2557   g_test_add_func ("/strfuncs/ascii-string-to-num/pathological", test_ascii_string_to_number_pathological);
2558   g_test_add_func ("/strfuncs/ascii-string-to-num/usual", test_ascii_string_to_number_usual);
2559   g_test_add_func ("/strfuncs/ascii_strdown", test_ascii_strdown);
2560   g_test_add_func ("/strfuncs/ascii_strdup", test_ascii_strup);
2561   g_test_add_func ("/strfuncs/ascii_strtod", test_ascii_strtod);
2562   g_test_add_func ("/strfuncs/bounds-check", test_bounds);
2563   g_test_add_func ("/strfuncs/has-prefix", test_has_prefix);
2564   g_test_add_func ("/strfuncs/has-suffix", test_has_suffix);
2565   g_test_add_func ("/strfuncs/memdup", test_memdup);
2566   g_test_add_func ("/strfuncs/memdup2", test_memdup2);
2567   g_test_add_func ("/strfuncs/stpcpy", test_stpcpy);
2568   g_test_add_func ("/strfuncs/str_match_string", test_str_match_string);
2569   g_test_add_func ("/strfuncs/str_tokenize_and_fold", test_str_tokenize_and_fold);
2570   g_test_add_func ("/strfuncs/strcanon", test_strcanon);
2571   g_test_add_func ("/strfuncs/strchomp", test_strchomp);
2572   g_test_add_func ("/strfuncs/strchug", test_strchug);
2573   g_test_add_func ("/strfuncs/strcompress-strescape", test_strcompress_strescape);
2574   g_test_add_func ("/strfuncs/strconcat", test_strconcat);
2575   g_test_add_func ("/strfuncs/strdelimit", test_strdelimit);
2576   g_test_add_func ("/strfuncs/strdup", test_strdup);
2577   g_test_add_func ("/strfuncs/strdup-printf", test_strdup_printf);
2578   g_test_add_func ("/strfuncs/strdupv", test_strdupv);
2579   g_test_add_func ("/strfuncs/strerror", test_strerror);
2580   g_test_add_func ("/strfuncs/strip-context", test_strip_context);
2581   g_test_add_func ("/strfuncs/strjoin", test_strjoin);
2582   g_test_add_func ("/strfuncs/strjoinv", test_strjoinv);
2583   g_test_add_func ("/strfuncs/strlcat", test_strlcat);
2584   g_test_add_func ("/strfuncs/strlcpy", test_strlcpy);
2585   g_test_add_func ("/strfuncs/strncasecmp", test_strncasecmp);
2586   g_test_add_func ("/strfuncs/strndup", test_strndup);
2587   g_test_add_func ("/strfuncs/strnfill", test_strnfill);
2588   g_test_add_func ("/strfuncs/strreverse", test_strreverse);
2589   g_test_add_func ("/strfuncs/strsignal", test_strsignal);
2590   g_test_add_func ("/strfuncs/strsplit", test_strsplit);
2591   g_test_add_func ("/strfuncs/strsplit-set", test_strsplit_set);
2592   g_test_add_func ("/strfuncs/strstr", test_strstr);
2593   g_test_add_func ("/strfuncs/strtod", test_strtod);
2594   g_test_add_func ("/strfuncs/strtoull-strtoll", test_strtoll);
2595   g_test_add_func ("/strfuncs/strup", test_strup);
2596   g_test_add_func ("/strfuncs/strv-contains", test_strv_contains);
2597   g_test_add_func ("/strfuncs/strv-equal", test_strv_equal);
2598   g_test_add_func ("/strfuncs/strv-length", test_strv_length);
2599   g_test_add_func ("/strfuncs/test-is-to-digit", test_is_to_digit);
2600   g_test_add_func ("/strfuncs/transliteration", test_transliteration);
2601
2602   return g_test_run();
2603 }