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