nexmon – Blame information for rev 1

Subversion Repositories:
Rev:
Rev Author Line No. Line
1 office 1 /*
2 * Copyright (C) 2005 - 2006, Marco Barisione <marco@barisione.org>
3 * Copyright (C) 2010 Red Hat, Inc.
4 *
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2 of the License, or (at your option) any later version.
9 *
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
14 *
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
17 */
18  
19 #undef G_DISABLE_ASSERT
20 #undef G_LOG_DOMAIN
21  
22 #include "config.h"
23  
24 #include <string.h>
25 #include <locale.h>
26 #include "glib.h"
27  
28 #ifdef USE_SYSTEM_PCRE
29 #include <pcre.h>
30 #else
31 #include "glib/pcre/pcre.h"
32 #endif
33  
34 /* U+20AC EURO SIGN (symbol, currency) */
35 #define EURO "\xe2\x82\xac"
36 /* U+00E0 LATIN SMALL LETTER A WITH GRAVE (letter, lowercase) */
37 #define AGRAVE "\xc3\xa0"
38 /* U+00C0 LATIN CAPITAL LETTER A WITH GRAVE (letter, uppercase) */
39 #define AGRAVE_UPPER "\xc3\x80"
40 /* U+00E8 LATIN SMALL LETTER E WITH GRAVE (letter, lowercase) */
41 #define EGRAVE "\xc3\xa8"
42 /* U+00F2 LATIN SMALL LETTER O WITH GRAVE (letter, lowercase) */
43 #define OGRAVE "\xc3\xb2"
44 /* U+014B LATIN SMALL LETTER ENG (letter, lowercase) */
45 #define ENG "\xc5\x8b"
46 /* U+0127 LATIN SMALL LETTER H WITH STROKE (letter, lowercase) */
47 #define HSTROKE "\xc4\xa7"
48 /* U+0634 ARABIC LETTER SHEEN (letter, other) */
49 #define SHEEN "\xd8\xb4"
50 /* U+1374 ETHIOPIC NUMBER THIRTY (number, other) */
51 #define ETH30 "\xe1\x8d\xb4"
52  
53 /* A random value use to mark untouched integer variables. */
54 #define UNTOUCHED -559038737
55  
56 static gint total;
57  
58 typedef struct {
59 const gchar *pattern;
60 GRegexCompileFlags compile_opts;
61 GRegexMatchFlags match_opts;
62 gint expected_error;
63 gboolean check_flags;
64 GRegexCompileFlags real_compile_opts;
65 GRegexMatchFlags real_match_opts;
66 } TestNewData;
67  
68 static void
69 test_new (gconstpointer d)
70 {
71 const TestNewData *data = d;
72 GRegex *regex;
73 GError *error = NULL;
74  
75 regex = g_regex_new (data->pattern, data->compile_opts, data->match_opts, &error);
76 g_assert (regex != NULL);
77 g_assert_no_error (error);
78 g_assert_cmpstr (data->pattern, ==, g_regex_get_pattern (regex));
79  
80 if (data->check_flags)
81 {
82 g_assert_cmphex (g_regex_get_compile_flags (regex), ==, data->real_compile_opts);
83 g_assert_cmphex (g_regex_get_match_flags (regex), ==, data->real_match_opts);
84 }
85  
86 g_regex_unref (regex);
87 }
88  
89 #define TEST_NEW(_pattern, _compile_opts, _match_opts) { \
90 TestNewData *data; \
91 gchar *path; \
92 data = g_new0 (TestNewData, 1); \
93 data->pattern = _pattern; \
94 data->compile_opts = _compile_opts; \
95 data->match_opts = _match_opts; \
96 data->expected_error = 0; \
97 data->check_flags = FALSE; \
98 path = g_strdup_printf ("/regex/new/%d", ++total); \
99 g_test_add_data_func_full (path, data, test_new, g_free); \
100 g_free (path); \
101 }
102  
103 #define TEST_NEW_CHECK_FLAGS(_pattern, _compile_opts, _match_opts, _real_compile_opts, _real_match_opts) { \
104 TestNewData *data; \
105 gchar *path; \
106 data = g_new0 (TestNewData, 1); \
107 data->pattern = _pattern; \
108 data->compile_opts = _compile_opts; \
109 data->match_opts = 0; \
110 data->expected_error = 0; \
111 data->check_flags = TRUE; \
112 data->real_compile_opts = _real_compile_opts; \
113 data->real_match_opts = _real_match_opts; \
114 path = g_strdup_printf ("/regex/new-check-flags/%d", ++total); \
115 g_test_add_data_func_full (path, data, test_new, g_free); \
116 g_free (path); \
117 }
118  
119 static void
120 test_new_fail (gconstpointer d)
121 {
122 const TestNewData *data = d;
123 GRegex *regex;
124 GError *error = NULL;
125  
126 regex = g_regex_new (data->pattern, data->compile_opts, data->match_opts, &error);
127  
128 g_assert (regex == NULL);
129 g_assert_error (error, G_REGEX_ERROR, data->expected_error);
130 g_error_free (error);
131 }
132  
133 #define TEST_NEW_FAIL(_pattern, _compile_opts, _expected_error) { \
134 TestNewData *data; \
135 gchar *path; \
136 data = g_new0 (TestNewData, 1); \
137 data->pattern = _pattern; \
138 data->compile_opts = _compile_opts; \
139 data->match_opts = 0; \
140 data->expected_error = _expected_error; \
141 path = g_strdup_printf ("/regex/new-fail/%d", ++total); \
142 g_test_add_data_func_full (path, data, test_new_fail, g_free); \
143 g_free (path); \
144 }
145  
146 typedef struct {
147 const gchar *pattern;
148 const gchar *string;
149 GRegexCompileFlags compile_opts;
150 GRegexMatchFlags match_opts;
151 gboolean expected;
152 gssize string_len;
153 gint start_position;
154 GRegexMatchFlags match_opts2;
155 } TestMatchData;
156  
157 static void
158 test_match_simple (gconstpointer d)
159 {
160 const TestMatchData *data = d;
161 gboolean match;
162  
163 match = g_regex_match_simple (data->pattern, data->string, data->compile_opts, data->match_opts);
164 g_assert_cmpint (match, ==, data->expected);
165 }
166  
167 #define TEST_MATCH_SIMPLE_NAMED(_name, _pattern, _string, _compile_opts, _match_opts, _expected) { \
168 TestMatchData *data; \
169 gchar *path; \
170 data = g_new0 (TestMatchData, 1); \
171 data->pattern = _pattern; \
172 data->string = _string; \
173 data->compile_opts = _compile_opts; \
174 data->match_opts = _match_opts; \
175 data->expected = _expected; \
176 path = g_strdup_printf ("/regex/match-%s/%d", _name, ++total); \
177 g_test_add_data_func_full (path, data, test_match_simple, g_free); \
178 g_free (path); \
179 }
180  
181 #define TEST_MATCH_SIMPLE(_pattern, _string, _compile_opts, _match_opts, _expected) \
182 TEST_MATCH_SIMPLE_NAMED("simple", _pattern, _string, _compile_opts, _match_opts, _expected)
183 #define TEST_MATCH_NOTEMPTY(_pattern, _string, _expected) \
184 TEST_MATCH_SIMPLE_NAMED("notempty", _pattern, _string, 0, G_REGEX_MATCH_NOTEMPTY, _expected)
185 #define TEST_MATCH_NOTEMPTY_ATSTART(_pattern, _string, _expected) \
186 TEST_MATCH_SIMPLE_NAMED("notempty-atstart", _pattern, _string, 0, G_REGEX_MATCH_NOTEMPTY_ATSTART, _expected)
187  
188 static void
189 test_match (gconstpointer d)
190 {
191 const TestMatchData *data = d;
192 GRegex *regex;
193 gboolean match;
194 GError *error = NULL;
195  
196 regex = g_regex_new (data->pattern, data->compile_opts, data->match_opts, &error);
197 g_assert (regex != NULL);
198 g_assert_no_error (error);
199  
200 match = g_regex_match_full (regex, data->string, data->string_len,
201 data->start_position, data->match_opts2, NULL, NULL);
202  
203 if (data->expected)
204 {
205 if (!match)
206 g_error ("Regex '%s' (with compile options %u and "
207 "match options %u) should have matched '%.*s' "
208 "(of length %d, at position %d, with match options %u) but did not",
209 data->pattern, data->compile_opts, data->match_opts,
210 data->string_len == -1 ? (int) strlen (data->string) :
211 (int) data->string_len,
212 data->string, (int) data->string_len,
213 data->start_position, data->match_opts2);
214  
215 g_assert_cmpint (match, ==, TRUE);
216 }
217 else
218 {
219 if (match)
220 g_error ("Regex '%s' (with compile options %u and "
221 "match options %u) should not have matched '%.*s' "
222 "(of length %d, at position %d, with match options %u) but did",
223 data->pattern, data->compile_opts, data->match_opts,
224 data->string_len == -1 ? (int) strlen (data->string) :
225 (int) data->string_len,
226 data->string, (int) data->string_len,
227 data->start_position, data->match_opts2);
228 }
229  
230 if (data->string_len == -1 && data->start_position == 0)
231 {
232 match = g_regex_match (regex, data->string, data->match_opts2, NULL);
233 g_assert_cmpint (match, ==, data->expected);
234 }
235  
236 g_regex_unref (regex);
237 }
238  
239 #define TEST_MATCH(_pattern, _compile_opts, _match_opts, _string, \
240 _string_len, _start_position, _match_opts2, _expected) { \
241 TestMatchData *data; \
242 gchar *path; \
243 data = g_new0 (TestMatchData, 1); \
244 data->pattern = _pattern; \
245 data->compile_opts = _compile_opts; \
246 data->match_opts = _match_opts; \
247 data->string = _string; \
248 data->string_len = _string_len; \
249 data->start_position = _start_position; \
250 data->match_opts2 = _match_opts2; \
251 data->expected = _expected; \
252 path = g_strdup_printf ("/regex/match/%d", ++total); \
253 g_test_add_data_func_full (path, data, test_match, g_free); \
254 g_free (path); \
255 }
256  
257 struct _Match
258 {
259 gchar *string;
260 gint start, end;
261 };
262 typedef struct _Match Match;
263  
264 static void
265 free_match (gpointer data)
266 {
267 Match *match = data;
268 if (match == NULL)
269 return;
270 g_free (match->string);
271 g_free (match);
272 }
273  
274 typedef struct {
275 const gchar *pattern;
276 const gchar *string;
277 gssize string_len;
278 gint start_position;
279 GSList *expected;
280 } TestMatchNextData;
281  
282 static void
283 test_match_next (gconstpointer d)
284 {
285 const TestMatchNextData *data = d;
286 GRegex *regex;
287 GMatchInfo *match_info;
288 GSList *matches;
289 GSList *l_exp, *l_match;
290  
291 regex = g_regex_new (data->pattern, 0, 0, NULL);
292  
293 g_assert (regex != NULL);
294  
295 g_regex_match_full (regex, data->string, data->string_len,
296 data->start_position, 0, &match_info, NULL);
297 matches = NULL;
298 while (g_match_info_matches (match_info))
299 {
300 Match *match = g_new0 (Match, 1);
301 match->string = g_match_info_fetch (match_info, 0);
302 match->start = UNTOUCHED;
303 match->end = UNTOUCHED;
304 g_match_info_fetch_pos (match_info, 0, &match->start, &match->end);
305 matches = g_slist_prepend (matches, match);
306 g_match_info_next (match_info, NULL);
307 }
308 g_assert (regex == g_match_info_get_regex (match_info));
309 g_assert_cmpstr (data->string, ==, g_match_info_get_string (match_info));
310 g_match_info_free (match_info);
311 matches = g_slist_reverse (matches);
312  
313 g_assert_cmpint (g_slist_length (matches), ==, g_slist_length (data->expected));
314  
315 l_exp = data->expected;
316 l_match = matches;
317 while (l_exp != NULL)
318 {
319 Match *exp = l_exp->data;
320 Match *match = l_match->data;
321  
322 g_assert_cmpstr (exp->string, ==, match->string);
323 g_assert_cmpint (exp->start, ==, match->start);
324 g_assert_cmpint (exp->end, ==, match->end);
325  
326 l_exp = g_slist_next (l_exp);
327 l_match = g_slist_next (l_match);
328 }
329  
330 g_regex_unref (regex);
331 g_slist_free_full (matches, free_match);
332 }
333  
334 static void
335 free_match_next_data (gpointer _data)
336 {
337 TestMatchNextData *data = _data;
338  
339 g_slist_free_full (data->expected, g_free);
340 g_free (data);
341 }
342  
343 #define TEST_MATCH_NEXT0(_pattern, _string, _string_len, _start_position) { \
344 TestMatchNextData *data; \
345 gchar *path; \
346 data = g_new0 (TestMatchNextData, 1); \
347 data->pattern = _pattern; \
348 data->string = _string; \
349 data->string_len = _string_len; \
350 data->start_position = _start_position; \
351 data->expected = NULL; \
352 path = g_strdup_printf ("/regex/match/next0/%d", ++total); \
353 g_test_add_data_func_full (path, data, test_match_next, free_match_next_data); \
354 g_free (path); \
355 }
356  
357 #define TEST_MATCH_NEXT1(_pattern, _string, _string_len, _start_position, \
358 t1, s1, e1) { \
359 TestMatchNextData *data; \
360 Match *match; \
361 gchar *path; \
362 data = g_new0 (TestMatchNextData, 1); \
363 data->pattern = _pattern; \
364 data->string = _string; \
365 data->string_len = _string_len; \
366 data->start_position = _start_position; \
367 match = g_new0 (Match, 1); \
368 match->string = t1; \
369 match->start = s1; \
370 match->end = e1; \
371 data->expected = g_slist_append (NULL, match); \
372 path = g_strdup_printf ("/regex/match/next1/%d", ++total); \
373 g_test_add_data_func_full (path, data, test_match_next, free_match_next_data); \
374 g_free (path); \
375 }
376  
377 #define TEST_MATCH_NEXT2(_pattern, _string, _string_len, _start_position, \
378 t1, s1, e1, t2, s2, e2) { \
379 TestMatchNextData *data; \
380 Match *match; \
381 gchar *path; \
382 data = g_new0 (TestMatchNextData, 1); \
383 data->pattern = _pattern; \
384 data->string = _string; \
385 data->string_len = _string_len; \
386 data->start_position = _start_position; \
387 match = g_new0 (Match, 1); \
388 match->string = t1; \
389 match->start = s1; \
390 match->end = e1; \
391 data->expected = g_slist_append (NULL, match); \
392 match = g_new0 (Match, 1); \
393 match->string = t2; \
394 match->start = s2; \
395 match->end = e2; \
396 data->expected = g_slist_append (data->expected, match); \
397 path = g_strdup_printf ("/regex/match/next2/%d", ++total); \
398 g_test_add_data_func_full (path, data, test_match_next, free_match_next_data); \
399 g_free (path); \
400 }
401  
402 #define TEST_MATCH_NEXT3(_pattern, _string, _string_len, _start_position, \
403 t1, s1, e1, t2, s2, e2, t3, s3, e3) { \
404 TestMatchNextData *data; \
405 Match *match; \
406 gchar *path; \
407 data = g_new0 (TestMatchNextData, 1); \
408 data->pattern = _pattern; \
409 data->string = _string; \
410 data->string_len = _string_len; \
411 data->start_position = _start_position; \
412 match = g_new0 (Match, 1); \
413 match->string = t1; \
414 match->start = s1; \
415 match->end = e1; \
416 data->expected = g_slist_append (NULL, match); \
417 match = g_new0 (Match, 1); \
418 match->string = t2; \
419 match->start = s2; \
420 match->end = e2; \
421 data->expected = g_slist_append (data->expected, match); \
422 match = g_new0 (Match, 1); \
423 match->string = t3; \
424 match->start = s3; \
425 match->end = e3; \
426 data->expected = g_slist_append (data->expected, match); \
427 path = g_strdup_printf ("/regex/match/next3/%d", ++total); \
428 g_test_add_data_func_full (path, data, test_match_next, free_match_next_data); \
429 g_free (path); \
430 }
431  
432 #define TEST_MATCH_NEXT4(_pattern, _string, _string_len, _start_position, \
433 t1, s1, e1, t2, s2, e2, t3, s3, e3, t4, s4, e4) { \
434 TestMatchNextData *data; \
435 Match *match; \
436 gchar *path; \
437 data = g_new0 (TestMatchNextData, 1); \
438 data->pattern = _pattern; \
439 data->string = _string; \
440 data->string_len = _string_len; \
441 data->start_position = _start_position; \
442 match = g_new0 (Match, 1); \
443 match->string = t1; \
444 match->start = s1; \
445 match->end = e1; \
446 data->expected = g_slist_append (NULL, match); \
447 match = g_new0 (Match, 1); \
448 match->string = t2; \
449 match->start = s2; \
450 match->end = e2; \
451 data->expected = g_slist_append (data->expected, match); \
452 match = g_new0 (Match, 1); \
453 match->string = t3; \
454 match->start = s3; \
455 match->end = e3; \
456 data->expected = g_slist_append (data->expected, match); \
457 match = g_new0 (Match, 1); \
458 match->string = t4; \
459 match->start = s4; \
460 match->end = e4; \
461 data->expected = g_slist_append (data->expected, match); \
462 path = g_strdup_printf ("/regex/match/next4/%d", ++total); \
463 g_test_add_data_func_full (path, data, test_match_next, free_match_next_data); \
464 g_free (path); \
465 }
466  
467 typedef struct {
468 const gchar *pattern;
469 const gchar *string;
470 gint start_position;
471 GRegexMatchFlags match_opts;
472 gint expected_count;
473 } TestMatchCountData;
474  
475 static void
476 test_match_count (gconstpointer d)
477 {
478 const TestMatchCountData *data = d;
479 GRegex *regex;
480 GMatchInfo *match_info;
481 gint count;
482  
483 regex = g_regex_new (data->pattern, 0, 0, NULL);
484  
485 g_assert (regex != NULL);
486  
487 g_regex_match_full (regex, data->string, -1, data->start_position,
488 data->match_opts, &match_info, NULL);
489 count = g_match_info_get_match_count (match_info);
490  
491 g_assert_cmpint (count, ==, data->expected_count);
492  
493 g_match_info_ref (match_info);
494 g_match_info_unref (match_info);
495 g_match_info_unref (match_info);
496 g_regex_unref (regex);
497 }
498  
499 #define TEST_MATCH_COUNT(_pattern, _string, _start_position, _match_opts, _expected_count) { \
500 TestMatchCountData *data; \
501 gchar *path; \
502 data = g_new0 (TestMatchCountData, 1); \
503 data->pattern = _pattern; \
504 data->string = _string; \
505 data->start_position = _start_position; \
506 data->match_opts = _match_opts; \
507 data->expected_count = _expected_count; \
508 path = g_strdup_printf ("/regex/match/count/%d", ++total); \
509 g_test_add_data_func_full (path, data, test_match_count, g_free); \
510 g_free (path); \
511 }
512  
513 static void
514 test_partial (gconstpointer d)
515 {
516 const TestMatchData *data = d;
517 GRegex *regex;
518 GMatchInfo *match_info;
519  
520 regex = g_regex_new (data->pattern, 0, 0, NULL);
521  
522 g_assert (regex != NULL);
523  
524 g_regex_match (regex, data->string, data->match_opts, &match_info);
525  
526 g_assert_cmpint (data->expected, ==, g_match_info_is_partial_match (match_info));
527  
528 if (data->expected)
529 {
530 g_assert (!g_match_info_fetch_pos (match_info, 0, NULL, NULL));
531 g_assert (!g_match_info_fetch_pos (match_info, 1, NULL, NULL));
532 }
533  
534 g_match_info_free (match_info);
535 g_regex_unref (regex);
536 }
537  
538 #define TEST_PARTIAL_FULL(_pattern, _string, _match_opts, _expected) { \
539 TestMatchData *data; \
540 gchar *path; \
541 data = g_new0 (TestMatchData, 1); \
542 data->pattern = _pattern; \
543 data->string = _string; \
544 data->match_opts = _match_opts; \
545 data->expected = _expected; \
546 path = g_strdup_printf ("/regex/match/partial/%d", ++total); \
547 g_test_add_data_func_full (path, data, test_partial, g_free); \
548 g_free (path); \
549 }
550  
551 #define TEST_PARTIAL(_pattern, _string, _expected) TEST_PARTIAL_FULL(_pattern, _string, G_REGEX_MATCH_PARTIAL, _expected)
552  
553 typedef struct {
554 const gchar *pattern;
555 const gchar *string;
556 gint start_position;
557 gint sub_n;
558 const gchar *expected_sub;
559 gint expected_start;
560 gint expected_end;
561 } TestSubData;
562  
563 static void
564 test_sub_pattern (gconstpointer d)
565 {
566 const TestSubData *data = d;
567 GRegex *regex;
568 GMatchInfo *match_info;
569 gchar *sub_expr;
570 gint start = UNTOUCHED, end = UNTOUCHED;
571  
572 regex = g_regex_new (data->pattern, 0, 0, NULL);
573  
574 g_assert (regex != NULL);
575  
576 g_regex_match_full (regex, data->string, -1, data->start_position, 0, &match_info, NULL);
577  
578 sub_expr = g_match_info_fetch (match_info, data->sub_n);
579 g_assert_cmpstr (sub_expr, ==, data->expected_sub);
580 g_free (sub_expr);
581  
582 g_match_info_fetch_pos (match_info, data->sub_n, &start, &end);
583 g_assert_cmpint (start, ==, data->expected_start);
584 g_assert_cmpint (end, ==, data->expected_end);
585  
586 g_match_info_free (match_info);
587 g_regex_unref (regex);
588 }
589  
590 #define TEST_SUB_PATTERN(_pattern, _string, _start_position, _sub_n, _expected_sub, \
591 _expected_start, _expected_end) { \
592 TestSubData *data; \
593 gchar *path; \
594 data = g_new0 (TestSubData, 1); \
595 data->pattern = _pattern; \
596 data->string = _string; \
597 data->start_position = _start_position; \
598 data->sub_n = _sub_n; \
599 data->expected_sub = _expected_sub; \
600 data->expected_start = _expected_start; \
601 data->expected_end = _expected_end; \
602 path = g_strdup_printf ("/regex/match/subpattern/%d", ++total); \
603 g_test_add_data_func_full (path, data, test_sub_pattern, g_free); \
604 g_free (path); \
605 }
606  
607 typedef struct {
608 const gchar *pattern;
609 GRegexCompileFlags flags;
610 const gchar *string;
611 gint start_position;
612 const gchar *sub_name;
613 const gchar *expected_sub;
614 gint expected_start;
615 gint expected_end;
616 } TestNamedSubData;
617  
618 static void
619 test_named_sub_pattern (gconstpointer d)
620 {
621 const TestNamedSubData *data = d;
622 GRegex *regex;
623 GMatchInfo *match_info;
624 gint start = UNTOUCHED, end = UNTOUCHED;
625 gchar *sub_expr;
626  
627 regex = g_regex_new (data->pattern, data->flags, 0, NULL);
628  
629 g_assert (regex != NULL);
630  
631 g_regex_match_full (regex, data->string, -1, data->start_position, 0, &match_info, NULL);
632 sub_expr = g_match_info_fetch_named (match_info, data->sub_name);
633 g_assert_cmpstr (sub_expr, ==, data->expected_sub);
634 g_free (sub_expr);
635  
636 g_match_info_fetch_named_pos (match_info, data->sub_name, &start, &end);
637 g_assert_cmpint (start, ==, data->expected_start);
638 g_assert_cmpint (end, ==, data->expected_end);
639  
640 g_match_info_free (match_info);
641 g_regex_unref (regex);
642 }
643  
644 #define TEST_NAMED_SUB_PATTERN(_pattern, _string, _start_position, _sub_name, \
645 _expected_sub, _expected_start, _expected_end) { \
646 TestNamedSubData *data; \
647 gchar *path; \
648 data = g_new0 (TestNamedSubData, 1); \
649 data->pattern = _pattern; \
650 data->string = _string; \
651 data->flags = 0; \
652 data->start_position = _start_position; \
653 data->sub_name = _sub_name; \
654 data->expected_sub = _expected_sub; \
655 data->expected_start = _expected_start; \
656 data->expected_end = _expected_end; \
657 path = g_strdup_printf ("/regex/match/named/subpattern/%d", ++total); \
658 g_test_add_data_func_full (path, data, test_named_sub_pattern, g_free); \
659 g_free (path); \
660 }
661  
662 #define TEST_NAMED_SUB_PATTERN_DUPNAMES(_pattern, _string, _start_position, _sub_name, \
663 _expected_sub, _expected_start, _expected_end) { \
664 TestNamedSubData *data; \
665 gchar *path; \
666 data = g_new0 (TestNamedSubData, 1); \
667 data->pattern = _pattern; \
668 data->string = _string; \
669 data->flags = G_REGEX_DUPNAMES; \
670 data->start_position = _start_position; \
671 data->sub_name = _sub_name; \
672 data->expected_sub = _expected_sub; \
673 data->expected_start = _expected_start; \
674 data->expected_end = _expected_end; \
675 path = g_strdup_printf ("/regex/match/subpattern/named/dupnames/%d", ++total); \
676 g_test_add_data_func_full (path, data, test_named_sub_pattern, g_free); \
677 g_free (path); \
678 }
679  
680 typedef struct {
681 const gchar *pattern;
682 const gchar *string;
683 GSList *expected;
684 gint start_position;
685 gint max_tokens;
686 } TestFetchAllData;
687  
688 static void
689 test_fetch_all (gconstpointer d)
690 {
691 const TestFetchAllData *data = d;
692 GRegex *regex;
693 GMatchInfo *match_info;
694 GSList *l_exp;
695 gchar **matches;
696 gint match_count;
697 gint i;
698  
699 regex = g_regex_new (data->pattern, 0, 0, NULL);
700  
701 g_assert (regex != NULL);
702  
703 g_regex_match (regex, data->string, 0, &match_info);
704 matches = g_match_info_fetch_all (match_info);
705 if (matches)
706 match_count = g_strv_length (matches);
707 else
708 match_count = 0;
709  
710 g_assert_cmpint (match_count, ==, g_slist_length (data->expected));
711  
712 l_exp = data->expected;
713 for (i = 0; l_exp != NULL; i++, l_exp = g_slist_next (l_exp))
714 {
715 g_assert_cmpstr (l_exp->data, ==, matches[i]);
716 }
717  
718 g_match_info_free (match_info);
719 g_regex_unref (regex);
720 g_strfreev (matches);
721 }
722  
723 static void
724 free_fetch_all_data (gpointer _data)
725 {
726 TestFetchAllData *data = _data;
727  
728 g_slist_free (data->expected);
729 g_free (data);
730 }
731  
732 #define TEST_FETCH_ALL0(_pattern, _string) { \
733 TestFetchAllData *data; \
734 gchar *path; \
735 data = g_new0 (TestFetchAllData, 1); \
736 data->pattern = _pattern; \
737 data->string = _string; \
738 data->expected = NULL; \
739 path = g_strdup_printf ("/regex/fetch-all0/%d", ++total); \
740 g_test_add_data_func_full (path, data, test_fetch_all, free_fetch_all_data); \
741 g_free (path); \
742 }
743  
744 #define TEST_FETCH_ALL1(_pattern, _string, e1) { \
745 TestFetchAllData *data; \
746 gchar *path; \
747 data = g_new0 (TestFetchAllData, 1); \
748 data->pattern = _pattern; \
749 data->string = _string; \
750 data->expected = g_slist_append (NULL, e1); \
751 path = g_strdup_printf ("/regex/fetch-all1/%d", ++total); \
752 g_test_add_data_func_full (path, data, test_fetch_all, free_fetch_all_data); \
753 g_free (path); \
754 }
755  
756 #define TEST_FETCH_ALL2(_pattern, _string, e1, e2) { \
757 TestFetchAllData *data; \
758 gchar *path; \
759 data = g_new0 (TestFetchAllData, 1); \
760 data->pattern = _pattern; \
761 data->string = _string; \
762 data->expected = g_slist_append (NULL, e1); \
763 data->expected = g_slist_append (data->expected, e2); \
764 path = g_strdup_printf ("/regex/fetch-all2/%d", ++total); \
765 g_test_add_data_func_full (path, data, test_fetch_all, free_fetch_all_data); \
766 g_free (path); \
767 }
768  
769 #define TEST_FETCH_ALL3(_pattern, _string, e1, e2, e3) { \
770 TestFetchAllData *data; \
771 gchar *path; \
772 data = g_new0 (TestFetchAllData, 1); \
773 data->pattern = _pattern; \
774 data->string = _string; \
775 data->expected = g_slist_append (NULL, e1); \
776 data->expected = g_slist_append (data->expected, e2); \
777 data->expected = g_slist_append (data->expected, e3); \
778 path = g_strdup_printf ("/regex/fetch-all3/%d", ++total); \
779 g_test_add_data_func_full (path, data, test_fetch_all, free_fetch_all_data); \
780 g_free (path); \
781 }
782  
783 static void
784 test_split_simple (gconstpointer d)
785 {
786 const TestFetchAllData *data = d;
787 GSList *l_exp;
788 gchar **tokens;
789 gint token_count;
790 gint i;
791  
792 tokens = g_regex_split_simple (data->pattern, data->string, 0, 0);
793 if (tokens)
794 token_count = g_strv_length (tokens);
795 else
796 token_count = 0;
797  
798 g_assert_cmpint (token_count, ==, g_slist_length (data->expected));
799  
800 l_exp = data->expected;
801 for (i = 0; l_exp != NULL; i++, l_exp = g_slist_next (l_exp))
802 {
803 g_assert_cmpstr (l_exp->data, ==, tokens[i]);
804 }
805  
806 g_strfreev (tokens);
807 }
808  
809 #define TEST_SPLIT_SIMPLE0(_pattern, _string) { \
810 TestFetchAllData *data; \
811 gchar *path; \
812 data = g_new0 (TestFetchAllData, 1); \
813 data->pattern = _pattern; \
814 data->string = _string; \
815 data->expected = NULL; \
816 path = g_strdup_printf ("/regex/split/simple0/%d", ++total); \
817 g_test_add_data_func_full (path, data, test_split_simple, free_fetch_all_data); \
818 g_free (path); \
819 }
820  
821 #define TEST_SPLIT_SIMPLE1(_pattern, _string, e1) { \
822 TestFetchAllData *data; \
823 gchar *path; \
824 data = g_new0 (TestFetchAllData, 1); \
825 data->pattern = _pattern; \
826 data->string = _string; \
827 data->expected = g_slist_append (NULL, e1); \
828 path = g_strdup_printf ("/regex/split/simple1/%d", ++total); \
829 g_test_add_data_func_full (path, data, test_split_simple, free_fetch_all_data); \
830 g_free (path); \
831 }
832  
833 #define TEST_SPLIT_SIMPLE2(_pattern, _string, e1, e2) { \
834 TestFetchAllData *data; \
835 gchar *path; \
836 data = g_new0 (TestFetchAllData, 1); \
837 data->pattern = _pattern; \
838 data->string = _string; \
839 data->expected = g_slist_append (NULL, e1); \
840 data->expected = g_slist_append (data->expected, e2); \
841 path = g_strdup_printf ("/regex/split/simple2/%d", ++total); \
842 g_test_add_data_func_full (path, data, test_split_simple, free_fetch_all_data); \
843 g_free (path); \
844 }
845  
846 #define TEST_SPLIT_SIMPLE3(_pattern, _string, e1, e2, e3) { \
847 TestFetchAllData *data; \
848 gchar *path; \
849 data = g_new0 (TestFetchAllData, 1); \
850 data->pattern = _pattern; \
851 data->string = _string; \
852 data->expected = g_slist_append (NULL, e1); \
853 data->expected = g_slist_append (data->expected, e2); \
854 data->expected = g_slist_append (data->expected, e3); \
855 path = g_strdup_printf ("/regex/split/simple3/%d", ++total); \
856 g_test_add_data_func_full (path, data, test_split_simple, free_fetch_all_data); \
857 g_free (path); \
858 }
859  
860 static void
861 test_split_full (gconstpointer d)
862 {
863 const TestFetchAllData *data = d;
864 GRegex *regex;
865 GSList *l_exp;
866 gchar **tokens;
867 gint token_count;
868 gint i;
869  
870 regex = g_regex_new (data->pattern, 0, 0, NULL);
871  
872 g_assert (regex != NULL);
873  
874 tokens = g_regex_split_full (regex, data->string, -1, data->start_position,
875 0, data->max_tokens, NULL);
876 if (tokens)
877 token_count = g_strv_length (tokens);
878 else
879 token_count = 0;
880  
881 g_assert_cmpint (token_count, ==, g_slist_length (data->expected));
882  
883 l_exp = data->expected;
884 for (i = 0; l_exp != NULL; i++, l_exp = g_slist_next (l_exp))
885 {
886 g_assert_cmpstr (l_exp->data, ==, tokens[i]);
887 }
888  
889 g_regex_unref (regex);
890 g_strfreev (tokens);
891 }
892  
893 static void
894 test_split (gconstpointer d)
895 {
896 const TestFetchAllData *data = d;
897 GRegex *regex;
898 GSList *l_exp;
899 gchar **tokens;
900 gint token_count;
901 gint i;
902  
903 regex = g_regex_new (data->pattern, 0, 0, NULL);
904  
905 g_assert (regex != NULL);
906  
907 tokens = g_regex_split (regex, data->string, 0);
908 if (tokens)
909 token_count = g_strv_length (tokens);
910 else
911 token_count = 0;
912  
913 g_assert_cmpint (token_count, ==, g_slist_length (data->expected));
914  
915 l_exp = data->expected;
916 for (i = 0; l_exp != NULL; i++, l_exp = g_slist_next (l_exp))
917 {
918 g_assert_cmpstr (l_exp->data, ==, tokens[i]);
919 }
920  
921 g_regex_unref (regex);
922 g_strfreev (tokens);
923 }
924  
925 #define TEST_SPLIT0(_pattern, _string, _start_position, _max_tokens) { \
926 TestFetchAllData *data; \
927 gchar *path; \
928 data = g_new0 (TestFetchAllData, 1); \
929 data->pattern = _pattern; \
930 data->string = _string; \
931 data->start_position = _start_position; \
932 data->max_tokens = _max_tokens; \
933 data->expected = NULL; \
934 if (_start_position == 0 && _max_tokens <= 0) { \
935 path = g_strdup_printf ("/regex/split0/%d", ++total); \
936 g_test_add_data_func (path, data, test_split); \
937 g_free (path); \
938 } \
939 path = g_strdup_printf ("/regex/full-split0/%d", ++total); \
940 g_test_add_data_func_full (path, data, test_split_full, free_fetch_all_data); \
941 g_free (path); \
942 }
943  
944 #define TEST_SPLIT1(_pattern, _string, _start_position, _max_tokens, e1) { \
945 TestFetchAllData *data; \
946 gchar *path; \
947 data = g_new0 (TestFetchAllData, 1); \
948 data->pattern = _pattern; \
949 data->string = _string; \
950 data->start_position = _start_position; \
951 data->max_tokens = _max_tokens; \
952 data->expected = NULL; \
953 data->expected = g_slist_append (data->expected, e1); \
954 if (_start_position == 0 && _max_tokens <= 0) { \
955 path = g_strdup_printf ("/regex/split1/%d", ++total); \
956 g_test_add_data_func (path, data, test_split); \
957 g_free (path); \
958 } \
959 path = g_strdup_printf ("/regex/full-split1/%d", ++total); \
960 g_test_add_data_func_full (path, data, test_split_full, free_fetch_all_data); \
961 g_free (path); \
962 }
963  
964 #define TEST_SPLIT2(_pattern, _string, _start_position, _max_tokens, e1, e2) { \
965 TestFetchAllData *data; \
966 gchar *path; \
967 data = g_new0 (TestFetchAllData, 1); \
968 data->pattern = _pattern; \
969 data->string = _string; \
970 data->start_position = _start_position; \
971 data->max_tokens = _max_tokens; \
972 data->expected = NULL; \
973 data->expected = g_slist_append (data->expected, e1); \
974 data->expected = g_slist_append (data->expected, e2); \
975 if (_start_position == 0 && _max_tokens <= 0) { \
976 path = g_strdup_printf ("/regex/split2/%d", ++total); \
977 g_test_add_data_func (path, data, test_split); \
978 g_free (path); \
979 } \
980 path = g_strdup_printf ("/regex/full-split2/%d", ++total); \
981 g_test_add_data_func_full (path, data, test_split_full, free_fetch_all_data); \
982 g_free (path); \
983 }
984  
985 #define TEST_SPLIT3(_pattern, _string, _start_position, _max_tokens, e1, e2, e3) { \
986 TestFetchAllData *data; \
987 gchar *path; \
988 data = g_new0 (TestFetchAllData, 1); \
989 data->pattern = _pattern; \
990 data->string = _string; \
991 data->start_position = _start_position; \
992 data->max_tokens = _max_tokens; \
993 data->expected = NULL; \
994 data->expected = g_slist_append (data->expected, e1); \
995 data->expected = g_slist_append (data->expected, e2); \
996 data->expected = g_slist_append (data->expected, e3); \
997 if (_start_position == 0 && _max_tokens <= 0) { \
998 path = g_strdup_printf ("/regex/split3/%d", ++total); \
999 g_test_add_data_func (path, data, test_split); \
1000 g_free (path); \
1001 } \
1002 path = g_strdup_printf ("/regex/full-split3/%d", ++total); \
1003 g_test_add_data_func_full (path, data, test_split_full, free_fetch_all_data); \
1004 g_free (path); \
1005 }
1006  
1007 typedef struct {
1008 const gchar *string_to_expand;
1009 gboolean expected;
1010 gboolean expected_refs;
1011 } TestCheckReplacementData;
1012  
1013 static void
1014 test_check_replacement (gconstpointer d)
1015 {
1016 const TestCheckReplacementData *data = d;
1017 gboolean has_refs;
1018 gboolean result;
1019  
1020 result = g_regex_check_replacement (data->string_to_expand, &has_refs, NULL);
1021 g_assert_cmpint (data->expected, ==, result);
1022  
1023 if (data->expected)
1024 g_assert_cmpint (data->expected_refs, ==, has_refs);
1025 }
1026  
1027 #define TEST_CHECK_REPLACEMENT(_string_to_expand, _expected, _expected_refs) { \
1028 TestCheckReplacementData *data; \
1029 gchar *path; \
1030 data = g_new0 (TestCheckReplacementData, 1); \
1031 data->string_to_expand = _string_to_expand; \
1032 data->expected = _expected; \
1033 data->expected_refs = _expected_refs; \
1034 path = g_strdup_printf ("/regex/check-repacement/%d", ++total); \
1035 g_test_add_data_func_full (path, data, test_check_replacement, g_free); \
1036 g_free (path); \
1037 }
1038  
1039 typedef struct {
1040 const gchar *pattern;
1041 const gchar *string;
1042 const gchar *string_to_expand;
1043 gboolean raw;
1044 const gchar *expected;
1045 } TestExpandData;
1046  
1047 static void
1048 test_expand (gconstpointer d)
1049 {
1050 const TestExpandData *data = d;
1051 GRegex *regex = NULL;
1052 GMatchInfo *match_info = NULL;
1053 gchar *res;
1054 GError *error = NULL;
1055  
1056 if (data->pattern)
1057 {
1058 regex = g_regex_new (data->pattern, data->raw ? G_REGEX_RAW : 0, 0,
1059 &error);
1060 g_assert_no_error (error);
1061 g_regex_match (regex, data->string, 0, &match_info);
1062 }
1063  
1064 res = g_match_info_expand_references (match_info, data->string_to_expand, NULL);
1065 g_assert_cmpstr (res, ==, data->expected);
1066 g_free (res);
1067 g_match_info_free (match_info);
1068 if (regex)
1069 g_regex_unref (regex);
1070 }
1071  
1072 #define TEST_EXPAND(_pattern, _string, _string_to_expand, _raw, _expected) { \
1073 TestExpandData *data; \
1074 gchar *path; \
1075 data = g_new0 (TestExpandData, 1); \
1076 data->pattern = _pattern; \
1077 data->string = _string; \
1078 data->string_to_expand = _string_to_expand; \
1079 data->raw = _raw; \
1080 data->expected = _expected; \
1081 path = g_strdup_printf ("/regex/expand/%d", ++total); \
1082 g_test_add_data_func_full (path, data, test_expand, g_free); \
1083 g_free (path); \
1084 }
1085  
1086 typedef struct {
1087 const gchar *pattern;
1088 const gchar *string;
1089 gint start_position;
1090 const gchar *replacement;
1091 const gchar *expected;
1092 } TestReplaceData;
1093  
1094 static void
1095 test_replace (gconstpointer d)
1096 {
1097 const TestReplaceData *data = d;
1098 GRegex *regex;
1099 gchar *res;
1100  
1101 regex = g_regex_new (data->pattern, 0, 0, NULL);
1102 res = g_regex_replace (regex, data->string, -1, data->start_position, data->replacement, 0, NULL);
1103  
1104 g_assert_cmpstr (res, ==, data->expected);
1105  
1106 g_free (res);
1107 g_regex_unref (regex);
1108 }
1109  
1110 #define TEST_REPLACE(_pattern, _string, _start_position, _replacement, _expected) { \
1111 TestReplaceData *data; \
1112 gchar *path; \
1113 data = g_new0 (TestReplaceData, 1); \
1114 data->pattern = _pattern; \
1115 data->string = _string; \
1116 data->start_position = _start_position; \
1117 data->replacement = _replacement; \
1118 data->expected = _expected; \
1119 path = g_strdup_printf ("/regex/replace/%d", ++total); \
1120 g_test_add_data_func_full (path, data, test_replace, g_free); \
1121 g_free (path); \
1122 }
1123  
1124 static void
1125 test_replace_lit (gconstpointer d)
1126 {
1127 const TestReplaceData *data = d;
1128 GRegex *regex;
1129 gchar *res;
1130  
1131 regex = g_regex_new (data->pattern, 0, 0, NULL);
1132 res = g_regex_replace_literal (regex, data->string, -1, data->start_position,
1133 data->replacement, 0, NULL);
1134 g_assert_cmpstr (res, ==, data->expected);
1135  
1136 g_free (res);
1137 g_regex_unref (regex);
1138 }
1139  
1140 #define TEST_REPLACE_LIT(_pattern, _string, _start_position, _replacement, _expected) { \
1141 TestReplaceData *data; \
1142 gchar *path; \
1143 data = g_new0 (TestReplaceData, 1); \
1144 data->pattern = _pattern; \
1145 data->string = _string; \
1146 data->start_position = _start_position; \
1147 data->replacement = _replacement; \
1148 data->expected = _expected; \
1149 path = g_strdup_printf ("/regex/replace-literally/%d", ++total); \
1150 g_test_add_data_func_full (path, data, test_replace_lit, g_free); \
1151 g_free (path); \
1152 }
1153  
1154 typedef struct {
1155 const gchar *pattern;
1156 const gchar *name;
1157 gint expected_num;
1158 } TestStringNumData;
1159  
1160 static void
1161 test_get_string_number (gconstpointer d)
1162 {
1163 const TestStringNumData *data = d;
1164 GRegex *regex;
1165 gint num;
1166  
1167 regex = g_regex_new (data->pattern, 0, 0, NULL);
1168 num = g_regex_get_string_number (regex, data->name);
1169  
1170 g_assert_cmpint (num, ==, data->expected_num);
1171 g_regex_unref (regex);
1172 }
1173  
1174 #define TEST_GET_STRING_NUMBER(_pattern, _name, _expected_num) { \
1175 TestStringNumData *data; \
1176 gchar *path; \
1177 data = g_new0 (TestStringNumData, 1); \
1178 data->pattern = _pattern; \
1179 data->name = _name; \
1180 data->expected_num = _expected_num; \
1181 path = g_strdup_printf ("/regex/string-number/%d", ++total); \
1182 g_test_add_data_func_full (path, data, test_get_string_number, g_free); \
1183 g_free (path); \
1184 }
1185  
1186 typedef struct {
1187 const gchar *string;
1188 gint length;
1189 const gchar *expected;
1190 } TestEscapeData;
1191  
1192 static void
1193 test_escape (gconstpointer d)
1194 {
1195 const TestEscapeData *data = d;
1196 gchar *escaped;
1197  
1198 escaped = g_regex_escape_string (data->string, data->length);
1199  
1200 g_assert_cmpstr (escaped, ==, data->expected);
1201  
1202 g_free (escaped);
1203 }
1204  
1205 #define TEST_ESCAPE(_string, _length, _expected) { \
1206 TestEscapeData *data; \
1207 gchar *path; \
1208 data = g_new0 (TestEscapeData, 1); \
1209 data->string = _string; \
1210 data->length = _length; \
1211 data->expected = _expected; \
1212 path = g_strdup_printf ("/regex/escape/%d", ++total); \
1213 g_test_add_data_func_full (path, data, test_escape, g_free); \
1214 g_free (path); \
1215 }
1216  
1217 static void
1218 test_escape_nul (gconstpointer d)
1219 {
1220 const TestEscapeData *data = d;
1221 gchar *escaped;
1222  
1223 escaped = g_regex_escape_nul (data->string, data->length);
1224  
1225 g_assert_cmpstr (escaped, ==, data->expected);
1226  
1227 g_free (escaped);
1228 }
1229  
1230 #define TEST_ESCAPE_NUL(_string, _length, _expected) { \
1231 TestEscapeData *data; \
1232 gchar *path; \
1233 data = g_new0 (TestEscapeData, 1); \
1234 data->string = _string; \
1235 data->length = _length; \
1236 data->expected = _expected; \
1237 path = g_strdup_printf ("/regex/escape_nul/%d", ++total); \
1238 g_test_add_data_func_full (path, data, test_escape_nul, g_free); \
1239 g_free (path); \
1240 }
1241  
1242 typedef struct {
1243 const gchar *pattern;
1244 const gchar *string;
1245 gssize string_len;
1246 gint start_position;
1247 GSList *expected;
1248 } TestMatchAllData;
1249  
1250 static void
1251 test_match_all_full (gconstpointer d)
1252 {
1253 const TestMatchAllData *data = d;
1254 GRegex *regex;
1255 GMatchInfo *match_info;
1256 GSList *l_exp;
1257 gboolean match_ok;
1258 gint match_count;
1259 gint i;
1260  
1261 regex = g_regex_new (data->pattern, 0, 0, NULL);
1262 match_ok = g_regex_match_all_full (regex, data->string, data->string_len, data->start_position,
1263 0, &match_info, NULL);
1264  
1265 if (g_slist_length (data->expected) == 0)
1266 g_assert (!match_ok);
1267 else
1268 g_assert (match_ok);
1269  
1270 match_count = g_match_info_get_match_count (match_info);
1271 g_assert_cmpint (match_count, ==, g_slist_length (data->expected));
1272  
1273 l_exp = data->expected;
1274 for (i = 0; i < match_count; i++)
1275 {
1276 gint start, end;
1277 gchar *matched_string;
1278 Match *exp = l_exp->data;
1279  
1280 matched_string = g_match_info_fetch (match_info, i);
1281 g_match_info_fetch_pos (match_info, i, &start, &end);
1282  
1283 g_assert_cmpstr (exp->string, ==, matched_string);
1284 g_assert_cmpint (exp->start, ==, start);
1285 g_assert_cmpint (exp->end, ==, end);
1286  
1287 g_free (matched_string);
1288  
1289 l_exp = g_slist_next (l_exp);
1290 }
1291  
1292 g_match_info_free (match_info);
1293 g_regex_unref (regex);
1294 }
1295  
1296 static void
1297 test_match_all (gconstpointer d)
1298 {
1299 const TestMatchAllData *data = d;
1300 GRegex *regex;
1301 GMatchInfo *match_info;
1302 GSList *l_exp;
1303 gboolean match_ok;
1304 gint match_count;
1305 gint i;
1306  
1307 regex = g_regex_new (data->pattern, 0, 0, NULL);
1308 match_ok = g_regex_match_all (regex, data->string, 0, &match_info);
1309  
1310 if (g_slist_length (data->expected) == 0)
1311 g_assert (!match_ok);
1312 else
1313 g_assert (match_ok);
1314  
1315 match_count = g_match_info_get_match_count (match_info);
1316  
1317 if (match_count != g_slist_length (data->expected))
1318 {
1319 g_message ("regex: %s", data->pattern);
1320 g_message ("string: %s", data->string);
1321 g_message ("matched strings:");
1322  
1323 for (i = 0; i < match_count; i++)
1324 {
1325 gint start, end;
1326 gchar *matched_string;
1327  
1328 matched_string = g_match_info_fetch (match_info, i);
1329 g_match_info_fetch_pos (match_info, i, &start, &end);
1330 g_message ("%d. %d-%d '%s'", i, start, end, matched_string);
1331 g_free (matched_string);
1332 }
1333  
1334 g_message ("expected strings:");
1335 i = 0;
1336  
1337 for (l_exp = data->expected; l_exp != NULL; l_exp = l_exp->next)
1338 {
1339 Match *exp = l_exp->data;
1340  
1341 g_message ("%d. %d-%d '%s'", i, exp->start, exp->end, exp->string);
1342 i++;
1343 }
1344  
1345 g_error ("match_count not as expected: %d != %d",
1346 match_count, g_slist_length (data->expected));
1347 }
1348  
1349 l_exp = data->expected;
1350 for (i = 0; i < match_count; i++)
1351 {
1352 gint start, end;
1353 gchar *matched_string;
1354 Match *exp = l_exp->data;
1355  
1356 matched_string = g_match_info_fetch (match_info, i);
1357 g_match_info_fetch_pos (match_info, i, &start, &end);
1358  
1359 g_assert_cmpstr (exp->string, ==, matched_string);
1360 g_assert_cmpint (exp->start, ==, start);
1361 g_assert_cmpint (exp->end, ==, end);
1362  
1363 g_free (matched_string);
1364  
1365 l_exp = g_slist_next (l_exp);
1366 }
1367  
1368 g_match_info_free (match_info);
1369 g_regex_unref (regex);
1370 }
1371  
1372 static void
1373 free_match_all_data (gpointer _data)
1374 {
1375 TestMatchAllData *data = _data;
1376  
1377 g_slist_free_full (data->expected, g_free);
1378 g_free (data);
1379 }
1380  
1381 #define TEST_MATCH_ALL0(_pattern, _string, _string_len, _start_position) { \
1382 TestMatchAllData *data; \
1383 gchar *path; \
1384 data = g_new0 (TestMatchAllData, 1); \
1385 data->pattern = _pattern; \
1386 data->string = _string; \
1387 data->string_len = _string_len; \
1388 data->start_position = _start_position; \
1389 data->expected = NULL; \
1390 if (_string_len == -1 && _start_position == 0) { \
1391 path = g_strdup_printf ("/regex/match-all0/%d", ++total); \
1392 g_test_add_data_func (path, data, test_match_all); \
1393 g_free (path); \
1394 } \
1395 path = g_strdup_printf ("/regex/match-all-full0/%d", ++total); \
1396 g_test_add_data_func_full (path, data, test_match_all_full, free_match_all_data); \
1397 g_free (path); \
1398 }
1399  
1400 #define TEST_MATCH_ALL1(_pattern, _string, _string_len, _start_position, \
1401 t1, s1, e1) { \
1402 TestMatchAllData *data; \
1403 Match *match; \
1404 gchar *path; \
1405 data = g_new0 (TestMatchAllData, 1); \
1406 data->pattern = _pattern; \
1407 data->string = _string; \
1408 data->string_len = _string_len; \
1409 data->start_position = _start_position; \
1410 data->expected = NULL; \
1411 match = g_new0 (Match, 1); \
1412 match->string = t1; \
1413 match->start = s1; \
1414 match->end = e1; \
1415 data->expected = g_slist_append (data->expected, match); \
1416 if (_string_len == -1 && _start_position == 0) { \
1417 path = g_strdup_printf ("/regex/match-all1/%d", ++total); \
1418 g_test_add_data_func (path, data, test_match_all); \
1419 g_free (path); \
1420 } \
1421 path = g_strdup_printf ("/regex/match-all-full1/%d", ++total); \
1422 g_test_add_data_func_full (path, data, test_match_all_full, free_match_all_data); \
1423 g_free (path); \
1424 }
1425  
1426 #define TEST_MATCH_ALL2(_pattern, _string, _string_len, _start_position, \
1427 t1, s1, e1, t2, s2, e2) { \
1428 TestMatchAllData *data; \
1429 Match *match; \
1430 gchar *path; \
1431 data = g_new0 (TestMatchAllData, 1); \
1432 data->pattern = _pattern; \
1433 data->string = _string; \
1434 data->string_len = _string_len; \
1435 data->start_position = _start_position; \
1436 data->expected = NULL; \
1437 match = g_new0 (Match, 1); \
1438 match->string = t1; \
1439 match->start = s1; \
1440 match->end = e1; \
1441 data->expected = g_slist_append (data->expected, match); \
1442 match = g_new0 (Match, 1); \
1443 match->string = t2; \
1444 match->start = s2; \
1445 match->end = e2; \
1446 data->expected = g_slist_append (data->expected, match); \
1447 if (_string_len == -1 && _start_position == 0) { \
1448 path = g_strdup_printf ("/regex/match-all2/%d", ++total); \
1449 g_test_add_data_func (path, data, test_match_all); \
1450 g_free (path); \
1451 } \
1452 path = g_strdup_printf ("/regex/match-all-full2/%d", ++total); \
1453 g_test_add_data_func_full (path, data, test_match_all_full, free_match_all_data); \
1454 g_free (path); \
1455 }
1456  
1457 #define TEST_MATCH_ALL3(_pattern, _string, _string_len, _start_position, \
1458 t1, s1, e1, t2, s2, e2, t3, s3, e3) { \
1459 TestMatchAllData *data; \
1460 Match *match; \
1461 gchar *path; \
1462 data = g_new0 (TestMatchAllData, 1); \
1463 data->pattern = _pattern; \
1464 data->string = _string; \
1465 data->string_len = _string_len; \
1466 data->start_position = _start_position; \
1467 data->expected = NULL; \
1468 match = g_new0 (Match, 1); \
1469 match->string = t1; \
1470 match->start = s1; \
1471 match->end = e1; \
1472 data->expected = g_slist_append (data->expected, match); \
1473 match = g_new0 (Match, 1); \
1474 match->string = t2; \
1475 match->start = s2; \
1476 match->end = e2; \
1477 data->expected = g_slist_append (data->expected, match); \
1478 match = g_new0 (Match, 1); \
1479 match->string = t3; \
1480 match->start = s3; \
1481 match->end = e3; \
1482 data->expected = g_slist_append (data->expected, match); \
1483 if (_string_len == -1 && _start_position == 0) { \
1484 path = g_strdup_printf ("/regex/match-all3/%d", ++total); \
1485 g_test_add_data_func (path, data, test_match_all); \
1486 g_free (path); \
1487 } \
1488 path = g_strdup_printf ("/regex/match-all-full3/%d", ++total); \
1489 g_test_add_data_func_full (path, data, test_match_all_full, free_match_all_data); \
1490 g_free (path); \
1491 }
1492  
1493 static void
1494 test_properties (void)
1495 {
1496 GRegex *regex;
1497 GError *error;
1498 gboolean res;
1499 GMatchInfo *match;
1500 gchar *str;
1501  
1502 error = NULL;
1503 regex = g_regex_new ("\\p{L}\\p{Ll}\\p{Lu}\\p{L&}\\p{N}\\p{Nd}", G_REGEX_OPTIMIZE, 0, &error);
1504 res = g_regex_match (regex, "ppPP01", 0, &match);
1505 g_assert (res);
1506 str = g_match_info_fetch (match, 0);
1507 g_assert_cmpstr (str, ==, "ppPP01");
1508 g_free (str);
1509  
1510 g_match_info_free (match);
1511 g_regex_unref (regex);
1512 }
1513  
1514 static void
1515 test_class (void)
1516 {
1517 GRegex *regex;
1518 GError *error;
1519 GMatchInfo *match;
1520 gboolean res;
1521 gchar *str;
1522  
1523 error = NULL;
1524 regex = g_regex_new ("[abc\\x{0B1E}\\p{Mn}\\x{0391}-\\x{03A9}]", G_REGEX_OPTIMIZE, 0, &error);
1525 res = g_regex_match (regex, "a:b:\340\254\236:\333\253:\316\240", 0, &match);
1526 g_assert (res);
1527 str = g_match_info_fetch (match, 0);
1528 g_assert_cmpstr (str, ==, "a");
1529 g_free (str);
1530 res = g_match_info_next (match, NULL);
1531 g_assert (res);
1532 str = g_match_info_fetch (match, 0);
1533 g_assert_cmpstr (str, ==, "b");
1534 g_free (str);
1535 res = g_match_info_next (match, NULL);
1536 g_assert (res);
1537 str = g_match_info_fetch (match, 0);
1538 g_assert_cmpstr (str, ==, "\340\254\236");
1539 g_free (str);
1540 res = g_match_info_next (match, NULL);
1541 g_assert (res);
1542 str = g_match_info_fetch (match, 0);
1543 g_assert_cmpstr (str, ==, "\333\253");
1544 g_free (str);
1545 res = g_match_info_next (match, NULL);
1546 g_assert (res);
1547 str = g_match_info_fetch (match, 0);
1548 g_assert_cmpstr (str, ==, "\316\240");
1549 g_free (str);
1550  
1551 res = g_match_info_next (match, NULL);
1552 g_assert (!res);
1553  
1554 g_match_info_free (match);
1555 g_regex_unref (regex);
1556 }
1557  
1558 /* examples for lookahead assertions taken from pcrepattern(3) */
1559 static void
1560 test_lookahead (void)
1561 {
1562 GRegex *regex;
1563 GError *error;
1564 GMatchInfo *match;
1565 gboolean res;
1566 gchar *str;
1567 gint start, end;
1568  
1569 error = NULL;
1570 regex = g_regex_new ("\\w+(?=;)", G_REGEX_OPTIMIZE, 0, &error);
1571 g_assert (regex);
1572 g_assert_no_error (error);
1573 res = g_regex_match (regex, "word1 word2: word3;", 0, &match);
1574 g_assert (res);
1575 g_assert (g_match_info_matches (match));
1576 g_assert_cmpint (g_match_info_get_match_count (match), ==, 1);
1577 str = g_match_info_fetch (match, 0);
1578 g_assert_cmpstr (str, ==, "word3");
1579 g_free (str);
1580 g_match_info_free (match);
1581 g_regex_unref (regex);
1582  
1583 error = NULL;
1584 regex = g_regex_new ("foo(?!bar)", G_REGEX_OPTIMIZE, 0, &error);
1585 g_assert (regex);
1586 g_assert_no_error (error);
1587 res = g_regex_match (regex, "foobar foobaz", 0, &match);
1588 g_assert (res);
1589 g_assert (g_match_info_matches (match));
1590 g_assert_cmpint (g_match_info_get_match_count (match), ==, 1);
1591 res = g_match_info_fetch_pos (match, 0, &start, &end);
1592 g_assert (res);
1593 g_assert_cmpint (start, ==, 7);
1594 g_assert_cmpint (end, ==, 10);
1595 g_match_info_free (match);
1596 g_regex_unref (regex);
1597  
1598 error = NULL;
1599 regex = g_regex_new ("(?!bar)foo", G_REGEX_OPTIMIZE, 0, &error);
1600 g_assert (regex);
1601 g_assert_no_error (error);
1602 res = g_regex_match (regex, "foobar foobaz", 0, &match);
1603 g_assert (res);
1604 g_assert (g_match_info_matches (match));
1605 g_assert_cmpint (g_match_info_get_match_count (match), ==, 1);
1606 res = g_match_info_fetch_pos (match, 0, &start, &end);
1607 g_assert (res);
1608 g_assert_cmpint (start, ==, 0);
1609 g_assert_cmpint (end, ==, 3);
1610 res = g_match_info_next (match, &error);
1611 g_assert (res);
1612 g_assert_no_error (error);
1613 res = g_match_info_fetch_pos (match, 0, &start, &end);
1614 g_assert (res);
1615 g_assert_cmpint (start, ==, 7);
1616 g_assert_cmpint (end, ==, 10);
1617 g_match_info_free (match);
1618 g_regex_unref (regex);
1619 }
1620  
1621 /* examples for lookbehind assertions taken from pcrepattern(3) */
1622 static void
1623 test_lookbehind (void)
1624 {
1625 GRegex *regex;
1626 GError *error;
1627 GMatchInfo *match;
1628 gboolean res;
1629 gint start, end;
1630  
1631 error = NULL;
1632 regex = g_regex_new ("(?<!foo)bar", G_REGEX_OPTIMIZE, 0, &error);
1633 g_assert (regex);
1634 g_assert_no_error (error);
1635 res = g_regex_match (regex, "foobar boobar", 0, &match);
1636 g_assert (res);
1637 g_assert (g_match_info_matches (match));
1638 g_assert_cmpint (g_match_info_get_match_count (match), ==, 1);
1639 res = g_match_info_fetch_pos (match, 0, &start, &end);
1640 g_assert (res);
1641 g_assert_cmpint (start, ==, 10);
1642 g_assert_cmpint (end, ==, 13);
1643 g_match_info_free (match);
1644 g_regex_unref (regex);
1645  
1646 error = NULL;
1647 regex = g_regex_new ("(?<=bullock|donkey) poo", G_REGEX_OPTIMIZE, 0, &error);
1648 g_assert (regex);
1649 g_assert_no_error (error);
1650 res = g_regex_match (regex, "don poo, and bullock poo", 0, &match);
1651 g_assert (res);
1652 g_assert (g_match_info_matches (match));
1653 g_assert_cmpint (g_match_info_get_match_count (match), ==, 1);
1654 res = g_match_info_fetch_pos (match, 0, &start, NULL);
1655 g_assert (res);
1656 g_assert_cmpint (start, ==, 20);
1657 g_match_info_free (match);
1658 g_regex_unref (regex);
1659  
1660 regex = g_regex_new ("(?<!dogs?|cats?) x", G_REGEX_OPTIMIZE, 0, &error);
1661 g_assert (regex == NULL);
1662 g_assert_error (error, G_REGEX_ERROR, G_REGEX_ERROR_VARIABLE_LENGTH_LOOKBEHIND);
1663 g_clear_error (&error);
1664  
1665 regex = g_regex_new ("(?<=ab(c|de)) foo", G_REGEX_OPTIMIZE, 0, &error);
1666 g_assert (regex == NULL);
1667 g_assert_error (error, G_REGEX_ERROR, G_REGEX_ERROR_VARIABLE_LENGTH_LOOKBEHIND);
1668 g_clear_error (&error);
1669  
1670 regex = g_regex_new ("(?<=abc|abde)foo", G_REGEX_OPTIMIZE, 0, &error);
1671 g_assert (regex);
1672 g_assert_no_error (error);
1673 res = g_regex_match (regex, "abfoo, abdfoo, abcfoo", 0, &match);
1674 g_assert (res);
1675 g_assert (g_match_info_matches (match));
1676 res = g_match_info_fetch_pos (match, 0, &start, NULL);
1677 g_assert (res);
1678 g_assert_cmpint (start, ==, 18);
1679 g_match_info_free (match);
1680 g_regex_unref (regex);
1681  
1682 regex = g_regex_new ("^.*+(?<=abcd)", G_REGEX_OPTIMIZE, 0, &error);
1683 g_assert (regex);
1684 g_assert_no_error (error);
1685 res = g_regex_match (regex, "abcabcabcabcabcabcabcabcabcd", 0, &match);
1686 g_assert (res);
1687 g_assert (g_match_info_matches (match));
1688 g_match_info_free (match);
1689 g_regex_unref (regex);
1690  
1691 regex = g_regex_new ("(?<=\\d{3})(?<!999)foo", G_REGEX_OPTIMIZE, 0, &error);
1692 g_assert (regex);
1693 g_assert_no_error (error);
1694 res = g_regex_match (regex, "999foo 123abcfoo 123foo", 0, &match);
1695 g_assert (res);
1696 g_assert (g_match_info_matches (match));
1697 res = g_match_info_fetch_pos (match, 0, &start, NULL);
1698 g_assert (res);
1699 g_assert_cmpint (start, ==, 20);
1700 g_match_info_free (match);
1701 g_regex_unref (regex);
1702  
1703 regex = g_regex_new ("(?<=\\d{3}...)(?<!999)foo", G_REGEX_OPTIMIZE, 0, &error);
1704 g_assert (regex);
1705 g_assert_no_error (error);
1706 res = g_regex_match (regex, "999foo 123abcfoo 123foo", 0, &match);
1707 g_assert (res);
1708 g_assert (g_match_info_matches (match));
1709 res = g_match_info_fetch_pos (match, 0, &start, NULL);
1710 g_assert (res);
1711 g_assert_cmpint (start, ==, 13);
1712 g_match_info_free (match);
1713 g_regex_unref (regex);
1714  
1715 regex = g_regex_new ("(?<=\\d{3}(?!999)...)foo", G_REGEX_OPTIMIZE, 0, &error);
1716 g_assert (regex);
1717 g_assert_no_error (error);
1718 res = g_regex_match (regex, "999foo 123abcfoo 123foo", 0, &match);
1719 g_assert (res);
1720 g_assert (g_match_info_matches (match));
1721 res = g_match_info_fetch_pos (match, 0, &start, NULL);
1722 g_assert (res);
1723 g_assert_cmpint (start, ==, 13);
1724 g_match_info_free (match);
1725 g_regex_unref (regex);
1726  
1727 regex = g_regex_new ("(?<=(?<!foo)bar)baz", G_REGEX_OPTIMIZE, 0, &error);
1728 g_assert (regex);
1729 g_assert_no_error (error);
1730 res = g_regex_match (regex, "foobarbaz barfoobaz barbarbaz", 0, &match);
1731 g_assert (res);
1732 g_assert (g_match_info_matches (match));
1733 res = g_match_info_fetch_pos (match, 0, &start, NULL);
1734 g_assert (res);
1735 g_assert_cmpint (start, ==, 26);
1736 g_match_info_free (match);
1737 g_regex_unref (regex);
1738 }
1739  
1740 /* examples for subpatterns taken from pcrepattern(3) */
1741 static void
1742 test_subpattern (void)
1743 {
1744 GRegex *regex;
1745 GError *error;
1746 GMatchInfo *match;
1747 gboolean res;
1748 gchar *str;
1749 gint start;
1750  
1751 error = NULL;
1752 regex = g_regex_new ("cat(aract|erpillar|)", G_REGEX_OPTIMIZE, 0, &error);
1753 g_assert (regex);
1754 g_assert_no_error (error);
1755 g_assert_cmpint (g_regex_get_capture_count (regex), ==, 1);
1756 g_assert_cmpint (g_regex_get_max_backref (regex), ==, 0);
1757 res = g_regex_match_all (regex, "caterpillar", 0, &match);
1758 g_assert (res);
1759 g_assert (g_match_info_matches (match));
1760 g_assert_cmpint (g_match_info_get_match_count (match), ==, 2);
1761 str = g_match_info_fetch (match, 0);
1762 g_assert_cmpstr (str, ==, "caterpillar");
1763 g_free (str);
1764 str = g_match_info_fetch (match, 1);
1765 g_assert_cmpstr (str, ==, "cat");
1766 g_free (str);
1767 g_match_info_free (match);
1768 g_regex_unref (regex);
1769  
1770 regex = g_regex_new ("the ((red|white) (king|queen))", G_REGEX_OPTIMIZE, 0, &error);
1771 g_assert (regex);
1772 g_assert_no_error (error);
1773 g_assert_cmpint (g_regex_get_capture_count (regex), ==, 3);
1774 g_assert_cmpint (g_regex_get_max_backref (regex), ==, 0);
1775 res = g_regex_match (regex, "the red king", 0, &match);
1776 g_assert (res);
1777 g_assert (g_match_info_matches (match));
1778 g_assert_cmpint (g_match_info_get_match_count (match), ==, 4);
1779 str = g_match_info_fetch (match, 0);
1780 g_assert_cmpstr (str, ==, "the red king");
1781 g_free (str);
1782 str = g_match_info_fetch (match, 1);
1783 g_assert_cmpstr (str, ==, "red king");
1784 g_free (str);
1785 str = g_match_info_fetch (match, 2);
1786 g_assert_cmpstr (str, ==, "red");
1787 g_free (str);
1788 str = g_match_info_fetch (match, 3);
1789 g_assert_cmpstr (str, ==, "king");
1790 g_free (str);
1791 g_match_info_free (match);
1792 g_regex_unref (regex);
1793  
1794 regex = g_regex_new ("the ((?:red|white) (king|queen))", G_REGEX_OPTIMIZE, 0, &error);
1795 g_assert (regex);
1796 g_assert_no_error (error);
1797 res = g_regex_match (regex, "the white queen", 0, &match);
1798 g_assert (res);
1799 g_assert (g_match_info_matches (match));
1800 g_assert_cmpint (g_match_info_get_match_count (match), ==, 3);
1801 g_assert_cmpint (g_regex_get_max_backref (regex), ==, 0);
1802 str = g_match_info_fetch (match, 0);
1803 g_assert_cmpstr (str, ==, "the white queen");
1804 g_free (str);
1805 str = g_match_info_fetch (match, 1);
1806 g_assert_cmpstr (str, ==, "white queen");
1807 g_free (str);
1808 str = g_match_info_fetch (match, 2);
1809 g_assert_cmpstr (str, ==, "queen");
1810 g_free (str);
1811 g_match_info_free (match);
1812 g_regex_unref (regex);
1813  
1814 regex = g_regex_new ("(?|(Sat)(ur)|(Sun))day (morning|afternoon)", G_REGEX_OPTIMIZE, 0, &error);
1815 g_assert (regex);
1816 g_assert_no_error (error);
1817 g_assert_cmpint (g_regex_get_capture_count (regex), ==, 3);
1818 res = g_regex_match (regex, "Saturday morning", 0, &match);
1819 g_assert (res);
1820 g_assert (g_match_info_matches (match));
1821 g_assert_cmpint (g_match_info_get_match_count (match), ==, 4);
1822 str = g_match_info_fetch (match, 1);
1823 g_assert_cmpstr (str, ==, "Sat");
1824 g_free (str);
1825 str = g_match_info_fetch (match, 2);
1826 g_assert_cmpstr (str, ==, "ur");
1827 g_free (str);
1828 str = g_match_info_fetch (match, 3);
1829 g_assert_cmpstr (str, ==, "morning");
1830 g_free (str);
1831 g_match_info_free (match);
1832 g_regex_unref (regex);
1833  
1834 regex = g_regex_new ("(?|(abc)|(def))\\1", G_REGEX_OPTIMIZE, 0, &error);
1835 g_assert (regex);
1836 g_assert_no_error (error);
1837 g_assert_cmpint (g_regex_get_max_backref (regex), ==, 1);
1838 res = g_regex_match (regex, "abcabc abcdef defabc defdef", 0, &match);
1839 g_assert (res);
1840 g_assert (g_match_info_matches (match));
1841 res = g_match_info_fetch_pos (match, 0, &start, NULL);
1842 g_assert (res);
1843 g_assert_cmpint (start, ==, 0);
1844 res = g_match_info_next (match, &error);
1845 g_assert (res);
1846 res = g_match_info_fetch_pos (match, 0, &start, NULL);
1847 g_assert (res);
1848 g_assert_cmpint (start, ==, 21);
1849 g_match_info_free (match);
1850 g_regex_unref (regex);
1851  
1852 regex = g_regex_new ("(?|(abc)|(def))(?1)", G_REGEX_OPTIMIZE, 0, &error);
1853 g_assert (regex);
1854 g_assert_no_error (error);
1855 res = g_regex_match (regex, "abcabc abcdef defabc defdef", 0, &match);
1856 g_assert (res);
1857 g_assert (g_match_info_matches (match));
1858 res = g_match_info_fetch_pos (match, 0, &start, NULL);
1859 g_assert (res);
1860 g_assert_cmpint (start, ==, 0);
1861 res = g_match_info_next (match, &error);
1862 g_assert (res);
1863 res = g_match_info_fetch_pos (match, 0, &start, NULL);
1864 g_assert (res);
1865 g_assert_cmpint (start, ==, 14);
1866 g_match_info_free (match);
1867 g_regex_unref (regex);
1868  
1869 regex = g_regex_new ("(?<DN>Mon|Fri|Sun)(?:day)?|(?<DN>Tue)(?:sday)?|(?<DN>Wed)(?:nesday)?|(?<DN>Thu)(?:rsday)?|(?<DN>Sat)(?:urday)?", G_REGEX_OPTIMIZE|G_REGEX_DUPNAMES, 0, &error);
1870 g_assert (regex);
1871 g_assert_no_error (error);
1872 res = g_regex_match (regex, "Mon Tuesday Wed Saturday", 0, &match);
1873 g_assert (res);
1874 g_assert (g_match_info_matches (match));
1875 str = g_match_info_fetch_named (match, "DN");
1876 g_assert_cmpstr (str, ==, "Mon");
1877 g_free (str);
1878 res = g_match_info_next (match, &error);
1879 g_assert (res);
1880 str = g_match_info_fetch_named (match, "DN");
1881 g_assert_cmpstr (str, ==, "Tue");
1882 g_free (str);
1883 res = g_match_info_next (match, &error);
1884 g_assert (res);
1885 str = g_match_info_fetch_named (match, "DN");
1886 g_assert_cmpstr (str, ==, "Wed");
1887 g_free (str);
1888 res = g_match_info_next (match, &error);
1889 g_assert (res);
1890 str = g_match_info_fetch_named (match, "DN");
1891 g_assert_cmpstr (str, ==, "Sat");
1892 g_free (str);
1893 g_match_info_free (match);
1894 g_regex_unref (regex);
1895  
1896 regex = g_regex_new ("^(a|b\\1)+$", G_REGEX_OPTIMIZE|G_REGEX_DUPNAMES, 0, &error);
1897 g_assert (regex);
1898 g_assert_no_error (error);
1899 res = g_regex_match (regex, "aaaaaaaaaaaaaaaa", 0, &match);
1900 g_assert (res);
1901 g_assert (g_match_info_matches (match));
1902 g_match_info_free (match);
1903 res = g_regex_match (regex, "ababbaa", 0, &match);
1904 g_assert (res);
1905 g_assert (g_match_info_matches (match));
1906 g_match_info_free (match);
1907 g_regex_unref (regex);
1908 }
1909  
1910 /* examples for conditions taken from pcrepattern(3) */
1911 static void
1912 test_condition (void)
1913 {
1914 GRegex *regex;
1915 GError *error;
1916 GMatchInfo *match;
1917 gboolean res;
1918  
1919 error = NULL;
1920 regex = g_regex_new ("^(a+)(\\()?[^()]+(?(-1)\\))(b+)$", G_REGEX_OPTIMIZE, 0, &error);
1921 g_assert (regex);
1922 g_assert_no_error (error);
1923 res = g_regex_match (regex, "a(zzzzzz)b", 0, &match);
1924 g_assert (res);
1925 g_assert (g_match_info_matches (match));
1926 g_match_info_free (match);
1927 res = g_regex_match (regex, "aaazzzzzzbbb", 0, &match);
1928 g_assert (res);
1929 g_assert (g_match_info_matches (match));
1930 g_match_info_free (match);
1931 g_regex_unref (regex);
1932  
1933 error = NULL;
1934 regex = g_regex_new ("^(a+)(?<OPEN>\\()?[^()]+(?(<OPEN>)\\))(b+)$", G_REGEX_OPTIMIZE, 0, &error);
1935 g_assert (regex);
1936 g_assert_no_error (error);
1937 res = g_regex_match (regex, "a(zzzzzz)b", 0, &match);
1938 g_assert (res);
1939 g_assert (g_match_info_matches (match));
1940 g_match_info_free (match);
1941 res = g_regex_match (regex, "aaazzzzzzbbb", 0, &match);
1942 g_assert (res);
1943 g_assert (g_match_info_matches (match));
1944 g_match_info_free (match);
1945 g_regex_unref (regex);
1946  
1947 regex = g_regex_new ("^(a+)(?(+1)\\[|\\<)?[^()]+(\\])?(b+)$", G_REGEX_OPTIMIZE, 0, &error);
1948 g_assert (regex);
1949 g_assert_no_error (error);
1950 res = g_regex_match (regex, "a[zzzzzz]b", 0, &match);
1951 g_assert (res);
1952 g_assert (g_match_info_matches (match));
1953 g_match_info_free (match);
1954 res = g_regex_match (regex, "aaa<zzzzzzbbb", 0, &match);
1955 g_assert (res);
1956 g_assert (g_match_info_matches (match));
1957 g_match_info_free (match);
1958 g_regex_unref (regex);
1959  
1960 regex = g_regex_new ("(?(DEFINE) (?<byte> 2[0-4]\\d | 25[0-5] | 1\\d\\d | [1-9]?\\d) )"
1961 "\\b (?&byte) (\\.(?&byte)){3} \\b",
1962 G_REGEX_OPTIMIZE|G_REGEX_EXTENDED, 0, &error);
1963 g_assert (regex);
1964 g_assert_no_error (error);
1965 res = g_regex_match (regex, "128.0.0.1", 0, &match);
1966 g_assert (res);
1967 g_assert (g_match_info_matches (match));
1968 g_match_info_free (match);
1969 res = g_regex_match (regex, "192.168.1.1", 0, &match);
1970 g_assert (res);
1971 g_assert (g_match_info_matches (match));
1972 g_match_info_free (match);
1973 res = g_regex_match (regex, "209.132.180.167", 0, &match);
1974 g_assert (res);
1975 g_assert (g_match_info_matches (match));
1976 g_match_info_free (match);
1977 g_regex_unref (regex);
1978  
1979 regex = g_regex_new ("^(?(?=[^a-z]*[a-z])"
1980 "\\d{2}-[a-z]{3}-\\d{2} | \\d{2}-\\d{2}-\\d{2} )$",
1981 G_REGEX_OPTIMIZE|G_REGEX_EXTENDED, 0, &error);
1982 g_assert (regex);
1983 g_assert_no_error (error);
1984 res = g_regex_match (regex, "01-abc-24", 0, &match);
1985 g_assert (res);
1986 g_assert (g_match_info_matches (match));
1987 g_match_info_free (match);
1988 res = g_regex_match (regex, "01-23-45", 0, &match);
1989 g_assert (res);
1990 g_assert (g_match_info_matches (match));
1991 g_match_info_free (match);
1992 res = g_regex_match (regex, "01-uv-45", 0, &match);
1993 g_assert (!res);
1994 g_assert (!g_match_info_matches (match));
1995 g_match_info_free (match);
1996 res = g_regex_match (regex, "01-234-45", 0, &match);
1997 g_assert (!res);
1998 g_assert (!g_match_info_matches (match));
1999 g_match_info_free (match);
2000 g_regex_unref (regex);
2001 }
2002  
2003 /* examples for recursion taken from pcrepattern(3) */
2004 static void
2005 test_recursion (void)
2006 {
2007 GRegex *regex;
2008 GError *error;
2009 GMatchInfo *match;
2010 gboolean res;
2011 gint start;
2012  
2013 error = NULL;
2014 regex = g_regex_new ("\\( ( [^()]++ | (?R) )* \\)", G_REGEX_OPTIMIZE|G_REGEX_EXTENDED, 0, &error);
2015 g_assert (regex);
2016 g_assert_no_error (error);
2017 res = g_regex_match (regex, "(middle)", 0, &match);
2018 g_assert (res);
2019 g_assert (g_match_info_matches (match));
2020 g_match_info_free (match);
2021 res = g_regex_match (regex, "((((((((((((((((middle))))))))))))))))", 0, &match);
2022 g_assert (res);
2023 g_assert (g_match_info_matches (match));
2024 g_match_info_free (match);
2025 res = g_regex_match (regex, "(((xxx(((", 0, &match);
2026 g_assert (!res);
2027 g_assert (!g_match_info_matches (match));
2028 g_match_info_free (match);
2029 g_regex_unref (regex);
2030  
2031 regex = g_regex_new ("^( \\( ( [^()]++ | (?1) )* \\) )$", G_REGEX_OPTIMIZE|G_REGEX_EXTENDED, 0, &error);
2032 g_assert (regex);
2033 g_assert_no_error (error);
2034 res = g_regex_match (regex, "((((((((((((((((middle))))))))))))))))", 0, &match);
2035 g_assert (res);
2036 g_assert (g_match_info_matches (match));
2037 g_match_info_free (match);
2038 res = g_regex_match (regex, "(((xxx((()", 0, &match);
2039 g_assert (!res);
2040 g_assert (!g_match_info_matches (match));
2041 g_match_info_free (match);
2042 g_regex_unref (regex);
2043  
2044 regex = g_regex_new ("^(?<pn> \\( ( [^()]++ | (?&pn) )* \\) )$", G_REGEX_OPTIMIZE|G_REGEX_EXTENDED, 0, &error);
2045 g_assert (regex);
2046 g_assert_no_error (error);
2047 g_regex_match (regex, "(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()", 0, &match);
2048 g_assert (!res);
2049 g_assert (!g_match_info_matches (match));
2050 g_match_info_free (match);
2051 g_regex_unref (regex);
2052  
2053 regex = g_regex_new ("< (?: (?(R) \\d++ | [^<>]*+) | (?R)) * >", G_REGEX_OPTIMIZE|G_REGEX_EXTENDED, 0, &error);
2054 g_assert (regex);
2055 g_assert_no_error (error);
2056 res = g_regex_match (regex, "<ab<01<23<4>>>>", 0, &match);
2057 g_assert (res);
2058 g_assert (g_match_info_matches (match));
2059 res = g_match_info_fetch_pos (match, 0, &start, NULL);
2060 g_assert (res);
2061 g_assert_cmpint (start, ==, 0);
2062 g_match_info_free (match);
2063 res = g_regex_match (regex, "<ab<01<xx<x>>>>", 0, &match);
2064 g_assert (res);
2065 g_assert (g_match_info_matches (match));
2066 res = g_match_info_fetch_pos (match, 0, &start, NULL);
2067 g_assert (res);
2068 g_assert_cmpint (start, >, 0);
2069 g_match_info_free (match);
2070 g_regex_unref (regex);
2071  
2072 regex = g_regex_new ("^((.)(?1)\\2|.)$", G_REGEX_OPTIMIZE, 0, &error);
2073 g_assert (regex);
2074 g_assert_no_error (error);
2075 res = g_regex_match (regex, "abcdcba", 0, &match);
2076 g_assert (res);
2077 g_assert (g_match_info_matches (match));
2078 g_match_info_free (match);
2079 res = g_regex_match (regex, "abcddcba", 0, &match);
2080 g_assert (!res);
2081 g_assert (!g_match_info_matches (match));
2082 g_match_info_free (match);
2083 g_regex_unref (regex);
2084  
2085 regex = g_regex_new ("^(?:((.)(?1)\\2|)|((.)(?3)\\4|.))$", G_REGEX_OPTIMIZE, 0, &error);
2086 g_assert (regex);
2087 g_assert_no_error (error);
2088 res = g_regex_match (regex, "abcdcba", 0, &match);
2089 g_assert (res);
2090 g_assert (g_match_info_matches (match));
2091 g_match_info_free (match);
2092 res = g_regex_match (regex, "abcddcba", 0, &match);
2093 g_assert (res);
2094 g_assert (g_match_info_matches (match));
2095 g_match_info_free (match);
2096 g_regex_unref (regex);
2097  
2098 regex = g_regex_new ("^\\W*+(?:((.)\\W*+(?1)\\W*+\\2|)|((.)\\W*+(?3)\\W*+\\4|\\W*+.\\W*+))\\W*+$", G_REGEX_OPTIMIZE|G_REGEX_CASELESS, 0, &error);
2099 g_assert (regex);
2100 g_assert_no_error (error);
2101 res = g_regex_match (regex, "abcdcba", 0, &match);
2102 g_assert (res);
2103 g_assert (g_match_info_matches (match));
2104 g_match_info_free (match);
2105 res = g_regex_match (regex, "A man, a plan, a canal: Panama!", 0, &match);
2106 g_assert (res);
2107 g_assert (g_match_info_matches (match));
2108 g_match_info_free (match);
2109 res = g_regex_match (regex, "Oozy rat in a sanitary zoo", 0, &match);
2110 g_assert (res);
2111 g_assert (g_match_info_matches (match));
2112 g_match_info_free (match);
2113 g_regex_unref (regex);
2114 }
2115  
2116 static void
2117 test_multiline (void)
2118 {
2119 GRegex *regex;
2120 GMatchInfo *info;
2121 gint count;
2122  
2123 g_test_bug ("640489");
2124  
2125 regex = g_regex_new ("^a$", G_REGEX_MULTILINE|G_REGEX_DOTALL, 0, NULL);
2126  
2127 count = 0;
2128 g_regex_match (regex, "a\nb\na", 0, &info);
2129 while (g_match_info_matches (info))
2130 {
2131 count++;
2132 g_match_info_next (info, NULL);
2133 }
2134 g_match_info_free (info);
2135 g_regex_unref (regex);
2136  
2137 g_assert_cmpint (count, ==, 2);
2138 }
2139  
2140 static void
2141 test_explicit_crlf (void)
2142 {
2143 GRegex *regex;
2144  
2145 regex = g_regex_new ("[\r\n]a", 0, 0, NULL);
2146 g_assert_cmpint (g_regex_get_has_cr_or_lf (regex), ==, TRUE);
2147 g_regex_unref (regex);
2148 }
2149  
2150 static void
2151 test_max_lookbehind (void)
2152 {
2153 GRegex *regex;
2154  
2155 regex = g_regex_new ("abc", 0, 0, NULL);
2156 g_assert_cmpint (g_regex_get_max_lookbehind (regex), ==, 0);
2157 g_regex_unref (regex);
2158  
2159 regex = g_regex_new ("\\babc", 0, 0, NULL);
2160 g_assert_cmpint (g_regex_get_max_lookbehind (regex), ==, 1);
2161 g_regex_unref (regex);
2162  
2163 regex = g_regex_new ("(?<=123)abc", 0, 0, NULL);
2164 g_assert_cmpint (g_regex_get_max_lookbehind (regex), ==, 3);
2165 g_regex_unref (regex);
2166 }
2167  
2168 static gboolean
2169 pcre_ge (guint64 major, guint64 minor)
2170 {
2171 const char *version;
2172 gchar *ptr;
2173 guint64 pcre_major, pcre_minor;
2174  
2175 /* e.g. 8.35 2014-04-04 */
2176 version = pcre_version ();
2177  
2178 pcre_major = g_ascii_strtoull (version, &ptr, 10);
2179 /* ptr points to ".MINOR (release date)" */
2180 g_assert (ptr[0] == '.');
2181 pcre_minor = g_ascii_strtoull (ptr + 1, NULL, 10);
2182  
2183 return (pcre_major > major) || (pcre_major == major && pcre_minor >= minor);
2184 }
2185  
2186 int
2187 main (int argc, char *argv[])
2188 {
2189 setlocale (LC_ALL, "");
2190  
2191 g_test_init (&argc, &argv, NULL);
2192  
2193 g_test_bug_base ("http://bugzilla.gnome.org/");
2194  
2195 g_test_add_func ("/regex/properties", test_properties);
2196 g_test_add_func ("/regex/class", test_class);
2197 g_test_add_func ("/regex/lookahead", test_lookahead);
2198 g_test_add_func ("/regex/lookbehind", test_lookbehind);
2199 g_test_add_func ("/regex/subpattern", test_subpattern);
2200 g_test_add_func ("/regex/condition", test_condition);
2201 g_test_add_func ("/regex/recursion", test_recursion);
2202 g_test_add_func ("/regex/multiline", test_multiline);
2203 g_test_add_func ("/regex/explicit-crlf", test_explicit_crlf);
2204 g_test_add_func ("/regex/max-lookbehind", test_max_lookbehind);
2205  
2206 /* TEST_NEW(pattern, compile_opts, match_opts) */
2207 TEST_NEW("[A-Z]+", G_REGEX_CASELESS | G_REGEX_EXTENDED | G_REGEX_OPTIMIZE, G_REGEX_MATCH_NOTBOL | G_REGEX_MATCH_PARTIAL);
2208 TEST_NEW("", 0, 0);
2209 TEST_NEW(".*", 0, 0);
2210 TEST_NEW(".*", G_REGEX_OPTIMIZE, 0);
2211 TEST_NEW(".*", G_REGEX_MULTILINE, 0);
2212 TEST_NEW(".*", G_REGEX_DOTALL, 0);
2213 TEST_NEW(".*", G_REGEX_DOTALL, G_REGEX_MATCH_NOTBOL);
2214 TEST_NEW("(123\\d*)[a-zA-Z]+(?P<hello>.*)", 0, 0);
2215 TEST_NEW("(123\\d*)[a-zA-Z]+(?P<hello>.*)", G_REGEX_CASELESS, 0);
2216 TEST_NEW("(123\\d*)[a-zA-Z]+(?P<hello>.*)", G_REGEX_CASELESS | G_REGEX_OPTIMIZE, 0);
2217 TEST_NEW("(?P<A>x)|(?P<A>y)", G_REGEX_DUPNAMES, 0);
2218 TEST_NEW("(?P<A>x)|(?P<A>y)", G_REGEX_DUPNAMES | G_REGEX_OPTIMIZE, 0);
2219 /* This gives "internal error: code overflow" with pcre 6.0 */
2220 TEST_NEW("(?i)(?-i)", 0, 0);
2221  
2222 /* Check that flags are correct if the pattern modifies them */
2223 /* TEST_NEW_CHECK_FLAGS(pattern, compile_opts, match_ops, real_compile_opts, real_match_opts) */
2224 TEST_NEW_CHECK_FLAGS ("a", G_REGEX_OPTIMIZE, 0, G_REGEX_OPTIMIZE, 0);
2225 TEST_NEW_CHECK_FLAGS ("a", G_REGEX_RAW, 0, G_REGEX_RAW, 0);
2226 TEST_NEW_CHECK_FLAGS ("(?i)a", 0, 0, G_REGEX_CASELESS, 0);
2227 TEST_NEW_CHECK_FLAGS ("(?m)a", 0, 0, G_REGEX_MULTILINE, 0);
2228 TEST_NEW_CHECK_FLAGS ("(?s)a", 0, 0, G_REGEX_DOTALL, 0);
2229 TEST_NEW_CHECK_FLAGS ("(?x)a", 0, 0, G_REGEX_EXTENDED, 0);
2230 TEST_NEW_CHECK_FLAGS ("(?J)a", 0, 0, G_REGEX_DUPNAMES, 0);
2231 TEST_NEW_CHECK_FLAGS ("(?U)[a-z]+", 0, 0, G_REGEX_UNGREEDY, 0);
2232 TEST_NEW_CHECK_FLAGS ("(?X)a", 0, 0, 0 /* not exposed by GRegex */, 0);
2233 TEST_NEW_CHECK_FLAGS ("^.*", 0, 0, G_REGEX_ANCHORED, 0);
2234 TEST_NEW_CHECK_FLAGS ("(*UTF8)a", 0, 0, 0 /* this is the default in GRegex */, 0);
2235 TEST_NEW_CHECK_FLAGS ("(*UCP)a", 0, 0, 0 /* this always on in GRegex */, 0);
2236 TEST_NEW_CHECK_FLAGS ("(*CR)a", 0, 0, G_REGEX_NEWLINE_CR, 0);
2237 TEST_NEW_CHECK_FLAGS ("(*LF)a", 0, 0, G_REGEX_NEWLINE_LF, 0);
2238 TEST_NEW_CHECK_FLAGS ("(*CRLF)a", 0, 0, G_REGEX_NEWLINE_CRLF, 0);
2239 TEST_NEW_CHECK_FLAGS ("(*ANY)a", 0, 0, 0 /* this is the default in GRegex */, 0);
2240 TEST_NEW_CHECK_FLAGS ("(*ANYCRLF)a", 0, 0, G_REGEX_NEWLINE_ANYCRLF, 0);
2241 TEST_NEW_CHECK_FLAGS ("(*BSR_ANYCRLF)a", 0, 0, G_REGEX_BSR_ANYCRLF, 0);
2242 TEST_NEW_CHECK_FLAGS ("(*BSR_UNICODE)a", 0, 0, 0 /* this is the default in GRegex */, 0);
2243 TEST_NEW_CHECK_FLAGS ("(*NO_START_OPT)a", 0, 0, 0 /* not exposed in GRegex */, 0);
2244  
2245 /* TEST_NEW_FAIL(pattern, compile_opts, expected_error) */
2246 TEST_NEW_FAIL("(", 0, G_REGEX_ERROR_UNMATCHED_PARENTHESIS);
2247 TEST_NEW_FAIL(")", 0, G_REGEX_ERROR_UNMATCHED_PARENTHESIS);
2248 TEST_NEW_FAIL("[", 0, G_REGEX_ERROR_UNTERMINATED_CHARACTER_CLASS);
2249 TEST_NEW_FAIL("*", 0, G_REGEX_ERROR_NOTHING_TO_REPEAT);
2250 TEST_NEW_FAIL("?", 0, G_REGEX_ERROR_NOTHING_TO_REPEAT);
2251 TEST_NEW_FAIL("(?P<A>x)|(?P<A>y)", 0, G_REGEX_ERROR_DUPLICATE_SUBPATTERN_NAME);
2252  
2253 /* Check all GRegexError codes */
2254 TEST_NEW_FAIL ("a\\", 0, G_REGEX_ERROR_STRAY_BACKSLASH);
2255 TEST_NEW_FAIL ("a\\c", 0, G_REGEX_ERROR_MISSING_CONTROL_CHAR);
2256 TEST_NEW_FAIL ("a\\l", 0, G_REGEX_ERROR_UNRECOGNIZED_ESCAPE);
2257 TEST_NEW_FAIL ("a{4,2}", 0, G_REGEX_ERROR_QUANTIFIERS_OUT_OF_ORDER);
2258 TEST_NEW_FAIL ("a{999999,}", 0, G_REGEX_ERROR_QUANTIFIER_TOO_BIG);
2259 TEST_NEW_FAIL ("[a-z", 0, G_REGEX_ERROR_UNTERMINATED_CHARACTER_CLASS);
2260 TEST_NEW_FAIL ("(?X)[\\B]", 0, G_REGEX_ERROR_INVALID_ESCAPE_IN_CHARACTER_CLASS);
2261 TEST_NEW_FAIL ("[z-a]", 0, G_REGEX_ERROR_RANGE_OUT_OF_ORDER);
2262 TEST_NEW_FAIL ("{2,4}", 0, G_REGEX_ERROR_NOTHING_TO_REPEAT);
2263 TEST_NEW_FAIL ("a(?u)", 0, G_REGEX_ERROR_UNRECOGNIZED_CHARACTER);
2264 TEST_NEW_FAIL ("a(?<$foo)bar", 0, G_REGEX_ERROR_UNRECOGNIZED_CHARACTER);
2265 TEST_NEW_FAIL ("a[:alpha:]b", 0, G_REGEX_ERROR_POSIX_NAMED_CLASS_OUTSIDE_CLASS);
2266 TEST_NEW_FAIL ("a(b", 0, G_REGEX_ERROR_UNMATCHED_PARENTHESIS);
2267 TEST_NEW_FAIL ("a)b", 0, G_REGEX_ERROR_UNMATCHED_PARENTHESIS);
2268 TEST_NEW_FAIL ("a(?R", 0, G_REGEX_ERROR_UNMATCHED_PARENTHESIS);
2269 TEST_NEW_FAIL ("a(?-54", 0, G_REGEX_ERROR_UNMATCHED_PARENTHESIS);
2270 TEST_NEW_FAIL ("(ab\\2)", 0, G_REGEX_ERROR_INEXISTENT_SUBPATTERN_REFERENCE);
2271 TEST_NEW_FAIL ("a(?#abc", 0, G_REGEX_ERROR_UNTERMINATED_COMMENT);
2272 TEST_NEW_FAIL ("(?<=a+)b", 0, G_REGEX_ERROR_VARIABLE_LENGTH_LOOKBEHIND);
2273 TEST_NEW_FAIL ("(?(1?)a|b)", 0, G_REGEX_ERROR_MALFORMED_CONDITION);
2274 TEST_NEW_FAIL ("(a)(?(1)a|b|c)", 0, G_REGEX_ERROR_TOO_MANY_CONDITIONAL_BRANCHES);
2275 TEST_NEW_FAIL ("(?(?i))", 0, G_REGEX_ERROR_ASSERTION_EXPECTED);
2276 TEST_NEW_FAIL ("a[[:fubar:]]b", 0, G_REGEX_ERROR_UNKNOWN_POSIX_CLASS_NAME);
2277 TEST_NEW_FAIL ("[[.ch.]]", 0, G_REGEX_ERROR_POSIX_COLLATING_ELEMENTS_NOT_SUPPORTED);
2278 TEST_NEW_FAIL ("\\x{110000}", 0, G_REGEX_ERROR_HEX_CODE_TOO_LARGE);
2279 TEST_NEW_FAIL ("^(?(0)f|b)oo", 0, G_REGEX_ERROR_INVALID_CONDITION);
2280 TEST_NEW_FAIL ("(?<=\\C)X", 0, G_REGEX_ERROR_SINGLE_BYTE_MATCH_IN_LOOKBEHIND);
2281 TEST_NEW_FAIL ("(?!\\w)(?R)", 0, G_REGEX_ERROR_INFINITE_LOOP);
2282 if (pcre_ge (8, 37))
2283 {
2284 /* The expected errors changed here. */
2285 TEST_NEW_FAIL ("(?(?<ab))", 0, G_REGEX_ERROR_ASSERTION_EXPECTED);
2286 }
2287 else
2288 {
2289 TEST_NEW_FAIL ("(?(?<ab))", 0, G_REGEX_ERROR_MISSING_SUBPATTERN_NAME_TERMINATOR);
2290 }
2291  
2292 if (pcre_ge (8, 35))
2293 {
2294 /* The expected errors changed here. */
2295 TEST_NEW_FAIL ("(?P<sub>foo)\\g<sub", 0, G_REGEX_ERROR_MISSING_SUBPATTERN_NAME_TERMINATOR);
2296 }
2297 else
2298 {
2299 TEST_NEW_FAIL ("(?P<sub>foo)\\g<sub", 0, G_REGEX_ERROR_MISSING_BACK_REFERENCE);
2300 }
2301 TEST_NEW_FAIL ("(?P<x>eks)(?P<x>eccs)", 0, G_REGEX_ERROR_DUPLICATE_SUBPATTERN_NAME);
2302 #if 0
2303 TEST_NEW_FAIL (?, 0, G_REGEX_ERROR_MALFORMED_PROPERTY);
2304 TEST_NEW_FAIL (?, 0, G_REGEX_ERROR_UNKNOWN_PROPERTY);
2305 #endif
2306 TEST_NEW_FAIL ("\\666", G_REGEX_RAW, G_REGEX_ERROR_INVALID_OCTAL_VALUE);
2307 TEST_NEW_FAIL ("^(?(DEFINE) abc | xyz ) ", 0, G_REGEX_ERROR_TOO_MANY_BRANCHES_IN_DEFINE);
2308 TEST_NEW_FAIL ("a", G_REGEX_NEWLINE_CRLF | G_REGEX_NEWLINE_ANYCRLF, G_REGEX_ERROR_INCONSISTENT_NEWLINE_OPTIONS);
2309 TEST_NEW_FAIL ("^(a)\\g{3", 0, G_REGEX_ERROR_MISSING_BACK_REFERENCE);
2310 TEST_NEW_FAIL ("^(a)\\g{0}", 0, G_REGEX_ERROR_INVALID_RELATIVE_REFERENCE);
2311 TEST_NEW_FAIL ("abc(*FAIL:123)xyz", 0, G_REGEX_ERROR_BACKTRACKING_CONTROL_VERB_ARGUMENT_FORBIDDEN);
2312 TEST_NEW_FAIL ("a(*FOOBAR)b", 0, G_REGEX_ERROR_UNKNOWN_BACKTRACKING_CONTROL_VERB);
2313 TEST_NEW_FAIL ("(?i:A{1,}\\6666666666)", 0, G_REGEX_ERROR_NUMBER_TOO_BIG);
2314 TEST_NEW_FAIL ("(?<a>)(?&)", 0, G_REGEX_ERROR_MISSING_SUBPATTERN_NAME);
2315 TEST_NEW_FAIL ("(?+-a)", 0, G_REGEX_ERROR_MISSING_DIGIT);
2316 TEST_NEW_FAIL ("TA]", G_REGEX_JAVASCRIPT_COMPAT, G_REGEX_ERROR_INVALID_DATA_CHARACTER);
2317 TEST_NEW_FAIL ("(?|(?<a>A)|(?<b>B))", 0, G_REGEX_ERROR_EXTRA_SUBPATTERN_NAME);
2318 TEST_NEW_FAIL ("a(*MARK)b", 0, G_REGEX_ERROR_BACKTRACKING_CONTROL_VERB_ARGUMENT_REQUIRED);
2319 TEST_NEW_FAIL ("^\\c€", 0, G_REGEX_ERROR_INVALID_CONTROL_CHAR);
2320 TEST_NEW_FAIL ("\\k", 0, G_REGEX_ERROR_MISSING_NAME);
2321 TEST_NEW_FAIL ("a[\\NB]c", 0, G_REGEX_ERROR_NOT_SUPPORTED_IN_CLASS);
2322 TEST_NEW_FAIL ("(*:0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEFG)XX", 0, G_REGEX_ERROR_NAME_TOO_LONG);
2323 TEST_NEW_FAIL ("\\u0100", G_REGEX_RAW | G_REGEX_JAVASCRIPT_COMPAT, G_REGEX_ERROR_CHARACTER_VALUE_TOO_LARGE);
2324  
2325 /* These errors can't really be tested sanely:
2326 * G_REGEX_ERROR_EXPRESSION_TOO_LARGE
2327 * G_REGEX_ERROR_MEMORY_ERROR
2328 * G_REGEX_ERROR_SUBPATTERN_NAME_TOO_LONG
2329 * G_REGEX_ERROR_TOO_MANY_SUBPATTERNS
2330 * G_REGEX_ERROR_TOO_MANY_FORWARD_REFERENCES
2331 *
2332 * These errors are obsolete and never raised by PCRE:
2333 * G_REGEX_ERROR_DEFINE_REPETION
2334 */
2335  
2336 /* TEST_MATCH_SIMPLE(pattern, string, compile_opts, match_opts, expected) */
2337 TEST_MATCH_SIMPLE("a", "", 0, 0, FALSE);
2338 TEST_MATCH_SIMPLE("a", "a", 0, 0, TRUE);
2339 TEST_MATCH_SIMPLE("a", "ba", 0, 0, TRUE);
2340 TEST_MATCH_SIMPLE("^a", "ba", 0, 0, FALSE);
2341 TEST_MATCH_SIMPLE("a", "ba", G_REGEX_ANCHORED, 0, FALSE);
2342 TEST_MATCH_SIMPLE("a", "ba", 0, G_REGEX_MATCH_ANCHORED, FALSE);
2343 TEST_MATCH_SIMPLE("a", "ab", G_REGEX_ANCHORED, 0, TRUE);
2344 TEST_MATCH_SIMPLE("a", "ab", 0, G_REGEX_MATCH_ANCHORED, TRUE);
2345 TEST_MATCH_SIMPLE("a", "a", G_REGEX_CASELESS, 0, TRUE);
2346 TEST_MATCH_SIMPLE("a", "A", G_REGEX_CASELESS, 0, TRUE);
2347 /* These are needed to test extended properties. */
2348 TEST_MATCH_SIMPLE(AGRAVE, AGRAVE, G_REGEX_CASELESS, 0, TRUE);
2349 TEST_MATCH_SIMPLE(AGRAVE, AGRAVE_UPPER, G_REGEX_CASELESS, 0, TRUE);
2350 TEST_MATCH_SIMPLE("\\p{L}", "a", 0, 0, TRUE);
2351 TEST_MATCH_SIMPLE("\\p{L}", "1", 0, 0, FALSE);
2352 TEST_MATCH_SIMPLE("\\p{L}", AGRAVE, 0, 0, TRUE);
2353 TEST_MATCH_SIMPLE("\\p{L}", AGRAVE_UPPER, 0, 0, TRUE);
2354 TEST_MATCH_SIMPLE("\\p{L}", SHEEN, 0, 0, TRUE);
2355 TEST_MATCH_SIMPLE("\\p{L}", ETH30, 0, 0, FALSE);
2356 TEST_MATCH_SIMPLE("\\p{Ll}", "a", 0, 0, TRUE);
2357 TEST_MATCH_SIMPLE("\\p{Ll}", AGRAVE, 0, 0, TRUE);
2358 TEST_MATCH_SIMPLE("\\p{Ll}", AGRAVE_UPPER, 0, 0, FALSE);
2359 TEST_MATCH_SIMPLE("\\p{Ll}", ETH30, 0, 0, FALSE);
2360 TEST_MATCH_SIMPLE("\\p{Sc}", AGRAVE, 0, 0, FALSE);
2361 TEST_MATCH_SIMPLE("\\p{Sc}", EURO, 0, 0, TRUE);
2362 TEST_MATCH_SIMPLE("\\p{Sc}", ETH30, 0, 0, FALSE);
2363 TEST_MATCH_SIMPLE("\\p{N}", "a", 0, 0, FALSE);
2364 TEST_MATCH_SIMPLE("\\p{N}", "1", 0, 0, TRUE);
2365 TEST_MATCH_SIMPLE("\\p{N}", AGRAVE, 0, 0, FALSE);
2366 TEST_MATCH_SIMPLE("\\p{N}", AGRAVE_UPPER, 0, 0, FALSE);
2367 TEST_MATCH_SIMPLE("\\p{N}", SHEEN, 0, 0, FALSE);
2368 TEST_MATCH_SIMPLE("\\p{N}", ETH30, 0, 0, TRUE);
2369 TEST_MATCH_SIMPLE("\\p{Nd}", "a", 0, 0, FALSE);
2370 TEST_MATCH_SIMPLE("\\p{Nd}", "1", 0, 0, TRUE);
2371 TEST_MATCH_SIMPLE("\\p{Nd}", AGRAVE, 0, 0, FALSE);
2372 TEST_MATCH_SIMPLE("\\p{Nd}", AGRAVE_UPPER, 0, 0, FALSE);
2373 TEST_MATCH_SIMPLE("\\p{Nd}", SHEEN, 0, 0, FALSE);
2374 TEST_MATCH_SIMPLE("\\p{Nd}", ETH30, 0, 0, FALSE);
2375 TEST_MATCH_SIMPLE("\\p{Common}", SHEEN, 0, 0, FALSE);
2376 TEST_MATCH_SIMPLE("\\p{Common}", "a", 0, 0, FALSE);
2377 TEST_MATCH_SIMPLE("\\p{Common}", AGRAVE, 0, 0, FALSE);
2378 TEST_MATCH_SIMPLE("\\p{Common}", AGRAVE_UPPER, 0, 0, FALSE);
2379 TEST_MATCH_SIMPLE("\\p{Common}", ETH30, 0, 0, FALSE);
2380 TEST_MATCH_SIMPLE("\\p{Common}", "%", 0, 0, TRUE);
2381 TEST_MATCH_SIMPLE("\\p{Common}", "1", 0, 0, TRUE);
2382 TEST_MATCH_SIMPLE("\\p{Arabic}", SHEEN, 0, 0, TRUE);
2383 TEST_MATCH_SIMPLE("\\p{Arabic}", "a", 0, 0, FALSE);
2384 TEST_MATCH_SIMPLE("\\p{Arabic}", AGRAVE, 0, 0, FALSE);
2385 TEST_MATCH_SIMPLE("\\p{Arabic}", AGRAVE_UPPER, 0, 0, FALSE);
2386 TEST_MATCH_SIMPLE("\\p{Arabic}", ETH30, 0, 0, FALSE);
2387 TEST_MATCH_SIMPLE("\\p{Arabic}", "%", 0, 0, FALSE);
2388 TEST_MATCH_SIMPLE("\\p{Arabic}", "1", 0, 0, FALSE);
2389 TEST_MATCH_SIMPLE("\\p{Latin}", SHEEN, 0, 0, FALSE);
2390 TEST_MATCH_SIMPLE("\\p{Latin}", "a", 0, 0, TRUE);
2391 TEST_MATCH_SIMPLE("\\p{Latin}", AGRAVE, 0, 0, TRUE);
2392 TEST_MATCH_SIMPLE("\\p{Latin}", AGRAVE_UPPER, 0, 0, TRUE);
2393 TEST_MATCH_SIMPLE("\\p{Latin}", ETH30, 0, 0, FALSE);
2394 TEST_MATCH_SIMPLE("\\p{Latin}", "%", 0, 0, FALSE);
2395 TEST_MATCH_SIMPLE("\\p{Latin}", "1", 0, 0, FALSE);
2396 TEST_MATCH_SIMPLE("\\p{Ethiopic}", SHEEN, 0, 0, FALSE);
2397 TEST_MATCH_SIMPLE("\\p{Ethiopic}", "a", 0, 0, FALSE);
2398 TEST_MATCH_SIMPLE("\\p{Ethiopic}", AGRAVE, 0, 0, FALSE);
2399 TEST_MATCH_SIMPLE("\\p{Ethiopic}", AGRAVE_UPPER, 0, 0, FALSE);
2400 TEST_MATCH_SIMPLE("\\p{Ethiopic}", ETH30, 0, 0, TRUE);
2401 TEST_MATCH_SIMPLE("\\p{Ethiopic}", "%", 0, 0, FALSE);
2402 TEST_MATCH_SIMPLE("\\p{Ethiopic}", "1", 0, 0, FALSE);
2403 TEST_MATCH_SIMPLE("\\p{L}(?<=\\p{Arabic})", SHEEN, 0, 0, TRUE);
2404 TEST_MATCH_SIMPLE("\\p{L}(?<=\\p{Latin})", SHEEN, 0, 0, FALSE);
2405 /* Invalid patterns. */
2406 TEST_MATCH_SIMPLE("\\", "a", 0, 0, FALSE);
2407 TEST_MATCH_SIMPLE("[", "", 0, 0, FALSE);
2408  
2409 /* TEST_MATCH(pattern, compile_opts, match_opts, string,
2410 * string_len, start_position, match_opts2, expected) */
2411 TEST_MATCH("a", 0, 0, "a", -1, 0, 0, TRUE);
2412 TEST_MATCH("a", 0, 0, "A", -1, 0, 0, FALSE);
2413 TEST_MATCH("a", G_REGEX_CASELESS, 0, "A", -1, 0, 0, TRUE);
2414 TEST_MATCH("a", 0, 0, "ab", -1, 1, 0, FALSE);
2415 TEST_MATCH("a", 0, 0, "ba", 1, 0, 0, FALSE);
2416 TEST_MATCH("a", 0, 0, "bab", -1, 0, 0, TRUE);
2417 TEST_MATCH("a", 0, 0, "b", -1, 0, 0, FALSE);
2418 TEST_MATCH("a", 0, G_REGEX_MATCH_ANCHORED, "a", -1, 0, 0, TRUE);
2419 TEST_MATCH("a", 0, G_REGEX_MATCH_ANCHORED, "ab", -1, 1, 0, FALSE);
2420 TEST_MATCH("a", 0, G_REGEX_MATCH_ANCHORED, "ba", 1, 0, 0, FALSE);
2421 TEST_MATCH("a", 0, G_REGEX_MATCH_ANCHORED, "bab", -1, 0, 0, FALSE);
2422 TEST_MATCH("a", 0, G_REGEX_MATCH_ANCHORED, "b", -1, 0, 0, FALSE);
2423 TEST_MATCH("a", 0, 0, "a", -1, 0, G_REGEX_MATCH_ANCHORED, TRUE);
2424 TEST_MATCH("a", 0, 0, "ab", -1, 1, G_REGEX_MATCH_ANCHORED, FALSE);
2425 TEST_MATCH("a", 0, 0, "ba", 1, 0, G_REGEX_MATCH_ANCHORED, FALSE);
2426 TEST_MATCH("a", 0, 0, "bab", -1, 0, G_REGEX_MATCH_ANCHORED, FALSE);
2427 TEST_MATCH("a", 0, 0, "b", -1, 0, G_REGEX_MATCH_ANCHORED, FALSE);
2428 TEST_MATCH("a|b", 0, 0, "a", -1, 0, 0, TRUE);
2429 TEST_MATCH("\\d", 0, 0, EURO, -1, 0, 0, FALSE);
2430 TEST_MATCH("^.$", 0, 0, EURO, -1, 0, 0, TRUE);
2431 TEST_MATCH("^.{3}$", 0, 0, EURO, -1, 0, 0, FALSE);
2432 TEST_MATCH("^.$", G_REGEX_RAW, 0, EURO, -1, 0, 0, FALSE);
2433 TEST_MATCH("^.{3}$", G_REGEX_RAW, 0, EURO, -1, 0, 0, TRUE);
2434 TEST_MATCH(AGRAVE, G_REGEX_CASELESS, 0, AGRAVE_UPPER, -1, 0, 0, TRUE);
2435  
2436 /* New lines handling. */
2437 TEST_MATCH("^a\\Rb$", 0, 0, "a\r\nb", -1, 0, 0, TRUE);
2438 TEST_MATCH("^a\\Rb$", 0, 0, "a\nb", -1, 0, 0, TRUE);
2439 TEST_MATCH("^a\\Rb$", 0, 0, "a\rb", -1, 0, 0, TRUE);
2440 TEST_MATCH("^a\\Rb$", 0, 0, "a\n\rb", -1, 0, 0, FALSE);
2441 TEST_MATCH("^a\\R\\Rb$", 0, 0, "a\n\rb", -1, 0, 0, TRUE);
2442 TEST_MATCH("^a\\nb$", 0, 0, "a\r\nb", -1, 0, 0, FALSE);
2443 TEST_MATCH("^a\\r\\nb$", 0, 0, "a\r\nb", -1, 0, 0, TRUE);
2444  
2445 TEST_MATCH("^b$", 0, 0, "a\nb\nc", -1, 0, 0, FALSE);
2446 TEST_MATCH("^b$", G_REGEX_MULTILINE, 0, "a\nb\nc", -1, 0, 0, TRUE);
2447 TEST_MATCH("^b$", G_REGEX_MULTILINE, 0, "a\r\nb\r\nc", -1, 0, 0, TRUE);
2448 TEST_MATCH("^b$", G_REGEX_MULTILINE, 0, "a\rb\rc", -1, 0, 0, TRUE);
2449 TEST_MATCH("^b$", G_REGEX_MULTILINE | G_REGEX_NEWLINE_CR, 0, "a\nb\nc", -1, 0, 0, FALSE);
2450 TEST_MATCH("^b$", G_REGEX_MULTILINE | G_REGEX_NEWLINE_LF, 0, "a\nb\nc", -1, 0, 0, TRUE);
2451 TEST_MATCH("^b$", G_REGEX_MULTILINE | G_REGEX_NEWLINE_CRLF, 0, "a\nb\nc", -1, 0, 0, FALSE);
2452 TEST_MATCH("^b$", G_REGEX_MULTILINE | G_REGEX_NEWLINE_CR, 0, "a\r\nb\r\nc", -1, 0, 0, FALSE);
2453 TEST_MATCH("^b$", G_REGEX_MULTILINE | G_REGEX_NEWLINE_LF, 0, "a\r\nb\r\nc", -1, 0, 0, FALSE);
2454 TEST_MATCH("^b$", G_REGEX_MULTILINE | G_REGEX_NEWLINE_CRLF, 0, "a\r\nb\r\nc", -1, 0, 0, TRUE);
2455 TEST_MATCH("^b$", G_REGEX_MULTILINE | G_REGEX_NEWLINE_CR, 0, "a\rb\rc", -1, 0, 0, TRUE);
2456 TEST_MATCH("^b$", G_REGEX_MULTILINE | G_REGEX_NEWLINE_LF, 0, "a\rb\rc", -1, 0, 0, FALSE);
2457 TEST_MATCH("^b$", G_REGEX_MULTILINE | G_REGEX_NEWLINE_CRLF, 0, "a\rb\rc", -1, 0, 0, FALSE);
2458 TEST_MATCH("^b$", G_REGEX_MULTILINE, G_REGEX_MATCH_NEWLINE_CR, "a\nb\nc", -1, 0, 0, FALSE);
2459 TEST_MATCH("^b$", G_REGEX_MULTILINE, G_REGEX_MATCH_NEWLINE_LF, "a\nb\nc", -1, 0, 0, TRUE);
2460 TEST_MATCH("^b$", G_REGEX_MULTILINE, G_REGEX_MATCH_NEWLINE_CRLF, "a\nb\nc", -1, 0, 0, FALSE);
2461 TEST_MATCH("^b$", G_REGEX_MULTILINE, G_REGEX_MATCH_NEWLINE_CR, "a\r\nb\r\nc", -1, 0, 0, FALSE);
2462 TEST_MATCH("^b$", G_REGEX_MULTILINE, G_REGEX_MATCH_NEWLINE_LF, "a\r\nb\r\nc", -1, 0, 0, FALSE);
2463 TEST_MATCH("^b$", G_REGEX_MULTILINE, G_REGEX_MATCH_NEWLINE_CRLF, "a\r\nb\r\nc", -1, 0, 0, TRUE);
2464 TEST_MATCH("^b$", G_REGEX_MULTILINE, G_REGEX_MATCH_NEWLINE_CR, "a\rb\rc", -1, 0, 0, TRUE);
2465 TEST_MATCH("^b$", G_REGEX_MULTILINE, G_REGEX_MATCH_NEWLINE_LF, "a\rb\rc", -1, 0, 0, FALSE);
2466 TEST_MATCH("^b$", G_REGEX_MULTILINE, G_REGEX_MATCH_NEWLINE_CRLF, "a\rb\rc", -1, 0, 0, FALSE);
2467  
2468 TEST_MATCH("^b$", G_REGEX_MULTILINE | G_REGEX_NEWLINE_CR, G_REGEX_MATCH_NEWLINE_ANY, "a\nb\nc", -1, 0, 0, TRUE);
2469 TEST_MATCH("^b$", G_REGEX_MULTILINE | G_REGEX_NEWLINE_CR, G_REGEX_MATCH_NEWLINE_ANY, "a\rb\rc", -1, 0, 0, TRUE);
2470 TEST_MATCH("^b$", G_REGEX_MULTILINE | G_REGEX_NEWLINE_CR, G_REGEX_MATCH_NEWLINE_ANY, "a\r\nb\r\nc", -1, 0, 0, TRUE);
2471 TEST_MATCH("^b$", G_REGEX_MULTILINE | G_REGEX_NEWLINE_CR, G_REGEX_MATCH_NEWLINE_LF, "a\nb\nc", -1, 0, 0, TRUE);
2472 TEST_MATCH("^b$", G_REGEX_MULTILINE | G_REGEX_NEWLINE_CR, G_REGEX_MATCH_NEWLINE_LF, "a\rb\rc", -1, 0, 0, FALSE);
2473 TEST_MATCH("^b$", G_REGEX_MULTILINE | G_REGEX_NEWLINE_CR, G_REGEX_MATCH_NEWLINE_CRLF, "a\r\nb\r\nc", -1, 0, 0, TRUE);
2474 TEST_MATCH("^b$", G_REGEX_MULTILINE | G_REGEX_NEWLINE_CR, G_REGEX_MATCH_NEWLINE_CRLF, "a\rb\rc", -1, 0, 0, FALSE);
2475  
2476 TEST_MATCH("a#\nb", G_REGEX_EXTENDED, 0, "a", -1, 0, 0, FALSE);
2477 TEST_MATCH("a#\r\nb", G_REGEX_EXTENDED, 0, "a", -1, 0, 0, FALSE);
2478 TEST_MATCH("a#\rb", G_REGEX_EXTENDED, 0, "a", -1, 0, 0, FALSE);
2479 TEST_MATCH("a#\nb", G_REGEX_EXTENDED, G_REGEX_MATCH_NEWLINE_CR, "a", -1, 0, 0, FALSE);
2480 TEST_MATCH("a#\nb", G_REGEX_EXTENDED | G_REGEX_NEWLINE_CR, 0, "a", -1, 0, 0, TRUE);
2481  
2482 TEST_MATCH("line\nbreak", G_REGEX_MULTILINE, 0, "this is a line\nbreak", -1, 0, 0, TRUE);
2483 TEST_MATCH("line\nbreak", G_REGEX_MULTILINE | G_REGEX_FIRSTLINE, 0, "first line\na line\nbreak", -1, 0, 0, FALSE);
2484  
2485 /* This failed with PCRE 7.2 (gnome bug #455640) */
2486 TEST_MATCH(".*$", 0, 0, "\xe1\xbb\x85", -1, 0, 0, TRUE);
2487  
2488 /* Test that othercasing in our pcre/glib integration is bug-for-bug compatible
2489 * with pcre's internal tables. Bug #678273 */
2490 TEST_MATCH("[DŽ]", G_REGEX_CASELESS, 0, "DŽ", -1, 0, 0, TRUE);
2491 TEST_MATCH("[DŽ]", G_REGEX_CASELESS, 0, "dž", -1, 0, 0, TRUE);
2492 #if PCRE_MAJOR > 8 || (PCRE_MAJOR == 8 && PCRE_MINOR >= 32)
2493 /* This would incorrectly fail to match in pcre < 8.32, so only assert
2494 * this for known-good pcre. */
2495 TEST_MATCH("[DŽ]", G_REGEX_CASELESS, 0, "Dž", -1, 0, 0, TRUE);
2496 #endif
2497  
2498 /* TEST_MATCH_NEXT#(pattern, string, string_len, start_position, ...) */
2499 TEST_MATCH_NEXT0("a", "x", -1, 0);
2500 TEST_MATCH_NEXT0("a", "ax", -1, 1);
2501 TEST_MATCH_NEXT0("a", "xa", 1, 0);
2502 TEST_MATCH_NEXT0("a", "axa", 1, 2);
2503 TEST_MATCH_NEXT1("a", "a", -1, 0, "a", 0, 1);
2504 TEST_MATCH_NEXT1("a", "xax", -1, 0, "a", 1, 2);
2505 TEST_MATCH_NEXT1(EURO, ENG EURO, -1, 0, EURO, 2, 5);
2506 TEST_MATCH_NEXT1("a*", "", -1, 0, "", 0, 0);
2507 TEST_MATCH_NEXT2("a*", "aa", -1, 0, "aa", 0, 2, "", 2, 2);
2508 TEST_MATCH_NEXT2(EURO "*", EURO EURO, -1, 0, EURO EURO, 0, 6, "", 6, 6);
2509 TEST_MATCH_NEXT2("a", "axa", -1, 0, "a", 0, 1, "a", 2, 3);
2510 TEST_MATCH_NEXT2("a+", "aaxa", -1, 0, "aa", 0, 2, "a", 3, 4);
2511 TEST_MATCH_NEXT2("a", "aa", -1, 0, "a", 0, 1, "a", 1, 2);
2512 TEST_MATCH_NEXT2("a", "ababa", -1, 2, "a", 2, 3, "a", 4, 5);
2513 TEST_MATCH_NEXT2(EURO "+", EURO "-" EURO, -1, 0, EURO, 0, 3, EURO, 4, 7);
2514 TEST_MATCH_NEXT3("", "ab", -1, 0, "", 0, 0, "", 1, 1, "", 2, 2);
2515 TEST_MATCH_NEXT3("", AGRAVE "b", -1, 0, "", 0, 0, "", 2, 2, "", 3, 3);
2516 TEST_MATCH_NEXT3("a", "aaxa", -1, 0, "a", 0, 1, "a", 1, 2, "a", 3, 4);
2517 TEST_MATCH_NEXT3("a", "aa" OGRAVE "a", -1, 0, "a", 0, 1, "a", 1, 2, "a", 4, 5);
2518 TEST_MATCH_NEXT3("a*", "aax", -1, 0, "aa", 0, 2, "", 2, 2, "", 3, 3);
2519 TEST_MATCH_NEXT3("(?=[A-Z0-9])", "RegExTest", -1, 0, "", 0, 0, "", 3, 3, "", 5, 5);
2520 TEST_MATCH_NEXT4("a*", "aaxa", -1, 0, "aa", 0, 2, "", 2, 2, "a", 3, 4, "", 4, 4);
2521  
2522 /* TEST_MATCH_COUNT(pattern, string, start_position, match_opts, expected_count) */
2523 TEST_MATCH_COUNT("a", "", 0, 0, 0);
2524 TEST_MATCH_COUNT("a", "a", 0, 0, 1);
2525 TEST_MATCH_COUNT("a", "a", 1, 0, 0);
2526 TEST_MATCH_COUNT("(.)", "a", 0, 0, 2);
2527 TEST_MATCH_COUNT("(.)", EURO, 0, 0, 2);
2528 TEST_MATCH_COUNT("(?:.)", "a", 0, 0, 1);
2529 TEST_MATCH_COUNT("(?P<A>.)", "a", 0, 0, 2);
2530 TEST_MATCH_COUNT("a$", "a", 0, G_REGEX_MATCH_NOTEOL, 0);
2531 TEST_MATCH_COUNT("(a)?(b)", "b", 0, 0, 3);
2532 TEST_MATCH_COUNT("(a)?(b)", "ab", 0, 0, 3);
2533  
2534 /* TEST_PARTIAL(pattern, string, expected) */
2535 TEST_PARTIAL("^ab", "a", TRUE);
2536 TEST_PARTIAL("^ab", "xa", FALSE);
2537 TEST_PARTIAL("ab", "xa", TRUE);
2538 TEST_PARTIAL("ab", "ab", FALSE); /* normal match. */
2539 TEST_PARTIAL("a+b", "aa", TRUE);
2540 TEST_PARTIAL("(a)+b", "aa", TRUE);
2541 TEST_PARTIAL("a?b", "a", TRUE);
2542  
2543 /* Test soft vs. hard partial matching */
2544 TEST_PARTIAL_FULL("cat(fish)?", "cat", G_REGEX_MATCH_PARTIAL_SOFT, FALSE);
2545 TEST_PARTIAL_FULL("cat(fish)?", "cat", G_REGEX_MATCH_PARTIAL_HARD, TRUE);
2546  
2547 /* TEST_SUB_PATTERN(pattern, string, start_position, sub_n, expected_sub,
2548 * expected_start, expected_end) */
2549 TEST_SUB_PATTERN("a", "a", 0, 0, "a", 0, 1);
2550 TEST_SUB_PATTERN("a(.)", "ab", 0, 1, "b", 1, 2);
2551 TEST_SUB_PATTERN("a(.)", "a" EURO, 0, 1, EURO, 1, 4);
2552 TEST_SUB_PATTERN("(?:.*)(a)(.)", "xxa" ENG, 0, 2, ENG, 3, 5);
2553 TEST_SUB_PATTERN("(" HSTROKE ")", "a" HSTROKE ENG, 0, 1, HSTROKE, 1, 3);
2554 TEST_SUB_PATTERN("a", "a", 0, 1, NULL, UNTOUCHED, UNTOUCHED);
2555 TEST_SUB_PATTERN("a", "a", 0, 1, NULL, UNTOUCHED, UNTOUCHED);
2556 TEST_SUB_PATTERN("(a)?(b)", "b", 0, 0, "b", 0, 1);
2557 TEST_SUB_PATTERN("(a)?(b)", "b", 0, 1, "", -1, -1);
2558 TEST_SUB_PATTERN("(a)?(b)", "b", 0, 2, "b", 0, 1);
2559  
2560 /* TEST_NAMED_SUB_PATTERN(pattern, string, start_position, sub_name,
2561 * expected_sub, expected_start, expected_end) */
2562 TEST_NAMED_SUB_PATTERN("a(?P<A>.)(?P<B>.)?", "ab", 0, "A", "b", 1, 2);
2563 TEST_NAMED_SUB_PATTERN("a(?P<A>.)(?P<B>.)?", "aab", 1, "A", "b", 2, 3);
2564 TEST_NAMED_SUB_PATTERN("a(?P<A>.)(?P<B>.)?", EURO "ab", 0, "A", "b", 4, 5);
2565 TEST_NAMED_SUB_PATTERN("a(?P<A>.)(?P<B>.)?", EURO "ab", 0, "B", NULL, UNTOUCHED, UNTOUCHED);
2566 TEST_NAMED_SUB_PATTERN("a(?P<A>.)(?P<B>.)?", EURO "ab", 0, "C", NULL, UNTOUCHED, UNTOUCHED);
2567 TEST_NAMED_SUB_PATTERN("a(?P<A>.)(?P<B>.)?", "a" EGRAVE "x", 0, "A", EGRAVE, 1, 3);
2568 TEST_NAMED_SUB_PATTERN("a(?P<A>.)(?P<B>.)?", "a" EGRAVE "x", 0, "B", "x", 3, 4);
2569 TEST_NAMED_SUB_PATTERN("(?P<A>a)?(?P<B>b)", "b", 0, "A", "", -1, -1);
2570 TEST_NAMED_SUB_PATTERN("(?P<A>a)?(?P<B>b)", "b", 0, "B", "b", 0, 1);
2571  
2572 /* TEST_NAMED_SUB_PATTERN_DUPNAMES(pattern, string, start_position, sub_name,
2573 * expected_sub, expected_start, expected_end) */
2574 TEST_NAMED_SUB_PATTERN_DUPNAMES("(?P<N>a)|(?P<N>b)", "ab", 0, "N", "a", 0, 1);
2575 TEST_NAMED_SUB_PATTERN_DUPNAMES("(?P<N>aa)|(?P<N>a)", "aa", 0, "N", "aa", 0, 2);
2576 TEST_NAMED_SUB_PATTERN_DUPNAMES("(?P<N>aa)(?P<N>a)", "aaa", 0, "N", "aa", 0, 2);
2577 TEST_NAMED_SUB_PATTERN_DUPNAMES("(?P<N>x)|(?P<N>a)", "a", 0, "N", "a", 0, 1);
2578 TEST_NAMED_SUB_PATTERN_DUPNAMES("(?P<N>x)y|(?P<N>a)b", "ab", 0, "N", "a", 0, 1);
2579  
2580 /* DUPNAMES option inside the pattern */
2581 TEST_NAMED_SUB_PATTERN("(?J)(?P<N>a)|(?P<N>b)", "ab", 0, "N", "a", 0, 1);
2582 TEST_NAMED_SUB_PATTERN("(?J)(?P<N>aa)|(?P<N>a)", "aa", 0, "N", "aa", 0, 2);
2583 TEST_NAMED_SUB_PATTERN("(?J)(?P<N>aa)(?P<N>a)", "aaa", 0, "N", "aa", 0, 2);
2584 TEST_NAMED_SUB_PATTERN("(?J)(?P<N>x)|(?P<N>a)", "a", 0, "N", "a", 0, 1);
2585 TEST_NAMED_SUB_PATTERN("(?J)(?P<N>x)y|(?P<N>a)b", "ab", 0, "N", "a", 0, 1);
2586  
2587 /* TEST_FETCH_ALL#(pattern, string, ...) */
2588 TEST_FETCH_ALL0("a", "");
2589 TEST_FETCH_ALL0("a", "b");
2590 TEST_FETCH_ALL1("a", "a", "a");
2591 TEST_FETCH_ALL1("a+", "aa", "aa");
2592 TEST_FETCH_ALL1("(?:a)", "a", "a");
2593 TEST_FETCH_ALL2("(a)", "a", "a", "a");
2594 TEST_FETCH_ALL2("a(.)", "ab", "ab", "b");
2595 TEST_FETCH_ALL2("a(.)", "a" HSTROKE, "a" HSTROKE, HSTROKE);
2596 TEST_FETCH_ALL3("(?:.*)(a)(.)", "xyazk", "xyaz", "a", "z");
2597 TEST_FETCH_ALL3("(?P<A>.)(a)", "xa", "xa", "x", "a");
2598 TEST_FETCH_ALL3("(?P<A>.)(a)", ENG "a", ENG "a", ENG, "a");
2599 TEST_FETCH_ALL3("(a)?(b)", "b", "b", "", "b");
2600 TEST_FETCH_ALL3("(a)?(b)", "ab", "ab", "a", "b");
2601  
2602 /* TEST_SPLIT_SIMPLE#(pattern, string, ...) */
2603 TEST_SPLIT_SIMPLE0("", "");
2604 TEST_SPLIT_SIMPLE0("a", "");
2605 TEST_SPLIT_SIMPLE1(",", "a", "a");
2606 TEST_SPLIT_SIMPLE1("(,)\\s*", "a", "a");
2607 TEST_SPLIT_SIMPLE2(",", "a,b", "a", "b");
2608 TEST_SPLIT_SIMPLE3(",", "a,b,c", "a", "b", "c");
2609 TEST_SPLIT_SIMPLE3(",\\s*", "a,b,c", "a", "b", "c");
2610 TEST_SPLIT_SIMPLE3(",\\s*", "a, b, c", "a", "b", "c");
2611 TEST_SPLIT_SIMPLE3("(,)\\s*", "a,b", "a", ",", "b");
2612 TEST_SPLIT_SIMPLE3("(,)\\s*", "a, b", "a", ",", "b");
2613 TEST_SPLIT_SIMPLE2("\\s", "ab c", "ab", "c");
2614 TEST_SPLIT_SIMPLE3("\\s*", "ab c", "a", "b", "c");
2615 /* Not matched sub-strings. */
2616 TEST_SPLIT_SIMPLE2("a|(b)", "xay", "x", "y");
2617 TEST_SPLIT_SIMPLE3("a|(b)", "xby", "x", "b", "y");
2618 /* Empty matches. */
2619 TEST_SPLIT_SIMPLE3("", "abc", "a", "b", "c");
2620 TEST_SPLIT_SIMPLE3(" *", "ab c", "a", "b", "c");
2621 /* Invalid patterns. */
2622 TEST_SPLIT_SIMPLE0("\\", "");
2623 TEST_SPLIT_SIMPLE0("[", "");
2624  
2625 /* TEST_SPLIT#(pattern, string, start_position, max_tokens, ...) */
2626 TEST_SPLIT0("", "", 0, 0);
2627 TEST_SPLIT0("a", "", 0, 0);
2628 TEST_SPLIT0("a", "", 0, 1);
2629 TEST_SPLIT0("a", "", 0, 2);
2630 TEST_SPLIT0("a", "a", 1, 0);
2631 TEST_SPLIT1(",", "a", 0, 0, "a");
2632 TEST_SPLIT1(",", "a,b", 0, 1, "a,b");
2633 TEST_SPLIT1("(,)\\s*", "a", 0, 0, "a");
2634 TEST_SPLIT1(",", "a,b", 2, 0, "b");
2635 TEST_SPLIT2(",", "a,b", 0, 0, "a", "b");
2636 TEST_SPLIT2(",", "a,b,c", 0, 2, "a", "b,c");
2637 TEST_SPLIT2(",", "a,b", 1, 0, "", "b");
2638 TEST_SPLIT2(",", "a,", 0, 0, "a", "");
2639 TEST_SPLIT3(",", "a,b,c", 0, 0, "a", "b", "c");
2640 TEST_SPLIT3(",\\s*", "a,b,c", 0, 0, "a", "b", "c");
2641 TEST_SPLIT3(",\\s*", "a, b, c", 0, 0, "a", "b", "c");
2642 TEST_SPLIT3("(,)\\s*", "a,b", 0, 0, "a", ",", "b");
2643 TEST_SPLIT3("(,)\\s*", "a, b", 0, 0, "a", ",", "b");
2644 /* Not matched sub-strings. */
2645 TEST_SPLIT2("a|(b)", "xay", 0, 0, "x", "y");
2646 TEST_SPLIT3("a|(b)", "xby", 0, -1, "x", "b", "y");
2647 /* Empty matches. */
2648 TEST_SPLIT2(" *", "ab c", 1, 0, "b", "c");
2649 TEST_SPLIT3("", "abc", 0, 0, "a", "b", "c");
2650 TEST_SPLIT3(" *", "ab c", 0, 0, "a", "b", "c");
2651 TEST_SPLIT1(" *", "ab c", 0, 1, "ab c");
2652 TEST_SPLIT2(" *", "ab c", 0, 2, "a", "b c");
2653 TEST_SPLIT3(" *", "ab c", 0, 3, "a", "b", "c");
2654 TEST_SPLIT3(" *", "ab c", 0, 4, "a", "b", "c");
2655  
2656 /* TEST_CHECK_REPLACEMENT(string_to_expand, expected, expected_refs) */
2657 TEST_CHECK_REPLACEMENT("", TRUE, FALSE);
2658 TEST_CHECK_REPLACEMENT("a", TRUE, FALSE);
2659 TEST_CHECK_REPLACEMENT("\\t\\n\\v\\r\\f\\a\\b\\\\\\x{61}", TRUE, FALSE);
2660 TEST_CHECK_REPLACEMENT("\\0", TRUE, TRUE);
2661 TEST_CHECK_REPLACEMENT("\\n\\2", TRUE, TRUE);
2662 TEST_CHECK_REPLACEMENT("\\g<foo>", TRUE, TRUE);
2663 /* Invalid strings */
2664 TEST_CHECK_REPLACEMENT("\\Q", FALSE, FALSE);
2665 TEST_CHECK_REPLACEMENT("x\\Ay", FALSE, FALSE);
2666  
2667 /* TEST_EXPAND(pattern, string, string_to_expand, raw, expected) */
2668 TEST_EXPAND("a", "a", "", FALSE, "");
2669 TEST_EXPAND("a", "a", "\\0", FALSE, "a");
2670 TEST_EXPAND("a", "a", "\\1", FALSE, "");
2671 TEST_EXPAND("(a)", "ab", "\\1", FALSE, "a");
2672 TEST_EXPAND("(a)", "a", "\\1", FALSE, "a");
2673 TEST_EXPAND("(a)", "a", "\\g<1>", FALSE, "a");
2674 TEST_EXPAND("a", "a", "\\0130", FALSE, "X");
2675 TEST_EXPAND("a", "a", "\\\\\\0", FALSE, "\\a");
2676 TEST_EXPAND("a(?P<G>.)c", "xabcy", "X\\g<G>X", FALSE, "XbX");
2677 #ifndef USE_SYSTEM_PCRE
2678 /* PCRE >= 8.34 no longer allows this usage. */
2679 TEST_EXPAND("(.)(?P<1>.)", "ab", "\\1", FALSE, "a");
2680 TEST_EXPAND("(.)(?P<1>.)", "ab", "\\g<1>", FALSE, "a");
2681 #endif
2682 TEST_EXPAND(".", EURO, "\\0", FALSE, EURO);
2683 TEST_EXPAND("(.)", EURO, "\\1", FALSE, EURO);
2684 TEST_EXPAND("(?P<G>.)", EURO, "\\g<G>", FALSE, EURO);
2685 TEST_EXPAND(".", "a", EURO, FALSE, EURO);
2686 TEST_EXPAND(".", "a", EURO "\\0", FALSE, EURO "a");
2687 TEST_EXPAND(".", "", "\\Lab\\Ec", FALSE, "abc");
2688 TEST_EXPAND(".", "", "\\LaB\\EC", FALSE, "abC");
2689 TEST_EXPAND(".", "", "\\Uab\\Ec", FALSE, "ABc");
2690 TEST_EXPAND(".", "", "a\\ubc", FALSE, "aBc");
2691 TEST_EXPAND(".", "", "a\\lbc", FALSE, "abc");
2692 TEST_EXPAND(".", "", "A\\uBC", FALSE, "ABC");
2693 TEST_EXPAND(".", "", "A\\lBC", FALSE, "AbC");
2694 TEST_EXPAND(".", "", "A\\l\\\\BC", FALSE, "A\\BC");
2695 TEST_EXPAND(".", "", "\\L" AGRAVE "\\E", FALSE, AGRAVE);
2696 TEST_EXPAND(".", "", "\\U" AGRAVE "\\E", FALSE, AGRAVE_UPPER);
2697 TEST_EXPAND(".", "", "\\u" AGRAVE "a", FALSE, AGRAVE_UPPER "a");
2698 TEST_EXPAND(".", "ab", "x\\U\\0y\\Ez", FALSE, "xAYz");
2699 TEST_EXPAND(".(.)", "AB", "x\\L\\1y\\Ez", FALSE, "xbyz");
2700 TEST_EXPAND(".", "ab", "x\\u\\0y\\Ez", FALSE, "xAyz");
2701 TEST_EXPAND(".(.)", "AB", "x\\l\\1y\\Ez", FALSE, "xbyz");
2702 TEST_EXPAND(".(.)", "a" AGRAVE_UPPER, "x\\l\\1y", FALSE, "x" AGRAVE "y");
2703 TEST_EXPAND("a", "bab", "\\x{61}", FALSE, "a");
2704 TEST_EXPAND("a", "bab", "\\x61", FALSE, "a");
2705 TEST_EXPAND("a", "bab", "\\x5a", FALSE, "Z");
2706 TEST_EXPAND("a", "bab", "\\0\\x5A", FALSE, "aZ");
2707 TEST_EXPAND("a", "bab", "\\1\\x{5A}", FALSE, "Z");
2708 TEST_EXPAND("a", "bab", "\\x{00E0}", FALSE, AGRAVE);
2709 TEST_EXPAND("", "bab", "\\x{0634}", FALSE, SHEEN);
2710 TEST_EXPAND("", "bab", "\\x{634}", FALSE, SHEEN);
2711 TEST_EXPAND("", "", "\\t", FALSE, "\t");
2712 TEST_EXPAND("", "", "\\v", FALSE, "\v");
2713 TEST_EXPAND("", "", "\\r", FALSE, "\r");
2714 TEST_EXPAND("", "", "\\n", FALSE, "\n");
2715 TEST_EXPAND("", "", "\\f", FALSE, "\f");
2716 TEST_EXPAND("", "", "\\a", FALSE, "\a");
2717 TEST_EXPAND("", "", "\\b", FALSE, "\b");
2718 TEST_EXPAND("a(.)", "abc", "\\0\\b\\1", FALSE, "ab\bb");
2719 TEST_EXPAND("a(.)", "abc", "\\0141", FALSE, "a");
2720 TEST_EXPAND("a(.)", "abc", "\\078", FALSE, "\a8");
2721 TEST_EXPAND("a(.)", "abc", "\\077", FALSE, "?");
2722 TEST_EXPAND("a(.)", "abc", "\\0778", FALSE, "?8");
2723 TEST_EXPAND("a(.)", "a" AGRAVE "b", "\\1", FALSE, AGRAVE);
2724 TEST_EXPAND("a(.)", "a" AGRAVE "b", "\\1", TRUE, "\xc3");
2725 TEST_EXPAND("a(.)", "a" AGRAVE "b", "\\0", TRUE, "a\xc3");
2726 /* Invalid strings. */
2727 TEST_EXPAND("", "", "\\Q", FALSE, NULL);
2728 TEST_EXPAND("", "", "x\\Ay", FALSE, NULL);
2729 TEST_EXPAND("", "", "\\g<", FALSE, NULL);
2730 TEST_EXPAND("", "", "\\g<>", FALSE, NULL);
2731 TEST_EXPAND("", "", "\\g<1a>", FALSE, NULL);
2732 TEST_EXPAND("", "", "\\g<a$>", FALSE, NULL);
2733 TEST_EXPAND("", "", "\\", FALSE, NULL);
2734 TEST_EXPAND("a", "a", "\\x{61", FALSE, NULL);
2735 TEST_EXPAND("a", "a", "\\x6X", FALSE, NULL);
2736 /* Pattern-less. */
2737 TEST_EXPAND(NULL, NULL, "", FALSE, "");
2738 TEST_EXPAND(NULL, NULL, "\\n", FALSE, "\n");
2739 /* Invalid strings */
2740 TEST_EXPAND(NULL, NULL, "\\Q", FALSE, NULL);
2741 TEST_EXPAND(NULL, NULL, "x\\Ay", FALSE, NULL);
2742  
2743 /* TEST_REPLACE(pattern, string, start_position, replacement, expected) */
2744 TEST_REPLACE("a", "ababa", 0, "A", "AbAbA");
2745 TEST_REPLACE("a", "ababa", 1, "A", "abAbA");
2746 TEST_REPLACE("a", "ababa", 2, "A", "abAbA");
2747 TEST_REPLACE("a", "ababa", 3, "A", "ababA");
2748 TEST_REPLACE("a", "ababa", 4, "A", "ababA");
2749 TEST_REPLACE("a", "ababa", 5, "A", "ababa");
2750 TEST_REPLACE("a", "ababa", 6, "A", "ababa");
2751 TEST_REPLACE("a", "abababa", 2, "A", "abAbAbA");
2752 TEST_REPLACE("a", "abab", 0, "A", "AbAb");
2753 TEST_REPLACE("a", "baba", 0, "A", "bAbA");
2754 TEST_REPLACE("a", "bab", 0, "A", "bAb");
2755 TEST_REPLACE("$^", "abc", 0, "X", "abc");
2756 TEST_REPLACE("(.)a", "ciao", 0, "a\\1", "caio");
2757 TEST_REPLACE("a.", "abc", 0, "\\0\\0", "ababc");
2758 TEST_REPLACE("a", "asd", 0, "\\0101", "Asd");
2759 TEST_REPLACE("(a).\\1", "aba cda", 0, "\\1\\n", "a\n cda");
2760 TEST_REPLACE("a" AGRAVE "a", "a" AGRAVE "a", 0, "x", "x");
2761 TEST_REPLACE("a" AGRAVE "a", "a" AGRAVE "a", 0, OGRAVE, OGRAVE);
2762 TEST_REPLACE("[^-]", "-" EURO "-x-" HSTROKE, 0, "a", "-a-a-a");
2763 TEST_REPLACE("[^-]", "-" EURO "-" HSTROKE, 0, "a\\g<0>a", "-a" EURO "a-a" HSTROKE "a");
2764 TEST_REPLACE("-", "-" EURO "-" HSTROKE, 0, "", EURO HSTROKE);
2765 TEST_REPLACE(".*", "hello", 0, "\\U\\0\\E", "HELLO");
2766 TEST_REPLACE(".*", "hello", 0, "\\u\\0", "Hello");
2767 TEST_REPLACE("\\S+", "hello world", 0, "\\U-\\0-", "-HELLO- -WORLD-");
2768 TEST_REPLACE(".", "a", 0, "\\A", NULL);
2769 TEST_REPLACE(".", "a", 0, "\\g", NULL);
2770  
2771 /* TEST_REPLACE_LIT(pattern, string, start_position, replacement, expected) */
2772 TEST_REPLACE_LIT("a", "ababa", 0, "A", "AbAbA");
2773 TEST_REPLACE_LIT("a", "ababa", 1, "A", "abAbA");
2774 TEST_REPLACE_LIT("a", "ababa", 2, "A", "abAbA");
2775 TEST_REPLACE_LIT("a", "ababa", 3, "A", "ababA");
2776 TEST_REPLACE_LIT("a", "ababa", 4, "A", "ababA");
2777 TEST_REPLACE_LIT("a", "ababa", 5, "A", "ababa");
2778 TEST_REPLACE_LIT("a", "ababa", 6, "A", "ababa");
2779 TEST_REPLACE_LIT("a", "abababa", 2, "A", "abAbAbA");
2780 TEST_REPLACE_LIT("a", "abcadaa", 0, "A", "AbcAdAA");
2781 TEST_REPLACE_LIT("$^", "abc", 0, "X", "abc");
2782 TEST_REPLACE_LIT("(.)a", "ciao", 0, "a\\1", "ca\\1o");
2783 TEST_REPLACE_LIT("a.", "abc", 0, "\\0\\0\\n", "\\0\\0\\nc");
2784 TEST_REPLACE_LIT("a" AGRAVE "a", "a" AGRAVE "a", 0, "x", "x");
2785 TEST_REPLACE_LIT("a" AGRAVE "a", "a" AGRAVE "a", 0, OGRAVE, OGRAVE);
2786 TEST_REPLACE_LIT(AGRAVE, "-" AGRAVE "-" HSTROKE, 0, "a" ENG "a", "-a" ENG "a-" HSTROKE);
2787 TEST_REPLACE_LIT("[^-]", "-" EURO "-" AGRAVE "-" HSTROKE, 0, "a", "-a-a-a");
2788 TEST_REPLACE_LIT("[^-]", "-" EURO "-" AGRAVE, 0, "a\\g<0>a", "-a\\g<0>a-a\\g<0>a");
2789 TEST_REPLACE_LIT("-", "-" EURO "-" AGRAVE "-" HSTROKE, 0, "", EURO AGRAVE HSTROKE);
2790 TEST_REPLACE_LIT("(?=[A-Z0-9])", "RegExTest", 0, "_", "_Reg_Ex_Test");
2791 TEST_REPLACE_LIT("(?=[A-Z0-9])", "RegExTest", 1, "_", "Reg_Ex_Test");
2792  
2793 /* TEST_GET_STRING_NUMBER(pattern, name, expected_num) */
2794 TEST_GET_STRING_NUMBER("", "A", -1);
2795 TEST_GET_STRING_NUMBER("(?P<A>.)", "A", 1);
2796 TEST_GET_STRING_NUMBER("(?P<A>.)", "B", -1);
2797 TEST_GET_STRING_NUMBER("(?P<A>.)(?P<B>a)", "A", 1);
2798 TEST_GET_STRING_NUMBER("(?P<A>.)(?P<B>a)", "B", 2);
2799 TEST_GET_STRING_NUMBER("(?P<A>.)(?P<B>a)", "C", -1);
2800 TEST_GET_STRING_NUMBER("(?P<A>.)(.)(?P<B>a)", "A", 1);
2801 TEST_GET_STRING_NUMBER("(?P<A>.)(.)(?P<B>a)", "B", 3);
2802 TEST_GET_STRING_NUMBER("(?P<A>.)(.)(?P<B>a)", "C", -1);
2803 TEST_GET_STRING_NUMBER("(?:a)(?P<A>.)", "A", 1);
2804 TEST_GET_STRING_NUMBER("(?:a)(?P<A>.)", "B", -1);
2805  
2806 /* TEST_ESCAPE_NUL(string, length, expected) */
2807 TEST_ESCAPE_NUL("hello world", -1, "hello world");
2808 TEST_ESCAPE_NUL("hello\0world", -1, "hello");
2809 TEST_ESCAPE_NUL("\0world", -1, "");
2810 TEST_ESCAPE_NUL("hello world", 5, "hello");
2811 TEST_ESCAPE_NUL("hello.world", 11, "hello.world");
2812 TEST_ESCAPE_NUL("a(b\\b.$", 7, "a(b\\b.$");
2813 TEST_ESCAPE_NUL("hello\0", 6, "hello\\x00");
2814 TEST_ESCAPE_NUL("\0world", 6, "\\x00world");
2815 TEST_ESCAPE_NUL("\0\0", 2, "\\x00\\x00");
2816 TEST_ESCAPE_NUL("hello\0world", 11, "hello\\x00world");
2817 TEST_ESCAPE_NUL("hello\0world\0", 12, "hello\\x00world\\x00");
2818 TEST_ESCAPE_NUL("hello\\\0world", 12, "hello\\x00world");
2819 TEST_ESCAPE_NUL("hello\\\\\0world", 13, "hello\\\\\\x00world");
2820 TEST_ESCAPE_NUL("|()[]{}^$*+?.", 13, "|()[]{}^$*+?.");
2821 TEST_ESCAPE_NUL("|()[]{}^$*+?.\\\\", 15, "|()[]{}^$*+?.\\\\");
2822  
2823 /* TEST_ESCAPE(string, length, expected) */
2824 TEST_ESCAPE("hello world", -1, "hello world");
2825 TEST_ESCAPE("hello world", 5, "hello");
2826 TEST_ESCAPE("hello.world", -1, "hello\\.world");
2827 TEST_ESCAPE("a(b\\b.$", -1, "a\\(b\\\\b\\.\\$");
2828 TEST_ESCAPE("hello\0world", -1, "hello");
2829 TEST_ESCAPE("hello\0world", 11, "hello\\0world");
2830 TEST_ESCAPE(EURO "*" ENG, -1, EURO "\\*" ENG);
2831 TEST_ESCAPE("a$", -1, "a\\$");
2832 TEST_ESCAPE("$a", -1, "\\$a");
2833 TEST_ESCAPE("a$a", -1, "a\\$a");
2834 TEST_ESCAPE("$a$", -1, "\\$a\\$");
2835 TEST_ESCAPE("$a$", 0, "");
2836 TEST_ESCAPE("$a$", 1, "\\$");
2837 TEST_ESCAPE("$a$", 2, "\\$a");
2838 TEST_ESCAPE("$a$", 3, "\\$a\\$");
2839 TEST_ESCAPE("$a$", 4, "\\$a\\$\\0");
2840 TEST_ESCAPE("|()[]{}^$*+?.", -1, "\\|\\(\\)\\[\\]\\{\\}\\^\\$\\*\\+\\?\\.");
2841 TEST_ESCAPE("a|a(a)a[a]a{a}a^a$a*a+a?a.a", -1,
2842 "a\\|a\\(a\\)a\\[a\\]a\\{a\\}a\\^a\\$a\\*a\\+a\\?a\\.a");
2843  
2844 /* TEST_MATCH_ALL#(pattern, string, string_len, start_position, ...) */
2845 TEST_MATCH_ALL0("<.*>", "", -1, 0);
2846 TEST_MATCH_ALL0("a+", "", -1, 0);
2847 TEST_MATCH_ALL0("a+", "a", 0, 0);
2848 TEST_MATCH_ALL0("a+", "a", -1, 1);
2849 TEST_MATCH_ALL1("<.*>", "<a>", -1, 0, "<a>", 0, 3);
2850 TEST_MATCH_ALL1("a+", "a", -1, 0, "a", 0, 1);
2851 TEST_MATCH_ALL1("a+", "aa", 1, 0, "a", 0, 1);
2852 TEST_MATCH_ALL1("a+", "aa", -1, 1, "a", 1, 2);
2853 TEST_MATCH_ALL1("a+", "aa", 2, 1, "a", 1, 2);
2854 TEST_MATCH_ALL1(".+", ENG, -1, 0, ENG, 0, 2);
2855 TEST_MATCH_ALL2("<.*>", "<a><b>", -1, 0, "<a><b>", 0, 6, "<a>", 0, 3);
2856 TEST_MATCH_ALL2("a+", "aa", -1, 0, "aa", 0, 2, "a", 0, 1);
2857 TEST_MATCH_ALL2(".+", ENG EURO, -1, 0, ENG EURO, 0, 5, ENG, 0, 2);
2858 TEST_MATCH_ALL3("<.*>", "<a><b><c>", -1, 0, "<a><b><c>", 0, 9,
2859 "<a><b>", 0, 6, "<a>", 0, 3);
2860 TEST_MATCH_ALL3("a+", "aaa", -1, 0, "aaa", 0, 3, "aa", 0, 2, "a", 0, 1);
2861  
2862 /* NOTEMPTY matching */
2863 TEST_MATCH_NOTEMPTY("a?b?", "xyz", FALSE);
2864 TEST_MATCH_NOTEMPTY_ATSTART("a?b?", "xyz", TRUE);
2865  
2866 return g_test_run ();
2867 }