tests/regex-test.c

   1 /*
   2  * Copyright (C) 2005 - 2006, Marco Barisione <marco@barisione.org>
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19
  20 #undef G_DISABLE_ASSERT
  21 #undef G_LOG_DOMAIN
  22
  23 #include <string.h>
  24 #include <locale.h>
  25 #include "glib.h"
  26
  27 #ifdef ENABLE_REGEX
  28
  29 /* U+20AC EURO SIGN (symbol, currency) */
  30 #define EURO "\xe2\x82\xac"
  31 /* U+00E0 LATIN SMALL LETTER A WITH GRAVE (letter, lowercase) */
  32 #define AGRAVE "\xc3\xa0"
  33 /* U+00C0 LATIN CAPITAL LETTER A WITH GRAVE (letter, uppercase) */
  34 #define AGRAVE_UPPER "\xc3\x80"
  35 /* U+00E8 LATIN SMALL LETTER E WITH GRAVE (letter, lowercase) */
  36 #define EGRAVE "\xc3\xa8"
  37 /* U+00F2 LATIN SMALL LETTER O WITH GRAVE (letter, lowercase) */
  38 #define OGRAVE "\xc3\xb2"
  39 /* U+014B LATIN SMALL LETTER ENG (letter, lowercase) */
  40 #define ENG "\xc5\x8b"
  41 /* U+0127 LATIN SMALL LETTER H WITH STROKE (letter, lowercase) */
  42 #define HSTROKE "\xc4\xa7"
  43 /* U+0634 ARABIC LETTER SHEEN (letter, other) */
  44 #define SHEEN "\xd8\xb4"
  45 /* U+1374 ETHIOPIC NUMBER THIRTY (number, other) */
  46 #define ETH30 "\xe1\x8d\xb4"
  47
  48 /* A random value use to mark untouched integer variables. */
  49 #define UNTOUCHED -559038737
  50
  51 static gboolean noisy = FALSE;
  52 static gboolean abort_on_fail = FALSE;
  53
  54 #define PASS passed++
  55 #define FAIL \
  56   G_STMT_START \
  57     { \
  58       failed++; \
  59       if (abort_on_fail) \
  60         goto end; \
  61     } \
  62   G_STMT_END
  63
  64 /* A replacement for strcmp that doesn't crash with null pointers. */
  65 static gboolean
  66 streq (const gchar *s1, const gchar *s2)
  67 {
  68   if (s1 == NULL && s2 == NULL)
  69     return TRUE;
  70   else if (s1 == NULL)
  71     return FALSE;
  72   else if (s2 == NULL)
  73     return FALSE;
  74   else
  75     return strcmp (s1, s2) == 0;
  76 }
  77
  78 static void
  79 verbose (const gchar *format, ...)
  80 {
  81   /* Function copied from glib/tests/patterntest.c by Matthias Clasen. */
  82   gchar *msg;
  83   va_list args;
  84
  85   va_start (args, format);
  86   msg = g_strdup_vprintf (format, args);
  87   va_end (args);
  88
  89   if (noisy)
  90     g_print ("%s", msg);
  91   g_free (msg);
  92 }
  93
  94 static gboolean
  95 test_new (const gchar        *pattern,
  96           GRegexCompileFlags  compile_opts,
  97           GRegexMatchFlags    match_opts)
  98 {
  99   GRegex *regex;
 100
 101   verbose ("compiling \"%s\" \t", pattern);
 102
 103   regex = g_regex_new (pattern, compile_opts, match_opts, NULL);
 104   if (regex == NULL)
 105     {
 106       g_print ("failed \t(pattern: \"%s\", compile: %d, match %d)\n",
 107                pattern, compile_opts, match_opts);
 108       return FALSE;
 109     }
 110
 111   if (!streq (g_regex_get_pattern (regex), pattern))
 112     {
 113       g_print ("failed \t(pattern: \"%s\")\n",
 114                pattern);
 115       g_regex_unref (regex);
 116       return FALSE;
 117     }
 118
 119   g_regex_unref (regex);
 120
 121   verbose ("passed\n");
 122   return TRUE;
 123 }
 124
 125 #define TEST_NEW(pattern, compile_opts, match_opts) { \
 126   total++; \
 127   if (test_new (pattern, compile_opts, match_opts)) \
 128     PASS; \
 129   else \
 130     FAIL; \
 131 }
 132
 133 static gboolean
 134 test_new_fail (const gchar        *pattern,
 135                GRegexCompileFlags  compile_opts,
 136                GRegexError         expected_error)
 137 {
 138   GRegex *regex;
 139   GError *error = NULL;
 140
 141   verbose ("compiling \"%s\" (expected a failure) \t", pattern);
 142
 143   regex = g_regex_new (pattern, compile_opts, 0, &error);
 144
 145   if (regex != NULL)
 146     {
 147       g_print ("failed \t(pattern: \"%s\", compile: %d)\n",
 148                pattern, compile_opts);
 149       g_regex_unref (regex);
 150       return FALSE;
 151     }
 152
 153   if (error->code != expected_error)
 154     {
 155       g_print ("failed \t(pattern: \"%s\", compile: %d, got error: %d, "
 156                "expected error: %d)\n",
 157                pattern, compile_opts, error->code, expected_error);
 158       g_error_free (error);
 159       return FALSE;
 160     }
 161
 162   verbose ("passed\n");
 163   return TRUE;
 164 }
 165
 166 #define TEST_NEW_FAIL(pattern, compile_opts, expected_error) { \
 167   total++; \
 168   if (test_new_fail (pattern, compile_opts, expected_error)) \
 169     PASS; \
 170   else \
 171     FAIL; \
 172 }
 173
 174 static gboolean
 175 test_match_simple (const gchar        *pattern,
 176                    const gchar        *string,
 177                    GRegexCompileFlags  compile_opts,
 178                    GRegexMatchFlags    match_opts,
 179                    gboolean            expected)
 180 {
 181   gboolean match;
 182
 183   verbose ("matching \"%s\" against \"%s\" \t", string, pattern);
 184
 185   match = g_regex_match_simple (pattern, string, compile_opts, match_opts);
 186   if (match != expected)
 187     {
 188       g_print ("failed \t(unexpected %s)\n", match ? "match" : "mismatch");
 189       return FALSE;
 190     }
 191   else
 192     {
 193       verbose ("passed (%s)\n", match ? "match" : "nomatch");
 194       return TRUE;
 195     }
 196 }
 197
 198 #define TEST_MATCH_SIMPLE(pattern, string, compile_opts, match_opts, expected) { \
 199   total++; \
 200   if (test_match_simple (pattern, string, compile_opts, match_opts, expected)) \
 201     PASS; \
 202   else \
 203     FAIL; \
 204 }
 205
 206 static gboolean
 207 test_match (const gchar        *pattern,
 208             GRegexCompileFlags  compile_opts,
 209             GRegexMatchFlags    match_opts,
 210             const gchar        *string,
 211             gssize              string_len,
 212             gint                start_position,
 213             GRegexMatchFlags    match_opts2,
 214             gboolean            expected)
 215 {
 216   GRegex *regex;
 217   gboolean match;
 218
 219   verbose ("matching \"%s\" against \"%s\" (start: %d, len: %d) \t",
 220            string, pattern, start_position, string_len);
 221
 222   regex = g_regex_new (pattern, compile_opts, match_opts, NULL);
 223   match = g_regex_match_full (regex, string, string_len,
 224                               start_position, match_opts2, NULL, NULL);
 225   if (match != expected)
 226     {
 227       gchar *e1 = g_strescape (pattern, NULL);
 228       gchar *e2 = g_strescape (string, NULL);
 229       g_print ("failed \t(unexpected %s) '%s' against '%s'\n", match ? "match" : "mismatch", e1, e2);
 230       g_free (e1);
 231       g_free (e2);
 232       g_regex_unref (regex);
 233       return FALSE;
 234     }
 235
 236   if (string_len == -1 && start_position == 0)
 237     {
 238       match = g_regex_match (regex, string, match_opts2, NULL);
 239       if (match != expected)
 240         {
 241           g_print ("failed \t(pattern: \"%s\", string: \"%s\")\n",
 242                    pattern, string);
 243           g_regex_unref (regex);
 244           return FALSE;
 245         }
 246     }
 247
 248   g_regex_unref (regex);
 249
 250   verbose ("passed (%s)\n", match ? "match" : "nomatch");
 251   return TRUE;
 252 }
 253
 254 #define TEST_MATCH(pattern, compile_opts, match_opts, string, \
 255                    string_len, start_position, match_opts2, expected) { \
 256   total++; \
 257   if (test_match (pattern, compile_opts, match_opts, string, \
 258                   string_len, start_position, match_opts2, expected)) \
 259     PASS; \
 260   else \
 261     FAIL; \
 262 }
 263
 264 struct _Match
 265 {
 266   gchar *string;
 267   gint start, end;
 268 };
 269 typedef struct _Match Match;
 270
 271 static void
 272 free_match (gpointer data, gpointer user_data)
 273 {
 274   Match *match = data;
 275   if (match == NULL)
 276     return;
 277   g_free (match->string);
 278   g_free (match);
 279 }
 280
 281 static gboolean
 282 test_match_next (const gchar *pattern,
 283                  const gchar *string,
 284                  gssize       string_len,
 285                  gint         start_position,
 286                  ...)
 287 {
 288   GRegex *regex;
 289   GMatchInfo *match_info;
 290   va_list args;
 291   GSList *matches = NULL;
 292   GSList *expected = NULL;
 293   GSList *l_exp, *l_match;
 294   gboolean ret = TRUE;
 295
 296   verbose ("matching \"%s\" against \"%s\" (start: %d, len: %d) \t",
 297            string, pattern, start_position, string_len);
 298
 299   /* The va_list is a NULL-terminated sequence of: extected matched string,
 300    * expected start and expected end. */
 301   va_start (args, start_position);
 302   while (TRUE)
 303    {
 304       Match *match;
 305       const gchar *expected_string = va_arg (args, const gchar *);
 306       if (expected_string == NULL)
 307         break;
 308       match = g_new0 (Match, 1);
 309       match->string = g_strdup (expected_string);
 310       match->start = va_arg (args, gint);
 311       match->end = va_arg (args, gint);
 312       expected = g_slist_prepend (expected, match);
 313     }
 314   expected = g_slist_reverse (expected);
 315   va_end (args);
 316
 317   regex = g_regex_new (pattern, 0, 0, NULL);
 318
 319   g_regex_match_full (regex, string, string_len,
 320                       start_position, 0, &match_info, NULL);
 321   while (g_match_info_matches (match_info))
 322     {
 323       Match *match = g_new0 (Match, 1);
 324       match->string = g_match_info_fetch (match_info, 0);
 325       match->start = UNTOUCHED;
 326       match->end = UNTOUCHED;
 327       g_match_info_fetch_pos (match_info, 0, &match->start, &match->end);
 328       matches = g_slist_prepend (matches, match);
 329       g_match_info_next (match_info, NULL);
 330     }
 331   g_assert (regex == g_match_info_get_regex (match_info));
 332   g_assert (string == g_match_info_get_string (match_info));
 333   g_match_info_free (match_info);
 334   matches = g_slist_reverse (matches);
 335
 336   if (g_slist_length (matches) != g_slist_length (expected))
 337     {
 338       gint match_count = g_slist_length (matches);
 339       g_print ("failed \t(got %d %s, expected %d)\n", match_count,
 340                match_count == 1 ? "match" : "matches",
 341                g_slist_length (expected));
 342       ret = FALSE;
 343       goto exit;
 344     }
 345
 346   l_exp = expected;
 347   l_match =  matches;
 348   while (l_exp != NULL)
 349     {
 350       Match *exp = l_exp->data;
 351       Match *match = l_match->data;
 352
 353       if (!streq(exp->string, match->string))
 354         {
 355           g_print ("failed \t(got \"%s\", expected \"%s\")\n",
 356                    match->string, exp->string);
 357           ret = FALSE;
 358           goto exit;
 359         }
 360
 361       if (exp->start != match->start || exp->end != match->end)
 362         {
 363           g_print ("failed \t(got [%d, %d], expected [%d, %d])\n",
 364                    match->start, match->end, exp->start, exp->end);
 365           ret = FALSE;
 366           goto exit;
 367         }
 368
 369       l_exp = g_slist_next (l_exp);
 370       l_match = g_slist_next (l_match);
 371     }
 372
 373 exit:
 374   if (ret)
 375     {
 376       gint count = g_slist_length (matches);
 377       verbose ("passed (%d %s)\n", count, count == 1 ? "match" : "matches");
 378     }
 379
 380   g_regex_unref (regex);
 381   g_slist_foreach (expected, free_match, NULL);
 382   g_slist_free (expected);
 383   g_slist_foreach (matches, free_match, NULL);
 384   g_slist_free (matches);
 385
 386   return ret;
 387 }
 388
 389 #define TEST_MATCH_NEXT0(pattern, string, string_len, start_position) { \
 390   total++; \
 391   if (test_match_next (pattern, string, string_len, start_position, NULL)) \
 392     PASS; \
 393   else \
 394     FAIL; \
 395 }
 396
 397 #define TEST_MATCH_NEXT1(pattern, string, string_len, start_position, \
 398                               t1, s1, e1) { \
 399   total++; \
 400   if (test_match_next (pattern, string, string_len, start_position, \
 401                        t1, s1, e1, NULL)) \
 402     PASS; \
 403   else \
 404     FAIL; \
 405 }
 406
 407 #define TEST_MATCH_NEXT2(pattern, string, string_len, start_position, \
 408                          t1, s1, e1, t2, s2, e2) { \
 409   total++; \
 410   if (test_match_next (pattern, string, string_len, start_position, \
 411                        t1, s1, e1, t2, s2, e2, NULL)) \
 412     PASS; \
 413   else \
 414     FAIL; \
 415 }
 416
 417 #define TEST_MATCH_NEXT3(pattern, string, string_len, start_position, \
 418                          t1, s1, e1, t2, s2, e2, t3, s3, e3) { \
 419   total++; \
 420   if (test_match_next (pattern, string, string_len, start_position, \
 421                        t1, s1, e1, t2, s2, e2, t3, s3, e3, NULL)) \
 422     PASS; \
 423   else \
 424     FAIL; \
 425 }
 426
 427 #define TEST_MATCH_NEXT4(pattern, string, string_len, start_position, \
 428                          t1, s1, e1, t2, s2, e2, t3, s3, e3, t4, s4, e4) { \
 429   total++; \
 430   if (test_match_next (pattern, string, string_len, start_position, \
 431                        t1, s1, e1, t2, s2, e2, t3, s3, e3, t4, s4, e4, NULL)) \
 432     PASS; \
 433   else \
 434     FAIL; \
 435 }
 436
 437 static gboolean
 438 test_match_count (const gchar      *pattern,
 439                   const gchar      *string,
 440                   gint              start_position,
 441                   GRegexMatchFlags  match_opts,
 442                   gint              expected_count)
 443 {
 444   GRegex *regex;
 445   GMatchInfo *match_info;
 446   gint count;
 447
 448   verbose ("fetching match count (string: \"%s\", pattern: \"%s\", start: %d) \t",
 449            string, pattern, start_position);
 450
 451   regex = g_regex_new (pattern, 0, 0, NULL);
 452
 453   g_regex_match_full (regex, string, -1, start_position,
 454                       match_opts, &match_info, NULL);
 455   count = g_match_info_get_match_count (match_info);
 456
 457   if (count != expected_count)
 458     {
 459       g_print ("failed \t(got %d, expected: %d)\n", count, expected_count);
 460       return FALSE;
 461     }
 462
 463   g_match_info_free (match_info);
 464   g_regex_unref (regex);
 465
 466   verbose ("passed\n");
 467   return TRUE;
 468 }
 469
 470 #define TEST_MATCH_COUNT(pattern, string, start_position, match_opts, expected_count) { \
 471   total++; \
 472   if (test_match_count (pattern, string, start_position, match_opts, expected_count)) \
 473     PASS; \
 474   else \
 475     FAIL; \
 476 }
 477
 478 static gboolean
 479 test_partial (const gchar *pattern,
 480               const gchar *string,
 481               gboolean     expected)
 482 {
 483   GRegex *regex;
 484   GMatchInfo *match_info;
 485
 486   verbose ("partial matching (string: \"%s\", pattern: \"%s\") \t",
 487            string, pattern);
 488
 489   regex = g_regex_new (pattern, 0, 0, NULL);
 490
 491   g_regex_match (regex, string, G_REGEX_MATCH_PARTIAL, &match_info);
 492   if (expected != g_match_info_is_partial_match (match_info))
 493     {
 494       g_print ("failed \t(got %d, expected: %d)\n", !expected, expected);
 495       g_regex_unref (regex);
 496       return FALSE;
 497     }
 498
 499   if (expected && g_match_info_fetch_pos (match_info, 0, NULL, NULL))
 500     {
 501       g_print ("failed \t(got sub-pattern 0)\n");
 502       g_regex_unref (regex);
 503       return FALSE;
 504     }
 505
 506   if (expected && g_match_info_fetch_pos (match_info, 1, NULL, NULL))
 507     {
 508       g_print ("failed \t(got sub-pattern 1)\n");
 509       g_regex_unref (regex);
 510       return FALSE;
 511     }
 512
 513   g_match_info_free (match_info);
 514   g_regex_unref (regex);
 515
 516   verbose ("passed\n");
 517   return TRUE;
 518 }
 519
 520 #define TEST_PARTIAL(pattern, string, expected) { \
 521   total++; \
 522   if (test_partial (pattern, string, expected)) \
 523     PASS; \
 524   else \
 525     FAIL; \
 526 }
 527
 528 static gboolean
 529 test_sub_pattern (const gchar *pattern,
 530                   const gchar *string,
 531                   gint         start_position,
 532                   gint         sub_n,
 533                   const gchar *expected_sub,
 534                   gint         expected_start,
 535                   gint         expected_end)
 536 {
 537   GRegex *regex;
 538   GMatchInfo *match_info;
 539   gchar *sub_expr;
 540   gint start = UNTOUCHED, end = UNTOUCHED;
 541
 542   verbose ("fetching sub-pattern %d from \"%s\" (pattern: \"%s\") \t",
 543            sub_n, string, pattern);
 544
 545   regex = g_regex_new (pattern, 0, 0, NULL);
 546   g_regex_match_full (regex, string, -1, start_position, 0, &match_info, NULL);
 547
 548   sub_expr = g_match_info_fetch (match_info, sub_n);
 549   if (!streq(sub_expr, expected_sub))
 550     {
 551       g_print ("failed \t(got \"%s\", expected \"%s\")\n",
 552                sub_expr, expected_sub);
 553       g_free (sub_expr);
 554       g_regex_unref (regex);
 555       return FALSE;
 556     }
 557   g_free (sub_expr);
 558
 559   g_match_info_fetch_pos (match_info, sub_n, &start, &end);
 560   if (start != expected_start || end != expected_end)
 561     {
 562       g_print ("failed \t(got [%d, %d], expected [%d, %d])\n",
 563                start, end, expected_start, expected_end);
 564       g_regex_unref (regex);
 565       return FALSE;
 566     }
 567
 568   g_match_info_free (match_info);
 569   g_regex_unref (regex);
 570
 571   verbose ("passed\n");
 572   return TRUE;
 573 }
 574
 575 #define TEST_SUB_PATTERN(pattern, string, start_position, sub_n, expected_sub, \
 576                          expected_start, expected_end) { \
 577   total++; \
 578   if (test_sub_pattern (pattern, string, start_position, sub_n, expected_sub, \
 579                         expected_start, expected_end)) \
 580     PASS; \
 581   else \
 582     FAIL; \
 583 }
 584
 585 static gboolean
 586 test_named_sub_pattern (const gchar *pattern,
 587                         GRegexCompileFlags flags,
 588                         const gchar *string,
 589                         gint         start_position,
 590                         const gchar *sub_name,
 591                         const gchar *expected_sub,
 592                         gint         expected_start,
 593                         gint         expected_end)
 594 {
 595   GRegex *regex;
 596   GMatchInfo *match_info;
 597   gint start = UNTOUCHED, end = UNTOUCHED;
 598   gchar *sub_expr;
 599
 600   verbose ("fetching sub-pattern \"%s\" from \"%s\" (pattern: \"%s\") \t",
 601            sub_name, string, pattern);
 602
 603   regex = g_regex_new (pattern, flags, 0, NULL);
 604
 605   g_regex_match_full (regex, string, -1, start_position, 0, &match_info, NULL);
 606   sub_expr = g_match_info_fetch_named (match_info, sub_name);
 607   if (!streq (sub_expr, expected_sub))
 608     {
 609       g_print ("failed \t(got \"%s\", expected \"%s\")\n",
 610                sub_expr, expected_sub);
 611       g_free (sub_expr);
 612       g_regex_unref (regex);
 613       return FALSE;
 614     }
 615   g_free (sub_expr);
 616
 617   g_match_info_fetch_named_pos (match_info, sub_name, &start, &end);
 618   if (start != expected_start || end != expected_end)
 619     {
 620       g_print ("failed \t(got [%d, %d], expected [%d, %d])\n",
 621                start, end, expected_start, expected_end);
 622       g_regex_unref (regex);
 623       return FALSE;
 624     }
 625
 626   g_match_info_free (match_info);
 627   g_regex_unref (regex);
 628
 629   verbose ("passed\n");
 630   return TRUE;
 631 }
 632
 633 #define TEST_NAMED_SUB_PATTERN(pattern, string, start_position, sub_name, \
 634                                expected_sub, expected_start, expected_end) { \
 635   total++; \
 636   if (test_named_sub_pattern (pattern, 0, string, start_position, sub_name, \
 637                               expected_sub, expected_start, expected_end)) \
 638     PASS; \
 639   else \
 640     FAIL; \
 641 }
 642
 643 #define TEST_NAMED_SUB_PATTERN_DUPNAMES(pattern, string, start_position, sub_name, \
 644                                         expected_sub, expected_start, expected_end) { \
 645   total++; \
 646   if (test_named_sub_pattern (pattern, G_REGEX_DUPNAMES, string, start_position, \
 647                               sub_name, expected_sub, expected_start, expected_end)) \
 648     PASS; \
 649   else \
 650     FAIL; \
 651 }
 652
 653 static gboolean
 654 test_fetch_all (const gchar *pattern,
 655                 const gchar *string,
 656                 ...)
 657 {
 658   GRegex *regex;
 659   GMatchInfo *match_info;
 660   va_list args;
 661   GSList *expected = NULL;
 662   GSList *l_exp;
 663   gchar **matches;
 664   gint match_count;
 665   gboolean ret = TRUE;
 666   gint i;
 667
 668   verbose ("fetching all sub-patterns from \"%s\" (pattern: \"%s\") \t",
 669            string, pattern);
 670
 671   /* The va_list is a NULL-terminated sequence of extected strings. */
 672   va_start (args, string);
 673   while (TRUE)
 674    {
 675       gchar *expected_string = va_arg (args, gchar *);
 676       if (expected_string == NULL)
 677         break;
 678       else
 679         expected = g_slist_prepend (expected, g_strdup (expected_string));
 680     }
 681   expected = g_slist_reverse (expected);
 682   va_end (args);
 683
 684   regex = g_regex_new (pattern, 0, 0, NULL);
 685   g_regex_match (regex, string, 0, &match_info);
 686   matches = g_match_info_fetch_all (match_info);
 687   if (matches)
 688     match_count = g_strv_length (matches);
 689   else
 690     match_count = 0;
 691
 692   if (match_count != g_slist_length (expected))
 693     {
 694       g_print ("failed \t(got %d %s, expected %d)\n", match_count,
 695                match_count == 1 ? "match" : "matches",
 696                g_slist_length (expected));
 697       ret = FALSE;
 698       goto exit;
 699     }
 700
 701   l_exp = expected;
 702   for (i = 0; l_exp != NULL; i++, l_exp = g_slist_next (l_exp))
 703     {
 704       if (!streq(l_exp->data, matches [i]))
 705         {
 706           g_print ("failed \t(got \"%s\", expected \"%s\")\n",
 707                    matches [i], (gchar *)l_exp->data);
 708           ret = FALSE;
 709           goto exit;
 710         }
 711     }
 712
 713   verbose ("passed (%d %s)\n", match_count,
 714            match_count == 1 ? "match" : "matches");
 715
 716 exit:
 717   g_match_info_free (match_info);
 718   g_regex_unref (regex);
 719   g_slist_foreach (expected, (GFunc)g_free, NULL);
 720   g_slist_free (expected);
 721   g_strfreev (matches);
 722
 723   return ret;
 724 }
 725
 726 #define TEST_FETCH_ALL0(pattern, string) { \
 727   total++; \
 728   if (test_fetch_all (pattern, string, NULL)) \
 729     PASS; \
 730   else \
 731     FAIL; \
 732 }
 733
 734 #define TEST_FETCH_ALL1(pattern, string, e1) { \
 735   total++; \
 736   if (test_fetch_all (pattern, string, e1, NULL)) \
 737     PASS; \
 738   else \
 739     FAIL; \
 740 }
 741
 742 #define TEST_FETCH_ALL2(pattern, string, e1, e2) { \
 743   total++; \
 744   if (test_fetch_all (pattern, string, e1, e2, NULL)) \
 745     PASS; \
 746   else \
 747     FAIL; \
 748 }
 749
 750 #define TEST_FETCH_ALL3(pattern, string, e1, e2, e3) { \
 751   total++; \
 752   if (test_fetch_all (pattern, string, e1, e2, e3, NULL)) \
 753     PASS; \
 754   else \
 755     FAIL; \
 756 }
 757
 758 static gboolean
 759 test_split_simple (const gchar *pattern,
 760                    const gchar *string,
 761                    ...)
 762 {
 763   va_list args;
 764   GSList *expected = NULL;
 765   GSList *l_exp;
 766   gchar **tokens;
 767   gint token_count;
 768   gboolean ret = TRUE;
 769   gint i;
 770
 771   verbose ("splitting \"%s\" against \"%s\" \t", string, pattern);
 772
 773   /* The va_list is a NULL-terminated sequence of extected strings. */
 774   va_start (args, string);
 775   while (TRUE)
 776    {
 777       gchar *expected_string = va_arg (args, gchar *);
 778       if (expected_string == NULL)
 779         break;
 780       else
 781         expected = g_slist_prepend (expected, g_strdup (expected_string));
 782     }
 783   expected = g_slist_reverse (expected);
 784   va_end (args);
 785
 786   tokens = g_regex_split_simple (pattern, string, 0, 0);
 787   if (tokens)
 788     token_count = g_strv_length (tokens);
 789   else
 790     token_count = 0;
 791
 792   if (token_count != g_slist_length (expected))
 793     {
 794       g_print ("failed \t(got %d %s, expected %d)\n", token_count,
 795                token_count == 1 ? "match" : "matches",
 796                g_slist_length (expected));
 797       ret = FALSE;
 798       goto exit;
 799     }
 800
 801   l_exp = expected;
 802   for (i = 0; l_exp != NULL; i++, l_exp = g_slist_next (l_exp))
 803     {
 804       if (!streq(l_exp->data, tokens [i]))
 805         {
 806           g_print ("failed \t(got \"%s\", expected \"%s\")\n",
 807                    tokens[i], (gchar *)l_exp->data);
 808           ret = FALSE;
 809           goto exit;
 810         }
 811     }
 812
 813   verbose ("passed (%d %s)\n", token_count,
 814            token_count == 1 ? "token" : "tokens");
 815
 816 exit:
 817   g_slist_foreach (expected, (GFunc)g_free, NULL);
 818   g_slist_free (expected);
 819   g_strfreev (tokens);
 820
 821   return ret;
 822 }
 823
 824 #define TEST_SPLIT_SIMPLE0(pattern, string) { \
 825   total++; \
 826   if (test_split_simple (pattern, string, NULL)) \
 827     PASS; \
 828   else \
 829     FAIL; \
 830 }
 831
 832 #define TEST_SPLIT_SIMPLE1(pattern, string, e1) { \
 833   total++; \
 834   if (test_split_simple (pattern, string, e1, NULL)) \
 835     PASS; \
 836   else \
 837     FAIL; \
 838 }
 839
 840 #define TEST_SPLIT_SIMPLE2(pattern, string, e1, e2) { \
 841   total++; \
 842   if (test_split_simple (pattern, string, e1, e2, NULL)) \
 843     PASS; \
 844   else \
 845     FAIL; \
 846 }
 847
 848 #define TEST_SPLIT_SIMPLE3(pattern, string, e1, e2, e3) { \
 849   total++; \
 850   if (test_split_simple (pattern, string, e1, e2, e3, NULL)) \
 851     PASS; \
 852   else \
 853     FAIL; \
 854 }
 855
 856 static gboolean
 857 test_split_full (const gchar *pattern,
 858                  const gchar *string,
 859                  gint         start_position,
 860                  gint         max_tokens,
 861                  ...)
 862 {
 863   GRegex *regex;
 864   va_list args;
 865   GSList *expected = NULL;
 866   GSList *l_exp;
 867   gchar **tokens;
 868   gint token_count;
 869   gboolean ret = TRUE;
 870   gint i;
 871
 872   verbose ("splitting \"%s\" against \"%s\" (start: %d, max: %d) \t",
 873            string, pattern, start_position, max_tokens);
 874
 875   /* The va_list is a NULL-terminated sequence of extected strings. */
 876   va_start (args, max_tokens);
 877   while (TRUE)
 878    {
 879       gchar *expected_string = va_arg (args, gchar *);
 880       if (expected_string == NULL)
 881         break;
 882       else
 883         expected = g_slist_prepend (expected, g_strdup (expected_string));
 884     }
 885   expected = g_slist_reverse (expected);
 886   va_end (args);
 887
 888   regex = g_regex_new (pattern, 0, 0, NULL);
 889   tokens = g_regex_split_full (regex, string, -1, start_position,
 890                                0, max_tokens, NULL);
 891   if (tokens)
 892     token_count = g_strv_length (tokens);
 893   else
 894     token_count = 0;
 895
 896   if (token_count != g_slist_length (expected))
 897     {
 898       g_print ("failed \t(got %d %s, expected %d)\n", token_count,
 899                token_count == 1 ? "match" : "matches",
 900                g_slist_length (expected));
 901       ret = FALSE;
 902       goto exit;
 903     }
 904
 905   l_exp = expected;
 906   for (i = 0; l_exp != NULL; i++, l_exp = g_slist_next (l_exp))
 907     {
 908       if (!streq(l_exp->data, tokens [i]))
 909         {
 910           g_print ("failed \t(got \"%s\", expected \"%s\")\n",
 911                    tokens[i], (gchar *)l_exp->data);
 912           ret = FALSE;
 913           goto exit;
 914         }
 915     }
 916
 917   verbose ("passed (%d %s)\n", token_count,
 918            token_count == 1 ? "token" : "tokens");
 919
 920 exit:
 921   g_regex_unref (regex);
 922   g_slist_foreach (expected, (GFunc)g_free, NULL);
 923   g_slist_free (expected);
 924   g_strfreev (tokens);
 925
 926   return ret;
 927 }
 928
 929 static gboolean
 930 test_split (const gchar *pattern,
 931             const gchar *string,
 932             ...)
 933 {
 934   GRegex *regex;
 935   va_list args;
 936   GSList *expected = NULL;
 937   GSList *l_exp;
 938   gchar **tokens;
 939   gint token_count;
 940   gboolean ret = TRUE;
 941   gint i;
 942
 943   verbose ("splitting \"%s\" against \"%s\" \t", string, pattern);
 944
 945   /* The va_list is a NULL-terminated sequence of extected strings. */
 946   va_start (args, string);
 947   while (TRUE)
 948    {
 949       gchar *expected_string = va_arg (args, gchar *);
 950       if (expected_string == NULL)
 951         break;
 952       else
 953         expected = g_slist_prepend (expected, g_strdup (expected_string));
 954     }
 955   expected = g_slist_reverse (expected);
 956   va_end (args);
 957
 958   regex = g_regex_new (pattern, 0, 0, NULL);
 959   tokens = g_regex_split (regex, string, 0);
 960   if (tokens)
 961     token_count = g_strv_length (tokens);
 962   else
 963     token_count = 0;
 964
 965   if (token_count != g_slist_length (expected))
 966     {
 967       g_print ("failed \t(got %d %s, expected %d)\n", token_count,
 968                token_count == 1 ? "match" : "matches",
 969                g_slist_length (expected));
 970       ret = FALSE;
 971       goto exit;
 972     }
 973
 974   l_exp = expected;
 975   for (i = 0; l_exp != NULL; i++, l_exp = g_slist_next (l_exp))
 976     {
 977       if (!streq(l_exp->data, tokens [i]))
 978         {
 979           g_print ("failed \t(got \"%s\", expected \"%s\")\n",
 980                    tokens[i], (gchar *)l_exp->data);
 981           ret = FALSE;
 982           goto exit;
 983         }
 984     }
 985
 986   verbose ("passed (%d %s)\n", token_count,
 987            token_count == 1 ? "token" : "tokens");
 988
 989 exit:
 990   g_regex_unref (regex);
 991   g_slist_foreach (expected, (GFunc)g_free, NULL);
 992   g_slist_free (expected);
 993   g_strfreev (tokens);
 994
 995   return ret;
 996 }
 997
 998 #define TEST_SPLIT0(pattern, string, start_position, max_tokens) { \
 999   total++; \
1000   if (test_split_full (pattern, string, start_position, max_tokens, NULL)) \
1001     PASS; \
1002   else \
1003     FAIL; \
1004   if (start_position == 0 && max_tokens <= 0) \
1005   { \
1006     total++; \
1007     if (test_split (pattern, string, NULL)) \
1008       PASS; \
1009     else \
1010       FAIL; \
1011   } \
1012 }
1013
1014 #define TEST_SPLIT1(pattern, string, start_position, max_tokens, e1) { \
1015   total++; \
1016   if (test_split_full (pattern, string, start_position, max_tokens, e1, NULL)) \
1017     PASS; \
1018   else \
1019     FAIL; \
1020   if (start_position == 0 && max_tokens <= 0) \
1021   { \
1022     total++; \
1023     if (test_split (pattern, string, e1, NULL)) \
1024       PASS; \
1025     else \
1026       FAIL; \
1027   } \
1028 }
1029
1030 #define TEST_SPLIT2(pattern, string, start_position, max_tokens, e1, e2) { \
1031   total++; \
1032   if (test_split_full (pattern, string, start_position, max_tokens, e1, e2, NULL)) \
1033     PASS; \
1034   else \
1035     FAIL; \
1036   if (start_position == 0 && max_tokens <= 0) \
1037   { \
1038     total++; \
1039     if (test_split (pattern, string, e1, e2, NULL)) \
1040       PASS; \
1041     else \
1042       FAIL; \
1043   } \
1044 }
1045
1046 #define TEST_SPLIT3(pattern, string, start_position, max_tokens, e1, e2, e3) { \
1047   total++; \
1048   if (test_split_full (pattern, string, start_position, max_tokens, e1, e2, e3, NULL)) \
1049     PASS; \
1050   else \
1051     FAIL; \
1052   if (start_position == 0 && max_tokens <= 0) \
1053   { \
1054     total++; \
1055     if (test_split (pattern, string, e1, e2, e3, NULL)) \
1056       PASS; \
1057     else \
1058       FAIL; \
1059   } \
1060 }
1061
1062 static gboolean
1063 test_check_replacement (const gchar *string_to_expand,
1064                         gboolean     expected,
1065                         gboolean     expected_refs)
1066 {
1067   gboolean result;
1068   gboolean has_refs;
1069
1070   verbose ("checking replacement string \"%s\" \t", string_to_expand);
1071
1072   result = g_regex_check_replacement (string_to_expand, &has_refs, NULL);
1073   if (expected != result)
1074     {
1075       g_print ("failed \t(got \"%s\", expected \"%s\")\n",
1076                result ? "TRUE" : "FALSE",
1077                expected ? "TRUE" : "FALSE");
1078       return FALSE;
1079     }
1080
1081   if (expected && expected_refs != has_refs)
1082     {
1083       g_print ("failed \t(got has_references \"%s\", expected \"%s\")\n",
1084                has_refs ? "TRUE" : "FALSE",
1085                expected_refs ? "TRUE" : "FALSE");
1086       return FALSE;
1087     }
1088
1089   verbose ("passed\n");
1090   return TRUE;
1091 }
1092
1093 #define TEST_CHECK_REPLACEMENT(string_to_expand, expected, expected_refs) { \
1094   total++; \
1095   if (test_check_replacement (string_to_expand, expected, expected_refs)) \
1096     PASS; \
1097   else \
1098     FAIL; \
1099 }
1100 static gboolean
1101 test_expand (const gchar *pattern,
1102              const gchar *string,
1103              const gchar *string_to_expand,
1104              gboolean     raw,
1105              const gchar *expected)
1106 {
1107   GRegex *regex = NULL;
1108   GMatchInfo *match_info = NULL;
1109   gchar *res;
1110
1111   verbose ("expanding the references in \"%s\" (pattern: \"%s\", string: \"%s\") \t",
1112            string_to_expand,
1113            pattern ? pattern : "(null)",
1114            string ? string : "(null)");
1115
1116   if (pattern)
1117     {
1118       regex = g_regex_new (pattern, raw ? G_REGEX_RAW : 0, 0, NULL);
1119       g_regex_match (regex, string, 0, &match_info);
1120     }
1121
1122   res = g_match_info_expand_references (match_info, string_to_expand, NULL);
1123   if (!streq (res, expected))
1124     {
1125       g_print ("failed \t(got \"%s\", expected \"%s\")\n", res, expected);
1126       g_free (res);
1127       g_match_info_free (match_info);
1128       g_regex_unref (regex);
1129       return FALSE;
1130     }
1131
1132   g_free (res);
1133   g_match_info_free (match_info);
1134   if (regex)
1135     g_regex_unref (regex);
1136
1137   verbose ("passed\n");
1138   return TRUE;
1139 }
1140
1141 #define TEST_EXPAND(pattern, string, string_to_expand, raw, expected) { \
1142   total++; \
1143   if (test_expand (pattern, string, string_to_expand, raw, expected)) \
1144     PASS; \
1145   else \
1146     FAIL; \
1147 }
1148
1149 static gboolean
1150 test_replace (const gchar *pattern,
1151               const gchar *string,
1152               gint         start_position,
1153               const gchar *replacement,
1154               const gchar *expected)
1155 {
1156   GRegex *regex;
1157   gchar *res;
1158
1159   verbose ("replacing \"%s\" in \"%s\" (pattern: \"%s\", start: %d) \t",
1160            replacement, string, pattern, start_position);
1161
1162   regex = g_regex_new (pattern, 0, 0, NULL);
1163   res = g_regex_replace (regex, string, -1, start_position, replacement, 0, NULL);
1164   if (!streq (res, expected))
1165     {
1166       g_print ("failed \t(got \"%s\", expected \"%s\")\n", res, expected);
1167       g_free (res);
1168       g_regex_unref (regex);
1169       return FALSE;
1170     }
1171
1172   g_free (res);
1173   g_regex_unref (regex);
1174
1175   verbose ("passed\n");
1176   return TRUE;
1177 }
1178
1179 #define TEST_REPLACE(pattern, string, start_position, replacement, expected) { \
1180   total++; \
1181   if (test_replace (pattern, string, start_position, replacement, expected)) \
1182     PASS; \
1183   else \
1184     FAIL; \
1185 }
1186
1187 static gboolean
1188 test_replace_lit (const gchar *pattern,
1189                   const gchar *string,
1190                   gint         start_position,
1191                   const gchar *replacement,
1192                   const gchar *expected)
1193 {
1194   GRegex *regex;
1195   gchar *res;
1196
1197   verbose ("replacing literally \"%s\" in \"%s\" (pattern: \"%s\", start: %d) \t",
1198            replacement, string, pattern, start_position);
1199
1200   regex = g_regex_new (pattern, 0, 0, NULL);
1201   res = g_regex_replace_literal (regex, string, -1, start_position,
1202                                  replacement, 0, NULL);
1203   if (!streq (res, expected))
1204     {
1205       g_print ("failed \t(got \"%s\", expected \"%s\")\n", res, expected);
1206       g_free (res);
1207       g_regex_unref (regex);
1208       return FALSE;
1209     }
1210
1211   g_free (res);
1212   g_regex_unref (regex);
1213
1214   verbose ("passed\n");
1215   return TRUE;
1216 }
1217
1218 #define TEST_REPLACE_LIT(pattern, string, start_position, replacement, expected) { \
1219   total++; \
1220   if (test_replace_lit (pattern, string, start_position, replacement, expected)) \
1221     PASS; \
1222   else \
1223     FAIL; \
1224 }
1225
1226 static gboolean
1227 test_get_string_number (const gchar *pattern,
1228                         const gchar *name,
1229                         gint         expected_num)
1230 {
1231   GRegex *regex;
1232   gint num;
1233
1234   verbose ("getting the number of \"%s\" (pattern: \"%s\") \t",
1235            name, pattern);
1236
1237   regex = g_regex_new (pattern, 0, 0, NULL);
1238   num = g_regex_get_string_number (regex, name);
1239   g_regex_unref (regex);
1240
1241   if (num != expected_num)
1242     {
1243       g_print ("failed \t(got %d, expected %d)\n", num, expected_num);
1244       return FALSE;
1245     }
1246   else
1247     {
1248       verbose ("passed\n");
1249       return TRUE;
1250     }
1251 }
1252
1253 #define TEST_GET_STRING_NUMBER(pattern, name, expected_num) { \
1254   total++; \
1255   if (test_get_string_number (pattern, name, expected_num)) \
1256     PASS; \
1257   else \
1258     FAIL; \
1259 }
1260
1261 static gboolean
1262 test_escape (const gchar *string,
1263              gint         length,
1264              const gchar *expected)
1265 {
1266   gchar *escaped;
1267
1268   verbose ("escaping \"%s\" (len: %d) \t", string, length);
1269
1270   escaped = g_regex_escape_string (string, length);
1271
1272   if (!streq (escaped, expected))
1273     {
1274       g_print ("failed \t(got \"%s\", expected \"%s\")\n", escaped, expected);
1275       g_free (escaped);
1276       return FALSE;
1277     }
1278
1279   g_free (escaped);
1280
1281   verbose ("passed\n");
1282   return TRUE;
1283 }
1284
1285 #define TEST_ESCAPE(string, length, expected) { \
1286   total++; \
1287   if (test_escape (string, length, expected)) \
1288     PASS; \
1289   else \
1290     FAIL; \
1291 }
1292
1293 static gboolean
1294 test_match_all_full (const gchar *pattern,
1295                      const gchar *string,
1296                      gssize       string_len,
1297                      gint         start_position,
1298                      ...)
1299 {
1300   GRegex *regex;
1301   GMatchInfo *match_info;
1302   va_list args;
1303   GSList *expected = NULL;
1304   GSList *l_exp;
1305   gboolean match_ok;
1306   gboolean ret = TRUE;
1307   gint match_count;
1308   gint i;
1309
1310   verbose ("matching all in \"%s\" against \"%s\" (start: %d, len: %d) \t",
1311            string, pattern, start_position, string_len);
1312
1313   /* The va_list is a NULL-terminated sequence of: extected matched string,
1314    * expected start and expected end. */
1315   va_start (args, start_position);
1316   while (TRUE)
1317    {
1318       Match *match;
1319       const gchar *expected_string = va_arg (args, const gchar *);
1320       if (expected_string == NULL)
1321         break;
1322       match = g_new0 (Match, 1);
1323       match->string = g_strdup (expected_string);
1324       match->start = va_arg (args, gint);
1325       match->end = va_arg (args, gint);
1326       expected = g_slist_prepend (expected, match);
1327     }
1328   expected = g_slist_reverse (expected);
1329   va_end (args);
1330
1331   regex = g_regex_new (pattern, 0, 0, NULL);
1332   match_ok = g_regex_match_all_full (regex, string, string_len, start_position,
1333                                      0, &match_info, NULL);
1334
1335   if (match_ok && g_slist_length (expected) == 0)
1336     {
1337       g_print ("failed\n");
1338       ret = FALSE;
1339       goto exit;
1340     }
1341   if (!match_ok && g_slist_length (expected) != 0)
1342     {
1343       g_print ("failed\n");
1344       ret = FALSE;
1345       goto exit;
1346     }
1347
1348   match_count = g_match_info_get_match_count (match_info);
1349   if (match_count != g_slist_length (expected))
1350     {
1351       g_print ("failed \t(got %d %s, expected %d)\n", match_count,
1352                match_count == 1 ? "match" : "matches",
1353                g_slist_length (expected));
1354       ret = FALSE;
1355       goto exit;
1356     }
1357
1358   l_exp = expected;
1359   for (i = 0; i < match_count; i++)
1360     {
1361       gint start, end;
1362       gchar *matched_string;
1363       Match *exp = l_exp->data;
1364
1365       matched_string = g_match_info_fetch (match_info, i);
1366       g_match_info_fetch_pos (match_info, i, &start, &end);
1367
1368       if (!streq(exp->string, matched_string))
1369         {
1370           g_print ("failed \t(got \"%s\", expected \"%s\")\n",
1371                    matched_string, exp->string);
1372           g_free (matched_string);
1373           ret = FALSE;
1374           goto exit;
1375         }
1376       g_free (matched_string);
1377
1378       if (exp->start != start || exp->end != end)
1379         {
1380           g_print ("failed \t(got [%d, %d], expected [%d, %d])\n",
1381                    start, end, exp->start, exp->end);
1382           ret = FALSE;
1383           goto exit;
1384         }
1385
1386       l_exp = g_slist_next (l_exp);
1387     }
1388
1389 exit:
1390   if (ret)
1391     {
1392       verbose ("passed (%d %s)\n", match_count, match_count == 1 ? "match" : "matches");
1393     }
1394
1395   g_match_info_free (match_info);
1396   g_regex_unref (regex);
1397   g_slist_foreach (expected, free_match, NULL);
1398   g_slist_free (expected);
1399
1400   return ret;
1401 }
1402
1403 static gboolean
1404 test_match_all (const gchar *pattern,
1405                 const gchar *string,
1406                 ...)
1407 {
1408   GRegex *regex;
1409   GMatchInfo *match_info;
1410   va_list args;
1411   GSList *expected = NULL;
1412   GSList *l_exp;
1413   gboolean match_ok;
1414   gboolean ret = TRUE;
1415   gint match_count;
1416   gint i;
1417
1418   verbose ("matching all in \"%s\" against \"%s\" \t", string, pattern);
1419
1420   /* The va_list is a NULL-terminated sequence of: extected matched string,
1421    * expected start and expected end. */
1422   va_start (args, string);
1423   while (TRUE)
1424    {
1425       Match *match;
1426       const gchar *expected_string = va_arg (args, const gchar *);
1427       if (expected_string == NULL)
1428         break;
1429       match = g_new0 (Match, 1);
1430       match->string = g_strdup (expected_string);
1431       match->start = va_arg (args, gint);
1432       match->end = va_arg (args, gint);
1433       expected = g_slist_prepend (expected, match);
1434     }
1435   expected = g_slist_reverse (expected);
1436   va_end (args);
1437
1438   regex = g_regex_new (pattern, 0, 0, NULL);
1439   match_ok = g_regex_match_all (regex, string, 0, &match_info);
1440
1441   if (match_ok && g_slist_length (expected) == 0)
1442     {
1443       g_print ("failed\n");
1444       ret = FALSE;
1445       goto exit;
1446     }
1447   if (!match_ok && g_slist_length (expected) != 0)
1448     {
1449       g_print ("failed\n");
1450       ret = FALSE;
1451       goto exit;
1452     }
1453
1454   match_count = g_match_info_get_match_count (match_info);
1455   if (match_count != g_slist_length (expected))
1456     {
1457       g_print ("failed \t(got %d %s, expected %d)\n", match_count,
1458                match_count == 1 ? "match" : "matches",
1459                g_slist_length (expected));
1460       ret = FALSE;
1461       goto exit;
1462     }
1463
1464   l_exp = expected;
1465   for (i = 0; i < match_count; i++)
1466     {
1467       gint start, end;
1468       gchar *matched_string;
1469       Match *exp = l_exp->data;
1470
1471       matched_string = g_match_info_fetch (match_info, i);
1472       g_match_info_fetch_pos (match_info, i, &start, &end);
1473
1474       if (!streq(exp->string, matched_string))
1475         {
1476           g_print ("failed \t(got \"%s\", expected \"%s\")\n",
1477                    matched_string, exp->string);
1478           g_free (matched_string);
1479           ret = FALSE;
1480           goto exit;
1481         }
1482       g_free (matched_string);
1483
1484       if (exp->start != start || exp->end != end)
1485         {
1486           g_print ("failed \t(got [%d, %d], expected [%d, %d])\n",
1487                    start, end, exp->start, exp->end);
1488           ret = FALSE;
1489           goto exit;
1490         }
1491
1492       l_exp = g_slist_next (l_exp);
1493     }
1494
1495 exit:
1496   if (ret)
1497     {
1498       verbose ("passed (%d %s)\n", match_count, match_count == 1 ? "match" : "matches");
1499     }
1500
1501   g_match_info_free (match_info);
1502   g_regex_unref (regex);
1503   g_slist_foreach (expected, free_match, NULL);
1504   g_slist_free (expected);
1505
1506   return ret;
1507 }
1508
1509 #define TEST_MATCH_ALL0(pattern, string, string_len, start_position) { \
1510   total++; \
1511   if (test_match_all_full (pattern, string, string_len, start_position, NULL)) \
1512     PASS; \
1513   else \
1514     FAIL; \
1515   if (string_len == -1 && start_position == 0) \
1516   { \
1517     total++; \
1518     if (test_match_all (pattern, string, NULL)) \
1519       PASS; \
1520     else \
1521       FAIL; \
1522   } \
1523 }
1524
1525 #define TEST_MATCH_ALL1(pattern, string, string_len, start_position, \
1526                         t1, s1, e1) { \
1527   total++; \
1528   if (test_match_all_full (pattern, string, string_len, start_position, \
1529                            t1, s1, e1, NULL)) \
1530     PASS; \
1531   else \
1532     FAIL; \
1533   if (string_len == -1 && start_position == 0) \
1534   { \
1535     total++; \
1536     if (test_match_all (pattern, string, t1, s1, e1, NULL)) \
1537       PASS; \
1538     else \
1539       FAIL; \
1540   } \
1541 }
1542
1543 #define TEST_MATCH_ALL2(pattern, string, string_len, start_position, \
1544                         t1, s1, e1, t2, s2, e2) { \
1545   total++; \
1546   if (test_match_all_full (pattern, string, string_len, start_position, \
1547                            t1, s1, e1, t2, s2, e2, NULL)) \
1548     PASS; \
1549   else \
1550     FAIL; \
1551   if (string_len == -1 && start_position == 0) \
1552   { \
1553     total++; \
1554     if (test_match_all (pattern, string, t1, s1, e1, t2, s2, e2, NULL)) \
1555       PASS; \
1556     else \
1557       FAIL; \
1558   } \
1559 }
1560
1561 #define TEST_MATCH_ALL3(pattern, string, string_len, start_position, \
1562                         t1, s1, e1, t2, s2, e2, t3, s3, e3) { \
1563   total++; \
1564   if (test_match_all_full (pattern, string, string_len, start_position, \
1565                            t1, s1, e1, t2, s2, e2, t3, s3, e3, NULL)) \
1566     PASS; \
1567   else \
1568     FAIL; \
1569   if (string_len == -1 && start_position == 0) \
1570   { \
1571     total++; \
1572     if (test_match_all (pattern, string, t1, s1, e1, t2, s2, e2, t3, s3, e3, NULL)) \
1573       PASS; \
1574     else \
1575       FAIL; \
1576   } \
1577 }
1578
1579 int
1580 main (int argc, char *argv[])
1581 {
1582   gint total = 0;
1583   gint passed = 0;
1584   gint failed = 0;
1585   gint i = 0;
1586
1587   setlocale (LC_ALL, "");
1588
1589   for (i = 1; i < argc; i++)
1590     {
1591       if (streq ("--noisy", argv[i]))
1592         noisy = TRUE;
1593       else if (streq ("--abort", argv[i]))
1594         abort_on_fail = TRUE;
1595     }
1596
1597   g_setenv ("G_DEBUG", "fatal_warnings", TRUE);
1598
1599   /* TEST_NEW(pattern, compile_opts, match_opts) */
1600   TEST_NEW("", 0, 0);
1601   TEST_NEW(".*", 0, 0);
1602   TEST_NEW(".*", G_REGEX_OPTIMIZE, 0);
1603   TEST_NEW(".*", G_REGEX_MULTILINE, 0);
1604   TEST_NEW(".*", G_REGEX_DOTALL, 0);
1605   TEST_NEW(".*", G_REGEX_DOTALL, G_REGEX_MATCH_NOTBOL);
1606   TEST_NEW("(123\\d*)[a-zA-Z]+(?P<hello>.*)", 0, 0);
1607   TEST_NEW("(123\\d*)[a-zA-Z]+(?P<hello>.*)", G_REGEX_CASELESS, 0);
1608   TEST_NEW("(123\\d*)[a-zA-Z]+(?P<hello>.*)", G_REGEX_CASELESS | G_REGEX_OPTIMIZE, 0);
1609   TEST_NEW("(?P<A>x)|(?P<A>y)", G_REGEX_DUPNAMES, 0);
1610   TEST_NEW("(?P<A>x)|(?P<A>y)", G_REGEX_DUPNAMES | G_REGEX_OPTIMIZE, 0);
1611   /* This gives "internal error: code overflow" with pcre 6.0 */
1612   TEST_NEW("(?i)(?-i)", 0, 0);
1613
1614   /* TEST_NEW_FAIL(pattern, compile_opts, expected_error) */
1615   TEST_NEW_FAIL("(", 0, G_REGEX_ERROR_UNMATCHED_PARENTHESIS);
1616   TEST_NEW_FAIL(")", 0, G_REGEX_ERROR_UNMATCHED_PARENTHESIS);
1617   TEST_NEW_FAIL("[", 0, G_REGEX_ERROR_UNTERMINATED_CHARACTER_CLASS);
1618   TEST_NEW_FAIL("*", 0, G_REGEX_ERROR_NOTHING_TO_REPEAT);
1619   TEST_NEW_FAIL("?", 0, G_REGEX_ERROR_NOTHING_TO_REPEAT);
1620   TEST_NEW_FAIL("(?P<A>x)|(?P<A>y)", 0, G_REGEX_ERROR_DUPLICATE_SUBPATTERN_NAME);
1621
1622   /* TEST_MATCH_SIMPLE(pattern, string, compile_opts, match_opts, expected) */
1623   TEST_MATCH_SIMPLE("a", "", 0, 0, FALSE);
1624   TEST_MATCH_SIMPLE("a", "a", 0, 0, TRUE);
1625   TEST_MATCH_SIMPLE("a", "ba", 0, 0, TRUE);
1626   TEST_MATCH_SIMPLE("^a", "ba", 0, 0, FALSE);
1627   TEST_MATCH_SIMPLE("a", "ba", G_REGEX_ANCHORED, 0, FALSE);
1628   TEST_MATCH_SIMPLE("a", "ba", 0, G_REGEX_MATCH_ANCHORED, FALSE);
1629   TEST_MATCH_SIMPLE("a", "ab", G_REGEX_ANCHORED, 0, TRUE);
1630   TEST_MATCH_SIMPLE("a", "ab", 0, G_REGEX_MATCH_ANCHORED, TRUE);
1631   TEST_MATCH_SIMPLE("a", "a", G_REGEX_CASELESS, 0, TRUE);
1632   TEST_MATCH_SIMPLE("a", "A", G_REGEX_CASELESS, 0, TRUE);
1633   /* These are needed to test extended properties. */
1634   TEST_MATCH_SIMPLE(AGRAVE, AGRAVE, G_REGEX_CASELESS, 0, TRUE);
1635   TEST_MATCH_SIMPLE(AGRAVE, AGRAVE_UPPER, G_REGEX_CASELESS, 0, TRUE);
1636   TEST_MATCH_SIMPLE("\\p{L}", "a", 0, 0, TRUE);
1637   TEST_MATCH_SIMPLE("\\p{L}", "1", 0, 0, FALSE);
1638   TEST_MATCH_SIMPLE("\\p{L}", AGRAVE, 0, 0, TRUE);
1639   TEST_MATCH_SIMPLE("\\p{L}", AGRAVE_UPPER, 0, 0, TRUE);
1640   TEST_MATCH_SIMPLE("\\p{L}", SHEEN, 0, 0, TRUE);
1641   TEST_MATCH_SIMPLE("\\p{L}", ETH30, 0, 0, FALSE);
1642   TEST_MATCH_SIMPLE("\\p{Ll}", "a", 0, 0, TRUE);
1643   TEST_MATCH_SIMPLE("\\p{Ll}", AGRAVE, 0, 0, TRUE);
1644   TEST_MATCH_SIMPLE("\\p{Ll}", AGRAVE_UPPER, 0, 0, FALSE);
1645   TEST_MATCH_SIMPLE("\\p{Ll}", ETH30, 0, 0, FALSE);
1646   TEST_MATCH_SIMPLE("\\p{Sc}", AGRAVE, 0, 0, FALSE);
1647   TEST_MATCH_SIMPLE("\\p{Sc}", EURO, 0, 0, TRUE);
1648   TEST_MATCH_SIMPLE("\\p{Sc}", ETH30, 0, 0, FALSE);
1649   TEST_MATCH_SIMPLE("\\p{N}", "a", 0, 0, FALSE);
1650   TEST_MATCH_SIMPLE("\\p{N}", "1", 0, 0, TRUE);
1651   TEST_MATCH_SIMPLE("\\p{N}", AGRAVE, 0, 0, FALSE);
1652   TEST_MATCH_SIMPLE("\\p{N}", AGRAVE_UPPER, 0, 0, FALSE);
1653   TEST_MATCH_SIMPLE("\\p{N}", SHEEN, 0, 0, FALSE);
1654   TEST_MATCH_SIMPLE("\\p{N}", ETH30, 0, 0, TRUE);
1655   TEST_MATCH_SIMPLE("\\p{Nd}", "a", 0, 0, FALSE);
1656   TEST_MATCH_SIMPLE("\\p{Nd}", "1", 0, 0, TRUE);
1657   TEST_MATCH_SIMPLE("\\p{Nd}", AGRAVE, 0, 0, FALSE);
1658   TEST_MATCH_SIMPLE("\\p{Nd}", AGRAVE_UPPER, 0, 0, FALSE);
1659   TEST_MATCH_SIMPLE("\\p{Nd}", SHEEN, 0, 0, FALSE);
1660   TEST_MATCH_SIMPLE("\\p{Nd}", ETH30, 0, 0, FALSE);
1661   TEST_MATCH_SIMPLE("\\p{Common}", SHEEN, 0, 0, FALSE);
1662   TEST_MATCH_SIMPLE("\\p{Common}", "a", 0, 0, FALSE);
1663   TEST_MATCH_SIMPLE("\\p{Common}", AGRAVE, 0, 0, FALSE);
1664   TEST_MATCH_SIMPLE("\\p{Common}", AGRAVE_UPPER, 0, 0, FALSE);
1665   TEST_MATCH_SIMPLE("\\p{Common}", ETH30, 0, 0, FALSE);
1666   TEST_MATCH_SIMPLE("\\p{Common}", "%", 0, 0, TRUE);
1667   TEST_MATCH_SIMPLE("\\p{Common}", "1", 0, 0, TRUE);
1668   TEST_MATCH_SIMPLE("\\p{Arabic}", SHEEN, 0, 0, TRUE);
1669   TEST_MATCH_SIMPLE("\\p{Arabic}", "a", 0, 0, FALSE);
1670   TEST_MATCH_SIMPLE("\\p{Arabic}", AGRAVE, 0, 0, FALSE);
1671   TEST_MATCH_SIMPLE("\\p{Arabic}", AGRAVE_UPPER, 0, 0, FALSE);
1672   TEST_MATCH_SIMPLE("\\p{Arabic}", ETH30, 0, 0, FALSE);
1673   TEST_MATCH_SIMPLE("\\p{Arabic}", "%", 0, 0, FALSE);
1674   TEST_MATCH_SIMPLE("\\p{Arabic}", "1", 0, 0, FALSE);
1675   TEST_MATCH_SIMPLE("\\p{Latin}", SHEEN, 0, 0, FALSE);
1676   TEST_MATCH_SIMPLE("\\p{Latin}", "a", 0, 0, TRUE);
1677   TEST_MATCH_SIMPLE("\\p{Latin}", AGRAVE, 0, 0, TRUE);
1678   TEST_MATCH_SIMPLE("\\p{Latin}", AGRAVE_UPPER, 0, 0, TRUE);
1679   TEST_MATCH_SIMPLE("\\p{Latin}", ETH30, 0, 0, FALSE);
1680   TEST_MATCH_SIMPLE("\\p{Latin}", "%", 0, 0, FALSE);
1681   TEST_MATCH_SIMPLE("\\p{Latin}", "1", 0, 0, FALSE);
1682   TEST_MATCH_SIMPLE("\\p{Ethiopic}", SHEEN, 0, 0, FALSE);
1683   TEST_MATCH_SIMPLE("\\p{Ethiopic}", "a", 0, 0, FALSE);
1684   TEST_MATCH_SIMPLE("\\p{Ethiopic}", AGRAVE, 0, 0, FALSE);
1685   TEST_MATCH_SIMPLE("\\p{Ethiopic}", AGRAVE_UPPER, 0, 0, FALSE);
1686   TEST_MATCH_SIMPLE("\\p{Ethiopic}", ETH30, 0, 0, TRUE);
1687   TEST_MATCH_SIMPLE("\\p{Ethiopic}", "%", 0, 0, FALSE);
1688   TEST_MATCH_SIMPLE("\\p{Ethiopic}", "1", 0, 0, FALSE);
1689   TEST_MATCH_SIMPLE("\\p{L}(?<=\\p{Arabic})", SHEEN, 0, 0, TRUE);
1690   TEST_MATCH_SIMPLE("\\p{L}(?<=\\p{Latin})", SHEEN, 0, 0, FALSE);
1691   /* Invalid patterns. */
1692   TEST_MATCH_SIMPLE("\\", "a", 0, 0, FALSE);
1693   TEST_MATCH_SIMPLE("[", "", 0, 0, FALSE);
1694
1695   /* TEST_MATCH(pattern, compile_opts, match_opts, string,
1696    *            string_len, start_position, match_opts2, expected) */
1697   TEST_MATCH("a", 0, 0, "a", -1, 0, 0, TRUE);
1698   TEST_MATCH("a", 0, 0, "A", -1, 0, 0, FALSE);
1699   TEST_MATCH("a", G_REGEX_CASELESS, 0, "A", -1, 0, 0, TRUE);
1700   TEST_MATCH("a", 0, 0, "ab", -1, 1, 0, FALSE);
1701   TEST_MATCH("a", 0, 0, "ba", 1, 0, 0, FALSE);
1702   TEST_MATCH("a", 0, 0, "bab", -1, 0, 0, TRUE);
1703   TEST_MATCH("a", 0, 0, "b", -1, 0, 0, FALSE);
1704   TEST_MATCH("a", 0, G_REGEX_ANCHORED, "a", -1, 0, 0, TRUE);
1705   TEST_MATCH("a", 0, G_REGEX_ANCHORED, "ab", -1, 1, 0, FALSE);
1706   TEST_MATCH("a", 0, G_REGEX_ANCHORED, "ba", 1, 0, 0, FALSE);
1707   TEST_MATCH("a", 0, G_REGEX_ANCHORED, "bab", -1, 0, 0, FALSE);
1708   TEST_MATCH("a", 0, G_REGEX_ANCHORED, "b", -1, 0, 0, FALSE);
1709   TEST_MATCH("a", 0, 0, "a", -1, 0, G_REGEX_ANCHORED, TRUE);
1710   TEST_MATCH("a", 0, 0, "ab", -1, 1, G_REGEX_ANCHORED, FALSE);
1711   TEST_MATCH("a", 0, 0, "ba", 1, 0, G_REGEX_ANCHORED, FALSE);
1712   TEST_MATCH("a", 0, 0, "bab", -1, 0, G_REGEX_ANCHORED, FALSE);
1713   TEST_MATCH("a", 0, 0, "b", -1, 0, G_REGEX_ANCHORED, FALSE);
1714   TEST_MATCH("a|b", 0, 0, "a", -1, 0, 0, TRUE);
1715   TEST_MATCH("\\d", 0, 0, EURO, -1, 0, 0, FALSE);
1716   TEST_MATCH("^.$", 0, 0, EURO, -1, 0, 0, TRUE);
1717   TEST_MATCH("^.{3}$", 0, 0, EURO, -1, 0, 0, FALSE);
1718   TEST_MATCH("^.$", G_REGEX_RAW, 0, EURO, -1, 0, 0, FALSE);
1719   TEST_MATCH("^.{3}$", G_REGEX_RAW, 0, EURO, -1, 0, 0, TRUE);
1720   TEST_MATCH(AGRAVE, G_REGEX_CASELESS, 0, AGRAVE_UPPER, -1, 0, 0, TRUE);
1721
1722   /* New lines handling. */
1723   TEST_MATCH("^a\\Rb$", 0, 0, "a\r\nb", -1, 0, 0, TRUE);
1724   TEST_MATCH("^a\\Rb$", 0, 0, "a\nb", -1, 0, 0, TRUE);
1725   TEST_MATCH("^a\\Rb$", 0, 0, "a\rb", -1, 0, 0, TRUE);
1726   TEST_MATCH("^a\\Rb$", 0, 0, "a\n\rb", -1, 0, 0, FALSE);
1727   TEST_MATCH("^a\\R\\Rb$", 0, 0, "a\n\rb", -1, 0, 0, TRUE);
1728   TEST_MATCH("^a\\nb$", 0, 0, "a\r\nb", -1, 0, 0, FALSE);
1729   TEST_MATCH("^a\\r\\nb$", 0, 0, "a\r\nb", -1, 0, 0, TRUE);
1730
1731   TEST_MATCH("^b$", 0, 0, "a\nb\nc", -1, 0, 0, FALSE);
1732   TEST_MATCH("^b$", G_REGEX_MULTILINE, 0, "a\nb\nc", -1, 0, 0, TRUE);
1733   TEST_MATCH("^b$", G_REGEX_MULTILINE, 0, "a\r\nb\r\nc", -1, 0, 0, TRUE);
1734   TEST_MATCH("^b$", G_REGEX_MULTILINE, 0, "a\rb\rc", -1, 0, 0, TRUE);
1735   TEST_MATCH("^b$", G_REGEX_MULTILINE | G_REGEX_NEWLINE_CR, 0, "a\nb\nc", -1, 0, 0, FALSE);
1736   TEST_MATCH("^b$", G_REGEX_MULTILINE | G_REGEX_NEWLINE_LF, 0, "a\nb\nc", -1, 0, 0, TRUE);
1737   TEST_MATCH("^b$", G_REGEX_MULTILINE | G_REGEX_NEWLINE_CRLF, 0, "a\nb\nc", -1, 0, 0, FALSE);
1738   TEST_MATCH("^b$", G_REGEX_MULTILINE | G_REGEX_NEWLINE_CR, 0, "a\r\nb\r\nc", -1, 0, 0, FALSE);
1739   TEST_MATCH("^b$", G_REGEX_MULTILINE | G_REGEX_NEWLINE_LF, 0, "a\r\nb\r\nc", -1, 0, 0, FALSE);
1740   TEST_MATCH("^b$", G_REGEX_MULTILINE | G_REGEX_NEWLINE_CRLF, 0, "a\r\nb\r\nc", -1, 0, 0, TRUE);
1741   TEST_MATCH("^b$", G_REGEX_MULTILINE | G_REGEX_NEWLINE_CR, 0, "a\rb\rc", -1, 0, 0, TRUE);
1742   TEST_MATCH("^b$", G_REGEX_MULTILINE | G_REGEX_NEWLINE_LF, 0, "a\rb\rc", -1, 0, 0, FALSE);
1743   TEST_MATCH("^b$", G_REGEX_MULTILINE | G_REGEX_NEWLINE_CRLF, 0, "a\rb\rc", -1, 0, 0, FALSE);
1744   TEST_MATCH("^b$", G_REGEX_MULTILINE, G_REGEX_MATCH_NEWLINE_CR, "a\nb\nc", -1, 0, 0, FALSE);
1745   TEST_MATCH("^b$", G_REGEX_MULTILINE, G_REGEX_MATCH_NEWLINE_LF, "a\nb\nc", -1, 0, 0, TRUE);
1746   TEST_MATCH("^b$", G_REGEX_MULTILINE, G_REGEX_MATCH_NEWLINE_CRLF, "a\nb\nc", -1, 0, 0, FALSE);
1747   TEST_MATCH("^b$", G_REGEX_MULTILINE, G_REGEX_MATCH_NEWLINE_CR, "a\r\nb\r\nc", -1, 0, 0, FALSE);
1748   TEST_MATCH("^b$", G_REGEX_MULTILINE, G_REGEX_MATCH_NEWLINE_LF, "a\r\nb\r\nc", -1, 0, 0, FALSE);
1749   TEST_MATCH("^b$", G_REGEX_MULTILINE, G_REGEX_MATCH_NEWLINE_CRLF, "a\r\nb\r\nc", -1, 0, 0, TRUE);
1750   TEST_MATCH("^b$", G_REGEX_MULTILINE, G_REGEX_MATCH_NEWLINE_CR, "a\rb\rc", -1, 0, 0, TRUE);
1751   TEST_MATCH("^b$", G_REGEX_MULTILINE, G_REGEX_MATCH_NEWLINE_LF, "a\rb\rc", -1, 0, 0, FALSE);
1752   TEST_MATCH("^b$", G_REGEX_MULTILINE, G_REGEX_MATCH_NEWLINE_CRLF, "a\rb\rc", -1, 0, 0, FALSE);
1753
1754   TEST_MATCH("^b$", G_REGEX_MULTILINE | G_REGEX_NEWLINE_CR, G_REGEX_MATCH_NEWLINE_ANY, "a\nb\nc", -1, 0, 0, TRUE);
1755   TEST_MATCH("^b$", G_REGEX_MULTILINE | G_REGEX_NEWLINE_CR, G_REGEX_MATCH_NEWLINE_ANY, "a\rb\rc", -1, 0, 0, TRUE);
1756   TEST_MATCH("^b$", G_REGEX_MULTILINE | G_REGEX_NEWLINE_CR, G_REGEX_MATCH_NEWLINE_ANY, "a\r\nb\r\nc", -1, 0, 0, TRUE);
1757   TEST_MATCH("^b$", G_REGEX_MULTILINE | G_REGEX_NEWLINE_CR, G_REGEX_MATCH_NEWLINE_LF, "a\nb\nc", -1, 0, 0, TRUE);
1758   TEST_MATCH("^b$", G_REGEX_MULTILINE | G_REGEX_NEWLINE_CR, G_REGEX_MATCH_NEWLINE_LF, "a\rb\rc", -1, 0, 0, FALSE);
1759   TEST_MATCH("^b$", G_REGEX_MULTILINE | G_REGEX_NEWLINE_CR, G_REGEX_MATCH_NEWLINE_CRLF, "a\r\nb\r\nc", -1, 0, 0, TRUE);
1760   TEST_MATCH("^b$", G_REGEX_MULTILINE | G_REGEX_NEWLINE_CR, G_REGEX_MATCH_NEWLINE_CRLF, "a\rb\rc", -1, 0, 0, FALSE);
1761
1762   TEST_MATCH("a#\nb", G_REGEX_EXTENDED, 0, "a", -1, 0, 0, FALSE);
1763   TEST_MATCH("a#\r\nb", G_REGEX_EXTENDED, 0, "a", -1, 0, 0, FALSE);
1764   TEST_MATCH("a#\rb", G_REGEX_EXTENDED, 0, "a", -1, 0, 0, FALSE);
1765   TEST_MATCH("a#\nb", G_REGEX_EXTENDED, G_REGEX_MATCH_NEWLINE_CR, "a", -1, 0, 0, FALSE);
1766   TEST_MATCH("a#\nb", G_REGEX_EXTENDED | G_REGEX_NEWLINE_CR, 0, "a", -1, 0, 0, TRUE);
1767
1768   /* TEST_MATCH_NEXT#(pattern, string, string_len, start_position, ...) */
1769   TEST_MATCH_NEXT0("a", "x", -1, 0);
1770   TEST_MATCH_NEXT0("a", "ax", -1, 1);
1771   TEST_MATCH_NEXT0("a", "xa", 1, 0);
1772   TEST_MATCH_NEXT0("a", "axa", 1, 2);
1773   TEST_MATCH_NEXT1("a", "a", -1, 0, "a", 0, 1);
1774   TEST_MATCH_NEXT1("a", "xax", -1, 0, "a", 1, 2);
1775   TEST_MATCH_NEXT1(EURO, ENG EURO, -1, 0, EURO, 2, 5);
1776   TEST_MATCH_NEXT1("a*", "", -1, 0, "", 0, 0);
1777   TEST_MATCH_NEXT2("a*", "aa", -1, 0, "aa", 0, 2, "", 2, 2);
1778   TEST_MATCH_NEXT2(EURO "*", EURO EURO, -1, 0, EURO EURO, 0, 6, "", 6, 6);
1779   TEST_MATCH_NEXT2("a", "axa", -1, 0, "a", 0, 1, "a", 2, 3);
1780   TEST_MATCH_NEXT2("a+", "aaxa", -1, 0, "aa", 0, 2, "a", 3, 4);
1781   TEST_MATCH_NEXT2("a", "aa", -1, 0, "a", 0, 1, "a", 1, 2);
1782   TEST_MATCH_NEXT2("a", "ababa", -1, 2, "a", 2, 3, "a", 4, 5);
1783   TEST_MATCH_NEXT2(EURO "+", EURO "-" EURO, -1, 0, EURO, 0, 3, EURO, 4, 7);
1784   TEST_MATCH_NEXT3("", "ab", -1, 0, "", 0, 0, "", 1, 1, "", 2, 2);
1785   TEST_MATCH_NEXT3("", AGRAVE "b", -1, 0, "", 0, 0, "", 2, 2, "", 3, 3);
1786   TEST_MATCH_NEXT3("a", "aaxa", -1, 0, "a", 0, 1, "a", 1, 2, "a", 3, 4);
1787   TEST_MATCH_NEXT3("a", "aa" OGRAVE "a", -1, 0, "a", 0, 1, "a", 1, 2, "a", 4, 5);
1788   TEST_MATCH_NEXT3("a*", "aax", -1, 0, "aa", 0, 2, "", 2, 2, "", 3, 3);
1789   TEST_MATCH_NEXT4("a*", "aaxa", -1, 0, "aa", 0, 2, "", 2, 2, "a", 3, 4, "", 4, 4);
1790
1791   /* TEST_MATCH_COUNT(pattern, string, start_position, match_opts, expected_count) */
1792   TEST_MATCH_COUNT("a", "", 0, 0, 0);
1793   TEST_MATCH_COUNT("a", "a", 0, 0, 1);
1794   TEST_MATCH_COUNT("a", "a", 1, 0, 0);
1795   TEST_MATCH_COUNT("(.)", "a", 0, 0, 2);
1796   TEST_MATCH_COUNT("(.)", EURO, 0, 0, 2);
1797   TEST_MATCH_COUNT("(?:.)", "a", 0, 0, 1);
1798   TEST_MATCH_COUNT("(?P<A>.)", "a", 0, 0, 2);
1799   TEST_MATCH_COUNT("a$", "a", 0, G_REGEX_MATCH_NOTEOL, 0);
1800   TEST_MATCH_COUNT("(a)?(b)", "b", 0, 0, 3);
1801   TEST_MATCH_COUNT("(a)?(b)", "ab", 0, 0, 3);
1802
1803   /* TEST_PARTIAL(pattern, string, expected) */
1804   TEST_PARTIAL("^ab", "a", TRUE);
1805   TEST_PARTIAL("^ab", "xa", FALSE);
1806   TEST_PARTIAL("ab", "xa", TRUE);
1807   TEST_PARTIAL("ab", "ab", FALSE); /* normal match. */
1808   TEST_PARTIAL("a+b", "aa", FALSE); /* PCRE_ERROR_BAD_PARTIAL */
1809   TEST_PARTIAL("(a)+b", "aa", TRUE);
1810   TEST_PARTIAL("a?b", "a", TRUE);
1811
1812   /* TEST_SUB_PATTERN(pattern, string, start_position, sub_n, expected_sub,
1813    *                  expected_start, expected_end) */
1814   TEST_SUB_PATTERN("a", "a", 0, 0, "a", 0, 1);
1815   TEST_SUB_PATTERN("a(.)", "ab", 0, 1, "b", 1, 2);
1816   TEST_SUB_PATTERN("a(.)", "a" EURO, 0, 1, EURO, 1, 4);
1817   TEST_SUB_PATTERN("(?:.*)(a)(.)", "xxa" ENG, 0, 2, ENG, 3, 5);
1818   TEST_SUB_PATTERN("(" HSTROKE ")", "a" HSTROKE ENG, 0, 1, HSTROKE, 1, 3);
1819   TEST_SUB_PATTERN("a", "a", 0, 1, NULL, UNTOUCHED, UNTOUCHED);
1820   TEST_SUB_PATTERN("a", "a", 0, 1, NULL, UNTOUCHED, UNTOUCHED);
1821   TEST_SUB_PATTERN("(a)?(b)", "b", 0, 0, "b", 0, 1);
1822   TEST_SUB_PATTERN("(a)?(b)", "b", 0, 1, "", -1, -1);
1823   TEST_SUB_PATTERN("(a)?(b)", "b", 0, 2, "b", 0, 1);
1824
1825   /* TEST_NAMED_SUB_PATTERN(pattern, string, start_position, sub_name,
1826    *                        expected_sub, expected_start, expected_end) */
1827   TEST_NAMED_SUB_PATTERN("a(?P<A>.)(?P<B>.)?", "ab", 0, "A", "b", 1, 2);
1828   TEST_NAMED_SUB_PATTERN("a(?P<A>.)(?P<B>.)?", "aab", 1, "A", "b", 2, 3);
1829   TEST_NAMED_SUB_PATTERN("a(?P<A>.)(?P<B>.)?", EURO "ab", 0, "A", "b", 4, 5);
1830   TEST_NAMED_SUB_PATTERN("a(?P<A>.)(?P<B>.)?", EURO "ab", 0, "B", NULL, UNTOUCHED, UNTOUCHED);
1831   TEST_NAMED_SUB_PATTERN("a(?P<A>.)(?P<B>.)?", EURO "ab", 0, "C", NULL, UNTOUCHED, UNTOUCHED);
1832   TEST_NAMED_SUB_PATTERN("a(?P<A>.)(?P<B>.)?", "a" EGRAVE "x", 0, "A", EGRAVE, 1, 3);
1833   TEST_NAMED_SUB_PATTERN("a(?P<A>.)(?P<B>.)?", "a" EGRAVE "x", 0, "B", "x", 3, 4);
1834   TEST_NAMED_SUB_PATTERN("(?P<A>a)?(?P<B>b)", "b", 0, "A", "", -1, -1);
1835   TEST_NAMED_SUB_PATTERN("(?P<A>a)?(?P<B>b)", "b", 0, "B", "b", 0, 1);
1836
1837   /* TEST_NAMED_SUB_PATTERN_DUPNAMES(pattern, string, start_position, sub_name,
1838    *                                 expected_sub, expected_start, expected_end) */
1839   TEST_NAMED_SUB_PATTERN_DUPNAMES("(?P<N>a)|(?P<N>b)", "ab", 0, "N", "a", 0, 1);
1840   TEST_NAMED_SUB_PATTERN_DUPNAMES("(?P<N>aa)|(?P<N>a)", "aa", 0, "N", "aa", 0, 2);
1841   TEST_NAMED_SUB_PATTERN_DUPNAMES("(?P<N>aa)(?P<N>a)", "aaa", 0, "N", "aa", 0, 2);
1842   TEST_NAMED_SUB_PATTERN_DUPNAMES("(?P<N>x)|(?P<N>a)", "a", 0, "N", "a", 0, 1);
1843   TEST_NAMED_SUB_PATTERN_DUPNAMES("(?P<N>x)y|(?P<N>a)b", "ab", 0, "N", "a", 0, 1);
1844
1845   /* DUPNAMES option inside the pattern */
1846   TEST_NAMED_SUB_PATTERN("(?J)(?P<N>a)|(?P<N>b)", "ab", 0, "N", "a", 0, 1);
1847   TEST_NAMED_SUB_PATTERN("(?J)(?P<N>aa)|(?P<N>a)", "aa", 0, "N", "aa", 0, 2);
1848   TEST_NAMED_SUB_PATTERN("(?J)(?P<N>aa)(?P<N>a)", "aaa", 0, "N", "aa", 0, 2);
1849   TEST_NAMED_SUB_PATTERN("(?J)(?P<N>x)|(?P<N>a)", "a", 0, "N", "a", 0, 1);
1850   TEST_NAMED_SUB_PATTERN("(?J)(?P<N>x)y|(?P<N>a)b", "ab", 0, "N", "a", 0, 1);
1851
1852   /* TEST_FETCH_ALL#(pattern, string, ...) */
1853   TEST_FETCH_ALL0("a", "");
1854   TEST_FETCH_ALL0("a", "b");
1855   TEST_FETCH_ALL1("a", "a", "a");
1856   TEST_FETCH_ALL1("a+", "aa", "aa");
1857   TEST_FETCH_ALL1("(?:a)", "a", "a");
1858   TEST_FETCH_ALL2("(a)", "a", "a", "a");
1859   TEST_FETCH_ALL2("a(.)", "ab", "ab", "b");
1860   TEST_FETCH_ALL2("a(.)", "a" HSTROKE, "a" HSTROKE, HSTROKE);
1861   TEST_FETCH_ALL3("(?:.*)(a)(.)", "xyazk", "xyaz", "a", "z");
1862   TEST_FETCH_ALL3("(?P<A>.)(a)", "xa", "xa", "x", "a");
1863   TEST_FETCH_ALL3("(?P<A>.)(a)", ENG "a", ENG "a", ENG, "a");
1864   TEST_FETCH_ALL3("(a)?(b)", "b", "b", "", "b");
1865   TEST_FETCH_ALL3("(a)?(b)", "ab", "ab", "a", "b");
1866
1867   /* TEST_SPLIT_SIMPLE#(pattern, string, ...) */
1868   TEST_SPLIT_SIMPLE0("", "");
1869   TEST_SPLIT_SIMPLE0("a", "");
1870   TEST_SPLIT_SIMPLE1(",", "a", "a");
1871   TEST_SPLIT_SIMPLE1("(,)\\s*", "a", "a");
1872   TEST_SPLIT_SIMPLE2(",", "a,b", "a", "b");
1873   TEST_SPLIT_SIMPLE3(",", "a,b,c", "a", "b", "c");
1874   TEST_SPLIT_SIMPLE3(",\\s*", "a,b,c", "a", "b", "c");
1875   TEST_SPLIT_SIMPLE3(",\\s*", "a, b, c", "a", "b", "c");
1876   TEST_SPLIT_SIMPLE3("(,)\\s*", "a,b", "a", ",", "b");
1877   TEST_SPLIT_SIMPLE3("(,)\\s*", "a, b", "a", ",", "b");
1878   /* Not matched sub-strings. */
1879   TEST_SPLIT_SIMPLE2("a|(b)", "xay", "x", "y");
1880   TEST_SPLIT_SIMPLE3("a|(b)", "xby", "x", "b", "y");
1881   /* Empty matches. */
1882   TEST_SPLIT_SIMPLE3("", "abc", "a", "b", "c");
1883   TEST_SPLIT_SIMPLE3(" *", "ab c", "a", "b", "c");
1884   /* Invalid patterns. */
1885   TEST_SPLIT_SIMPLE0("\\", "");
1886   TEST_SPLIT_SIMPLE0("[", "");
1887
1888   /* TEST_SPLIT#(pattern, string, start_position, max_tokens, ...) */
1889   TEST_SPLIT0("", "", 0, 0);
1890   TEST_SPLIT0("a", "", 0, 0);
1891   TEST_SPLIT0("a", "", 0, 1);
1892   TEST_SPLIT0("a", "", 0, 2);
1893   TEST_SPLIT0("a", "a", 1, 0);
1894   TEST_SPLIT1(",", "a", 0, 0, "a");
1895   TEST_SPLIT1(",", "a,b", 0, 1, "a,b");
1896   TEST_SPLIT1("(,)\\s*", "a", 0, 0, "a");
1897   TEST_SPLIT1(",", "a,b", 2, 0, "b");
1898   TEST_SPLIT2(",", "a,b", 0, 0, "a", "b");
1899   TEST_SPLIT2(",", "a,b,c", 0, 2, "a", "b,c");
1900   TEST_SPLIT2(",", "a,b", 1, 0, "", "b");
1901   TEST_SPLIT2(",", "a,", 0, 0, "a", "");
1902   TEST_SPLIT3(",", "a,b,c", 0, 0, "a", "b", "c");
1903   TEST_SPLIT3(",\\s*", "a,b,c", 0, 0, "a", "b", "c");
1904   TEST_SPLIT3(",\\s*", "a, b, c", 0, 0, "a", "b", "c");
1905   TEST_SPLIT3("(,)\\s*", "a,b", 0, 0, "a", ",", "b");
1906   TEST_SPLIT3("(,)\\s*", "a, b", 0, 0, "a", ",", "b");
1907   /* Not matched sub-strings. */
1908   TEST_SPLIT2("a|(b)", "xay", 0, 0, "x", "y");
1909   TEST_SPLIT3("a|(b)", "xby", 0, -1, "x", "b", "y");
1910   /* Empty matches. */
1911   TEST_SPLIT2(" *", "ab c", 1, 0, "b", "c");
1912   TEST_SPLIT3("", "abc", 0, 0, "a", "b", "c");
1913   TEST_SPLIT3(" *", "ab c", 0, 0, "a", "b", "c");
1914   TEST_SPLIT1(" *", "ab c", 0, 1, "ab c");
1915   TEST_SPLIT2(" *", "ab c", 0, 2, "a", "b c");
1916   TEST_SPLIT3(" *", "ab c", 0, 3, "a", "b", "c");
1917   TEST_SPLIT3(" *", "ab c", 0, 4, "a", "b", "c");
1918
1919   /* TEST_CHECK_REPLACEMENT(string_to_expand, expected, expected_refs) */
1920   TEST_CHECK_REPLACEMENT("", TRUE, FALSE);
1921   TEST_CHECK_REPLACEMENT("a", TRUE, FALSE);
1922   TEST_CHECK_REPLACEMENT("\\t\\n\\v\\r\\f\\a\\b\\\\\\x{61}", TRUE, FALSE);
1923   TEST_CHECK_REPLACEMENT("\\0", TRUE, TRUE);
1924   TEST_CHECK_REPLACEMENT("\\n\\2", TRUE, TRUE);
1925   TEST_CHECK_REPLACEMENT("\\g<foo>", TRUE, TRUE);
1926   /* Invalid strings */
1927   TEST_CHECK_REPLACEMENT("\\Q", FALSE, FALSE);
1928   TEST_CHECK_REPLACEMENT("x\\Ay", FALSE, FALSE);
1929
1930   /* TEST_EXPAND(pattern, string, string_to_expand, raw, expected) */
1931   TEST_EXPAND("a", "a", "", FALSE, "");
1932   TEST_EXPAND("a", "a", "\\0", FALSE, "a");
1933   TEST_EXPAND("a", "a", "\\1", FALSE, "");
1934   TEST_EXPAND("(a)", "ab", "\\1", FALSE, "a");
1935   TEST_EXPAND("(a)", "a", "\\1", FALSE, "a");
1936   TEST_EXPAND("(a)", "a", "\\g<1>", FALSE, "a");
1937   TEST_EXPAND("a", "a", "\\0130", FALSE, "X");
1938   TEST_EXPAND("a", "a", "\\\\\\0", FALSE, "\\a");
1939   TEST_EXPAND("a(?P<G>.)c", "xabcy", "X\\g<G>X", FALSE, "XbX");
1940   TEST_EXPAND("(.)(?P<1>.)", "ab", "\\1", FALSE, "a");
1941   TEST_EXPAND("(.)(?P<1>.)", "ab", "\\g<1>", FALSE, "a");
1942   TEST_EXPAND(".", EURO, "\\0", FALSE, EURO);
1943   TEST_EXPAND("(.)", EURO, "\\1", FALSE, EURO);
1944   TEST_EXPAND("(?P<G>.)", EURO, "\\g<G>", FALSE, EURO);
1945   TEST_EXPAND(".", "a", EURO, FALSE, EURO);
1946   TEST_EXPAND(".", "a", EURO "\\0", FALSE, EURO "a");
1947   TEST_EXPAND(".", "", "\\Lab\\Ec", FALSE, "abc");
1948   TEST_EXPAND(".", "", "\\LaB\\EC", FALSE, "abC");
1949   TEST_EXPAND(".", "", "\\Uab\\Ec", FALSE, "ABc");
1950   TEST_EXPAND(".", "", "a\\ubc", FALSE, "aBc");
1951   TEST_EXPAND(".", "", "a\\lbc", FALSE, "abc");
1952   TEST_EXPAND(".", "", "A\\uBC", FALSE, "ABC");
1953   TEST_EXPAND(".", "", "A\\lBC", FALSE, "AbC");
1954   TEST_EXPAND(".", "", "A\\l\\\\BC", FALSE, "A\\BC");
1955   TEST_EXPAND(".", "", "\\L" AGRAVE "\\E", FALSE, AGRAVE);
1956   TEST_EXPAND(".", "", "\\U" AGRAVE "\\E", FALSE, AGRAVE_UPPER);
1957   TEST_EXPAND(".", "", "\\u" AGRAVE "a", FALSE, AGRAVE_UPPER "a");
1958   TEST_EXPAND(".", "ab", "x\\U\\0y\\Ez", FALSE, "xAYz");
1959   TEST_EXPAND(".(.)", "AB", "x\\L\\1y\\Ez", FALSE, "xbyz");
1960   TEST_EXPAND(".", "ab", "x\\u\\0y\\Ez", FALSE, "xAyz");
1961   TEST_EXPAND(".(.)", "AB", "x\\l\\1y\\Ez", FALSE, "xbyz");
1962   TEST_EXPAND(".(.)", "a" AGRAVE_UPPER, "x\\l\\1y", FALSE, "x" AGRAVE "y");
1963   TEST_EXPAND("a", "bab", "\\x{61}", FALSE, "a");
1964   TEST_EXPAND("a", "bab", "\\x61", FALSE, "a");
1965   TEST_EXPAND("a", "bab", "\\x5a", FALSE, "Z");
1966   TEST_EXPAND("a", "bab", "\\0\\x5A", FALSE, "aZ");
1967   TEST_EXPAND("a", "bab", "\\1\\x{5A}", FALSE, "Z");
1968   TEST_EXPAND("a", "bab", "\\x{00E0}", FALSE, AGRAVE);
1969   TEST_EXPAND("", "bab", "\\x{0634}", FALSE, SHEEN);
1970   TEST_EXPAND("", "bab", "\\x{634}", FALSE, SHEEN);
1971   TEST_EXPAND("", "", "\\t", FALSE, "\t");
1972   TEST_EXPAND("", "", "\\v", FALSE, "\v");
1973   TEST_EXPAND("", "", "\\r", FALSE, "\r");
1974   TEST_EXPAND("", "", "\\n", FALSE, "\n");
1975   TEST_EXPAND("", "", "\\f", FALSE, "\f");
1976   TEST_EXPAND("", "", "\\a", FALSE, "\a");
1977   TEST_EXPAND("", "", "\\b", FALSE, "\b");
1978   TEST_EXPAND("a(.)", "abc", "\\0\\b\\1", FALSE, "ab\bb");
1979   TEST_EXPAND("a(.)", "abc", "\\0141", FALSE, "a");
1980   TEST_EXPAND("a(.)", "abc", "\\078", FALSE, "\a8");
1981   TEST_EXPAND("a(.)", "abc", "\\077", FALSE, "?");
1982   TEST_EXPAND("a(.)", "abc", "\\0778", FALSE, "?8");
1983   TEST_EXPAND("a(.)", "a" AGRAVE "b", "\\1", FALSE, AGRAVE);
1984   TEST_EXPAND("a(.)", "a" AGRAVE "b", "\\1", TRUE, "\xc3");
1985   TEST_EXPAND("a(.)", "a" AGRAVE "b", "\\0", TRUE, "a\xc3");
1986   /* Invalid strings. */
1987   TEST_EXPAND("", "", "\\Q", FALSE, NULL);
1988   TEST_EXPAND("", "", "x\\Ay", FALSE, NULL);
1989   TEST_EXPAND("", "", "\\g<", FALSE, NULL);
1990   TEST_EXPAND("", "", "\\g<>", FALSE, NULL);
1991   TEST_EXPAND("", "", "\\g<1a>", FALSE, NULL);
1992   TEST_EXPAND("", "", "\\g<a$>", FALSE, NULL);
1993   TEST_EXPAND("", "", "\\", FALSE, NULL);
1994   TEST_EXPAND("a", "a", "\\x{61", FALSE, NULL);
1995   TEST_EXPAND("a", "a", "\\x6X", FALSE, NULL);
1996   /* Pattern-less. */
1997   TEST_EXPAND(NULL, NULL, "", FALSE, "");
1998   TEST_EXPAND(NULL, NULL, "\\n", FALSE, "\n");
1999   /* Invalid strings */
2000   TEST_EXPAND(NULL, NULL, "\\Q", FALSE, NULL);
2001   TEST_EXPAND(NULL, NULL, "x\\Ay", FALSE, NULL);
2002
2003   /* TEST_REPLACE(pattern, string, start_position, replacement, expected) */
2004   TEST_REPLACE("a", "ababa", 0, "A", "AbAbA");
2005   TEST_REPLACE("a", "ababa", 1, "A", "abAbA");
2006   TEST_REPLACE("a", "ababa", 2, "A", "abAbA");
2007   TEST_REPLACE("a", "ababa", 3, "A", "ababA");
2008   TEST_REPLACE("a", "ababa", 4, "A", "ababA");
2009   TEST_REPLACE("a", "ababa", 5, "A", "ababa");
2010   TEST_REPLACE("a", "ababa", 6, "A", "ababa");
2011   TEST_REPLACE("a", "abababa", 2, "A", "abAbAbA");
2012   TEST_REPLACE("a", "abab", 0, "A", "AbAb");
2013   TEST_REPLACE("a", "baba", 0, "A", "bAbA");
2014   TEST_REPLACE("a", "bab", 0, "A", "bAb");
2015   TEST_REPLACE("$^", "abc", 0, "X", "abc");
2016   TEST_REPLACE("(.)a", "ciao", 0, "a\\1", "caio");
2017   TEST_REPLACE("a.", "abc", 0, "\\0\\0", "ababc");
2018   TEST_REPLACE("a", "asd", 0, "\\0101", "Asd");
2019   TEST_REPLACE("(a).\\1", "aba cda", 0, "\\1\\n", "a\n cda");
2020   TEST_REPLACE("a" AGRAVE "a", "a" AGRAVE "a", 0, "x", "x");
2021   TEST_REPLACE("a" AGRAVE "a", "a" AGRAVE "a", 0, OGRAVE, OGRAVE);
2022   TEST_REPLACE("[^-]", "-" EURO "-x-" HSTROKE, 0, "a", "-a-a-a");
2023   TEST_REPLACE("[^-]", "-" EURO "-" HSTROKE, 0, "a\\g<0>a", "-a" EURO "a-a" HSTROKE "a");
2024   TEST_REPLACE("-", "-" EURO "-" HSTROKE, 0, "", EURO HSTROKE);
2025   TEST_REPLACE(".*", "hello", 0, "\\U\\0\\E", "HELLO");
2026   TEST_REPLACE(".*", "hello", 0, "\\u\\0", "Hello");
2027   TEST_REPLACE("\\S+", "hello world", 0, "\\U-\\0-", "-HELLO- -WORLD-");
2028   TEST_REPLACE(".", "a", 0, "\\A", NULL);
2029   TEST_REPLACE(".", "a", 0, "\\g", NULL);
2030
2031   /* TEST_REPLACE_LIT(pattern, string, start_position, replacement, expected) */
2032   TEST_REPLACE_LIT("a", "ababa", 0, "A", "AbAbA");
2033   TEST_REPLACE_LIT("a", "ababa", 1, "A", "abAbA");
2034   TEST_REPLACE_LIT("a", "ababa", 2, "A", "abAbA");
2035   TEST_REPLACE_LIT("a", "ababa", 3, "A", "ababA");
2036   TEST_REPLACE_LIT("a", "ababa", 4, "A", "ababA");
2037   TEST_REPLACE_LIT("a", "ababa", 5, "A", "ababa");
2038   TEST_REPLACE_LIT("a", "ababa", 6, "A", "ababa");
2039   TEST_REPLACE_LIT("a", "abababa", 2, "A", "abAbAbA");
2040   TEST_REPLACE_LIT("a", "abcadaa", 0, "A", "AbcAdAA");
2041   TEST_REPLACE_LIT("$^", "abc", 0, "X", "abc");
2042   TEST_REPLACE_LIT("(.)a", "ciao", 0, "a\\1", "ca\\1o");
2043   TEST_REPLACE_LIT("a.", "abc", 0, "\\0\\0\\n", "\\0\\0\\nc");
2044   TEST_REPLACE_LIT("a" AGRAVE "a", "a" AGRAVE "a", 0, "x", "x");
2045   TEST_REPLACE_LIT("a" AGRAVE "a", "a" AGRAVE "a", 0, OGRAVE, OGRAVE);
2046   TEST_REPLACE_LIT(AGRAVE, "-" AGRAVE "-" HSTROKE, 0, "a" ENG "a", "-a" ENG "a-" HSTROKE);
2047   TEST_REPLACE_LIT("[^-]", "-" EURO "-" AGRAVE "-" HSTROKE, 0, "a", "-a-a-a");
2048   TEST_REPLACE_LIT("[^-]", "-" EURO "-" AGRAVE, 0, "a\\g<0>a", "-a\\g<0>a-a\\g<0>a");
2049   TEST_REPLACE_LIT("-", "-" EURO "-" AGRAVE "-" HSTROKE, 0, "", EURO AGRAVE HSTROKE);
2050
2051   /* TEST_GET_STRING_NUMBER(pattern, name, expected_num) */
2052   TEST_GET_STRING_NUMBER("", "A", -1);
2053   TEST_GET_STRING_NUMBER("(?P<A>.)", "A", 1);
2054   TEST_GET_STRING_NUMBER("(?P<A>.)", "B", -1);
2055   TEST_GET_STRING_NUMBER("(?P<A>.)(?P<B>a)", "A", 1);
2056   TEST_GET_STRING_NUMBER("(?P<A>.)(?P<B>a)", "B", 2);
2057   TEST_GET_STRING_NUMBER("(?P<A>.)(?P<B>a)", "C", -1);
2058   TEST_GET_STRING_NUMBER("(?P<A>.)(.)(?P<B>a)", "A", 1);
2059   TEST_GET_STRING_NUMBER("(?P<A>.)(.)(?P<B>a)", "B", 3);
2060   TEST_GET_STRING_NUMBER("(?P<A>.)(.)(?P<B>a)", "C", -1);
2061   TEST_GET_STRING_NUMBER("(?:a)(?P<A>.)", "A", 1);
2062   TEST_GET_STRING_NUMBER("(?:a)(?P<A>.)", "B", -1);
2063
2064   /* TEST_ESCAPE(string, length, expected) */
2065   TEST_ESCAPE("hello world", -1, "hello world");
2066   TEST_ESCAPE("hello world", 5, "hello");
2067   TEST_ESCAPE("hello.world", -1, "hello\\.world");
2068   TEST_ESCAPE("a(b\\b.$", -1, "a\\(b\\\\b\\.\\$");
2069   TEST_ESCAPE("hello\0world", -1, "hello");
2070   TEST_ESCAPE("hello\0world", 11, "hello\\0world");
2071   TEST_ESCAPE(EURO "*" ENG, -1, EURO "\\*" ENG);
2072   TEST_ESCAPE("a$", -1, "a\\$");
2073   TEST_ESCAPE("$a", -1, "\\$a");
2074   TEST_ESCAPE("a$a", -1, "a\\$a");
2075   TEST_ESCAPE("$a$", -1, "\\$a\\$");
2076   TEST_ESCAPE("$a$", 0, "");
2077   TEST_ESCAPE("$a$", 1, "\\$");
2078   TEST_ESCAPE("$a$", 2, "\\$a");
2079   TEST_ESCAPE("$a$", 3, "\\$a\\$");
2080   TEST_ESCAPE("$a$", 4, "\\$a\\$\\0");
2081   TEST_ESCAPE("|()[]{}^$*+?.", -1, "\\|\\(\\)\\[\\]\\{\\}\\^\\$\\*\\+\\?\\.");
2082   TEST_ESCAPE("a|a(a)a[a]a{a}a^a$a*a+a?a.a", -1,
2083               "a\\|a\\(a\\)a\\[a\\]a\\{a\\}a\\^a\\$a\\*a\\+a\\?a\\.a");
2084
2085   /* TEST_MATCH_ALL#(pattern, string, string_len, start_position, ...) */
2086   TEST_MATCH_ALL0("<.*>", "", -1, 0);
2087   TEST_MATCH_ALL0("a+", "", -1, 0);
2088   TEST_MATCH_ALL0("a+", "a", 0, 0);
2089   TEST_MATCH_ALL0("a+", "a", -1, 1);
2090   TEST_MATCH_ALL1("<.*>", "<a>", -1, 0, "<a>", 0, 3);
2091   TEST_MATCH_ALL1("a+", "a", -1, 0, "a", 0, 1);
2092   TEST_MATCH_ALL1("a+", "aa", 1, 0, "a", 0, 1);
2093   TEST_MATCH_ALL1("a+", "aa", -1, 1, "a", 1, 2);
2094   TEST_MATCH_ALL1("a+", "aa", 2, 1, "a", 1, 2);
2095   TEST_MATCH_ALL1(".+", ENG, -1, 0, ENG, 0, 2);
2096   TEST_MATCH_ALL2("<.*>", "<a><b>", -1, 0, "<a><b>", 0, 6, "<a>", 0, 3);
2097   TEST_MATCH_ALL2("a+", "aa", -1, 0, "aa", 0, 2, "a", 0, 1);
2098   TEST_MATCH_ALL2(".+", ENG EURO, -1, 0, ENG EURO, 0, 5, ENG, 0, 2);
2099   TEST_MATCH_ALL3("<.*>", "<a><b><c>", -1, 0, "<a><b><c>", 0, 9,
2100                   "<a><b>", 0, 6, "<a>", 0, 3);
2101   TEST_MATCH_ALL3("a+", "aaa", -1, 0, "aaa", 0, 3, "aa", 0, 2, "a", 0, 1);
2102
2103 end: /* if abort_on_fail is TRUE the flow passes to this label. */
2104   verbose ("\n%u tests passed, %u failed\n", passed, failed);
2105   return failed;
2106 }
2107
2108 #else /* ENABLE_REGEX false */
2109
2110 int
2111 main (int argc, char *argv[])
2112 {
2113   g_print ("GRegex is disabled.\n");
2114   return 0;
2115 }
2116
2117 #endif /* ENABLE_REGEX */