← Back to branch summary

~ubuntu-branches/debian/sid/glib2.0/sid

« back to all changes in this revision

Viewing changes to glib/tests/regex.c

  • Committer: Package Import Robot
  • Author(s): Martin Pitt
  • Date: 2013-05-08 06:25:57 UTC
  • mfrom: (1.27.14) (3.1.181 experimental)
  • Revision ID: package-import@ubuntu.com-20130508062557-i7gbku66mls70gi2
Tags: 2.36.1-2
Merge experimental branch, upload to unstable.

Show diffs side-by-side

added added

removed removed

Lines of Context:
glib/tests/regex.c
56
56
  GRegexCompileFlags compile_opts;
57
57
  GRegexMatchFlags   match_opts;
58
58
  gint expected_error;
 
59
  gboolean check_flags;
 
60
  GRegexCompileFlags real_compile_opts;
 
61
  GRegexMatchFlags real_match_opts;
59
62
} TestNewData;
60
63
 
61
64
static void
70
73
  g_assert_no_error (error);
71
74
  g_assert_cmpstr (data->pattern, ==, g_regex_get_pattern (regex));
72
75
 
 
76
  if (data->check_flags)
 
77
    {
 
78
      g_assert_cmphex (g_regex_get_compile_flags (regex), ==, data->real_compile_opts);
 
79
      g_assert_cmphex (g_regex_get_match_flags (regex), ==, data->real_match_opts);
 
80
    }
 
81
 
73
82
  g_regex_unref (regex);
74
83
}
75
84
 
76
 
#define TEST_NEW(_pattern, _compile_opts, _match_opts) {   \
77
 
  TestNewData *data;                                    \
78
 
  gchar *path;                                          \
79
 
  data = g_new0 (TestNewData, 1);                       \
80
 
  data->pattern = _pattern;                              \
81
 
  data->compile_opts = _compile_opts;                    \
82
 
  data->match_opts = _match_opts;                        \
83
 
  data->expected_error = 0;                             \
84
 
  path = g_strdup_printf ("/regex/new/%d", ++total);    \
85
 
  g_test_add_data_func (path, data, test_new);          \
86
 
  g_free (path);                                        \
 
85
#define TEST_NEW(_pattern, _compile_opts, _match_opts) {    \
 
86
  TestNewData *data;                                        \
 
87
  gchar *path;                                              \
 
88
  data = g_new0 (TestNewData, 1);                           \
 
89
  data->pattern = _pattern;                                 \
 
90
  data->compile_opts = _compile_opts;                       \
 
91
  data->match_opts = _match_opts;                           \
 
92
  data->expected_error = 0;                                 \
 
93
  data->check_flags = FALSE;                                \
 
94
  path = g_strdup_printf ("/regex/new/%d", ++total);        \
 
95
  g_test_add_data_func_full (path, data, test_new, g_free); \
 
96
  g_free (path);                                            \
 
97
}
 
98
 
 
99
#define TEST_NEW_CHECK_FLAGS(_pattern, _compile_opts, _match_opts, _real_compile_opts, _real_match_opts) { \
 
100
  TestNewData *data;                                             \
 
101
  gchar *path;                                                   \
 
102
  data = g_new0 (TestNewData, 1);                                \
 
103
  data->pattern = _pattern;                                      \
 
104
  data->compile_opts = _compile_opts;                            \
 
105
  data->match_opts = 0;                                          \
 
106
  data->expected_error = 0;                                      \
 
107
  data->check_flags = TRUE;                                      \
 
108
  data->real_compile_opts = _real_compile_opts;                  \
 
109
  data->real_match_opts = _real_match_opts;                      \
 
110
  path = g_strdup_printf ("/regex/new-check-flags/%d", ++total); \
 
111
  g_test_add_data_func_full (path, data, test_new, g_free);      \
 
112
  g_free (path);                                                 \
87
113
}
88
114
 
89
115
static void
100
126
  g_error_free (error);
101
127
}
102
128
 
103
 
#define TEST_NEW_FAIL(_pattern, _compile_opts, _expected_error) {  \
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 = _expected_error;                        \
111
 
  path = g_strdup_printf ("/regex/new-fail/%d", ++total);       \
112
 
  g_test_add_data_func (path, data, test_new_fail);             \
113
 
  g_free (path);                                                \
 
129
#define TEST_NEW_FAIL(_pattern, _compile_opts, _expected_error) { \
 
130
  TestNewData *data;                                              \
 
131
  gchar *path;                                                    \
 
132
  data = g_new0 (TestNewData, 1);                                 \
 
133
  data->pattern = _pattern;                                       \
 
134
  data->compile_opts = _compile_opts;                             \
 
135
  data->match_opts = 0;                                           \
 
136
  data->expected_error = _expected_error;                         \
 
137
  path = g_strdup_printf ("/regex/new-fail/%d", ++total);         \
 
138
  g_test_add_data_func_full (path, data, test_new_fail, g_free);  \
 
139
  g_free (path);                                                  \
114
140
}
115
141
 
116
142
typedef struct {
134
160
  g_assert_cmpint (match, ==, data->expected);
135
161
}
136
162
 
137
 
#define TEST_MATCH_SIMPLE(_pattern, _string, _compile_opts, _match_opts, _expected) { \
 
163
#define TEST_MATCH_SIMPLE_NAMED(_name, _pattern, _string, _compile_opts, _match_opts, _expected) { \
138
164
  TestMatchData *data;                                                  \
139
165
  gchar *path;                                                          \
140
166
  data = g_new0 (TestMatchData, 1);                                     \
141
 
  data->pattern = _pattern;                                              \
142
 
  data->string = _string;                                                \
143
 
  data->compile_opts = _compile_opts;                                    \
144
 
  data->match_opts = _match_opts;                                        \
145
 
  data->expected = _expected;                                            \
146
 
  path = g_strdup_printf ("/regex/match-simple/%d", ++total);           \
147
 
  g_test_add_data_func (path, data, test_match_simple);                 \
 
167
  data->pattern = _pattern;                                             \
 
168
  data->string = _string;                                               \
 
169
  data->compile_opts = _compile_opts;                                   \
 
170
  data->match_opts = _match_opts;                                       \
 
171
  data->expected = _expected;                                           \
 
172
  path = g_strdup_printf ("/regex/match-%s/%d", _name, ++total);        \
 
173
  g_test_add_data_func_full (path, data, test_match_simple, g_free);    \
148
174
  g_free (path);                                                        \
149
175
}
150
176
 
 
177
#define TEST_MATCH_SIMPLE(_pattern, _string, _compile_opts, _match_opts, _expected) \
 
178
  TEST_MATCH_SIMPLE_NAMED("simple", _pattern, _string, _compile_opts, _match_opts, _expected)
 
179
#define TEST_MATCH_NOTEMPTY(_pattern, _string, _expected) \
 
180
  TEST_MATCH_SIMPLE_NAMED("notempty", _pattern, _string, 0, G_REGEX_MATCH_NOTEMPTY, _expected)
 
181
#define TEST_MATCH_NOTEMPTY_ATSTART(_pattern, _string, _expected) \
 
182
  TEST_MATCH_SIMPLE_NAMED("notempty-atstart", _pattern, _string, 0, G_REGEX_MATCH_NOTEMPTY_ATSTART, _expected)
 
183
 
151
184
static void
152
185
test_match (gconstpointer d)
153
186
{
179
212
  TestMatchData *data;                                                  \
180
213
  gchar *path;                                                          \
181
214
  data = g_new0 (TestMatchData, 1);                                     \
182
 
  data->pattern = _pattern;                                              \
183
 
  data->compile_opts = _compile_opts;                                    \
184
 
  data->match_opts = _match_opts;                                        \
185
 
  data->string = _string;                                                \
186
 
  data->string_len = _string_len;                                        \
187
 
  data->start_position = _start_position;                                \
188
 
  data->match_opts2 = _match_opts2;                                      \
189
 
  data->expected = _expected;                                            \
 
215
  data->pattern = _pattern;                                             \
 
216
  data->compile_opts = _compile_opts;                                   \
 
217
  data->match_opts = _match_opts;                                       \
 
218
  data->string = _string;                                               \
 
219
  data->string_len = _string_len;                                       \
 
220
  data->start_position = _start_position;                               \
 
221
  data->match_opts2 = _match_opts2;                                     \
 
222
  data->expected = _expected;                                           \
190
223
  path = g_strdup_printf ("/regex/match/%d", ++total);                  \
191
 
  g_test_add_data_func (path, data, test_match);                        \
 
224
  g_test_add_data_func_full (path, data, test_match, g_free);           \
192
225
  g_free (path);                                                        \
193
226
}
194
227
 
269
302
  g_slist_free_full (matches, free_match);
270
303
}
271
304
 
 
305
static void
 
306
free_match_next_data (gpointer _data)
 
307
{
 
308
  TestMatchNextData *data = _data;
 
309
 
 
310
  g_slist_free_full (data->expected, g_free);
 
311
  g_free (data);
 
312
}
 
313
 
272
314
#define TEST_MATCH_NEXT0(_pattern, _string, _string_len, _start_position) { \
273
315
  TestMatchNextData *data;                                              \
274
316
  gchar *path;                                                          \
275
317
  data = g_new0 (TestMatchNextData, 1);                                 \
276
 
  data->pattern = _pattern;                                              \
277
 
  data->string = _string;                                                \
278
 
  data->string_len = _string_len;                                        \
279
 
  data->start_position = _start_position;                                \
 
318
  data->pattern = _pattern;                                             \
 
319
  data->string = _string;                                               \
 
320
  data->string_len = _string_len;                                       \
 
321
  data->start_position = _start_position;                               \
280
322
  data->expected = NULL;                                                \
281
323
  path = g_strdup_printf ("/regex/match/next0/%d", ++total);            \
282
 
  g_test_add_data_func (path, data, test_match_next);                   \
 
324
  g_test_add_data_func_full (path, data, test_match_next, free_match_next_data); \
283
325
  g_free (path);                                                        \
284
326
}
285
327
 
289
331
  Match *match;                                                         \
290
332
  gchar *path;                                                          \
291
333
  data = g_new0 (TestMatchNextData, 1);                                 \
292
 
  data->pattern = _pattern;                                              \
293
 
  data->string = _string;                                                \
294
 
  data->string_len = _string_len;                                        \
295
 
  data->start_position = _start_position;                                \
 
334
  data->pattern = _pattern;                                             \
 
335
  data->string = _string;                                               \
 
336
  data->string_len = _string_len;                                       \
 
337
  data->start_position = _start_position;                               \
296
338
  match = g_new0 (Match, 1);                                            \
297
339
  match->string = t1;                                                   \
298
340
  match->start = s1;                                                    \
299
341
  match->end = e1;                                                      \
300
342
  data->expected = g_slist_append (NULL, match);                        \
301
343
  path = g_strdup_printf ("/regex/match/next1/%d", ++total);            \
302
 
  g_test_add_data_func (path, data, test_match_next);                   \
 
344
  g_test_add_data_func_full (path, data, test_match_next, free_match_next_data); \
303
345
  g_free (path);                                                        \
304
346
}
305
347
 
309
351
  Match *match;                                                         \
310
352
  gchar *path;                                                          \
311
353
  data = g_new0 (TestMatchNextData, 1);                                 \
312
 
  data->pattern = _pattern;                                              \
313
 
  data->string = _string;                                                \
314
 
  data->string_len = _string_len;                                        \
315
 
  data->start_position = _start_position;                                \
 
354
  data->pattern = _pattern;                                             \
 
355
  data->string = _string;                                               \
 
356
  data->string_len = _string_len;                                       \
 
357
  data->start_position = _start_position;                               \
316
358
  match = g_new0 (Match, 1);                                            \
317
359
  match->string = t1;                                                   \
318
360
  match->start = s1;                                                    \
324
366
  match->end = e2;                                                      \
325
367
  data->expected = g_slist_append (data->expected, match);              \
326
368
  path = g_strdup_printf ("/regex/match/next2/%d", ++total);            \
327
 
  g_test_add_data_func (path, data, test_match_next);                   \
 
369
  g_test_add_data_func_full (path, data, test_match_next, free_match_next_data); \
328
370
  g_free (path);                                                        \
329
371
}
330
372
 
334
376
  Match *match;                                                         \
335
377
  gchar *path;                                                          \
336
378
  data = g_new0 (TestMatchNextData, 1);                                 \
337
 
  data->pattern = _pattern;                                              \
338
 
  data->string = _string;                                                \
339
 
  data->string_len = _string_len;                                        \
340
 
  data->start_position = _start_position;                                \
 
379
  data->pattern = _pattern;                                             \
 
380
  data->string = _string;                                               \
 
381
  data->string_len = _string_len;                                       \
 
382
  data->start_position = _start_position;                               \
341
383
  match = g_new0 (Match, 1);                                            \
342
384
  match->string = t1;                                                   \
343
385
  match->start = s1;                                                    \
354
396
  match->end = e3;                                                      \
355
397
  data->expected = g_slist_append (data->expected, match);              \
356
398
  path = g_strdup_printf ("/regex/match/next3/%d", ++total);            \
357
 
  g_test_add_data_func (path, data, test_match_next);                   \
 
399
  g_test_add_data_func_full (path, data, test_match_next, free_match_next_data); \
358
400
  g_free (path);                                                        \
359
401
}
360
402
 
364
406
  Match *match;                                                         \
365
407
  gchar *path;                                                          \
366
408
  data = g_new0 (TestMatchNextData, 1);                                 \
367
 
  data->pattern = _pattern;                                              \
368
 
  data->string = _string;                                                \
369
 
  data->string_len = _string_len;                                        \
370
 
  data->start_position = _start_position;                                \
 
409
  data->pattern = _pattern;                                             \
 
410
  data->string = _string;                                               \
 
411
  data->string_len = _string_len;                                       \
 
412
  data->start_position = _start_position;                               \
371
413
  match = g_new0 (Match, 1);                                            \
372
414
  match->string = t1;                                                   \
373
415
  match->start = s1;                                                    \
389
431
  match->end = e4;                                                      \
390
432
  data->expected = g_slist_append (data->expected, match);              \
391
433
  path = g_strdup_printf ("/regex/match/next4/%d", ++total);            \
392
 
  g_test_add_data_func (path, data, test_match_next);                   \
 
434
  g_test_add_data_func_full (path, data, test_match_next, free_match_next_data); \
393
435
  g_free (path);                                                        \
394
436
}
395
437
 
419
461
 
420
462
  g_assert_cmpint (count, ==, data->expected_count);
421
463
 
422
 
  g_match_info_free (match_info);
 
464
  g_match_info_ref (match_info);
 
465
  g_match_info_unref (match_info);
 
466
  g_match_info_unref (match_info);
423
467
  g_regex_unref (regex);
424
468
}
425
469
 
427
471
  TestMatchCountData *data;                                             \
428
472
  gchar *path;                                                          \
429
473
  data = g_new0 (TestMatchCountData, 1);                                \
430
 
  data->pattern = _pattern;                                              \
431
 
  data->string = _string;                                                \
432
 
  data->start_position = _start_position;                                \
433
 
  data->match_opts = _match_opts;                                        \
434
 
  data->expected_count = _expected_count;                                \
 
474
  data->pattern = _pattern;                                             \
 
475
  data->string = _string;                                               \
 
476
  data->start_position = _start_position;                               \
 
477
  data->match_opts = _match_opts;                                       \
 
478
  data->expected_count = _expected_count;                               \
435
479
  path = g_strdup_printf ("/regex/match/count/%d", ++total);            \
436
 
  g_test_add_data_func (path, data, test_match_count);                 \
 
480
  g_test_add_data_func_full (path, data, test_match_count, g_free);     \
437
481
  g_free (path);                                                        \
438
482
}
439
483
 
448
492
 
449
493
  g_assert (regex != NULL);
450
494
 
451
 
  g_regex_match (regex, data->string, G_REGEX_MATCH_PARTIAL, &match_info);
 
495
  g_regex_match (regex, data->string, data->match_opts, &match_info);
452
496
 
453
497
  g_assert_cmpint (data->expected, ==, g_match_info_is_partial_match (match_info));
454
498
 
462
506
  g_regex_unref (regex);
463
507
}
464
508
 
465
 
#define TEST_PARTIAL(_pattern, _string, _expected) {               \
 
509
#define TEST_PARTIAL_FULL(_pattern, _string, _match_opts, _expected) { \
466
510
  TestMatchData *data;                                          \
467
511
  gchar *path;                                                  \
468
512
  data = g_new0 (TestMatchData, 1);                             \
469
 
  data->pattern = _pattern;                                      \
470
 
  data->string = _string;                                        \
471
 
  data->expected = _expected;                                    \
 
513
  data->pattern = _pattern;                                     \
 
514
  data->string = _string;                                       \
 
515
  data->match_opts = _match_opts;                               \
 
516
  data->expected = _expected;                                   \
472
517
  path = g_strdup_printf ("/regex/match/partial/%d", ++total);  \
473
 
  g_test_add_data_func (path, data, test_partial);              \
 
518
  g_test_add_data_func_full (path, data, test_partial, g_free); \
474
519
  g_free (path);                                                \
475
520
}
476
521
 
 
522
#define TEST_PARTIAL(_pattern, _string, _expected) TEST_PARTIAL_FULL(_pattern, _string, G_REGEX_MATCH_PARTIAL, _expected)
 
523
 
477
524
typedef struct {
478
525
  const gchar *pattern;
479
526
  const gchar *string;
516
563
  TestSubData *data;                                                    \
517
564
  gchar *path;                                                          \
518
565
  data = g_new0 (TestSubData, 1);                                       \
519
 
  data->pattern = _pattern;                                              \
520
 
  data->string = _string;                                                \
521
 
  data->start_position = _start_position;                                \
522
 
  data->sub_n = _sub_n;                                                  \
523
 
  data->expected_sub = _expected_sub;                                    \
524
 
  data->expected_start = _expected_start;                                \
525
 
  data->expected_end = _expected_end;                                    \
 
566
  data->pattern = _pattern;                                             \
 
567
  data->string = _string;                                               \
 
568
  data->start_position = _start_position;                               \
 
569
  data->sub_n = _sub_n;                                                 \
 
570
  data->expected_sub = _expected_sub;                                   \
 
571
  data->expected_start = _expected_start;                               \
 
572
  data->expected_end = _expected_end;                                   \
526
573
  path = g_strdup_printf ("/regex/match/subpattern/%d", ++total);       \
527
 
  g_test_add_data_func (path, data, test_sub_pattern);                  \
 
574
  g_test_add_data_func_full (path, data, test_sub_pattern, g_free);     \
528
575
  g_free (path);                                                        \
529
576
}
530
577
 
567
614
 
568
615
#define TEST_NAMED_SUB_PATTERN(_pattern, _string, _start_position, _sub_name, \
569
616
                               _expected_sub, _expected_start, _expected_end) { \
570
 
  TestNamedSubData *data;                                               \
571
 
  gchar *path;                                                          \
572
 
  data = g_new0 (TestNamedSubData, 1);                                  \
573
 
  data->pattern = _pattern;                                              \
574
 
  data->string = _string;                                                \
575
 
  data->flags = 0;                                                      \
576
 
  data->start_position = _start_position;                                \
577
 
  data->sub_name = _sub_name;                                            \
578
 
  data->expected_sub = _expected_sub;                                    \
579
 
  data->expected_start = _expected_start;                                \
580
 
  data->expected_end = _expected_end;                                    \
581
 
  path = g_strdup_printf ("/regex/match/named/subpattern/%d", ++total); \
582
 
  g_test_add_data_func (path, data, test_named_sub_pattern);            \
583
 
  g_free (path);                                                        \
 
617
  TestNamedSubData *data;                                                 \
 
618
  gchar *path;                                                            \
 
619
  data = g_new0 (TestNamedSubData, 1);                                    \
 
620
  data->pattern = _pattern;                                               \
 
621
  data->string = _string;                                                 \
 
622
  data->flags = 0;                                                        \
 
623
  data->start_position = _start_position;                                 \
 
624
  data->sub_name = _sub_name;                                             \
 
625
  data->expected_sub = _expected_sub;                                     \
 
626
  data->expected_start = _expected_start;                                 \
 
627
  data->expected_end = _expected_end;                                     \
 
628
  path = g_strdup_printf ("/regex/match/named/subpattern/%d", ++total);   \
 
629
  g_test_add_data_func_full (path, data, test_named_sub_pattern, g_free); \
 
630
  g_free (path);                                                          \
584
631
}
585
632
 
586
633
#define TEST_NAMED_SUB_PATTERN_DUPNAMES(_pattern, _string, _start_position, _sub_name, \
587
634
                                        _expected_sub, _expected_start, _expected_end) { \
588
 
  TestNamedSubData *data;                                               \
589
 
  gchar *path;                                                          \
590
 
  data = g_new0 (TestNamedSubData, 1);                                  \
591
 
  data->pattern = _pattern;                                              \
592
 
  data->string = _string;                                                \
593
 
  data->flags = G_REGEX_DUPNAMES;                                       \
594
 
  data->start_position = _start_position;                                \
595
 
  data->sub_name = _sub_name;                                            \
596
 
  data->expected_sub = _expected_sub;                                    \
597
 
  data->expected_start = _expected_start;                                \
598
 
  data->expected_end = _expected_end;                                    \
 
635
  TestNamedSubData *data;                                                        \
 
636
  gchar *path;                                                                   \
 
637
  data = g_new0 (TestNamedSubData, 1);                                           \
 
638
  data->pattern = _pattern;                                                      \
 
639
  data->string = _string;                                                        \
 
640
  data->flags = G_REGEX_DUPNAMES;                                                \
 
641
  data->start_position = _start_position;                                        \
 
642
  data->sub_name = _sub_name;                                                    \
 
643
  data->expected_sub = _expected_sub;                                            \
 
644
  data->expected_start = _expected_start;                                        \
 
645
  data->expected_end = _expected_end;                                            \
599
646
  path = g_strdup_printf ("/regex/match/subpattern/named/dupnames/%d", ++total); \
600
 
  g_test_add_data_func (path, data, test_named_sub_pattern);            \
601
 
  g_free (path);                                                        \
 
647
  g_test_add_data_func_full (path, data, test_named_sub_pattern, g_free);        \
 
648
  g_free (path);                                                                 \
602
649
}
603
650
 
604
651
typedef struct {
644
691
  g_strfreev (matches);
645
692
}
646
693
 
647
 
#define TEST_FETCH_ALL0(_pattern, _string) {                      \
648
 
  TestFetchAllData *data;                                       \
649
 
  gchar *path;                                                  \
650
 
  data = g_new0 (TestFetchAllData, 1);                          \
651
 
  data->pattern = _pattern;                                      \
652
 
  data->string = _string;                                        \
653
 
  data->expected = NULL;                                        \
654
 
  path = g_strdup_printf ("/regex/fetch-all0/%d", ++total);     \
655
 
  g_test_add_data_func (path, data, test_fetch_all);            \
656
 
  g_free (path);                                                \
657
 
}
658
 
 
659
 
#define TEST_FETCH_ALL1(_pattern, _string, e1) {                  \
660
 
  TestFetchAllData *data;                                       \
661
 
  gchar *path;                                                  \
662
 
  data = g_new0 (TestFetchAllData, 1);                          \
663
 
  data->pattern = _pattern;                                      \
664
 
  data->string = _string;                                        \
665
 
  data->expected = g_slist_append (NULL, e1);                   \
666
 
  path = g_strdup_printf ("/regex/fetch-all1/%d", ++total);     \
667
 
  g_test_add_data_func (path, data, test_fetch_all);            \
668
 
  g_free (path);                                                \
669
 
}
670
 
 
671
 
#define TEST_FETCH_ALL2(_pattern, _string, e1, e2) {              \
672
 
  TestFetchAllData *data;                                       \
673
 
  gchar *path;                                                  \
674
 
  data = g_new0 (TestFetchAllData, 1);                          \
675
 
  data->pattern = _pattern;                                      \
676
 
  data->string = _string;                                        \
677
 
  data->expected = g_slist_append (NULL, e1);                   \
678
 
  data->expected = g_slist_append (data->expected, e2);         \
679
 
  path = g_strdup_printf ("/regex/fetch-all2/%d", ++total);     \
680
 
  g_test_add_data_func (path, data, test_fetch_all);            \
681
 
  g_free (path);                                                \
682
 
}
683
 
 
684
 
#define TEST_FETCH_ALL3(_pattern, _string, e1, e2, e3) {          \
685
 
  TestFetchAllData *data;                                       \
686
 
  gchar *path;                                                  \
687
 
  data = g_new0 (TestFetchAllData, 1);                          \
688
 
  data->pattern = _pattern;                                      \
689
 
  data->string = _string;                                        \
690
 
  data->expected = g_slist_append (NULL, e1);                   \
691
 
  data->expected = g_slist_append (data->expected, e2);         \
692
 
  data->expected = g_slist_append (data->expected, e3);         \
693
 
  path = g_strdup_printf ("/regex/fetch-all3/%d", ++total);     \
694
 
  g_test_add_data_func (path, data, test_fetch_all);            \
695
 
  g_free (path);                                                \
 
694
static void
 
695
free_fetch_all_data (gpointer _data)
 
696
{
 
697
  TestFetchAllData *data = _data;
 
698
 
 
699
  g_slist_free (data->expected);
 
700
  g_free (data);
 
701
}
 
702
 
 
703
#define TEST_FETCH_ALL0(_pattern, _string) {                                   \
 
704
  TestFetchAllData *data;                                                      \
 
705
  gchar *path;                                                                 \
 
706
  data = g_new0 (TestFetchAllData, 1);                                         \
 
707
  data->pattern = _pattern;                                                    \
 
708
  data->string = _string;                                                      \
 
709
  data->expected = NULL;                                                       \
 
710
  path = g_strdup_printf ("/regex/fetch-all0/%d", ++total);                    \
 
711
  g_test_add_data_func_full (path, data, test_fetch_all, free_fetch_all_data); \
 
712
  g_free (path);                                                               \
 
713
}
 
714
 
 
715
#define TEST_FETCH_ALL1(_pattern, _string, e1) {                               \
 
716
  TestFetchAllData *data;                                                      \
 
717
  gchar *path;                                                                 \
 
718
  data = g_new0 (TestFetchAllData, 1);                                         \
 
719
  data->pattern = _pattern;                                                    \
 
720
  data->string = _string;                                                      \
 
721
  data->expected = g_slist_append (NULL, e1);                                  \
 
722
  path = g_strdup_printf ("/regex/fetch-all1/%d", ++total);                    \
 
723
  g_test_add_data_func_full (path, data, test_fetch_all, free_fetch_all_data); \
 
724
  g_free (path);                                                               \
 
725
}
 
726
 
 
727
#define TEST_FETCH_ALL2(_pattern, _string, e1, e2) {                           \
 
728
  TestFetchAllData *data;                                                      \
 
729
  gchar *path;                                                                 \
 
730
  data = g_new0 (TestFetchAllData, 1);                                         \
 
731
  data->pattern = _pattern;                                                    \
 
732
  data->string = _string;                                                      \
 
733
  data->expected = g_slist_append (NULL, e1);                                  \
 
734
  data->expected = g_slist_append (data->expected, e2);                        \
 
735
  path = g_strdup_printf ("/regex/fetch-all2/%d", ++total);                    \
 
736
  g_test_add_data_func_full (path, data, test_fetch_all, free_fetch_all_data); \
 
737
  g_free (path);                                                               \
 
738
}
 
739
 
 
740
#define TEST_FETCH_ALL3(_pattern, _string, e1, e2, e3) {                       \
 
741
  TestFetchAllData *data;                                                      \
 
742
  gchar *path;                                                                 \
 
743
  data = g_new0 (TestFetchAllData, 1);                                         \
 
744
  data->pattern = _pattern;                                                    \
 
745
  data->string = _string;                                                      \
 
746
  data->expected = g_slist_append (NULL, e1);                                  \
 
747
  data->expected = g_slist_append (data->expected, e2);                        \
 
748
  data->expected = g_slist_append (data->expected, e3);                        \
 
749
  path = g_strdup_printf ("/regex/fetch-all3/%d", ++total);                    \
 
750
  g_test_add_data_func_full (path, data, test_fetch_all, free_fetch_all_data); \
 
751
  g_free (path);                                                               \
696
752
}
697
753
 
698
754
static void
721
777
  g_strfreev (tokens);
722
778
}
723
779
 
724
 
#define TEST_SPLIT_SIMPLE0(_pattern, _string) {                   \
725
 
  TestFetchAllData *data;                                       \
726
 
  gchar *path;                                                  \
727
 
  data = g_new0 (TestFetchAllData, 1);                          \
728
 
  data->pattern = _pattern;                                      \
729
 
  data->string = _string;                                        \
730
 
  data->expected = NULL;                                        \
731
 
  path = g_strdup_printf ("/regex/split/simple0/%d", ++total);  \
732
 
  g_test_add_data_func (path, data, test_split_simple);         \
733
 
  g_free (path);                                                \
734
 
}
735
 
 
736
 
#define TEST_SPLIT_SIMPLE1(_pattern, _string, e1) {               \
737
 
  TestFetchAllData *data;                                       \
738
 
  gchar *path;                                                  \
739
 
  data = g_new0 (TestFetchAllData, 1);                          \
740
 
  data->pattern = _pattern;                                      \
741
 
  data->string = _string;                                        \
742
 
  data->expected = g_slist_append (NULL, e1);                   \
743
 
  path = g_strdup_printf ("/regex/split/simple1/%d", ++total);  \
744
 
  g_test_add_data_func (path, data, test_split_simple);         \
745
 
  g_free (path);                                                \
746
 
}
747
 
 
748
 
#define TEST_SPLIT_SIMPLE2(_pattern, _string, e1, e2) {           \
749
 
  TestFetchAllData *data;                                       \
750
 
  gchar *path;                                                  \
751
 
  data = g_new0 (TestFetchAllData, 1);                          \
752
 
  data->pattern = _pattern;                                      \
753
 
  data->string = _string;                                        \
754
 
  data->expected = g_slist_append (NULL, e1);                   \
755
 
  data->expected = g_slist_append (data->expected, e2);         \
756
 
  path = g_strdup_printf ("/regex/split/simple2/%d", ++total);  \
757
 
  g_test_add_data_func (path, data, test_split_simple);         \
758
 
  g_free (path);                                                \
759
 
}
760
 
 
761
 
#define TEST_SPLIT_SIMPLE3(_pattern, _string, e1, e2, e3) {       \
762
 
  TestFetchAllData *data;                                       \
763
 
  gchar *path;                                                  \
764
 
  data = g_new0 (TestFetchAllData, 1);                          \
765
 
  data->pattern = _pattern;                                      \
766
 
  data->string = _string;                                        \
767
 
  data->expected = g_slist_append (NULL, e1);                   \
768
 
  data->expected = g_slist_append (data->expected, e2);         \
769
 
  data->expected = g_slist_append (data->expected, e3);         \
770
 
  path = g_strdup_printf ("/regex/split/simple3/%d", ++total);  \
771
 
  g_test_add_data_func (path, data, test_split_simple);         \
772
 
  g_free (path);                                                \
 
780
#define TEST_SPLIT_SIMPLE0(_pattern, _string) {                                   \
 
781
  TestFetchAllData *data;                                                         \
 
782
  gchar *path;                                                                    \
 
783
  data = g_new0 (TestFetchAllData, 1);                                            \
 
784
  data->pattern = _pattern;                                                       \
 
785
  data->string = _string;                                                         \
 
786
  data->expected = NULL;                                                          \
 
787
  path = g_strdup_printf ("/regex/split/simple0/%d", ++total);                    \
 
788
  g_test_add_data_func_full (path, data, test_split_simple, free_fetch_all_data); \
 
789
  g_free (path);                                                                  \
 
790
}
 
791
 
 
792
#define TEST_SPLIT_SIMPLE1(_pattern, _string, e1) {                               \
 
793
  TestFetchAllData *data;                                                         \
 
794
  gchar *path;                                                                    \
 
795
  data = g_new0 (TestFetchAllData, 1);                                            \
 
796
  data->pattern = _pattern;                                                       \
 
797
  data->string = _string;                                                         \
 
798
  data->expected = g_slist_append (NULL, e1);                                     \
 
799
  path = g_strdup_printf ("/regex/split/simple1/%d", ++total);                    \
 
800
  g_test_add_data_func_full (path, data, test_split_simple, free_fetch_all_data); \
 
801
  g_free (path);                                                                  \
 
802
}
 
803
 
 
804
#define TEST_SPLIT_SIMPLE2(_pattern, _string, e1, e2) {                           \
 
805
  TestFetchAllData *data;                                                         \
 
806
  gchar *path;                                                                    \
 
807
  data = g_new0 (TestFetchAllData, 1);                                            \
 
808
  data->pattern = _pattern;                                                       \
 
809
  data->string = _string;                                                         \
 
810
  data->expected = g_slist_append (NULL, e1);                                     \
 
811
  data->expected = g_slist_append (data->expected, e2);                           \
 
812
  path = g_strdup_printf ("/regex/split/simple2/%d", ++total);                    \
 
813
  g_test_add_data_func_full (path, data, test_split_simple, free_fetch_all_data); \
 
814
  g_free (path);                                                                  \
 
815
}
 
816
 
 
817
#define TEST_SPLIT_SIMPLE3(_pattern, _string, e1, e2, e3) {                       \
 
818
  TestFetchAllData *data;                                                         \
 
819
  gchar *path;                                                                    \
 
820
  data = g_new0 (TestFetchAllData, 1);                                            \
 
821
  data->pattern = _pattern;                                                       \
 
822
  data->string = _string;                                                         \
 
823
  data->expected = g_slist_append (NULL, e1);                                     \
 
824
  data->expected = g_slist_append (data->expected, e2);                           \
 
825
  data->expected = g_slist_append (data->expected, e3);                           \
 
826
  path = g_strdup_printf ("/regex/split/simple3/%d", ++total);                    \
 
827
  g_test_add_data_func_full (path, data, test_split_simple, free_fetch_all_data); \
 
828
  g_free (path);                                                                  \
773
829
}
774
830
 
775
831
static void
837
893
  g_strfreev (tokens);
838
894
}
839
895
 
840
 
#define TEST_SPLIT0(_pattern, _string, _start_position, _max_tokens) {      \
841
 
  TestFetchAllData *data;                                               \
842
 
  gchar *path;                                                          \
843
 
  data = g_new0 (TestFetchAllData, 1);                                  \
844
 
  data->pattern = _pattern;                                              \
845
 
  data->string = _string;                                                \
846
 
  data->start_position = _start_position;                                \
847
 
  data->max_tokens = _max_tokens;                                        \
848
 
  data->expected = NULL;                                                \
849
 
  path = g_strdup_printf ("/regex/full-split0/%d", ++total);            \
850
 
  g_test_add_data_func (path, data, test_split_full);                   \
851
 
  g_free (path);                                                        \
852
 
  if (_start_position == 0 && _max_tokens <= 0) {                         \
853
 
    path = g_strdup_printf ("/regex/split0/%d", ++total);               \
854
 
    g_test_add_data_func (path, data, test_split);                      \
855
 
    g_free (path);                                                      \
856
 
  }                                                                     \
857
 
}
858
 
 
859
 
#define TEST_SPLIT1(_pattern, _string, _start_position, _max_tokens, e1) { \
860
 
  TestFetchAllData *data;                                               \
861
 
  gchar *path;                                                          \
862
 
  data = g_new0 (TestFetchAllData, 1);                                  \
863
 
  data->pattern = _pattern;                                              \
864
 
  data->string = _string;                                                \
865
 
  data->start_position = _start_position;                                \
866
 
  data->max_tokens = _max_tokens;                                        \
867
 
  data->expected = NULL;                                                \
868
 
  data->expected = g_slist_append (data->expected, e1);                 \
869
 
  path = g_strdup_printf ("/regex/full-split1/%d", ++total);            \
870
 
  g_test_add_data_func (path, data, test_split_full);                   \
871
 
  g_free (path);                                                        \
872
 
  if (_start_position == 0 && _max_tokens <= 0) {                         \
873
 
    path = g_strdup_printf ("/regex/split1/%d", ++total);               \
874
 
    g_test_add_data_func (path, data, test_split);                      \
875
 
    g_free (path);                                                      \
876
 
  }                                                                     \
877
 
}
878
 
 
879
 
#define TEST_SPLIT2(_pattern, _string, _start_position, _max_tokens, e1, e2) { \
880
 
  TestFetchAllData *data;                                               \
881
 
  gchar *path;                                                          \
882
 
  data = g_new0 (TestFetchAllData, 1);                                  \
883
 
  data->pattern = _pattern;                                              \
884
 
  data->string = _string;                                                \
885
 
  data->start_position = _start_position;                                \
886
 
  data->max_tokens = _max_tokens;                                        \
887
 
  data->expected = NULL;                                                \
888
 
  data->expected = g_slist_append (data->expected, e1);                 \
889
 
  data->expected = g_slist_append (data->expected, e2);                 \
890
 
  path = g_strdup_printf ("/regex/full-split2/%d", ++total);            \
891
 
  g_test_add_data_func (path, data, test_split_full);                   \
892
 
  g_free (path);                                                        \
893
 
  if (_start_position == 0 && _max_tokens <= 0) {                         \
894
 
    path = g_strdup_printf ("/regex/split2/%d", ++total);               \
895
 
    g_test_add_data_func (path, data, test_split);                      \
896
 
    g_free (path);                                                      \
897
 
  }                                                                     \
 
896
#define TEST_SPLIT0(_pattern, _string, _start_position, _max_tokens) {          \
 
897
  TestFetchAllData *data;                                                       \
 
898
  gchar *path;                                                                  \
 
899
  data = g_new0 (TestFetchAllData, 1);                                          \
 
900
  data->pattern = _pattern;                                                     \
 
901
  data->string = _string;                                                       \
 
902
  data->start_position = _start_position;                                       \
 
903
  data->max_tokens = _max_tokens;                                               \
 
904
  data->expected = NULL;                                                        \
 
905
  if (_start_position == 0 && _max_tokens <= 0) {                               \
 
906
    path = g_strdup_printf ("/regex/split0/%d", ++total);                       \
 
907
    g_test_add_data_func (path, data, test_split);                              \
 
908
    g_free (path);                                                              \
 
909
  }                                                                             \
 
910
  path = g_strdup_printf ("/regex/full-split0/%d", ++total);                    \
 
911
  g_test_add_data_func_full (path, data, test_split_full, free_fetch_all_data); \
 
912
  g_free (path);                                                                \
 
913
}
 
914
 
 
915
#define TEST_SPLIT1(_pattern, _string, _start_position, _max_tokens, e1) {      \
 
916
  TestFetchAllData *data;                                                       \
 
917
  gchar *path;                                                                  \
 
918
  data = g_new0 (TestFetchAllData, 1);                                          \
 
919
  data->pattern = _pattern;                                                     \
 
920
  data->string = _string;                                                       \
 
921
  data->start_position = _start_position;                                       \
 
922
  data->max_tokens = _max_tokens;                                               \
 
923
  data->expected = NULL;                                                        \
 
924
  data->expected = g_slist_append (data->expected, e1);                         \
 
925
  if (_start_position == 0 && _max_tokens <= 0) {                               \
 
926
    path = g_strdup_printf ("/regex/split1/%d", ++total);                       \
 
927
    g_test_add_data_func (path, data, test_split);                              \
 
928
    g_free (path);                                                              \
 
929
  }                                                                             \
 
930
  path = g_strdup_printf ("/regex/full-split1/%d", ++total);                    \
 
931
  g_test_add_data_func_full (path, data, test_split_full, free_fetch_all_data); \
 
932
  g_free (path);                                                                \
 
933
}
 
934
 
 
935
#define TEST_SPLIT2(_pattern, _string, _start_position, _max_tokens, e1, e2) {  \
 
936
  TestFetchAllData *data;                                                       \
 
937
  gchar *path;                                                                  \
 
938
  data = g_new0 (TestFetchAllData, 1);                                          \
 
939
  data->pattern = _pattern;                                                     \
 
940
  data->string = _string;                                                       \
 
941
  data->start_position = _start_position;                                       \
 
942
  data->max_tokens = _max_tokens;                                               \
 
943
  data->expected = NULL;                                                        \
 
944
  data->expected = g_slist_append (data->expected, e1);                         \
 
945
  data->expected = g_slist_append (data->expected, e2);                         \
 
946
  if (_start_position == 0 && _max_tokens <= 0) {                               \
 
947
    path = g_strdup_printf ("/regex/split2/%d", ++total);                       \
 
948
    g_test_add_data_func (path, data, test_split);                              \
 
949
    g_free (path);                                                              \
 
950
  }                                                                             \
 
951
  path = g_strdup_printf ("/regex/full-split2/%d", ++total);                    \
 
952
  g_test_add_data_func_full (path, data, test_split_full, free_fetch_all_data); \
 
953
  g_free (path);                                                                \
898
954
}
899
955
 
900
956
#define TEST_SPLIT3(_pattern, _string, _start_position, _max_tokens, e1, e2, e3) { \
901
 
  TestFetchAllData *data;                                               \
902
 
  gchar *path;                                                          \
903
 
  data = g_new0 (TestFetchAllData, 1);                                  \
904
 
  data->pattern = _pattern;                                              \
905
 
  data->string = _string;                                                \
906
 
  data->start_position = _start_position;                                \
907
 
  data->max_tokens = _max_tokens;                                        \
908
 
  data->expected = NULL;                                                \
909
 
  data->expected = g_slist_append (data->expected, e1);                 \
910
 
  data->expected = g_slist_append (data->expected, e2);                 \
911
 
  data->expected = g_slist_append (data->expected, e3);                 \
912
 
  path = g_strdup_printf ("/regex/full-split3/%d", ++total);            \
913
 
  g_test_add_data_func (path, data, test_split_full);                   \
914
 
  g_free (path);                                                        \
915
 
  if (_start_position == 0 && _max_tokens <= 0) {                         \
916
 
    path = g_strdup_printf ("/regex/split3/%d", ++total);               \
917
 
    g_test_add_data_func (path, data, test_split);                      \
918
 
    g_free (path);                                                      \
919
 
  }                                                                     \
 
957
  TestFetchAllData *data;                                                          \
 
958
  gchar *path;                                                                     \
 
959
  data = g_new0 (TestFetchAllData, 1);                                             \
 
960
  data->pattern = _pattern;                                                        \
 
961
  data->string = _string;                                                          \
 
962
  data->start_position = _start_position;                                          \
 
963
  data->max_tokens = _max_tokens;                                                  \
 
964
  data->expected = NULL;                                                           \
 
965
  data->expected = g_slist_append (data->expected, e1);                            \
 
966
  data->expected = g_slist_append (data->expected, e2);                            \
 
967
  data->expected = g_slist_append (data->expected, e3);                            \
 
968
  if (_start_position == 0 && _max_tokens <= 0) {                                  \
 
969
    path = g_strdup_printf ("/regex/split3/%d", ++total);                          \
 
970
    g_test_add_data_func (path, data, test_split);                                 \
 
971
    g_free (path);                                                                 \
 
972
  }                                                                                \
 
973
  path = g_strdup_printf ("/regex/full-split3/%d", ++total);                       \
 
974
  g_test_add_data_func_full (path, data, test_split_full, free_fetch_all_data);    \
 
975
  g_free (path);                                                                   \
920
976
}
921
977
 
922
978
typedef struct {
940
996
}
941
997
 
942
998
#define TEST_CHECK_REPLACEMENT(_string_to_expand, _expected, _expected_refs) { \
943
 
  TestCheckReplacementData *data;                                           \
944
 
  gchar *path;                                                              \
945
 
  data = g_new0 (TestCheckReplacementData, 1);                              \
946
 
  data->string_to_expand = _string_to_expand;                                \
947
 
  data->expected = _expected;                                                \
948
 
  data->expected_refs = _expected_refs;                                      \
949
 
  path = g_strdup_printf ("/regex/check-repacement/%d", ++total);  \
950
 
  g_test_add_data_func (path, data, test_check_replacement);                \
951
 
  g_free (path);                                                            \
 
999
  TestCheckReplacementData *data;                                              \
 
1000
  gchar *path;                                                                 \
 
1001
  data = g_new0 (TestCheckReplacementData, 1);                                 \
 
1002
  data->string_to_expand = _string_to_expand;                                  \
 
1003
  data->expected = _expected;                                                  \
 
1004
  data->expected_refs = _expected_refs;                                        \
 
1005
  path = g_strdup_printf ("/regex/check-repacement/%d", ++total);              \
 
1006
  g_test_add_data_func_full (path, data, test_check_replacement, g_free);      \
 
1007
  g_free (path);                                                               \
952
1008
}
953
1009
 
954
1010
typedef struct {
982
1038
}
983
1039
 
984
1040
#define TEST_EXPAND(_pattern, _string, _string_to_expand, _raw, _expected) { \
985
 
  TestExpandData *data;                                                 \
986
 
  gchar *path;                                                          \
987
 
  data = g_new0 (TestExpandData, 1);                                    \
988
 
  data->pattern = _pattern;                                              \
989
 
  data->string = _string;                                                \
990
 
  data->string_to_expand = _string_to_expand;                            \
991
 
  data->raw = _raw;                                                      \
992
 
  data->expected = _expected;                                            \
993
 
  path = g_strdup_printf ("/regex/expand/%d", ++total);                 \
994
 
  g_test_add_data_func (path, data, test_expand);                       \
995
 
  g_free (path);                                                        \
 
1041
  TestExpandData *data;                                                      \
 
1042
  gchar *path;                                                               \
 
1043
  data = g_new0 (TestExpandData, 1);                                         \
 
1044
  data->pattern = _pattern;                                                  \
 
1045
  data->string = _string;                                                    \
 
1046
  data->string_to_expand = _string_to_expand;                                \
 
1047
  data->raw = _raw;                                                          \
 
1048
  data->expected = _expected;                                                \
 
1049
  path = g_strdup_printf ("/regex/expand/%d", ++total);                      \
 
1050
  g_test_add_data_func_full (path, data, test_expand, g_free);               \
 
1051
  g_free (path);                                                             \
996
1052
}
997
1053
 
998
1054
typedef struct {
1023
1079
  TestReplaceData *data;                                                \
1024
1080
  gchar *path;                                                          \
1025
1081
  data = g_new0 (TestReplaceData, 1);                                   \
1026
 
  data->pattern = _pattern;                                              \
1027
 
  data->string = _string;                                                \
1028
 
  data->start_position = _start_position;                                \
1029
 
  data->replacement = _replacement;                                      \
1030
 
  data->expected = _expected;                                            \
 
1082
  data->pattern = _pattern;                                             \
 
1083
  data->string = _string;                                               \
 
1084
  data->start_position = _start_position;                               \
 
1085
  data->replacement = _replacement;                                     \
 
1086
  data->expected = _expected;                                           \
1031
1087
  path = g_strdup_printf ("/regex/replace/%d", ++total);                \
1032
 
  g_test_add_data_func (path, data, test_replace);                      \
 
1088
  g_test_add_data_func_full (path, data, test_replace, g_free);         \
1033
1089
  g_free (path);                                                        \
1034
1090
}
1035
1091
 
1053
1109
  TestReplaceData *data;                                                \
1054
1110
  gchar *path;                                                          \
1055
1111
  data = g_new0 (TestReplaceData, 1);                                   \
1056
 
  data->pattern = _pattern;                                              \
1057
 
  data->string = _string;                                                \
1058
 
  data->start_position = _start_position;                                \
1059
 
  data->replacement = _replacement;                                      \
1060
 
  data->expected = _expected;                                            \
 
1112
  data->pattern = _pattern;                                             \
 
1113
  data->string = _string;                                               \
 
1114
  data->start_position = _start_position;                               \
 
1115
  data->replacement = _replacement;                                     \
 
1116
  data->expected = _expected;                                           \
1061
1117
  path = g_strdup_printf ("/regex/replace-literally/%d", ++total);      \
1062
 
  g_test_add_data_func (path, data, test_replace_lit);                  \
 
1118
  g_test_add_data_func_full (path, data, test_replace_lit, g_free);     \
1063
1119
  g_free (path);                                                        \
1064
1120
}
1065
1121
 
1083
1139
  g_regex_unref (regex);
1084
1140
}
1085
1141
 
1086
 
#define TEST_GET_STRING_NUMBER(_pattern, _name, _expected_num) { \
1087
 
  TestStringNumData *data;                                      \
1088
 
  gchar *path;                                                  \
1089
 
  data = g_new0 (TestStringNumData, 1);                         \
1090
 
  data->pattern = _pattern;                                      \
1091
 
  data->name = _name;                                            \
1092
 
  data->expected_num = _expected_num;                            \
1093
 
  path = g_strdup_printf ("/regex/string-number/%d", ++total);  \
1094
 
  g_test_add_data_func (path, data, test_get_string_number);    \
1095
 
  g_free (path);                                                \
 
1142
#define TEST_GET_STRING_NUMBER(_pattern, _name, _expected_num) {          \
 
1143
  TestStringNumData *data;                                                \
 
1144
  gchar *path;                                                            \
 
1145
  data = g_new0 (TestStringNumData, 1);                                   \
 
1146
  data->pattern = _pattern;                                               \
 
1147
  data->name = _name;                                                     \
 
1148
  data->expected_num = _expected_num;                                     \
 
1149
  path = g_strdup_printf ("/regex/string-number/%d", ++total);            \
 
1150
  g_test_add_data_func_full (path, data, test_get_string_number, g_free); \
 
1151
  g_free (path);                                                          \
1096
1152
}
1097
1153
 
1098
1154
typedef struct {
1114
1170
  g_free (escaped);
1115
1171
}
1116
1172
 
1117
 
#define TEST_ESCAPE(_string, _length, _expected) {         \
1118
 
  TestEscapeData *data;                                 \
1119
 
  gchar *path;                                          \
1120
 
  data = g_new0 (TestEscapeData, 1);                    \
1121
 
  data->string = _string;                                \
1122
 
  data->length = _length;                                \
1123
 
  data->expected = _expected;                            \
1124
 
  path = g_strdup_printf ("/regex/escape/%d", ++total);  \
1125
 
  g_test_add_data_func (path, data, test_escape);       \
1126
 
  g_free (path);                                        \
 
1173
#define TEST_ESCAPE(_string, _length, _expected) {             \
 
1174
  TestEscapeData *data;                                        \
 
1175
  gchar *path;                                                 \
 
1176
  data = g_new0 (TestEscapeData, 1);                           \
 
1177
  data->string = _string;                                      \
 
1178
  data->length = _length;                                      \
 
1179
  data->expected = _expected;                                  \
 
1180
  path = g_strdup_printf ("/regex/escape/%d", ++total);        \
 
1181
  g_test_add_data_func_full (path, data, test_escape, g_free); \
 
1182
  g_free (path);                                               \
1127
1183
}
1128
1184
 
1129
1185
static void
1139
1195
  g_free (escaped);
1140
1196
}
1141
1197
 
1142
 
#define TEST_ESCAPE_NUL(_string, _length, _expected) {  \
1143
 
  TestEscapeData *data;                                 \
1144
 
  gchar *path;                                          \
1145
 
  data = g_new0 (TestEscapeData, 1);                    \
1146
 
  data->string = _string;                               \
1147
 
  data->length = _length;                               \
1148
 
  data->expected = _expected;                           \
1149
 
  path = g_strdup_printf ("/regex/escape_nul/%d", ++total);  \
1150
 
  g_test_add_data_func (path, data, test_escape_nul);   \
1151
 
  g_free (path);                                        \
 
1198
#define TEST_ESCAPE_NUL(_string, _length, _expected) {             \
 
1199
  TestEscapeData *data;                                            \
 
1200
  gchar *path;                                                     \
 
1201
  data = g_new0 (TestEscapeData, 1);                               \
 
1202
  data->string = _string;                                          \
 
1203
  data->length = _length;                                          \
 
1204
  data->expected = _expected;                                      \
 
1205
  path = g_strdup_printf ("/regex/escape_nul/%d", ++total);        \
 
1206
  g_test_add_data_func_full (path, data, test_escape_nul, g_free); \
 
1207
  g_free (path);                                                   \
1152
1208
}
1153
1209
 
1154
1210
typedef struct {
1250
1306
  g_regex_unref (regex);
1251
1307
}
1252
1308
 
1253
 
#define TEST_MATCH_ALL0(_pattern, _string, _string_len, _start_position) { \
1254
 
  TestMatchAllData *data;                                               \
1255
 
  gchar *path;                                                          \
1256
 
  data = g_new0 (TestMatchAllData, 1);                                  \
1257
 
  data->pattern = _pattern;                                              \
1258
 
  data->string = _string;                                                \
1259
 
  data->string_len = _string_len;                                        \
1260
 
  data->start_position = _start_position;                                \
1261
 
  data->expected = NULL;                                                \
1262
 
  path = g_strdup_printf ("/regex/match-all-full0/%d", ++total);        \
1263
 
  g_test_add_data_func (path, data, test_match_all_full);               \
1264
 
  g_free (path);                                                        \
1265
 
  if (_string_len == -1 && _start_position == 0) {                        \
1266
 
    path = g_strdup_printf ("/regex/match-all0/%d", ++total);           \
1267
 
    g_test_add_data_func (path, data, test_match_all);                  \
1268
 
    g_free (path);                                                      \
1269
 
  }                                                                     \
1270
 
}
1271
 
 
1272
 
#define TEST_MATCH_ALL1(_pattern, _string, _string_len, _start_position, \
1273
 
                        t1, s1, e1) {                                   \
1274
 
  TestMatchAllData *data;                                               \
1275
 
  Match *match;                                                         \
1276
 
  gchar *path;                                                          \
1277
 
  data = g_new0 (TestMatchAllData, 1);                                  \
1278
 
  data->pattern = _pattern;                                              \
1279
 
  data->string = _string;                                                \
1280
 
  data->string_len = _string_len;                                        \
1281
 
  data->start_position = _start_position;                                \
1282
 
  data->expected = NULL;                                                \
1283
 
  match = g_new0 (Match, 1);                                            \
1284
 
  match->string = t1;                                                   \
1285
 
  match->start = s1;                                                    \
1286
 
  match->end = e1;                                                      \
1287
 
  data->expected = g_slist_append (data->expected, match);              \
1288
 
  path = g_strdup_printf ("/regex/match-all-full1/%d", ++total);        \
1289
 
  g_test_add_data_func (path, data, test_match_all_full);               \
1290
 
  g_free (path);                                                        \
1291
 
  if (_string_len == -1 && _start_position == 0) {                        \
1292
 
    path = g_strdup_printf ("/regex/match-all1/%d", ++total);           \
1293
 
    g_test_add_data_func (path, data, test_match_all);                  \
1294
 
    g_free (path);                                                      \
1295
 
  }                                                                     \
1296
 
}
1297
 
 
1298
 
#define TEST_MATCH_ALL2(_pattern, _string, _string_len, _start_position, \
1299
 
                        t1, s1, e1, t2, s2, e2) {                       \
1300
 
  TestMatchAllData *data;                                               \
1301
 
  Match *match;                                                         \
1302
 
  gchar *path;                                                          \
1303
 
  data = g_new0 (TestMatchAllData, 1);                                  \
1304
 
  data->pattern = _pattern;                                              \
1305
 
  data->string = _string;                                                \
1306
 
  data->string_len = _string_len;                                        \
1307
 
  data->start_position = _start_position;                                \
1308
 
  data->expected = NULL;                                                \
1309
 
  match = g_new0 (Match, 1);                                            \
1310
 
  match->string = t1;                                                   \
1311
 
  match->start = s1;                                                    \
1312
 
  match->end = e1;                                                      \
1313
 
  data->expected = g_slist_append (data->expected, match);              \
1314
 
  match = g_new0 (Match, 1);                                            \
1315
 
  match->string = t2;                                                   \
1316
 
  match->start = s2;                                                    \
1317
 
  match->end = e2;                                                      \
1318
 
  data->expected = g_slist_append (data->expected, match);              \
1319
 
  path = g_strdup_printf ("/regex/match-all-full2/%d", ++total);        \
1320
 
  g_test_add_data_func (path, data, test_match_all_full);               \
1321
 
  g_free (path);                                                        \
1322
 
  if (_string_len == -1 && _start_position == 0) {                        \
1323
 
    path = g_strdup_printf ("/regex/match-all2/%d", ++total);           \
1324
 
    g_test_add_data_func (path, data, test_match_all);                  \
1325
 
    g_free (path);                                                      \
1326
 
  }                                                                     \
1327
 
}
1328
 
 
1329
 
#define TEST_MATCH_ALL3(_pattern, _string, _string_len, _start_position, \
1330
 
                        t1, s1, e1, t2, s2, e2, t3, s3, e3) {           \
1331
 
  TestMatchAllData *data;                                               \
1332
 
  Match *match;                                                         \
1333
 
  gchar *path;                                                          \
1334
 
  data = g_new0 (TestMatchAllData, 1);                                  \
1335
 
  data->pattern = _pattern;                                              \
1336
 
  data->string = _string;                                                \
1337
 
  data->string_len = _string_len;                                        \
1338
 
  data->start_position = _start_position;                                \
1339
 
  data->expected = NULL;                                                \
1340
 
  match = g_new0 (Match, 1);                                            \
1341
 
  match->string = t1;                                                   \
1342
 
  match->start = s1;                                                    \
1343
 
  match->end = e1;                                                      \
1344
 
  data->expected = g_slist_append (data->expected, match);              \
1345
 
  match = g_new0 (Match, 1);                                            \
1346
 
  match->string = t2;                                                   \
1347
 
  match->start = s2;                                                    \
1348
 
  match->end = e2;                                                      \
1349
 
  data->expected = g_slist_append (data->expected, match);              \
1350
 
  match = g_new0 (Match, 1);                                            \
1351
 
  match->string = t3;                                                   \
1352
 
  match->start = s3;                                                    \
1353
 
  match->end = e3;                                                      \
1354
 
  data->expected = g_slist_append (data->expected, match);              \
1355
 
  path = g_strdup_printf ("/regex/match-all-full3/%d", ++total);        \
1356
 
  g_test_add_data_func (path, data, test_match_all_full);               \
1357
 
  g_free (path);                                                        \
1358
 
  if (_string_len == -1 && _start_position == 0) {                        \
1359
 
    path = g_strdup_printf ("/regex/match-all3/%d", ++total);           \
1360
 
    g_test_add_data_func (path, data, test_match_all);                  \
1361
 
    g_free (path);                                                      \
1362
 
  }                                                                     \
1363
 
}
1364
 
 
1365
 
#define PCRE_UTF8               0x00000800
1366
 
#define PCRE_NO_UTF8_CHECK      0x00002000
1367
 
#define PCRE_NEWLINE_ANY        0x00400000
1368
 
#define PCRE_UCP                0x20000000
1369
 
 
1370
 
static void
1371
 
test_basic (void)
1372
 
{
1373
 
  GRegexCompileFlags cflags = G_REGEX_CASELESS | G_REGEX_EXTENDED | G_REGEX_OPTIMIZE;
1374
 
  GRegexMatchFlags mflags = G_REGEX_MATCH_NOTBOL | G_REGEX_MATCH_PARTIAL;
1375
 
  GRegex *regex;
1376
 
 
1377
 
  regex = g_regex_new ("[A-Z]+", cflags, mflags, NULL);
1378
 
 
1379
 
  g_assert (regex != NULL);
1380
 
  g_assert_cmpint (g_regex_get_compile_flags (regex), ==, cflags|PCRE_UTF8|PCRE_NO_UTF8_CHECK|PCRE_NEWLINE_ANY|PCRE_UCP );
1381
 
  g_assert_cmpint (g_regex_get_match_flags (regex), ==, mflags|PCRE_NO_UTF8_CHECK);
1382
 
 
1383
 
  g_regex_unref (regex);
1384
 
}
1385
 
 
1386
 
static void
1387
 
test_compile (void)
1388
 
{
1389
 
  GRegex *regex;
1390
 
  GError *error;
1391
 
 
1392
 
  error = NULL;
1393
 
  regex = g_regex_new ("a\\", 0, 0, &error);
1394
 
  g_assert (regex == NULL);
1395
 
  g_assert_error (error, G_REGEX_ERROR, G_REGEX_ERROR_STRAY_BACKSLASH);
1396
 
  g_clear_error (&error);
1397
 
  regex = g_regex_new ("a\\c", 0, 0, &error);
1398
 
  g_assert (regex == NULL);
1399
 
  g_assert_error (error, G_REGEX_ERROR, G_REGEX_ERROR_MISSING_CONTROL_CHAR);
1400
 
  g_clear_error (&error);
1401
 
  regex = g_regex_new ("a\\l", 0, 0, &error);
1402
 
  g_assert (regex == NULL);
1403
 
  g_assert_error (error, G_REGEX_ERROR, G_REGEX_ERROR_UNRECOGNIZED_ESCAPE);
1404
 
  g_clear_error (&error);
1405
 
  regex = g_regex_new ("a{4,2}", 0, 0, &error);
1406
 
  g_assert (regex == NULL);
1407
 
  g_assert_error (error, G_REGEX_ERROR, G_REGEX_ERROR_QUANTIFIERS_OUT_OF_ORDER);
1408
 
  g_clear_error (&error);
1409
 
  regex = g_regex_new ("a{999999,}", 0, 0, &error);
1410
 
  g_assert (regex == NULL);
1411
 
  g_assert_error (error, G_REGEX_ERROR, G_REGEX_ERROR_QUANTIFIER_TOO_BIG);
1412
 
  g_clear_error (&error);
1413
 
  regex = g_regex_new ("[a-z", 0, 0, &error);
1414
 
  g_assert (regex == NULL);
1415
 
  g_assert_error (error, G_REGEX_ERROR, G_REGEX_ERROR_UNTERMINATED_CHARACTER_CLASS);
1416
 
  g_clear_error (&error);
1417
 
#if 0
1418
 
  regex = g_regex_new ("[\\b]", 0, 0, &error);
1419
 
  g_assert (regex == NULL);
1420
 
  g_assert_error (error, G_REGEX_ERROR, G_REGEX_ERROR_INVALID_ESCAPE_IN_CHARACTER_CLASS);
1421
 
  g_clear_error (&error);
1422
 
#endif
1423
 
  regex = g_regex_new ("[z-a]", 0, 0, &error);
1424
 
  g_assert (regex == NULL);
1425
 
  g_assert_error (error, G_REGEX_ERROR, G_REGEX_ERROR_RANGE_OUT_OF_ORDER);
1426
 
  g_clear_error (&error);
1427
 
  regex = g_regex_new ("{2,4}", 0, 0, &error);
1428
 
  g_assert (regex == NULL);
1429
 
  g_assert_error (error, G_REGEX_ERROR, G_REGEX_ERROR_NOTHING_TO_REPEAT);
1430
 
  g_clear_error (&error);
1431
 
  regex = g_regex_new ("a(?u)", 0, 0, &error);
1432
 
  g_assert (regex == NULL);
1433
 
  g_assert_error (error, G_REGEX_ERROR, G_REGEX_ERROR_UNRECOGNIZED_CHARACTER);
1434
 
  g_clear_error (&error);
1435
 
  regex = g_regex_new ("a(?<$foo)bar", 0, 0, &error);
1436
 
  g_assert (regex == NULL);
1437
 
  g_assert_error (error, G_REGEX_ERROR, G_REGEX_ERROR_UNRECOGNIZED_CHARACTER);
1438
 
  g_clear_error (&error);
1439
 
  regex = g_regex_new ("a[:alpha:]b", 0, 0, &error);
1440
 
  g_assert (regex == NULL);
1441
 
  g_assert_error (error, G_REGEX_ERROR, G_REGEX_ERROR_POSIX_NAMED_CLASS_OUTSIDE_CLASS);
1442
 
  g_clear_error (&error);
1443
 
  regex = g_regex_new ("a(b", 0, 0, &error);
1444
 
  g_assert (regex == NULL);
1445
 
  g_assert_error (error, G_REGEX_ERROR, G_REGEX_ERROR_UNMATCHED_PARENTHESIS);
1446
 
  g_clear_error (&error);
1447
 
  regex = g_regex_new ("a)b", 0, 0, &error);
1448
 
  g_assert (regex == NULL);
1449
 
  g_assert_error (error, G_REGEX_ERROR, G_REGEX_ERROR_UNMATCHED_PARENTHESIS);
1450
 
  g_clear_error (&error);
1451
 
  regex = g_regex_new ("a(?R", 0, 0, &error);
1452
 
  g_assert (regex == NULL);
1453
 
  g_assert_error (error, G_REGEX_ERROR, G_REGEX_ERROR_UNMATCHED_PARENTHESIS);
1454
 
  g_clear_error (&error);
1455
 
  regex = g_regex_new ("a(?-54", 0, 0, &error);
1456
 
  g_assert (regex == NULL);
1457
 
  g_assert_error (error, G_REGEX_ERROR, G_REGEX_ERROR_UNMATCHED_PARENTHESIS);
1458
 
  g_clear_error (&error);
1459
 
  regex = g_regex_new ("a(?#abc", 0, 0, &error);
1460
 
  g_assert (regex == NULL);
1461
 
  g_assert_error (error, G_REGEX_ERROR, G_REGEX_ERROR_UNTERMINATED_COMMENT);
1462
 
  g_clear_error (&error);
1463
 
  regex = g_regex_new ("a[[:fubar:]]b", 0, 0, &error);
1464
 
  g_assert (regex == NULL);
1465
 
  g_assert_error (error, G_REGEX_ERROR, G_REGEX_ERROR_UNKNOWN_POSIX_CLASS_NAME);
1466
 
  g_clear_error (&error);
 
1309
static void
 
1310
free_match_all_data (gpointer _data)
 
1311
{
 
1312
  TestMatchAllData *data = _data;
 
1313
 
 
1314
  g_slist_free_full (data->expected, g_free);
 
1315
  g_free (data);
 
1316
}
 
1317
 
 
1318
#define TEST_MATCH_ALL0(_pattern, _string, _string_len, _start_position) {          \
 
1319
  TestMatchAllData *data;                                                           \
 
1320
  gchar *path;                                                                      \
 
1321
  data = g_new0 (TestMatchAllData, 1);                                              \
 
1322
  data->pattern = _pattern;                                                         \
 
1323
  data->string = _string;                                                           \
 
1324
  data->string_len = _string_len;                                                   \
 
1325
  data->start_position = _start_position;                                           \
 
1326
  data->expected = NULL;                                                            \
 
1327
  if (_string_len == -1 && _start_position == 0) {                                  \
 
1328
    path = g_strdup_printf ("/regex/match-all0/%d", ++total);                       \
 
1329
    g_test_add_data_func (path, data, test_match_all);                              \
 
1330
    g_free (path);                                                                  \
 
1331
  }                                                                                 \
 
1332
  path = g_strdup_printf ("/regex/match-all-full0/%d", ++total);                    \
 
1333
  g_test_add_data_func_full (path, data, test_match_all_full, free_match_all_data); \
 
1334
  g_free (path);                                                                    \
 
1335
}
 
1336
 
 
1337
#define TEST_MATCH_ALL1(_pattern, _string, _string_len, _start_position,            \
 
1338
                        t1, s1, e1) {                                               \
 
1339
  TestMatchAllData *data;                                                           \
 
1340
  Match *match;                                                                     \
 
1341
  gchar *path;                                                                      \
 
1342
  data = g_new0 (TestMatchAllData, 1);                                              \
 
1343
  data->pattern = _pattern;                                                         \
 
1344
  data->string = _string;                                                           \
 
1345
  data->string_len = _string_len;                                                   \
 
1346
  data->start_position = _start_position;                                           \
 
1347
  data->expected = NULL;                                                            \
 
1348
  match = g_new0 (Match, 1);                                                        \
 
1349
  match->string = t1;                                                               \
 
1350
  match->start = s1;                                                                \
 
1351
  match->end = e1;                                                                  \
 
1352
  data->expected = g_slist_append (data->expected, match);                          \
 
1353
  if (_string_len == -1 && _start_position == 0) {                                  \
 
1354
    path = g_strdup_printf ("/regex/match-all1/%d", ++total);                       \
 
1355
    g_test_add_data_func (path, data, test_match_all);                              \
 
1356
    g_free (path);                                                                  \
 
1357
  }                                                                                 \
 
1358
  path = g_strdup_printf ("/regex/match-all-full1/%d", ++total);                    \
 
1359
  g_test_add_data_func_full (path, data, test_match_all_full, free_match_all_data); \
 
1360
  g_free (path);                                                                    \
 
1361
}
 
1362
 
 
1363
#define TEST_MATCH_ALL2(_pattern, _string, _string_len, _start_position,            \
 
1364
                        t1, s1, e1, t2, s2, e2) {                                   \
 
1365
  TestMatchAllData *data;                                                           \
 
1366
  Match *match;                                                                     \
 
1367
  gchar *path;                                                                      \
 
1368
  data = g_new0 (TestMatchAllData, 1);                                              \
 
1369
  data->pattern = _pattern;                                                         \
 
1370
  data->string = _string;                                                           \
 
1371
  data->string_len = _string_len;                                                   \
 
1372
  data->start_position = _start_position;                                           \
 
1373
  data->expected = NULL;                                                            \
 
1374
  match = g_new0 (Match, 1);                                                        \
 
1375
  match->string = t1;                                                               \
 
1376
  match->start = s1;                                                                \
 
1377
  match->end = e1;                                                                  \
 
1378
  data->expected = g_slist_append (data->expected, match);                          \
 
1379
  match = g_new0 (Match, 1);                                                        \
 
1380
  match->string = t2;                                                               \
 
1381
  match->start = s2;                                                                \
 
1382
  match->end = e2;                                                                  \
 
1383
  data->expected = g_slist_append (data->expected, match);                          \
 
1384
  if (_string_len == -1 && _start_position == 0) {                                  \
 
1385
    path = g_strdup_printf ("/regex/match-all2/%d", ++total);                       \
 
1386
    g_test_add_data_func (path, data, test_match_all);                              \
 
1387
    g_free (path);                                                                  \
 
1388
  }                                                                                 \
 
1389
  path = g_strdup_printf ("/regex/match-all-full2/%d", ++total);                    \
 
1390
  g_test_add_data_func_full (path, data, test_match_all_full, free_match_all_data); \
 
1391
  g_free (path);                                                                    \
 
1392
}
 
1393
 
 
1394
#define TEST_MATCH_ALL3(_pattern, _string, _string_len, _start_position,            \
 
1395
                        t1, s1, e1, t2, s2, e2, t3, s3, e3) {                       \
 
1396
  TestMatchAllData *data;                                                           \
 
1397
  Match *match;                                                                     \
 
1398
  gchar *path;                                                                      \
 
1399
  data = g_new0 (TestMatchAllData, 1);                                              \
 
1400
  data->pattern = _pattern;                                                         \
 
1401
  data->string = _string;                                                           \
 
1402
  data->string_len = _string_len;                                                   \
 
1403
  data->start_position = _start_position;                                           \
 
1404
  data->expected = NULL;                                                            \
 
1405
  match = g_new0 (Match, 1);                                                        \
 
1406
  match->string = t1;                                                               \
 
1407
  match->start = s1;                                                                \
 
1408
  match->end = e1;                                                                  \
 
1409
  data->expected = g_slist_append (data->expected, match);                          \
 
1410
  match = g_new0 (Match, 1);                                                        \
 
1411
  match->string = t2;                                                               \
 
1412
  match->start = s2;                                                                \
 
1413
  match->end = e2;                                                                  \
 
1414
  data->expected = g_slist_append (data->expected, match);                          \
 
1415
  match = g_new0 (Match, 1);                                                        \
 
1416
  match->string = t3;                                                               \
 
1417
  match->start = s3;                                                                \
 
1418
  match->end = e3;                                                                  \
 
1419
  data->expected = g_slist_append (data->expected, match);                          \
 
1420
  if (_string_len == -1 && _start_position == 0) {                                  \
 
1421
    path = g_strdup_printf ("/regex/match-all3/%d", ++total);                       \
 
1422
    g_test_add_data_func (path, data, test_match_all);                              \
 
1423
    g_free (path);                                                                  \
 
1424
  }                                                                                 \
 
1425
  path = g_strdup_printf ("/regex/match-all-full3/%d", ++total);                    \
 
1426
  g_test_add_data_func_full (path, data, test_match_all_full, free_match_all_data); \
 
1427
  g_free (path);                                                                    \
1467
1428
}
1468
1429
 
1469
1430
static void
1728
1689
  regex = g_regex_new ("cat(aract|erpillar|)", G_REGEX_OPTIMIZE, 0, &error);
1729
1690
  g_assert (regex);
1730
1691
  g_assert_no_error (error);
 
1692
  g_assert_cmpint (g_regex_get_capture_count (regex), ==, 1);
 
1693
  g_assert_cmpint (g_regex_get_max_backref (regex), ==, 0);
1731
1694
  res = g_regex_match_all (regex, "caterpillar", 0, &match);
1732
1695
  g_assert (res);
1733
1696
  g_assert (g_match_info_matches (match));
1744
1707
  regex = g_regex_new ("the ((red|white) (king|queen))", G_REGEX_OPTIMIZE, 0, &error);
1745
1708
  g_assert (regex);
1746
1709
  g_assert_no_error (error);
 
1710
  g_assert_cmpint (g_regex_get_capture_count (regex), ==, 3);
 
1711
  g_assert_cmpint (g_regex_get_max_backref (regex), ==, 0);
1747
1712
  res = g_regex_match (regex, "the red king", 0, &match);
1748
1713
  g_assert (res);
1749
1714
  g_assert (g_match_info_matches (match));
1770
1735
  g_assert (res);
1771
1736
  g_assert (g_match_info_matches (match));
1772
1737
  g_assert_cmpint (g_match_info_get_match_count (match), ==, 3);
 
1738
  g_assert_cmpint (g_regex_get_max_backref (regex), ==, 0);
1773
1739
  str = g_match_info_fetch (match, 0);
1774
1740
  g_assert_cmpstr (str, ==, "the white queen");
1775
1741
  g_free (str);
1785
1751
  regex = g_regex_new ("(?|(Sat)(ur)|(Sun))day (morning|afternoon)", G_REGEX_OPTIMIZE, 0, &error);
1786
1752
  g_assert (regex);
1787
1753
  g_assert_no_error (error);
 
1754
  g_assert_cmpint (g_regex_get_capture_count (regex), ==, 3);
1788
1755
  res = g_regex_match (regex, "Saturday morning", 0, &match);
1789
1756
  g_assert (res);
1790
1757
  g_assert (g_match_info_matches (match));
1804
1771
  regex = g_regex_new ("(?|(abc)|(def))\\1", G_REGEX_OPTIMIZE, 0, &error);
1805
1772
  g_assert (regex);
1806
1773
  g_assert_no_error (error);
 
1774
  g_assert_cmpint (g_regex_get_max_backref (regex), ==, 1);
1807
1775
  res = g_regex_match (regex, "abcabc abcdef defabc defdef", 0, &match);
1808
1776
  g_assert (res);
1809
1777
  g_assert (g_match_info_matches (match));
2106
2074
  g_assert_cmpint (count, ==, 2);
2107
2075
}
2108
2076
 
 
2077
static void
 
2078
test_explicit_crlf (void)
 
2079
{
 
2080
  GRegex *regex;
 
2081
 
 
2082
  regex = g_regex_new ("[\r\n]a", 0, 0, NULL);
 
2083
  g_assert_cmpint (g_regex_get_has_cr_or_lf (regex), ==, TRUE);
 
2084
  g_regex_unref (regex);
 
2085
}
 
2086
 
2109
2087
int
2110
2088
main (int argc, char *argv[])
2111
2089
{
2115
2093
 
2116
2094
  g_test_bug_base ("http://bugzilla.gnome.org/");
2117
2095
 
2118
 
  g_test_add_func ("/regex/basic", test_basic);
2119
 
  g_test_add_func ("/regex/compile", test_compile);
2120
2096
  g_test_add_func ("/regex/properties", test_properties);
2121
2097
  g_test_add_func ("/regex/class", test_class);
2122
2098
  g_test_add_func ("/regex/lookahead", test_lookahead);
2125
2101
  g_test_add_func ("/regex/condition", test_condition);
2126
2102
  g_test_add_func ("/regex/recursion", test_recursion);
2127
2103
  g_test_add_func ("/regex/multiline", test_multiline);
 
2104
  g_test_add_func ("/regex/explicit-crlf", test_explicit_crlf);
2128
2105
 
2129
2106
  /* TEST_NEW(pattern, compile_opts, match_opts) */
 
2107
  TEST_NEW("[A-Z]+", G_REGEX_CASELESS | G_REGEX_EXTENDED | G_REGEX_OPTIMIZE, G_REGEX_MATCH_NOTBOL | G_REGEX_MATCH_PARTIAL);
2130
2108
  TEST_NEW("", 0, 0);
2131
2109
  TEST_NEW(".*", 0, 0);
2132
2110
  TEST_NEW(".*", G_REGEX_OPTIMIZE, 0);
2141
2119
  /* This gives "internal error: code overflow" with pcre 6.0 */
2142
2120
  TEST_NEW("(?i)(?-i)", 0, 0);
2143
2121
 
 
2122
  /* Check that flags are correct if the pattern modifies them */
 
2123
  /* TEST_NEW_CHECK_FLAGS(pattern, compile_opts, match_ops, real_compile_opts, real_match_opts) */
 
2124
  TEST_NEW_CHECK_FLAGS ("a", G_REGEX_OPTIMIZE, 0, G_REGEX_OPTIMIZE, 0);
 
2125
  TEST_NEW_CHECK_FLAGS ("a", G_REGEX_RAW, 0, G_REGEX_RAW, 0);
 
2126
  TEST_NEW_CHECK_FLAGS ("(?i)a", 0, 0, G_REGEX_CASELESS, 0);
 
2127
  TEST_NEW_CHECK_FLAGS ("(?m)a", 0, 0, G_REGEX_MULTILINE, 0);
 
2128
  TEST_NEW_CHECK_FLAGS ("(?s)a", 0, 0, G_REGEX_DOTALL, 0);
 
2129
  TEST_NEW_CHECK_FLAGS ("(?x)a", 0, 0, G_REGEX_EXTENDED, 0);
 
2130
  TEST_NEW_CHECK_FLAGS ("(?J)a", 0, 0, G_REGEX_DUPNAMES, 0);
 
2131
  TEST_NEW_CHECK_FLAGS ("(?U)[a-z]+", 0, 0, G_REGEX_UNGREEDY, 0);
 
2132
  TEST_NEW_CHECK_FLAGS ("(?X)a", 0, 0, 0 /* not exposed by GRegex */, 0);
 
2133
  TEST_NEW_CHECK_FLAGS ("^.*", 0, 0, G_REGEX_ANCHORED, 0);
 
2134
  TEST_NEW_CHECK_FLAGS ("(*UTF8)a", 0, 0, 0 /* this is the default in GRegex */, 0);
 
2135
  TEST_NEW_CHECK_FLAGS ("(*UCP)a", 0, 0, 0 /* this always on in GRegex */, 0);
 
2136
  TEST_NEW_CHECK_FLAGS ("(*CR)a", 0, 0, G_REGEX_NEWLINE_CR, 0);
 
2137
  TEST_NEW_CHECK_FLAGS ("(*LF)a", 0, 0, G_REGEX_NEWLINE_LF, 0);
 
2138
  TEST_NEW_CHECK_FLAGS ("(*CRLF)a", 0, 0, G_REGEX_NEWLINE_CRLF, 0);
 
2139
  TEST_NEW_CHECK_FLAGS ("(*ANY)a", 0, 0, 0 /* this is the default in GRegex */, 0);
 
2140
  TEST_NEW_CHECK_FLAGS ("(*ANYCRLF)a", 0, 0, G_REGEX_NEWLINE_ANYCRLF, 0);
 
2141
  TEST_NEW_CHECK_FLAGS ("(*BSR_ANYCRLF)a", 0, 0, G_REGEX_BSR_ANYCRLF, 0);
 
2142
  TEST_NEW_CHECK_FLAGS ("(*BSR_UNICODE)a", 0, 0, 0 /* this is the default in GRegex */, 0);
 
2143
  TEST_NEW_CHECK_FLAGS ("(*NO_START_OPT)a", 0, 0, 0 /* not exposed in GRegex */, 0);
 
2144
 
2144
2145
  /* TEST_NEW_FAIL(pattern, compile_opts, expected_error) */
2145
2146
  TEST_NEW_FAIL("(", 0, G_REGEX_ERROR_UNMATCHED_PARENTHESIS);
2146
2147
  TEST_NEW_FAIL(")", 0, G_REGEX_ERROR_UNMATCHED_PARENTHESIS);
2149
2150
  TEST_NEW_FAIL("?", 0, G_REGEX_ERROR_NOTHING_TO_REPEAT);
2150
2151
  TEST_NEW_FAIL("(?P<A>x)|(?P<A>y)", 0, G_REGEX_ERROR_DUPLICATE_SUBPATTERN_NAME);
2151
2152
 
 
2153
  /* Check all GRegexError codes */
 
2154
  TEST_NEW_FAIL ("a\\", 0, G_REGEX_ERROR_STRAY_BACKSLASH);
 
2155
  TEST_NEW_FAIL ("a\\c", 0, G_REGEX_ERROR_MISSING_CONTROL_CHAR);
 
2156
  TEST_NEW_FAIL ("a\\l", 0, G_REGEX_ERROR_UNRECOGNIZED_ESCAPE);
 
2157
  TEST_NEW_FAIL ("a{4,2}", 0, G_REGEX_ERROR_QUANTIFIERS_OUT_OF_ORDER);
 
2158
  TEST_NEW_FAIL ("a{999999,}", 0, G_REGEX_ERROR_QUANTIFIER_TOO_BIG);
 
2159
  TEST_NEW_FAIL ("[a-z", 0, G_REGEX_ERROR_UNTERMINATED_CHARACTER_CLASS);
 
2160
  TEST_NEW_FAIL ("(?X)[\\B]", 0, G_REGEX_ERROR_INVALID_ESCAPE_IN_CHARACTER_CLASS);
 
2161
  TEST_NEW_FAIL ("[z-a]", 0, G_REGEX_ERROR_RANGE_OUT_OF_ORDER);
 
2162
  TEST_NEW_FAIL ("{2,4}", 0, G_REGEX_ERROR_NOTHING_TO_REPEAT);
 
2163
  TEST_NEW_FAIL ("a(?u)", 0, G_REGEX_ERROR_UNRECOGNIZED_CHARACTER);
 
2164
  TEST_NEW_FAIL ("a(?<$foo)bar", 0, G_REGEX_ERROR_UNRECOGNIZED_CHARACTER);
 
2165
  TEST_NEW_FAIL ("a[:alpha:]b", 0, G_REGEX_ERROR_POSIX_NAMED_CLASS_OUTSIDE_CLASS);
 
2166
  TEST_NEW_FAIL ("a(b", 0, G_REGEX_ERROR_UNMATCHED_PARENTHESIS);
 
2167
  TEST_NEW_FAIL ("a)b", 0, G_REGEX_ERROR_UNMATCHED_PARENTHESIS);
 
2168
  TEST_NEW_FAIL ("a(?R", 0, G_REGEX_ERROR_UNMATCHED_PARENTHESIS);
 
2169
  TEST_NEW_FAIL ("a(?-54", 0, G_REGEX_ERROR_UNMATCHED_PARENTHESIS);
 
2170
  TEST_NEW_FAIL ("(ab\\2)", 0, G_REGEX_ERROR_INEXISTENT_SUBPATTERN_REFERENCE);
 
2171
  TEST_NEW_FAIL ("a(?#abc", 0, G_REGEX_ERROR_UNTERMINATED_COMMENT);
 
2172
  TEST_NEW_FAIL ("(?<=a+)b", 0, G_REGEX_ERROR_VARIABLE_LENGTH_LOOKBEHIND);
 
2173
  TEST_NEW_FAIL ("(?(1?)a|b)", 0, G_REGEX_ERROR_MALFORMED_CONDITION);
 
2174
  TEST_NEW_FAIL ("(a)(?(1)a|b|c)", 0, G_REGEX_ERROR_TOO_MANY_CONDITIONAL_BRANCHES);
 
2175
  TEST_NEW_FAIL ("(?(?i))", 0, G_REGEX_ERROR_ASSERTION_EXPECTED);
 
2176
  TEST_NEW_FAIL ("a[[:fubar:]]b", 0, G_REGEX_ERROR_UNKNOWN_POSIX_CLASS_NAME);
 
2177
  TEST_NEW_FAIL ("[[.ch.]]", 0, G_REGEX_ERROR_POSIX_COLLATING_ELEMENTS_NOT_SUPPORTED);
 
2178
  TEST_NEW_FAIL ("\\x{110000}", 0, G_REGEX_ERROR_HEX_CODE_TOO_LARGE);
 
2179
  TEST_NEW_FAIL ("^(?(0)f|b)oo", 0, G_REGEX_ERROR_INVALID_CONDITION);
 
2180
  TEST_NEW_FAIL ("(?<=\\C)X", 0, G_REGEX_ERROR_SINGLE_BYTE_MATCH_IN_LOOKBEHIND);
 
2181
  TEST_NEW_FAIL ("(?!\\w)(?R)", 0, G_REGEX_ERROR_INFINITE_LOOP);
 
2182
  TEST_NEW_FAIL ("(?(?<ab))", 0, G_REGEX_ERROR_MISSING_SUBPATTERN_NAME_TERMINATOR);
 
2183
  TEST_NEW_FAIL ("(?P<x>eks)(?P<x>eccs)", 0, G_REGEX_ERROR_DUPLICATE_SUBPATTERN_NAME);
 
2184
#if 0
 
2185
  TEST_NEW_FAIL (?, 0, G_REGEX_ERROR_MALFORMED_PROPERTY);
 
2186
  TEST_NEW_FAIL (?, 0, G_REGEX_ERROR_UNKNOWN_PROPERTY);
 
2187
#endif
 
2188
  TEST_NEW_FAIL ("\\666", G_REGEX_RAW, G_REGEX_ERROR_INVALID_OCTAL_VALUE);
 
2189
  TEST_NEW_FAIL ("^(?(DEFINE) abc | xyz ) ", 0, G_REGEX_ERROR_TOO_MANY_BRANCHES_IN_DEFINE);
 
2190
  TEST_NEW_FAIL ("a", G_REGEX_NEWLINE_CRLF | G_REGEX_NEWLINE_ANYCRLF, G_REGEX_ERROR_INCONSISTENT_NEWLINE_OPTIONS);
 
2191
  TEST_NEW_FAIL ("^(a)\\g{3", 0, G_REGEX_ERROR_MISSING_BACK_REFERENCE);
 
2192
  TEST_NEW_FAIL ("^(a)\\g{0}", 0, G_REGEX_ERROR_INVALID_RELATIVE_REFERENCE);
 
2193
  TEST_NEW_FAIL ("abc(*FAIL:123)xyz", 0, G_REGEX_ERROR_BACKTRACKING_CONTROL_VERB_ARGUMENT_FORBIDDEN);
 
2194
  TEST_NEW_FAIL ("a(*FOOBAR)b", 0, G_REGEX_ERROR_UNKNOWN_BACKTRACKING_CONTROL_VERB);
 
2195
  TEST_NEW_FAIL ("(?i:A{1,}\\6666666666)", 0, G_REGEX_ERROR_NUMBER_TOO_BIG);
 
2196
  TEST_NEW_FAIL ("(?<a>)(?&)", 0, G_REGEX_ERROR_MISSING_SUBPATTERN_NAME);
 
2197
  TEST_NEW_FAIL ("(?+-a)", 0, G_REGEX_ERROR_MISSING_DIGIT);
 
2198
  TEST_NEW_FAIL ("TA]", G_REGEX_JAVASCRIPT_COMPAT, G_REGEX_ERROR_INVALID_DATA_CHARACTER);
 
2199
  TEST_NEW_FAIL ("(?|(?<a>A)|(?<b>B))", 0, G_REGEX_ERROR_EXTRA_SUBPATTERN_NAME);
 
2200
  TEST_NEW_FAIL ("a(*MARK)b", 0, G_REGEX_ERROR_BACKTRACKING_CONTROL_VERB_ARGUMENT_REQUIRED);
 
2201
  TEST_NEW_FAIL ("^\\c€", 0, G_REGEX_ERROR_INVALID_CONTROL_CHAR);
 
2202
  TEST_NEW_FAIL ("\\k", 0, G_REGEX_ERROR_MISSING_NAME);
 
2203
  TEST_NEW_FAIL ("a[\\NB]c", 0, G_REGEX_ERROR_NOT_SUPPORTED_IN_CLASS);
 
2204
  TEST_NEW_FAIL ("(*:0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEFG)XX", 0, G_REGEX_ERROR_NAME_TOO_LONG);
 
2205
  TEST_NEW_FAIL ("\\u0100", G_REGEX_RAW | G_REGEX_JAVASCRIPT_COMPAT, G_REGEX_ERROR_CHARACTER_VALUE_TOO_LARGE);
 
2206
 
 
2207
  /* These errors can't really be tested sanely:
 
2208
   * G_REGEX_ERROR_EXPRESSION_TOO_LARGE
 
2209
   * G_REGEX_ERROR_MEMORY_ERROR
 
2210
   * G_REGEX_ERROR_SUBPATTERN_NAME_TOO_LONG
 
2211
   * G_REGEX_ERROR_TOO_MANY_SUBPATTERNS
 
2212
   * G_REGEX_ERROR_TOO_MANY_FORWARD_REFERENCES
 
2213
   *
 
2214
   * These errors are obsolete and never raised by PCRE:
 
2215
   * G_REGEX_ERROR_DEFINE_REPETION
 
2216
   */
 
2217
 
2152
2218
  /* TEST_MATCH_SIMPLE(pattern, string, compile_opts, match_opts, expected) */
2153
2219
  TEST_MATCH_SIMPLE("a", "", 0, 0, FALSE);
2154
2220
  TEST_MATCH_SIMPLE("a", "a", 0, 0, TRUE);
2295
2361
  TEST_MATCH("a#\nb", G_REGEX_EXTENDED, G_REGEX_MATCH_NEWLINE_CR, "a", -1, 0, 0, FALSE);
2296
2362
  TEST_MATCH("a#\nb", G_REGEX_EXTENDED | G_REGEX_NEWLINE_CR, 0, "a", -1, 0, 0, TRUE);
2297
2363
 
 
2364
  TEST_MATCH("line\nbreak", G_REGEX_MULTILINE, 0, "this is a line\nbreak", -1, 0, 0, TRUE);
 
2365
  TEST_MATCH("line\nbreak", G_REGEX_MULTILINE | G_REGEX_FIRSTLINE, 0, "first line\na line\nbreak", -1, 0, 0, FALSE);
 
2366
 
2298
2367
  /* This failed with PCRE 7.2 (gnome bug #455640) */
2299
2368
  TEST_MATCH(".*$", 0, 0, "\xe1\xbb\x85", -1, 0, 0, TRUE);
2300
2369
 
 
2370
  /* Test that othercasing in our pcre/glib integration is bug-for-bug compatible
 
2371
   * with pcre's internal tables. Bug #678273 */
 
2372
  TEST_MATCH("[DŽ]", G_REGEX_CASELESS, 0, "DŽ", -1, 0, 0, TRUE);
 
2373
  TEST_MATCH("[DŽ]", G_REGEX_CASELESS, 0, "Dž", -1, 0, 0, FALSE);
 
2374
  TEST_MATCH("[DŽ]", G_REGEX_CASELESS, 0, "dž", -1, 0, 0, TRUE);
 
2375
 
2301
2376
  /* TEST_MATCH_NEXT#(pattern, string, string_len, start_position, ...) */
2302
2377
  TEST_MATCH_NEXT0("a", "x", -1, 0);
2303
2378
  TEST_MATCH_NEXT0("a", "ax", -1, 1);
2343
2418
  TEST_PARTIAL("(a)+b", "aa", TRUE);
2344
2419
  TEST_PARTIAL("a?b", "a", TRUE);
2345
2420
 
 
2421
  /* Test soft vs. hard partial matching */
 
2422
  TEST_PARTIAL_FULL("cat(fish)?", "cat", G_REGEX_MATCH_PARTIAL_SOFT, FALSE);
 
2423
  TEST_PARTIAL_FULL("cat(fish)?", "cat", G_REGEX_MATCH_PARTIAL_HARD, TRUE);
 
2424
 
2346
2425
  /* TEST_SUB_PATTERN(pattern, string, start_position, sub_n, expected_sub,
2347
2426
   *                  expected_start, expected_end) */
2348
2427
  TEST_SUB_PATTERN("a", "a", 0, 0, "a", 0, 1);
2655
2734
                  "<a><b>", 0, 6, "<a>", 0, 3);
2656
2735
  TEST_MATCH_ALL3("a+", "aaa", -1, 0, "aaa", 0, 3, "aa", 0, 2, "a", 0, 1);
2657
2736
 
 
2737
  /* NOTEMPTY matching */
 
2738
  TEST_MATCH_NOTEMPTY("a?b?", "xyz", FALSE);
 
2739
  TEST_MATCH_NOTEMPTY_ATSTART("a?b?", "xyz", TRUE);
 
2740
 
2658
2741
  return g_test_run ();
2659
2742
}