Symaptic: os/ossrv/glib/tests/regex-test.c@260cb5ec6c19

     1 /*

     2  * Copyright (C) 2005 - 2006, Marco Barisione <marco@barisione.org>

     3  * Portions copyright (c) 2009 Nokia Corporation.  All rights reserved.

     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  */

    20 #undef G_DISABLE_ASSERT

    21 #undef G_LOG_DOMAIN

    22 #define ENABLE_REGEX

    23 #include <string.h>

    24 #include <locale.h>

    25 #include "glib.h"

    26 #ifdef __SYMBIAN32__

    27 #include "mrt2_glib2_test.h"

    28 #endif /*__SYMBIAN32__*/

    29 #ifdef ENABLE_REGEX

    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"

    50 /* A random value use to mark untouched integer variables. */

    51 #define UNTOUCHED -559038737

    53 static gboolean noisy = FALSE;

    54 static gboolean abort_on_fail = FALSE;

    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

    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 }

    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;

    87   va_start (args, format);

    88   msg = g_strdup_vprintf (format, args);

    89   va_end (args);

    91   if (noisy)

    92     g_print ("%s", msg);

    93   g_free (msg);

    94 }

    96 static gboolean

    97 test_new (const gchar        *pattern,

    98 	  GRegexCompileFlags  compile_opts,

    99 	  GRegexMatchFlags    match_opts)

   100 {

   101   GRegex *regex;

   103   verbose ("compiling \"%s\" \t", pattern);

   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     }

   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     }

   121   g_regex_unref (regex);

   123   verbose ("passed\n");

   124   return TRUE;

   125 }

   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 }

   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;

   143   verbose ("compiling \"%s\" (expected a failure) \t", pattern);

   145   regex = g_regex_new (pattern, compile_opts, 0, &error);

   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     }

   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     }

   164   verbose ("passed\n");

   165   return TRUE;

   166 }

   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 }

   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;

   185   verbose ("matching \"%s\" against \"%s\" \t", string, pattern);

   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 }

   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 }

   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;

   221   verbose ("matching \"%s\" against \"%s\" (start: %d, len: %d) \t",

   222 	   string, pattern, start_position, string_len);

   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     }

   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     }

   250   g_regex_unref (regex);

   252   verbose ("passed (%s)\n", match ? "match" : "nomatch");

   253   return TRUE;

   254 }

   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 }

   266 struct _Match

   267 {

   268   gchar *string;

   269   gint start, end;

   270 };

   271 typedef struct _Match Match;

   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 }

   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;

   298   verbose ("matching \"%s\" against \"%s\" (start: %d, len: %d) \t",

   299 	   string, pattern, start_position, string_len);

   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);

   319   regex = g_regex_new (pattern, 0, 0, NULL);

   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);

   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     }

   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;

   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 	}

   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 	}

   371       l_exp = g_slist_next (l_exp);

   372       l_match = g_slist_next (l_match);

   373     }

   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     }

   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);

   388   return ret;

   389 }

   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 }

   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 }

   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 }

   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 }

   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 }

   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;

   450   verbose ("fetching match count (string: \"%s\", pattern: \"%s\", start: %d) \t",

   451 	   string, pattern, start_position);

   453   regex = g_regex_new (pattern, 0, 0, NULL);

   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);

   459   if (count != expected_count)

   460     {

   461       g_print ("failed \t(got %d, expected: %d)\n", count, expected_count);

   462       return FALSE;

   463     }

   465   g_match_info_free (match_info);

   466   g_regex_unref (regex);

   468   verbose ("passed\n");

   469   return TRUE;

   470 }

   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 }

   480 static gboolean

   481 test_partial (const gchar *pattern,

   482 	      const gchar *string,

   483 	      gboolean     expected)

   484 {

   485   GRegex *regex;

   486   GMatchInfo *match_info;

   488   verbose ("partial matching (string: \"%s\", pattern: \"%s\") \t",

   489 	   string, pattern);

   491   regex = g_regex_new (pattern, 0, 0, NULL);

   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     }

   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     }

   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     }

   515   g_match_info_free (match_info);

   516   g_regex_unref (regex);

   518   verbose ("passed\n");

   519   return TRUE;

   520 }

   522 #define TEST_PARTIAL(pattern, string, expected) { \

   523   total++; \

   524   if (test_partial (pattern, string, expected)) \

   525     PASS; \

   526   else \

   527     FAIL; \

   528 }

   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;

   544   verbose ("fetching sub-pattern %d from \"%s\" (pattern: \"%s\") \t",

   545 	   sub_n, string, pattern);

   547   regex = g_regex_new (pattern, 0, 0, NULL);

   548   g_regex_match_full (regex, string, -1, start_position, 0, &match_info, NULL);

   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);

   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     }

   570   g_match_info_free (match_info);

   571   g_regex_unref (regex);

   573   verbose ("passed\n");

   574   return TRUE;

   575 }

   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 }

   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;

   602   verbose ("fetching sub-pattern \"%s\" from \"%s\" (pattern: \"%s\") \t",

   603 	   sub_name, string, pattern);

   605   regex = g_regex_new (pattern, flags, 0, NULL);

   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);

   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     }

   628   g_match_info_free (match_info);

   629   g_regex_unref (regex);

   631   verbose ("passed\n");

   632   return TRUE;

   633 }

   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 }

   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 }

   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;

   670   verbose ("fetching all sub-patterns from \"%s\" (pattern: \"%s\") \t",

   671 	   string, pattern);

   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);

   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;

   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     }

   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     }

   715   verbose ("passed (%d %s)\n", match_count,

   716 	   match_count == 1 ? "match" : "matches");

   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);

   725   return ret;

   726 }

   728 #define TEST_FETCH_ALL0(pattern, string) { \

   729   total++; \

   730   if (test_fetch_all (pattern, string, NULL)) \

   731     PASS; \

   732   else \

   733     FAIL; \

   734 }

   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 }

   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 }

   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 }

   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;

   773   verbose ("splitting \"%s\" against \"%s\" \t", string, pattern);

   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);

   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;

   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     }

   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     }

   815   verbose ("passed (%d %s)\n", token_count,

   816 	   token_count == 1 ? "token" : "tokens");

   818 exit:

   819   g_slist_foreach (expected, (GFunc)g_free, NULL);

   820   g_slist_free (expected);

   821   g_strfreev (tokens);

   823   return ret;

   824 }

   826 #define TEST_SPLIT_SIMPLE0(pattern, string) { \

   827   total++; \

   828   if (test_split_simple (pattern, string, NULL)) \

   829     PASS; \

   830   else \

   831     FAIL; \

   832 }

   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 }

   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 }

   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 }

   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;

   874   verbose ("splitting \"%s\" against \"%s\" (start: %d, max: %d) \t",

   875 	   string, pattern, start_position, max_tokens);

   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);

   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;

   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     }

   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     }

   919   verbose ("passed (%d %s)\n", token_count,

   920 	   token_count == 1 ? "token" : "tokens");

   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);

   928   return ret;

   929 }

   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;

   945   verbose ("splitting \"%s\" against \"%s\" \t", string, pattern);

   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);

   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;

   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     }

   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     }

   988   verbose ("passed (%d %s)\n", token_count,

   989 	   token_count == 1 ? "token" : "tokens");

   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);

   997   return ret;

   998 }

  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 }

  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 }

  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 }

  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 }

  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;

  1072   verbose ("checking replacement string \"%s\" \t", string_to_expand);

  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     }

  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     }

  1091   verbose ("passed\n");

  1092   return TRUE;

  1093 }

  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;

  1113   verbose ("expanding the references in \"%s\" (pattern: \"%s\", string: \"%s\") \t",

  1114 	   string_to_expand,

  1115 	   pattern ? pattern : "(null)",

  1116 	   string ? string : "(null)");

  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     }

  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     }

  1134   g_free (res);

  1135   g_match_info_free (match_info);

  1136   if (regex)

  1137     g_regex_unref (regex);

  1139   verbose ("passed\n");

  1140   return TRUE;

  1141 }

  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 }

  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;

  1161   verbose ("replacing \"%s\" in \"%s\" (pattern: \"%s\", start: %d) \t",

  1162 	   replacement, string, pattern, start_position);

  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     }

  1174   g_free (res);

  1175   g_regex_unref (regex);

  1177   verbose ("passed\n");

  1178   return TRUE;

  1179 }

  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 }

  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;

  1199   verbose ("replacing literally \"%s\" in \"%s\" (pattern: \"%s\", start: %d) \t",

  1200 	   replacement, string, pattern, start_position);

  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     }

  1213   g_free (res);

  1214   g_regex_unref (regex);

  1216   verbose ("passed\n");

  1217   return TRUE;

  1218 }

  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 }

  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;

  1236   verbose ("getting the number of \"%s\" (pattern: \"%s\") \t",

  1237 	   name, pattern);

  1239   regex = g_regex_new (pattern, 0, 0, NULL);

  1240   num = g_regex_get_string_number (regex, name);

  1241   g_regex_unref (regex);

  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 }

  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 }

  1263 static gboolean

  1264 test_escape (const gchar *string,

  1265 	     gint         length,

  1266 	     const gchar *expected)

  1267 {

  1268   gchar *escaped;

  1270   verbose ("escaping \"%s\" (len: %d) \t", string, length);

  1272   escaped = g_regex_escape_string (string, length);

  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     }

  1281   g_free (escaped);

  1283   verbose ("passed\n");

  1284   return TRUE;

  1285 }

  1287 #define TEST_ESCAPE(string, length, expected) { \

  1288   total++; \

  1289   if (test_escape (string, length, expected)) \

  1290     PASS; \

  1291   else \

  1292     FAIL; \

  1293 }

  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;

  1312   verbose ("matching all in \"%s\" against \"%s\" (start: %d, len: %d) \t",

  1313 	   string, pattern, start_position, string_len);

  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);

  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);

  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     }

  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     }

  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;

  1367       matched_string = g_match_info_fetch (match_info, i);

  1368       g_match_info_fetch_pos (match_info, i, &start, &end);

  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);

  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 	}

  1388       l_exp = g_slist_next (l_exp);

  1389     }

  1391 exit:

  1392   if (ret)

  1393     {

  1394       verbose ("passed (%d %s)\n", match_count, match_count == 1 ? "match" : "matches");

  1395     }

  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);

  1402   return ret;

  1403 }

  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;

  1420   verbose ("matching all in \"%s\" against \"%s\" \t", string, pattern);

  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);

  1440   regex = g_regex_new (pattern, 0, 0, NULL);

  1441   match_ok = g_regex_match_all (regex, string, 0, &match_info);

  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     }

  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     }

  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;

  1473       matched_string = g_match_info_fetch (match_info, i);

  1474       g_match_info_fetch_pos (match_info, i, &start, &end);

  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);

  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 	}

  1494       l_exp = g_slist_next (l_exp);

  1495     }

  1497 exit:

  1498   if (ret)

  1499     {

  1500       verbose ("passed (%d %s)\n", match_count, match_count == 1 ? "match" : "matches");

  1501     }

  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);

  1508   return ret;

  1509 }

  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 }

  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 }

  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 }

  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 }

  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 #ifdef __SYMBIAN32__

  1589   g_log_set_handler (NULL,  G_LOG_FLAG_FATAL| G_LOG_FLAG_RECURSION | G_LOG_LEVEL_CRITICAL | G_LOG_LEVEL_WARNING | G_LOG_LEVEL_MESSAGE | G_LOG_LEVEL_INFO | G_LOG_LEVEL_DEBUG, &mrtLogHandler, NULL);

  1590   g_set_print_handler(mrtPrintHandler);

  1591   #endif /*__SYMBIAN32__*/

  1592   setlocale (LC_ALL, "");

  1594   for (i = 1; i < argc; i++)

  1595     {

  1596       if (streq ("-noisy", argv[i]))

  1597 	noisy = TRUE;

  1598       else if (streq ("-abort", argv[i]))

  1599 	abort_on_fail = TRUE;

  1600     }

  1602   g_setenv ("G_DEBUG", "fatal_warnings", TRUE);

  1604   /* TEST_NEW(pattern, compile_opts, match_opts) */

  1605   TEST_NEW("", 0, 0);

  1606   TEST_NEW(".*", 0, 0);

  1607   TEST_NEW(".*", G_REGEX_OPTIMIZE, 0);

  1608   TEST_NEW(".*", G_REGEX_MULTILINE, 0);

  1609   TEST_NEW(".*", G_REGEX_DOTALL, 0);

  1610   TEST_NEW(".*", G_REGEX_DOTALL, G_REGEX_MATCH_NOTBOL);

  1611   TEST_NEW("(123\\d*)[a-zA-Z]+(?P<hello>.*)", 0, 0);

  1612   TEST_NEW("(123\\d*)[a-zA-Z]+(?P<hello>.*)", G_REGEX_CASELESS, 0);

  1613   TEST_NEW("(123\\d*)[a-zA-Z]+(?P<hello>.*)", G_REGEX_CASELESS | G_REGEX_OPTIMIZE, 0);

  1614   TEST_NEW("(?P<A>x)|(?P<A>y)", G_REGEX_DUPNAMES, 0);

  1615   TEST_NEW("(?P<A>x)|(?P<A>y)", G_REGEX_DUPNAMES | G_REGEX_OPTIMIZE, 0);

  1616   /* This gives "internal error: code overflow" with pcre 6.0 */

  1617   TEST_NEW("(?i)(?-i)", 0, 0);

  1619   /* TEST_NEW_FAIL(pattern, compile_opts, expected_error) */

  1620   TEST_NEW_FAIL("(", 0, G_REGEX_ERROR_UNMATCHED_PARENTHESIS);

  1621   TEST_NEW_FAIL(")", 0, G_REGEX_ERROR_UNMATCHED_PARENTHESIS);

  1622   TEST_NEW_FAIL("[", 0, G_REGEX_ERROR_UNTERMINATED_CHARACTER_CLASS);

  1623   TEST_NEW_FAIL("*", 0, G_REGEX_ERROR_NOTHING_TO_REPEAT);

  1624   TEST_NEW_FAIL("?", 0, G_REGEX_ERROR_NOTHING_TO_REPEAT);

  1625   TEST_NEW_FAIL("(?P<A>x)|(?P<A>y)", 0, G_REGEX_ERROR_DUPLICATE_SUBPATTERN_NAME);

  1627   /* TEST_MATCH_SIMPLE(pattern, string, compile_opts, match_opts, expected) */

  1628   TEST_MATCH_SIMPLE("a", "", 0, 0, FALSE);

  1629   TEST_MATCH_SIMPLE("a", "a", 0, 0, TRUE);

  1630   TEST_MATCH_SIMPLE("a", "ba", 0, 0, TRUE);

  1631   TEST_MATCH_SIMPLE("^a", "ba", 0, 0, FALSE);

  1632   TEST_MATCH_SIMPLE("a", "ba", G_REGEX_ANCHORED, 0, FALSE);

  1633   TEST_MATCH_SIMPLE("a", "ba", 0, G_REGEX_MATCH_ANCHORED, FALSE);

  1634   TEST_MATCH_SIMPLE("a", "ab", G_REGEX_ANCHORED, 0, TRUE);

  1635   TEST_MATCH_SIMPLE("a", "ab", 0, G_REGEX_MATCH_ANCHORED, TRUE);

  1636   TEST_MATCH_SIMPLE("a", "a", G_REGEX_CASELESS, 0, TRUE);

  1637   TEST_MATCH_SIMPLE("a", "A", G_REGEX_CASELESS, 0, TRUE);

  1638   /* These are needed to test extended properties. */

  1639   TEST_MATCH_SIMPLE(AGRAVE, AGRAVE, G_REGEX_CASELESS, 0, TRUE);

  1640   TEST_MATCH_SIMPLE(AGRAVE, AGRAVE_UPPER, G_REGEX_CASELESS, 0, TRUE);

  1641   TEST_MATCH_SIMPLE("\\p{L}", "a", 0, 0, TRUE);

  1642   TEST_MATCH_SIMPLE("\\p{L}", "1", 0, 0, FALSE);

  1643   TEST_MATCH_SIMPLE("\\p{L}", AGRAVE, 0, 0, TRUE);

  1644   TEST_MATCH_SIMPLE("\\p{L}", AGRAVE_UPPER, 0, 0, TRUE);

  1645   TEST_MATCH_SIMPLE("\\p{L}", SHEEN, 0, 0, TRUE);

  1646   TEST_MATCH_SIMPLE("\\p{L}", ETH30, 0, 0, FALSE);

  1647   TEST_MATCH_SIMPLE("\\p{Ll}", "a", 0, 0, TRUE);

  1648   TEST_MATCH_SIMPLE("\\p{Ll}", AGRAVE, 0, 0, TRUE);

  1649   TEST_MATCH_SIMPLE("\\p{Ll}", AGRAVE_UPPER, 0, 0, FALSE);

  1650   TEST_MATCH_SIMPLE("\\p{Ll}", ETH30, 0, 0, FALSE);

  1651   TEST_MATCH_SIMPLE("\\p{Sc}", AGRAVE, 0, 0, FALSE);

  1652   TEST_MATCH_SIMPLE("\\p{Sc}", EURO, 0, 0, TRUE);

  1653   TEST_MATCH_SIMPLE("\\p{Sc}", ETH30, 0, 0, FALSE);

  1654   TEST_MATCH_SIMPLE("\\p{N}", "a", 0, 0, FALSE);

  1655   TEST_MATCH_SIMPLE("\\p{N}", "1", 0, 0, TRUE);

  1656   TEST_MATCH_SIMPLE("\\p{N}", AGRAVE, 0, 0, FALSE);

  1657   TEST_MATCH_SIMPLE("\\p{N}", AGRAVE_UPPER, 0, 0, FALSE);

  1658   TEST_MATCH_SIMPLE("\\p{N}", SHEEN, 0, 0, FALSE);

  1659   TEST_MATCH_SIMPLE("\\p{N}", ETH30, 0, 0, TRUE);

  1660   TEST_MATCH_SIMPLE("\\p{Nd}", "a", 0, 0, FALSE);

  1661   TEST_MATCH_SIMPLE("\\p{Nd}", "1", 0, 0, TRUE);

  1662   TEST_MATCH_SIMPLE("\\p{Nd}", AGRAVE, 0, 0, FALSE);

  1663   TEST_MATCH_SIMPLE("\\p{Nd}", AGRAVE_UPPER, 0, 0, FALSE);

  1664   TEST_MATCH_SIMPLE("\\p{Nd}", SHEEN, 0, 0, FALSE);

  1665   TEST_MATCH_SIMPLE("\\p{Nd}", ETH30, 0, 0, FALSE);

  1666   TEST_MATCH_SIMPLE("\\p{Common}", SHEEN, 0, 0, FALSE);

  1667   TEST_MATCH_SIMPLE("\\p{Common}", "a", 0, 0, FALSE);

  1668   TEST_MATCH_SIMPLE("\\p{Common}", AGRAVE, 0, 0, FALSE);

  1669   TEST_MATCH_SIMPLE("\\p{Common}", AGRAVE_UPPER, 0, 0, FALSE);

  1670   TEST_MATCH_SIMPLE("\\p{Common}", ETH30, 0, 0, FALSE);

  1671   TEST_MATCH_SIMPLE("\\p{Common}", "%", 0, 0, TRUE);

  1672   TEST_MATCH_SIMPLE("\\p{Common}", "1", 0, 0, TRUE);

  1673   TEST_MATCH_SIMPLE("\\p{Arabic}", SHEEN, 0, 0, TRUE);

  1674   TEST_MATCH_SIMPLE("\\p{Arabic}", "a", 0, 0, FALSE);

  1675   TEST_MATCH_SIMPLE("\\p{Arabic}", AGRAVE, 0, 0, FALSE);

  1676   TEST_MATCH_SIMPLE("\\p{Arabic}", AGRAVE_UPPER, 0, 0, FALSE);

  1677   TEST_MATCH_SIMPLE("\\p{Arabic}", ETH30, 0, 0, FALSE);

  1678   TEST_MATCH_SIMPLE("\\p{Arabic}", "%", 0, 0, FALSE);

  1679   TEST_MATCH_SIMPLE("\\p{Arabic}", "1", 0, 0, FALSE);

  1680   TEST_MATCH_SIMPLE("\\p{Latin}", SHEEN, 0, 0, FALSE);

  1681   TEST_MATCH_SIMPLE("\\p{Latin}", "a", 0, 0, TRUE);

  1682   TEST_MATCH_SIMPLE("\\p{Latin}", AGRAVE, 0, 0, TRUE);

  1683   TEST_MATCH_SIMPLE("\\p{Latin}", AGRAVE_UPPER, 0, 0, TRUE);

  1684   TEST_MATCH_SIMPLE("\\p{Latin}", ETH30, 0, 0, FALSE);

  1685   TEST_MATCH_SIMPLE("\\p{Latin}", "%", 0, 0, FALSE);

  1686   TEST_MATCH_SIMPLE("\\p{Latin}", "1", 0, 0, FALSE);

  1687   TEST_MATCH_SIMPLE("\\p{Ethiopic}", SHEEN, 0, 0, FALSE);

  1688   TEST_MATCH_SIMPLE("\\p{Ethiopic}", "a", 0, 0, FALSE);

  1689   TEST_MATCH_SIMPLE("\\p{Ethiopic}", AGRAVE, 0, 0, FALSE);

  1690   TEST_MATCH_SIMPLE("\\p{Ethiopic}", AGRAVE_UPPER, 0, 0, FALSE);

  1691   TEST_MATCH_SIMPLE("\\p{Ethiopic}", ETH30, 0, 0, TRUE);

  1692   TEST_MATCH_SIMPLE("\\p{Ethiopic}", "%", 0, 0, FALSE);

  1693   TEST_MATCH_SIMPLE("\\p{Ethiopic}", "1", 0, 0, FALSE);

  1694   TEST_MATCH_SIMPLE("\\p{L}(?<=\\p{Arabic})", SHEEN, 0, 0, TRUE);

  1695   TEST_MATCH_SIMPLE("\\p{L}(?<=\\p{Latin})", SHEEN, 0, 0, FALSE);

  1696   /* Invalid patterns. */

  1697   TEST_MATCH_SIMPLE("\\", "a", 0, 0, FALSE);

  1698   TEST_MATCH_SIMPLE("[", "", 0, 0, FALSE);

  1700   /* TEST_MATCH(pattern, compile_opts, match_opts, string,

  1701    * 		string_len, start_position, match_opts2, expected) */

  1702   TEST_MATCH("a", 0, 0, "a", -1, 0, 0, TRUE);

  1703   TEST_MATCH("a", 0, 0, "A", -1, 0, 0, FALSE);

  1704   TEST_MATCH("a", G_REGEX_CASELESS, 0, "A", -1, 0, 0, TRUE);

  1705   TEST_MATCH("a", 0, 0, "ab", -1, 1, 0, FALSE);

  1706   TEST_MATCH("a", 0, 0, "ba", 1, 0, 0, FALSE);

  1707   TEST_MATCH("a", 0, 0, "bab", -1, 0, 0, TRUE);

  1708   TEST_MATCH("a", 0, 0, "b", -1, 0, 0, FALSE);

  1709   TEST_MATCH("a", 0, G_REGEX_ANCHORED, "a", -1, 0, 0, TRUE);

  1710   TEST_MATCH("a", 0, G_REGEX_ANCHORED, "ab", -1, 1, 0, FALSE);

  1711   TEST_MATCH("a", 0, G_REGEX_ANCHORED, "ba", 1, 0, 0, FALSE);

  1712   TEST_MATCH("a", 0, G_REGEX_ANCHORED, "bab", -1, 0, 0, FALSE);

  1713   TEST_MATCH("a", 0, G_REGEX_ANCHORED, "b", -1, 0, 0, FALSE);

  1714   TEST_MATCH("a", 0, 0, "a", -1, 0, G_REGEX_ANCHORED, TRUE);

  1715   TEST_MATCH("a", 0, 0, "ab", -1, 1, G_REGEX_ANCHORED, FALSE);

  1716   TEST_MATCH("a", 0, 0, "ba", 1, 0, G_REGEX_ANCHORED, FALSE);

  1717   TEST_MATCH("a", 0, 0, "bab", -1, 0, G_REGEX_ANCHORED, FALSE);

  1718   TEST_MATCH("a", 0, 0, "b", -1, 0, G_REGEX_ANCHORED, FALSE);

  1719   TEST_MATCH("a|b", 0, 0, "a", -1, 0, 0, TRUE);

  1720   TEST_MATCH("\\d", 0, 0, EURO, -1, 0, 0, FALSE);

  1721   TEST_MATCH("^.$", 0, 0, EURO, -1, 0, 0, TRUE);

  1722   TEST_MATCH("^.{3}$", 0, 0, EURO, -1, 0, 0, FALSE);

  1723   TEST_MATCH("^.$", G_REGEX_RAW, 0, EURO, -1, 0, 0, FALSE);

  1724   TEST_MATCH("^.{3}$", G_REGEX_RAW, 0, EURO, -1, 0, 0, TRUE);

  1725   TEST_MATCH(AGRAVE, G_REGEX_CASELESS, 0, AGRAVE_UPPER, -1, 0, 0, TRUE);

  1727   /* New lines handling. */

  1728   TEST_MATCH("^a\\Rb$", 0, 0, "a\r\nb", -1, 0, 0, TRUE);

  1729   TEST_MATCH("^a\\Rb$", 0, 0, "a\nb", -1, 0, 0, TRUE);

  1730   TEST_MATCH("^a\\Rb$", 0, 0, "a\rb", -1, 0, 0, TRUE);

  1731   TEST_MATCH("^a\\Rb$", 0, 0, "a\n\rb", -1, 0, 0, FALSE);

  1732   TEST_MATCH("^a\\R\\Rb$", 0, 0, "a\n\rb", -1, 0, 0, TRUE);

  1733   TEST_MATCH("^a\\nb$", 0, 0, "a\r\nb", -1, 0, 0, FALSE);

  1734   TEST_MATCH("^a\\r\\nb$", 0, 0, "a\r\nb", -1, 0, 0, TRUE);

  1736   TEST_MATCH("^b$", 0, 0, "a\nb\nc", -1, 0, 0, FALSE);

  1737   TEST_MATCH("^b$", G_REGEX_MULTILINE, 0, "a\nb\nc", -1, 0, 0, TRUE);

  1738   TEST_MATCH("^b$", G_REGEX_MULTILINE, 0, "a\r\nb\r\nc", -1, 0, 0, TRUE);

  1739   TEST_MATCH("^b$", G_REGEX_MULTILINE, 0, "a\rb\rc", -1, 0, 0, TRUE);

  1740   TEST_MATCH("^b$", G_REGEX_MULTILINE | G_REGEX_NEWLINE_CR, 0, "a\nb\nc", -1, 0, 0, FALSE);

  1741   TEST_MATCH("^b$", G_REGEX_MULTILINE | G_REGEX_NEWLINE_LF, 0, "a\nb\nc", -1, 0, 0, TRUE);

  1742   TEST_MATCH("^b$", G_REGEX_MULTILINE | G_REGEX_NEWLINE_CRLF, 0, "a\nb\nc", -1, 0, 0, FALSE);

  1743   TEST_MATCH("^b$", G_REGEX_MULTILINE | G_REGEX_NEWLINE_CR, 0, "a\r\nb\r\nc", -1, 0, 0, FALSE);

  1744   TEST_MATCH("^b$", G_REGEX_MULTILINE | G_REGEX_NEWLINE_LF, 0, "a\r\nb\r\nc", -1, 0, 0, FALSE);

  1745   TEST_MATCH("^b$", G_REGEX_MULTILINE | G_REGEX_NEWLINE_CRLF, 0, "a\r\nb\r\nc", -1, 0, 0, TRUE);

  1746   TEST_MATCH("^b$", G_REGEX_MULTILINE | G_REGEX_NEWLINE_CR, 0, "a\rb\rc", -1, 0, 0, TRUE);

  1747   TEST_MATCH("^b$", G_REGEX_MULTILINE | G_REGEX_NEWLINE_LF, 0, "a\rb\rc", -1, 0, 0, FALSE);

  1748   TEST_MATCH("^b$", G_REGEX_MULTILINE | G_REGEX_NEWLINE_CRLF, 0, "a\rb\rc", -1, 0, 0, FALSE);

  1749   TEST_MATCH("^b$", G_REGEX_MULTILINE, G_REGEX_MATCH_NEWLINE_CR, "a\nb\nc", -1, 0, 0, FALSE);

  1750   TEST_MATCH("^b$", G_REGEX_MULTILINE, G_REGEX_MATCH_NEWLINE_LF, "a\nb\nc", -1, 0, 0, TRUE);

  1751   TEST_MATCH("^b$", G_REGEX_MULTILINE, G_REGEX_MATCH_NEWLINE_CRLF, "a\nb\nc", -1, 0, 0, FALSE);

  1752   TEST_MATCH("^b$", G_REGEX_MULTILINE, G_REGEX_MATCH_NEWLINE_CR, "a\r\nb\r\nc", -1, 0, 0, FALSE);

  1753   TEST_MATCH("^b$", G_REGEX_MULTILINE, G_REGEX_MATCH_NEWLINE_LF, "a\r\nb\r\nc", -1, 0, 0, FALSE);

  1754   TEST_MATCH("^b$", G_REGEX_MULTILINE, G_REGEX_MATCH_NEWLINE_CRLF, "a\r\nb\r\nc", -1, 0, 0, TRUE);

  1755   TEST_MATCH("^b$", G_REGEX_MULTILINE, G_REGEX_MATCH_NEWLINE_CR, "a\rb\rc", -1, 0, 0, TRUE);

  1756   TEST_MATCH("^b$", G_REGEX_MULTILINE, G_REGEX_MATCH_NEWLINE_LF, "a\rb\rc", -1, 0, 0, FALSE);

  1757   TEST_MATCH("^b$", G_REGEX_MULTILINE, G_REGEX_MATCH_NEWLINE_CRLF, "a\rb\rc", -1, 0, 0, FALSE);

  1759   TEST_MATCH("^b$", G_REGEX_MULTILINE | G_REGEX_NEWLINE_CR, G_REGEX_MATCH_NEWLINE_ANY, "a\nb\nc", -1, 0, 0, TRUE);

  1760   TEST_MATCH("^b$", G_REGEX_MULTILINE | G_REGEX_NEWLINE_CR, G_REGEX_MATCH_NEWLINE_ANY, "a\rb\rc", -1, 0, 0, TRUE);

  1761   TEST_MATCH("^b$", G_REGEX_MULTILINE | G_REGEX_NEWLINE_CR, G_REGEX_MATCH_NEWLINE_ANY, "a\r\nb\r\nc", -1, 0, 0, TRUE);

  1762   TEST_MATCH("^b$", G_REGEX_MULTILINE | G_REGEX_NEWLINE_CR, G_REGEX_MATCH_NEWLINE_LF, "a\nb\nc", -1, 0, 0, TRUE);

  1763   TEST_MATCH("^b$", G_REGEX_MULTILINE | G_REGEX_NEWLINE_CR, G_REGEX_MATCH_NEWLINE_LF, "a\rb\rc", -1, 0, 0, FALSE);

  1764   TEST_MATCH("^b$", G_REGEX_MULTILINE | G_REGEX_NEWLINE_CR, G_REGEX_MATCH_NEWLINE_CRLF, "a\r\nb\r\nc", -1, 0, 0, TRUE);

  1765   TEST_MATCH("^b$", G_REGEX_MULTILINE | G_REGEX_NEWLINE_CR, G_REGEX_MATCH_NEWLINE_CRLF, "a\rb\rc", -1, 0, 0, FALSE);

  1767   TEST_MATCH("a#\nb", G_REGEX_EXTENDED, 0, "a", -1, 0, 0, FALSE);

  1768   TEST_MATCH("a#\r\nb", G_REGEX_EXTENDED, 0, "a", -1, 0, 0, FALSE);

  1769   TEST_MATCH("a#\rb", G_REGEX_EXTENDED, 0, "a", -1, 0, 0, FALSE);

  1770   TEST_MATCH("a#\nb", G_REGEX_EXTENDED, G_REGEX_MATCH_NEWLINE_CR, "a", -1, 0, 0, FALSE);

  1771   TEST_MATCH("a#\nb", G_REGEX_EXTENDED | G_REGEX_NEWLINE_CR, 0, "a", -1, 0, 0, TRUE);

  1773   /* TEST_MATCH_NEXT#(pattern, string, string_len, start_position, ...) */

  1774   TEST_MATCH_NEXT0("a", "x", -1, 0);

  1775   TEST_MATCH_NEXT0("a", "ax", -1, 1);

  1776   TEST_MATCH_NEXT0("a", "xa", 1, 0);

  1777   TEST_MATCH_NEXT0("a", "axa", 1, 2);

  1778   TEST_MATCH_NEXT1("a", "a", -1, 0, "a", 0, 1);

  1779   TEST_MATCH_NEXT1("a", "xax", -1, 0, "a", 1, 2);

  1780   TEST_MATCH_NEXT1(EURO, ENG EURO, -1, 0, EURO, 2, 5);

  1781   TEST_MATCH_NEXT1("a*", "", -1, 0, "", 0, 0);

  1782   TEST_MATCH_NEXT2("a*", "aa", -1, 0, "aa", 0, 2, "", 2, 2);

  1783   TEST_MATCH_NEXT2(EURO "*", EURO EURO, -1, 0, EURO EURO, 0, 6, "", 6, 6);

  1784   TEST_MATCH_NEXT2("a", "axa", -1, 0, "a", 0, 1, "a", 2, 3);

  1785   TEST_MATCH_NEXT2("a+", "aaxa", -1, 0, "aa", 0, 2, "a", 3, 4);

  1786   TEST_MATCH_NEXT2("a", "aa", -1, 0, "a", 0, 1, "a", 1, 2);

  1787   TEST_MATCH_NEXT2("a", "ababa", -1, 2, "a", 2, 3, "a", 4, 5);

  1788   TEST_MATCH_NEXT2(EURO "+", EURO "-" EURO, -1, 0, EURO, 0, 3, EURO, 4, 7);

  1789   TEST_MATCH_NEXT3("", "ab", -1, 0, "", 0, 0, "", 1, 1, "", 2, 2);

  1790   TEST_MATCH_NEXT3("", AGRAVE "b", -1, 0, "", 0, 0, "", 2, 2, "", 3, 3);

  1791   TEST_MATCH_NEXT3("a", "aaxa", -1, 0, "a", 0, 1, "a", 1, 2, "a", 3, 4);

  1792   TEST_MATCH_NEXT3("a", "aa" OGRAVE "a", -1, 0, "a", 0, 1, "a", 1, 2, "a", 4, 5);

  1793   TEST_MATCH_NEXT3("a*", "aax", -1, 0, "aa", 0, 2, "", 2, 2, "", 3, 3);

  1794   TEST_MATCH_NEXT3("(?=[A-Z0-9])", "RegExTest", -1, 0, "", 0, 0, "", 3, 3, "", 5, 5);

  1795   TEST_MATCH_NEXT4("a*", "aaxa", -1, 0, "aa", 0, 2, "", 2, 2, "a", 3, 4, "", 4, 4);

  1797   /* TEST_MATCH_COUNT(pattern, string, start_position, match_opts, expected_count) */

  1798   TEST_MATCH_COUNT("a", "", 0, 0, 0);

  1799   TEST_MATCH_COUNT("a", "a", 0, 0, 1);

  1800   TEST_MATCH_COUNT("a", "a", 1, 0, 0);

  1801   TEST_MATCH_COUNT("(.)", "a", 0, 0, 2);

  1802   TEST_MATCH_COUNT("(.)", EURO, 0, 0, 2);

  1803   TEST_MATCH_COUNT("(?:.)", "a", 0, 0, 1);

  1804   TEST_MATCH_COUNT("(?P<A>.)", "a", 0, 0, 2);

  1805   TEST_MATCH_COUNT("a$", "a", 0, G_REGEX_MATCH_NOTEOL, 0);

  1806   TEST_MATCH_COUNT("(a)?(b)", "b", 0, 0, 3);

  1807   TEST_MATCH_COUNT("(a)?(b)", "ab", 0, 0, 3);

  1809   /* TEST_PARTIAL(pattern, string, expected) */

  1810   TEST_PARTIAL("^ab", "a", TRUE);

  1811   TEST_PARTIAL("^ab", "xa", FALSE);

  1812   TEST_PARTIAL("ab", "xa", TRUE);

  1813   TEST_PARTIAL("ab", "ab", FALSE); /* normal match. */

  1814   TEST_PARTIAL("a+b", "aa", FALSE); /* PCRE_ERROR_BAD_PARTIAL */

  1815   TEST_PARTIAL("(a)+b", "aa", TRUE);

  1816   TEST_PARTIAL("a?b", "a", TRUE);

  1818   /* TEST_SUB_PATTERN(pattern, string, start_position, sub_n, expected_sub,

  1819    * 		      expected_start, expected_end) */

  1820   TEST_SUB_PATTERN("a", "a", 0, 0, "a", 0, 1);

  1821   TEST_SUB_PATTERN("a(.)", "ab", 0, 1, "b", 1, 2);

  1822   TEST_SUB_PATTERN("a(.)", "a" EURO, 0, 1, EURO, 1, 4);

  1823   TEST_SUB_PATTERN("(?:.*)(a)(.)", "xxa" ENG, 0, 2, ENG, 3, 5);

  1824   TEST_SUB_PATTERN("(" HSTROKE ")", "a" HSTROKE ENG, 0, 1, HSTROKE, 1, 3);

  1825   TEST_SUB_PATTERN("a", "a", 0, 1, NULL, UNTOUCHED, UNTOUCHED);

  1826   TEST_SUB_PATTERN("a", "a", 0, 1, NULL, UNTOUCHED, UNTOUCHED);

  1827   TEST_SUB_PATTERN("(a)?(b)", "b", 0, 0, "b", 0, 1);

  1828   TEST_SUB_PATTERN("(a)?(b)", "b", 0, 1, "", -1, -1);

  1829   TEST_SUB_PATTERN("(a)?(b)", "b", 0, 2, "b", 0, 1);

  1831   /* TEST_NAMED_SUB_PATTERN(pattern, string, start_position, sub_name,

  1832    * 			    expected_sub, expected_start, expected_end) */

  1833   TEST_NAMED_SUB_PATTERN("a(?P<A>.)(?P<B>.)?", "ab", 0, "A", "b", 1, 2);

  1834   TEST_NAMED_SUB_PATTERN("a(?P<A>.)(?P<B>.)?", "aab", 1, "A", "b", 2, 3);

  1835   TEST_NAMED_SUB_PATTERN("a(?P<A>.)(?P<B>.)?", EURO "ab", 0, "A", "b", 4, 5);

  1836   TEST_NAMED_SUB_PATTERN("a(?P<A>.)(?P<B>.)?", EURO "ab", 0, "B", NULL, UNTOUCHED, UNTOUCHED);

  1837   TEST_NAMED_SUB_PATTERN("a(?P<A>.)(?P<B>.)?", EURO "ab", 0, "C", NULL, UNTOUCHED, UNTOUCHED);

  1838   TEST_NAMED_SUB_PATTERN("a(?P<A>.)(?P<B>.)?", "a" EGRAVE "x", 0, "A", EGRAVE, 1, 3);

  1839   TEST_NAMED_SUB_PATTERN("a(?P<A>.)(?P<B>.)?", "a" EGRAVE "x", 0, "B", "x", 3, 4);

  1840   TEST_NAMED_SUB_PATTERN("(?P<A>a)?(?P<B>b)", "b", 0, "A", "", -1, -1);

  1841   TEST_NAMED_SUB_PATTERN("(?P<A>a)?(?P<B>b)", "b", 0, "B", "b", 0, 1);

  1843   /* TEST_NAMED_SUB_PATTERN_DUPNAMES(pattern, string, start_position, sub_name,

  1844    *				     expected_sub, expected_start, expected_end) */

  1845   TEST_NAMED_SUB_PATTERN_DUPNAMES("(?P<N>a)|(?P<N>b)", "ab", 0, "N", "a", 0, 1);

  1846   TEST_NAMED_SUB_PATTERN_DUPNAMES("(?P<N>aa)|(?P<N>a)", "aa", 0, "N", "aa", 0, 2);

  1847   TEST_NAMED_SUB_PATTERN_DUPNAMES("(?P<N>aa)(?P<N>a)", "aaa", 0, "N", "aa", 0, 2);

  1848   TEST_NAMED_SUB_PATTERN_DUPNAMES("(?P<N>x)|(?P<N>a)", "a", 0, "N", "a", 0, 1);

  1849   TEST_NAMED_SUB_PATTERN_DUPNAMES("(?P<N>x)y|(?P<N>a)b", "ab", 0, "N", "a", 0, 1);

  1851   /* DUPNAMES option inside the pattern */

  1852   TEST_NAMED_SUB_PATTERN("(?J)(?P<N>a)|(?P<N>b)", "ab", 0, "N", "a", 0, 1);

  1853   TEST_NAMED_SUB_PATTERN("(?J)(?P<N>aa)|(?P<N>a)", "aa", 0, "N", "aa", 0, 2);

  1854   TEST_NAMED_SUB_PATTERN("(?J)(?P<N>aa)(?P<N>a)", "aaa", 0, "N", "aa", 0, 2);

  1855   TEST_NAMED_SUB_PATTERN("(?J)(?P<N>x)|(?P<N>a)", "a", 0, "N", "a", 0, 1);

  1856   TEST_NAMED_SUB_PATTERN("(?J)(?P<N>x)y|(?P<N>a)b", "ab", 0, "N", "a", 0, 1);

  1858   /* TEST_FETCH_ALL#(pattern, string, ...) */

  1859   TEST_FETCH_ALL0("a", "");

  1860   TEST_FETCH_ALL0("a", "b");

  1861   TEST_FETCH_ALL1("a", "a", "a");

  1862   TEST_FETCH_ALL1("a+", "aa", "aa");

  1863   TEST_FETCH_ALL1("(?:a)", "a", "a");

  1864   TEST_FETCH_ALL2("(a)", "a", "a", "a");

  1865   TEST_FETCH_ALL2("a(.)", "ab", "ab", "b");

  1866   TEST_FETCH_ALL2("a(.)", "a" HSTROKE, "a" HSTROKE, HSTROKE);

  1867   TEST_FETCH_ALL3("(?:.*)(a)(.)", "xyazk", "xyaz", "a", "z");

  1868   TEST_FETCH_ALL3("(?P<A>.)(a)", "xa", "xa", "x", "a");

  1869   TEST_FETCH_ALL3("(?P<A>.)(a)", ENG "a", ENG "a", ENG, "a");

  1870   TEST_FETCH_ALL3("(a)?(b)", "b", "b", "", "b");

  1871   TEST_FETCH_ALL3("(a)?(b)", "ab", "ab", "a", "b");

  1873   /* TEST_SPLIT_SIMPLE#(pattern, string, ...) */

  1874   TEST_SPLIT_SIMPLE0("", "");

  1875   TEST_SPLIT_SIMPLE0("a", "");

  1876   TEST_SPLIT_SIMPLE1(",", "a", "a");

  1877   TEST_SPLIT_SIMPLE1("(,)\\s*", "a", "a");

  1878   TEST_SPLIT_SIMPLE2(",", "a,b", "a", "b");

  1879   TEST_SPLIT_SIMPLE3(",", "a,b,c", "a", "b", "c");

  1880   TEST_SPLIT_SIMPLE3(",\\s*", "a,b,c", "a", "b", "c");

  1881   TEST_SPLIT_SIMPLE3(",\\s*", "a, b, c", "a", "b", "c");

  1882   TEST_SPLIT_SIMPLE3("(,)\\s*", "a,b", "a", ",", "b");

  1883   TEST_SPLIT_SIMPLE3("(,)\\s*", "a, b", "a", ",", "b");

  1884   /* Not matched sub-strings. */

  1885   TEST_SPLIT_SIMPLE2("a|(b)", "xay", "x", "y");

  1886   TEST_SPLIT_SIMPLE3("a|(b)", "xby", "x", "b", "y");

  1887   /* Empty matches. */

  1888   TEST_SPLIT_SIMPLE3("", "abc", "a", "b", "c");

  1889   TEST_SPLIT_SIMPLE3(" *", "ab c", "a", "b", "c");

  1890   /* Invalid patterns. */

  1891   TEST_SPLIT_SIMPLE0("\\", "");

  1892   TEST_SPLIT_SIMPLE0("[", "");

  1894   /* TEST_SPLIT#(pattern, string, start_position, max_tokens, ...) */

  1895   TEST_SPLIT0("", "", 0, 0);

  1896   TEST_SPLIT0("a", "", 0, 0);

  1897   TEST_SPLIT0("a", "", 0, 1);

  1898   TEST_SPLIT0("a", "", 0, 2);

  1899   TEST_SPLIT0("a", "a", 1, 0);

  1900   TEST_SPLIT1(",", "a", 0, 0, "a");

  1901   TEST_SPLIT1(",", "a,b", 0, 1, "a,b");

  1902   TEST_SPLIT1("(,)\\s*", "a", 0, 0, "a");

  1903   TEST_SPLIT1(",", "a,b", 2, 0, "b");

  1904   TEST_SPLIT2(",", "a,b", 0, 0, "a", "b");

  1905   TEST_SPLIT2(",", "a,b,c", 0, 2, "a", "b,c");

  1906   TEST_SPLIT2(",", "a,b", 1, 0, "", "b");

  1907   TEST_SPLIT2(",", "a,", 0, 0, "a", "");

  1908   TEST_SPLIT3(",", "a,b,c", 0, 0, "a", "b", "c");

  1909   TEST_SPLIT3(",\\s*", "a,b,c", 0, 0, "a", "b", "c");

  1910   TEST_SPLIT3(",\\s*", "a, b, c", 0, 0, "a", "b", "c");

  1911   TEST_SPLIT3("(,)\\s*", "a,b", 0, 0, "a", ",", "b");

  1912   TEST_SPLIT3("(,)\\s*", "a, b", 0, 0, "a", ",", "b");

  1913   /* Not matched sub-strings. */

  1914   TEST_SPLIT2("a|(b)", "xay", 0, 0, "x", "y");

  1915   TEST_SPLIT3("a|(b)", "xby", 0, -1, "x", "b", "y");

  1916   /* Empty matches. */

  1917   TEST_SPLIT2(" *", "ab c", 1, 0, "b", "c");

  1918   TEST_SPLIT3("", "abc", 0, 0, "a", "b", "c");

  1919   TEST_SPLIT3(" *", "ab c", 0, 0, "a", "b", "c");

  1920   TEST_SPLIT1(" *", "ab c", 0, 1, "ab c");

  1921   TEST_SPLIT2(" *", "ab c", 0, 2, "a", "b c");

  1922   TEST_SPLIT3(" *", "ab c", 0, 3, "a", "b", "c");

  1923   TEST_SPLIT3(" *", "ab c", 0, 4, "a", "b", "c");

  1925   /* TEST_CHECK_REPLACEMENT(string_to_expand, expected, expected_refs) */

  1926   TEST_CHECK_REPLACEMENT("", TRUE, FALSE);

  1927   TEST_CHECK_REPLACEMENT("a", TRUE, FALSE);

  1928   TEST_CHECK_REPLACEMENT("\\t\\n\\v\\r\\f\\a\\b\\\\\\x{61}", TRUE, FALSE);

  1929   TEST_CHECK_REPLACEMENT("\\0", TRUE, TRUE);

  1930   TEST_CHECK_REPLACEMENT("\\n\\2", TRUE, TRUE);

  1931   TEST_CHECK_REPLACEMENT("\\g<foo>", TRUE, TRUE);

  1932   /* Invalid strings */

  1933   TEST_CHECK_REPLACEMENT("\\Q", FALSE, FALSE);

  1934   TEST_CHECK_REPLACEMENT("x\\Ay", FALSE, FALSE);

  1936   /* TEST_EXPAND(pattern, string, string_to_expand, raw, expected) */

  1937   TEST_EXPAND("a", "a", "", FALSE, "");

  1938   TEST_EXPAND("a", "a", "\\0", FALSE, "a");

  1939   TEST_EXPAND("a", "a", "\\1", FALSE, "");

  1940   TEST_EXPAND("(a)", "ab", "\\1", FALSE, "a");

  1941   TEST_EXPAND("(a)", "a", "\\1", FALSE, "a");

  1942   TEST_EXPAND("(a)", "a", "\\g<1>", FALSE, "a");

  1943   TEST_EXPAND("a", "a", "\\0130", FALSE, "X");

  1944   TEST_EXPAND("a", "a", "\\\\\\0", FALSE, "\\a");

  1945   TEST_EXPAND("a(?P<G>.)c", "xabcy", "X\\g<G>X", FALSE, "XbX");

  1946   TEST_EXPAND("(.)(?P<1>.)", "ab", "\\1", FALSE, "a");

  1947   TEST_EXPAND("(.)(?P<1>.)", "ab", "\\g<1>", FALSE, "a");

  1948   TEST_EXPAND(".", EURO, "\\0", FALSE, EURO);

  1949   TEST_EXPAND("(.)", EURO, "\\1", FALSE, EURO);

  1950   TEST_EXPAND("(?P<G>.)", EURO, "\\g<G>", FALSE, EURO);

  1951   TEST_EXPAND(".", "a", EURO, FALSE, EURO);

  1952   TEST_EXPAND(".", "a", EURO "\\0", FALSE, EURO "a");

  1953   TEST_EXPAND(".", "", "\\Lab\\Ec", FALSE, "abc");

  1954   TEST_EXPAND(".", "", "\\LaB\\EC", FALSE, "abC");

  1955   TEST_EXPAND(".", "", "\\Uab\\Ec", FALSE, "ABc");

  1956   TEST_EXPAND(".", "", "a\\ubc", FALSE, "aBc");

  1957   TEST_EXPAND(".", "", "a\\lbc", FALSE, "abc");

  1958   TEST_EXPAND(".", "", "A\\uBC", FALSE, "ABC");

  1959   TEST_EXPAND(".", "", "A\\lBC", FALSE, "AbC");

  1960   TEST_EXPAND(".", "", "A\\l\\\\BC", FALSE, "A\\BC");

  1961   TEST_EXPAND(".", "", "\\L" AGRAVE "\\E", FALSE, AGRAVE);

  1962   TEST_EXPAND(".", "", "\\U" AGRAVE "\\E", FALSE, AGRAVE_UPPER);

  1963   TEST_EXPAND(".", "", "\\u" AGRAVE "a", FALSE, AGRAVE_UPPER "a");

  1964   TEST_EXPAND(".", "ab", "x\\U\\0y\\Ez", FALSE, "xAYz");

  1965   TEST_EXPAND(".(.)", "AB", "x\\L\\1y\\Ez", FALSE, "xbyz");

  1966   TEST_EXPAND(".", "ab", "x\\u\\0y\\Ez", FALSE, "xAyz");

  1967   TEST_EXPAND(".(.)", "AB", "x\\l\\1y\\Ez", FALSE, "xbyz");

  1968   TEST_EXPAND(".(.)", "a" AGRAVE_UPPER, "x\\l\\1y", FALSE, "x" AGRAVE "y");

  1969   TEST_EXPAND("a", "bab", "\\x{61}", FALSE, "a");

  1970   TEST_EXPAND("a", "bab", "\\x61", FALSE, "a");

  1971   TEST_EXPAND("a", "bab", "\\x5a", FALSE, "Z");

  1972   TEST_EXPAND("a", "bab", "\\0\\x5A", FALSE, "aZ");

  1973   TEST_EXPAND("a", "bab", "\\1\\x{5A}", FALSE, "Z");

  1974   TEST_EXPAND("a", "bab", "\\x{00E0}", FALSE, AGRAVE);

  1975   TEST_EXPAND("", "bab", "\\x{0634}", FALSE, SHEEN);

  1976   TEST_EXPAND("", "bab", "\\x{634}", FALSE, SHEEN);

  1977   TEST_EXPAND("", "", "\\t", FALSE, "\t");

  1978   TEST_EXPAND("", "", "\\v", FALSE, "\v");

  1979   TEST_EXPAND("", "", "\\r", FALSE, "\r");

  1980   TEST_EXPAND("", "", "\\n", FALSE, "\n");

  1981   TEST_EXPAND("", "", "\\f", FALSE, "\f");

  1982   TEST_EXPAND("", "", "\\a", FALSE, "\a");

  1983   TEST_EXPAND("", "", "\\b", FALSE, "\b");

  1984   TEST_EXPAND("a(.)", "abc", "\\0\\b\\1", FALSE, "ab\bb");

  1985   TEST_EXPAND("a(.)", "abc", "\\0141", FALSE, "a");

  1986   TEST_EXPAND("a(.)", "abc", "\\078", FALSE, "\a8");

  1987   TEST_EXPAND("a(.)", "abc", "\\077", FALSE, "?");

  1988   TEST_EXPAND("a(.)", "abc", "\\0778", FALSE, "?8");

  1989   TEST_EXPAND("a(.)", "a" AGRAVE "b", "\\1", FALSE, AGRAVE);

  1990   TEST_EXPAND("a(.)", "a" AGRAVE "b", "\\1", TRUE, "\xc3");

  1991   TEST_EXPAND("a(.)", "a" AGRAVE "b", "\\0", TRUE, "a\xc3");

  1992   /* Invalid strings. */

  1993   TEST_EXPAND("", "", "\\Q", FALSE, NULL);

  1994   TEST_EXPAND("", "", "x\\Ay", FALSE, NULL);

  1995   TEST_EXPAND("", "", "\\g<", FALSE, NULL);

  1996   TEST_EXPAND("", "", "\\g<>", FALSE, NULL);

  1997   TEST_EXPAND("", "", "\\g<1a>", FALSE, NULL);

  1998   TEST_EXPAND("", "", "\\g<a$>", FALSE, NULL);

  1999   TEST_EXPAND("", "", "\\", FALSE, NULL);

  2000   TEST_EXPAND("a", "a", "\\x{61", FALSE, NULL);

  2001   TEST_EXPAND("a", "a", "\\x6X", FALSE, NULL);

  2002   /* Pattern-less. */

  2003   TEST_EXPAND(NULL, NULL, "", FALSE, "");

  2004   TEST_EXPAND(NULL, NULL, "\\n", FALSE, "\n");

  2005   /* Invalid strings */

  2006   TEST_EXPAND(NULL, NULL, "\\Q", FALSE, NULL);

  2007   TEST_EXPAND(NULL, NULL, "x\\Ay", FALSE, NULL);

  2009   /* TEST_REPLACE(pattern, string, start_position, replacement, expected) */

  2010   TEST_REPLACE("a", "ababa", 0, "A", "AbAbA");

  2011   TEST_REPLACE("a", "ababa", 1, "A", "abAbA");

  2012   TEST_REPLACE("a", "ababa", 2, "A", "abAbA");

  2013   TEST_REPLACE("a", "ababa", 3, "A", "ababA");

  2014   TEST_REPLACE("a", "ababa", 4, "A", "ababA");

  2015   TEST_REPLACE("a", "ababa", 5, "A", "ababa");

  2016   TEST_REPLACE("a", "ababa", 6, "A", "ababa");

  2017   TEST_REPLACE("a", "abababa", 2, "A", "abAbAbA");

  2018   TEST_REPLACE("a", "abab", 0, "A", "AbAb");

  2019   TEST_REPLACE("a", "baba", 0, "A", "bAbA");

  2020   TEST_REPLACE("a", "bab", 0, "A", "bAb");

  2021   TEST_REPLACE("$^", "abc", 0, "X", "abc");

  2022   TEST_REPLACE("(.)a", "ciao", 0, "a\\1", "caio");

  2023   TEST_REPLACE("a.", "abc", 0, "\\0\\0", "ababc");

  2024   TEST_REPLACE("a", "asd", 0, "\\0101", "Asd");

  2025   TEST_REPLACE("(a).\\1", "aba cda", 0, "\\1\\n", "a\n cda");

  2026   TEST_REPLACE("a" AGRAVE "a", "a" AGRAVE "a", 0, "x", "x");

  2027   TEST_REPLACE("a" AGRAVE "a", "a" AGRAVE "a", 0, OGRAVE, OGRAVE);

  2028   TEST_REPLACE("[^-]", "-" EURO "-x-" HSTROKE, 0, "a", "-a-a-a");

  2029   TEST_REPLACE("[^-]", "-" EURO "-" HSTROKE, 0, "a\\g<0>a", "-a" EURO "a-a" HSTROKE "a");

  2030   TEST_REPLACE("-", "-" EURO "-" HSTROKE, 0, "", EURO HSTROKE);

  2031   TEST_REPLACE(".*", "hello", 0, "\\U\\0\\E", "HELLO");

  2032   TEST_REPLACE(".*", "hello", 0, "\\u\\0", "Hello");

  2033   TEST_REPLACE("\\S+", "hello world", 0, "\\U-\\0-", "-HELLO- -WORLD-");

  2034   TEST_REPLACE(".", "a", 0, "\\A", NULL);

  2035   TEST_REPLACE(".", "a", 0, "\\g", NULL);

  2037   /* TEST_REPLACE_LIT(pattern, string, start_position, replacement, expected) */

  2038   TEST_REPLACE_LIT("a", "ababa", 0, "A", "AbAbA");

  2039   TEST_REPLACE_LIT("a", "ababa", 1, "A", "abAbA");

  2040   TEST_REPLACE_LIT("a", "ababa", 2, "A", "abAbA");

  2041   TEST_REPLACE_LIT("a", "ababa", 3, "A", "ababA");

  2042   TEST_REPLACE_LIT("a", "ababa", 4, "A", "ababA");

  2043   TEST_REPLACE_LIT("a", "ababa", 5, "A", "ababa");

  2044   TEST_REPLACE_LIT("a", "ababa", 6, "A", "ababa");

  2045   TEST_REPLACE_LIT("a", "abababa", 2, "A", "abAbAbA");

  2046   TEST_REPLACE_LIT("a", "abcadaa", 0, "A", "AbcAdAA");

  2047   TEST_REPLACE_LIT("$^", "abc", 0, "X", "abc");

  2048   TEST_REPLACE_LIT("(.)a", "ciao", 0, "a\\1", "ca\\1o");

  2049   TEST_REPLACE_LIT("a.", "abc", 0, "\\0\\0\\n", "\\0\\0\\nc");

  2050   TEST_REPLACE_LIT("a" AGRAVE "a", "a" AGRAVE "a", 0, "x", "x");

  2051   TEST_REPLACE_LIT("a" AGRAVE "a", "a" AGRAVE "a", 0, OGRAVE, OGRAVE);

  2052   TEST_REPLACE_LIT(AGRAVE, "-" AGRAVE "-" HSTROKE, 0, "a" ENG "a", "-a" ENG "a-" HSTROKE);

  2053   TEST_REPLACE_LIT("[^-]", "-" EURO "-" AGRAVE "-" HSTROKE, 0, "a", "-a-a-a");

  2054   TEST_REPLACE_LIT("[^-]", "-" EURO "-" AGRAVE, 0, "a\\g<0>a", "-a\\g<0>a-a\\g<0>a");

  2055   TEST_REPLACE_LIT("-", "-" EURO "-" AGRAVE "-" HSTROKE, 0, "", EURO AGRAVE HSTROKE);

  2056   TEST_REPLACE_LIT("(?=[A-Z0-9])", "RegExTest", 0, "_", "_Reg_Ex_Test");

  2057   TEST_REPLACE_LIT("(?=[A-Z0-9])", "RegExTest", 1, "_", "Reg_Ex_Test");

  2059   /* TEST_GET_STRING_NUMBER(pattern, name, expected_num) */

  2060   TEST_GET_STRING_NUMBER("", "A", -1);

  2061   TEST_GET_STRING_NUMBER("(?P<A>.)", "A", 1);

  2062   TEST_GET_STRING_NUMBER("(?P<A>.)", "B", -1);

  2063   TEST_GET_STRING_NUMBER("(?P<A>.)(?P<B>a)", "A", 1);

  2064   TEST_GET_STRING_NUMBER("(?P<A>.)(?P<B>a)", "B", 2);

  2065   TEST_GET_STRING_NUMBER("(?P<A>.)(?P<B>a)", "C", -1);

  2066   TEST_GET_STRING_NUMBER("(?P<A>.)(.)(?P<B>a)", "A", 1);

  2067   TEST_GET_STRING_NUMBER("(?P<A>.)(.)(?P<B>a)", "B", 3);

  2068   TEST_GET_STRING_NUMBER("(?P<A>.)(.)(?P<B>a)", "C", -1);

  2069   TEST_GET_STRING_NUMBER("(?:a)(?P<A>.)", "A", 1);

  2070   TEST_GET_STRING_NUMBER("(?:a)(?P<A>.)", "B", -1);

  2072   /* TEST_ESCAPE(string, length, expected) */

  2073   TEST_ESCAPE("hello world", -1, "hello world");

  2074   TEST_ESCAPE("hello world", 5, "hello");

  2075   TEST_ESCAPE("hello.world", -1, "hello\\.world");

  2076   TEST_ESCAPE("a(b\\b.$", -1, "a\\(b\\\\b\\.\\$");

  2077   TEST_ESCAPE("hello\0world", -1, "hello");

  2078   TEST_ESCAPE("hello\0world", 11, "hello\\0world");

  2079   TEST_ESCAPE(EURO "*" ENG, -1, EURO "\\*" ENG);

  2080   TEST_ESCAPE("a$", -1, "a\\$");

  2081   TEST_ESCAPE("$a", -1, "\\$a");

  2082   TEST_ESCAPE("a$a", -1, "a\\$a");

  2083   TEST_ESCAPE("$a$", -1, "\\$a\\$");

  2084   TEST_ESCAPE("$a$", 0, "");

  2085   TEST_ESCAPE("$a$", 1, "\\$");

  2086   TEST_ESCAPE("$a$", 2, "\\$a");

  2087   TEST_ESCAPE("$a$", 3, "\\$a\\$");

  2088   TEST_ESCAPE("$a$", 4, "\\$a\\$\\0");

  2089   TEST_ESCAPE("|()[]{}^$*+?.", -1, "\\|\\(\\)\\[\\]\\{\\}\\^\\$\\*\\+\\?\\.");

  2090   TEST_ESCAPE("a|a(a)a[a]a{a}a^a$a*a+a?a.a", -1,

  2091 	      "a\\|a\\(a\\)a\\[a\\]a\\{a\\}a\\^a\\$a\\*a\\+a\\?a\\.a");

  2093   /* TEST_MATCH_ALL#(pattern, string, string_len, start_position, ...) */

  2094   TEST_MATCH_ALL0("<.*>", "", -1, 0);

  2095   TEST_MATCH_ALL0("a+", "", -1, 0);

  2096   TEST_MATCH_ALL0("a+", "a", 0, 0);

  2097   TEST_MATCH_ALL0("a+", "a", -1, 1);

  2098 //  TEST_MATCH_ALL1("<.*>", "<a>", -1, 0, "<a>", 0, 3);

  2099   TEST_MATCH_ALL1("a+", "a", -1, 0, "a", 0, 1);

  2100   TEST_MATCH_ALL1("a+", "aa", 1, 0, "a", 0, 1);

  2101   TEST_MATCH_ALL1("a+", "aa", -1, 1, "a", 1, 2);

  2102   TEST_MATCH_ALL1("a+", "aa", 2, 1, "a", 1, 2);

  2103   TEST_MATCH_ALL1(".+", ENG, -1, 0, ENG, 0, 2);

  2104 //  TEST_MATCH_ALL2("<.*>", "<a><b>", -1, 0, "<a><b>", 0, 6, "<a>", 0, 3);

  2105   TEST_MATCH_ALL2("a+", "aa", -1, 0, "aa", 0, 2, "a", 0, 1);

  2106   TEST_MATCH_ALL2(".+", ENG EURO, -1, 0, ENG EURO, 0, 5, ENG, 0, 2);

  2107 //  TEST_MATCH_ALL3("<.*>", "<a><b><c>", -1, 0, "<a><b><c>", 0, 9,

  2108 //		  "<a><b>", 0, 6, "<a>", 0, 3);

  2109 //  TEST_MATCH_ALL3("a+", "aaa", -1, 0, "aaa", 0, 3, "aa", 0, 2, "a", 0, 1);

  2111 end: /* if abort_on_fail is TRUE the flow passes to this label. */

  2112   verbose ("\n%u tests passed, %u failed\n", passed, failed);

  2113   #if __SYMBIAN32__

  2114   testResultXml("regex-test");

  2115   #endif /* EMULATOR */

  2116   return failed;

  2117 }

  2119 #else /* ENABLE_REGEX false */

  2121 int

  2122 main (int argc, char *argv[])

  2123 {

  2124   g_print ("GRegex is disabled.\n");

  2125   return 0;

  2126 }

  2128 #endif /* ENABLE_REGEX */

author	sl
	Tue, 10 Jun 2014 14:32:02 +0200
changeset 1	260cb5ec6c19
permissions	-rw-r--r--