chiark / gitweb /
Reapply patches
[pcre3.git] / pcrecpp_unittest.cc
1 // -*- coding: utf-8 -*-
2 //
3 // Copyright (c) 2005 - 2010, Google Inc.
4 // All rights reserved.
5 //
6 // Redistribution and use in source and binary forms, with or without
7 // modification, are permitted provided that the following conditions are
8 // met:
9 //
10 //     * Redistributions of source code must retain the above copyright
11 // notice, this list of conditions and the following disclaimer.
12 //     * Redistributions in binary form must reproduce the above
13 // copyright notice, this list of conditions and the following disclaimer
14 // in the documentation and/or other materials provided with the
15 // distribution.
16 //     * Neither the name of Google Inc. nor the names of its
17 // contributors may be used to endorse or promote products derived from
18 // this software without specific prior written permission.
19 //
20 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
21 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
23 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
24 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
25 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
26 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
27 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
28 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
29 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
30 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31 //
32 // Author: Sanjay Ghemawat
33 //
34 // TODO: Test extractions for PartialMatch/Consume
35
36 #ifdef HAVE_CONFIG_H
37 #include "config.h"
38 #endif
39
40 #include <stdio.h>
41 #include <string.h>      /* for memset and strcmp */
42 #include <cassert>
43 #include <vector>
44 #include "pcrecpp.h"
45
46 using pcrecpp::StringPiece;
47 using pcrecpp::RE;
48 using pcrecpp::RE_Options;
49 using pcrecpp::Hex;
50 using pcrecpp::Octal;
51 using pcrecpp::CRadix;
52
53 static bool VERBOSE_TEST  = false;
54
55 // CHECK dies with a fatal error if condition is not true.  It is *not*
56 // controlled by NDEBUG, so the check will be executed regardless of
57 // compilation mode.  Therefore, it is safe to do things like:
58 //    CHECK_EQ(fp->Write(x), 4)
59 #define CHECK(condition) do {                           \
60   if (!(condition)) {                                   \
61     fprintf(stderr, "%s:%d: Check failed: %s\n",        \
62             __FILE__, __LINE__, #condition);            \
63     exit(1);                                            \
64   }                                                     \
65 } while (0)
66
67 #define CHECK_EQ(a, b)   CHECK(a == b)
68
69 static void Timing1(int num_iters) {
70   // Same pattern lots of times
71   RE pattern("ruby:\\d+");
72   StringPiece p("ruby:1234");
73   for (int j = num_iters; j > 0; j--) {
74     CHECK(pattern.FullMatch(p));
75   }
76 }
77
78 static void Timing2(int num_iters) {
79   // Same pattern lots of times
80   RE pattern("ruby:(\\d+)");
81   int i;
82   for (int j = num_iters; j > 0; j--) {
83     CHECK(pattern.FullMatch("ruby:1234", &i));
84     CHECK_EQ(i, 1234);
85   }
86 }
87
88 static void Timing3(int num_iters) {
89   string text_string;
90   for (int j = num_iters; j > 0; j--) {
91     text_string += "this is another line\n";
92   }
93
94   RE line_matcher(".*\n");
95   string line;
96   StringPiece text(text_string);
97   int counter = 0;
98   while (line_matcher.Consume(&text)) {
99     counter++;
100   }
101   printf("Matched %d lines\n", counter);
102 }
103
104 #if 0  // uncomment this if you have a way of defining VirtualProcessSize()
105
106 static void LeakTest() {
107   // Check for memory leaks
108   unsigned long long initial_size = 0;
109   for (int i = 0; i < 100000; i++) {
110     if (i == 50000) {
111       initial_size = VirtualProcessSize();
112       printf("Size after 50000: %llu\n", initial_size);
113     }
114     char buf[100];  // definitely big enough
115     sprintf(buf, "pat%09d", i);
116     RE newre(buf);
117   }
118   uint64 final_size = VirtualProcessSize();
119   printf("Size after 100000: %llu\n", final_size);
120   const double growth = double(final_size - initial_size) / final_size;
121   printf("Growth: %0.2f%%", growth * 100);
122   CHECK(growth < 0.02);       // Allow < 2% growth
123 }
124
125 #endif
126
127 static void RadixTests() {
128   printf("Testing hex\n");
129
130 #define CHECK_HEX(type, value) \
131   do { \
132     type v; \
133     CHECK(RE("([0-9a-fA-F]+)[uUlL]*").FullMatch(#value, Hex(&v))); \
134     CHECK_EQ(v, 0x ## value); \
135     CHECK(RE("([0-9a-fA-FxX]+)[uUlL]*").FullMatch("0x" #value, CRadix(&v))); \
136     CHECK_EQ(v, 0x ## value); \
137   } while(0)
138
139   CHECK_HEX(short,              2bad);
140   CHECK_HEX(unsigned short,     2badU);
141   CHECK_HEX(int,                dead);
142   CHECK_HEX(unsigned int,       deadU);
143   CHECK_HEX(long,               7eadbeefL);
144   CHECK_HEX(unsigned long,      deadbeefUL);
145 #ifdef HAVE_LONG_LONG
146   CHECK_HEX(long long,          12345678deadbeefLL);
147 #endif
148 #ifdef HAVE_UNSIGNED_LONG_LONG
149   CHECK_HEX(unsigned long long, cafebabedeadbeefULL);
150 #endif
151
152 #undef CHECK_HEX
153
154   printf("Testing octal\n");
155
156 #define CHECK_OCTAL(type, value) \
157   do { \
158     type v; \
159     CHECK(RE("([0-7]+)[uUlL]*").FullMatch(#value, Octal(&v))); \
160     CHECK_EQ(v, 0 ## value); \
161     CHECK(RE("([0-9a-fA-FxX]+)[uUlL]*").FullMatch("0" #value, CRadix(&v))); \
162     CHECK_EQ(v, 0 ## value); \
163   } while(0)
164
165   CHECK_OCTAL(short,              77777);
166   CHECK_OCTAL(unsigned short,     177777U);
167   CHECK_OCTAL(int,                17777777777);
168   CHECK_OCTAL(unsigned int,       37777777777U);
169   CHECK_OCTAL(long,               17777777777L);
170   CHECK_OCTAL(unsigned long,      37777777777UL);
171 #ifdef HAVE_LONG_LONG
172   CHECK_OCTAL(long long,          777777777777777777777LL);
173 #endif
174 #ifdef HAVE_UNSIGNED_LONG_LONG
175   CHECK_OCTAL(unsigned long long, 1777777777777777777777ULL);
176 #endif
177
178 #undef CHECK_OCTAL
179
180   printf("Testing decimal\n");
181
182 #define CHECK_DECIMAL(type, value) \
183   do { \
184     type v; \
185     CHECK(RE("(-?[0-9]+)[uUlL]*").FullMatch(#value, &v)); \
186     CHECK_EQ(v, value); \
187     CHECK(RE("(-?[0-9a-fA-FxX]+)[uUlL]*").FullMatch(#value, CRadix(&v))); \
188     CHECK_EQ(v, value); \
189   } while(0)
190
191   CHECK_DECIMAL(short,              -1);
192   CHECK_DECIMAL(unsigned short,     9999);
193   CHECK_DECIMAL(int,                -1000);
194   CHECK_DECIMAL(unsigned int,       12345U);
195   CHECK_DECIMAL(long,               -10000000L);
196   CHECK_DECIMAL(unsigned long,      3083324652U);
197 #ifdef HAVE_LONG_LONG
198   CHECK_DECIMAL(long long,          -100000000000000LL);
199 #endif
200 #ifdef HAVE_UNSIGNED_LONG_LONG
201   CHECK_DECIMAL(unsigned long long, 1234567890987654321ULL);
202 #endif
203
204 #undef CHECK_DECIMAL
205
206 }
207
208 static void TestReplace() {
209   printf("Testing Replace\n");
210
211   struct ReplaceTest {
212     const char *regexp;
213     const char *rewrite;
214     const char *original;
215     const char *single;
216     const char *global;
217     int global_count;         // the expected return value from ReplaceAll
218   };
219   static const ReplaceTest tests[] = {
220     { "(qu|[b-df-hj-np-tv-z]*)([a-z]+)",
221       "\\2\\1ay",
222       "the quick brown fox jumps over the lazy dogs.",
223       "ethay quick brown fox jumps over the lazy dogs.",
224       "ethay ickquay ownbray oxfay umpsjay overay ethay azylay ogsday.",
225       9 },
226     { "\\w+",
227       "\\0-NOSPAM",
228       "paul.haahr@google.com",
229       "paul-NOSPAM.haahr@google.com",
230       "paul-NOSPAM.haahr-NOSPAM@google-NOSPAM.com-NOSPAM",
231       4 },
232     { "^",
233       "(START)",
234       "foo",
235       "(START)foo",
236       "(START)foo",
237       1 },
238     { "^",
239       "(START)",
240       "",
241       "(START)",
242       "(START)",
243       1 },
244     { "$",
245       "(END)",
246       "",
247       "(END)",
248       "(END)",
249       1 },
250     { "b",
251       "bb",
252       "ababababab",
253       "abbabababab",
254       "abbabbabbabbabb",
255        5 },
256     { "b",
257       "bb",
258       "bbbbbb",
259       "bbbbbbb",
260       "bbbbbbbbbbbb",
261       6 },
262     { "b+",
263       "bb",
264       "bbbbbb",
265       "bb",
266       "bb",
267       1 },
268     { "b*",
269       "bb",
270       "bbbbbb",
271       "bb",
272       "bbbb",
273       2 },
274     { "b*",
275       "bb",
276       "aaaaa",
277       "bbaaaaa",
278       "bbabbabbabbabbabb",
279       6 },
280     { "b*",
281       "bb",
282       "aa\naa\n",
283       "bbaa\naa\n",
284       "bbabbabb\nbbabbabb\nbb",
285       7 },
286     { "b*",
287       "bb",
288       "aa\raa\r",
289       "bbaa\raa\r",
290       "bbabbabb\rbbabbabb\rbb",
291       7 },
292     { "b*",
293       "bb",
294       "aa\r\naa\r\n",
295       "bbaa\r\naa\r\n",
296       "bbabbabb\r\nbbabbabb\r\nbb",
297       7 },
298     // Check empty-string matching (it's tricky!)
299     { "aa|b*",
300       "@",
301       "aa",
302       "@",
303       "@@",
304       2 },
305     { "b*|aa",
306       "@",
307       "aa",
308       "@aa",
309       "@@@",
310       3 },
311 #ifdef SUPPORT_UTF8
312     { "b*",
313       "bb",
314       "\xE3\x83\x9B\xE3\x83\xBC\xE3\x83\xA0\xE3\x81\xB8",   // utf8
315       "bb\xE3\x83\x9B\xE3\x83\xBC\xE3\x83\xA0\xE3\x81\xB8",
316       "bb\xE3\x83\x9B""bb""\xE3\x83\xBC""bb""\xE3\x83\xA0""bb""\xE3\x81\xB8""bb",
317       5 },
318     { "b*",
319       "bb",
320       "\xE3\x83\x9B\r\n\xE3\x83\xBC\r\xE3\x83\xA0\n\xE3\x81\xB8\r\n",   // utf8
321       "bb\xE3\x83\x9B\r\n\xE3\x83\xBC\r\xE3\x83\xA0\n\xE3\x81\xB8\r\n",
322       ("bb\xE3\x83\x9B""bb\r\nbb""\xE3\x83\xBC""bb\rbb""\xE3\x83\xA0"
323        "bb\nbb""\xE3\x81\xB8""bb\r\nbb"),
324       9 },
325 #endif
326     { "", NULL, NULL, NULL, NULL, 0 }
327   };
328
329 #ifdef SUPPORT_UTF8
330   const bool support_utf8 = true;
331 #else
332   const bool support_utf8 = false;
333 #endif
334
335   for (const ReplaceTest *t = tests; t->original != NULL; ++t) {
336     RE re(t->regexp, RE_Options(PCRE_NEWLINE_CRLF).set_utf8(support_utf8));
337     assert(re.error().empty());
338     string one(t->original);
339     CHECK(re.Replace(t->rewrite, &one));
340     CHECK_EQ(one, t->single);
341     string all(t->original);
342     const int replace_count = re.GlobalReplace(t->rewrite, &all);
343     CHECK_EQ(all, t->global);
344     CHECK_EQ(replace_count, t->global_count);
345   }
346
347   // One final test: test \r\n replacement when we're not in CRLF mode
348   {
349     RE re("b*", RE_Options(PCRE_NEWLINE_CR).set_utf8(support_utf8));
350     assert(re.error().empty());
351     string all("aa\r\naa\r\n");
352     CHECK_EQ(re.GlobalReplace("bb", &all), 9);
353     CHECK_EQ(all, string("bbabbabb\rbb\nbbabbabb\rbb\nbb"));
354   }
355   {
356     RE re("b*", RE_Options(PCRE_NEWLINE_LF).set_utf8(support_utf8));
357     assert(re.error().empty());
358     string all("aa\r\naa\r\n");
359     CHECK_EQ(re.GlobalReplace("bb", &all), 9);
360     CHECK_EQ(all, string("bbabbabb\rbb\nbbabbabb\rbb\nbb"));
361   }
362   // TODO: test what happens when no PCRE_NEWLINE_* flag is set.
363   //       Alas, the answer depends on how pcre was compiled.
364 }
365
366 static void TestExtract() {
367   printf("Testing Extract\n");
368
369   string s;
370
371   CHECK(RE("(.*)@([^.]*)").Extract("\\2!\\1", "boris@kremvax.ru", &s));
372   CHECK_EQ(s, "kremvax!boris");
373
374   // check the RE interface as well
375   CHECK(RE(".*").Extract("'\\0'", "foo", &s));
376   CHECK_EQ(s, "'foo'");
377   CHECK(!RE("bar").Extract("'\\0'", "baz", &s));
378   CHECK_EQ(s, "'foo'");
379 }
380
381 static void TestConsume() {
382   printf("Testing Consume\n");
383
384   string word;
385
386   string s("   aaa b!@#$@#$cccc");
387   StringPiece input(s);
388
389   RE r("\\s*(\\w+)");    // matches a word, possibly proceeded by whitespace
390   CHECK(r.Consume(&input, &word));
391   CHECK_EQ(word, "aaa");
392   CHECK(r.Consume(&input, &word));
393   CHECK_EQ(word, "b");
394   CHECK(! r.Consume(&input, &word));
395 }
396
397 static void TestFindAndConsume() {
398   printf("Testing FindAndConsume\n");
399
400   string word;
401
402   string s("   aaa b!@#$@#$cccc");
403   StringPiece input(s);
404
405   RE r("(\\w+)");      // matches a word
406   CHECK(r.FindAndConsume(&input, &word));
407   CHECK_EQ(word, "aaa");
408   CHECK(r.FindAndConsume(&input, &word));
409   CHECK_EQ(word, "b");
410   CHECK(r.FindAndConsume(&input, &word));
411   CHECK_EQ(word, "cccc");
412   CHECK(! r.FindAndConsume(&input, &word));
413 }
414
415 static void TestMatchNumberPeculiarity() {
416   printf("Testing match-number peculiarity\n");
417
418   string word1;
419   string word2;
420   string word3;
421
422   RE r("(foo)|(bar)|(baz)");
423   CHECK(r.PartialMatch("foo", &word1, &word2, &word3));
424   CHECK_EQ(word1, "foo");
425   CHECK_EQ(word2, "");
426   CHECK_EQ(word3, "");
427   CHECK(r.PartialMatch("bar", &word1, &word2, &word3));
428   CHECK_EQ(word1, "");
429   CHECK_EQ(word2, "bar");
430   CHECK_EQ(word3, "");
431   CHECK(r.PartialMatch("baz", &word1, &word2, &word3));
432   CHECK_EQ(word1, "");
433   CHECK_EQ(word2, "");
434   CHECK_EQ(word3, "baz");
435   CHECK(!r.PartialMatch("f", &word1, &word2, &word3));
436
437   string a;
438   CHECK(RE("(foo)|hello").FullMatch("hello", &a));
439   CHECK_EQ(a, "");
440 }
441
442 static void TestRecursion() {
443   printf("Testing recursion\n");
444
445   // Get one string that passes (sometimes), one that never does.
446   string text_good("abcdefghijk");
447   string text_bad("acdefghijkl");
448
449   // According to pcretest, matching text_good against (\w+)*b
450   // requires match_limit of at least 8192, and match_recursion_limit
451   // of at least 37.
452
453   RE_Options options_ml;
454   options_ml.set_match_limit(8192);
455   RE re("(\\w+)*b", options_ml);
456   CHECK(re.PartialMatch(text_good) == true);
457   CHECK(re.PartialMatch(text_bad) == false);
458   CHECK(re.FullMatch(text_good) == false);
459   CHECK(re.FullMatch(text_bad) == false);
460
461   options_ml.set_match_limit(1024);
462   RE re2("(\\w+)*b", options_ml);
463   CHECK(re2.PartialMatch(text_good) == false);   // because of match_limit
464   CHECK(re2.PartialMatch(text_bad) == false);
465   CHECK(re2.FullMatch(text_good) == false);
466   CHECK(re2.FullMatch(text_bad) == false);
467
468   RE_Options options_mlr;
469   options_mlr.set_match_limit_recursion(50);
470   RE re3("(\\w+)*b", options_mlr);
471   CHECK(re3.PartialMatch(text_good) == true);
472   CHECK(re3.PartialMatch(text_bad) == false);
473   CHECK(re3.FullMatch(text_good) == false);
474   CHECK(re3.FullMatch(text_bad) == false);
475
476   options_mlr.set_match_limit_recursion(10);
477   RE re4("(\\w+)*b", options_mlr);
478   CHECK(re4.PartialMatch(text_good) == false);
479   CHECK(re4.PartialMatch(text_bad) == false);
480   CHECK(re4.FullMatch(text_good) == false);
481   CHECK(re4.FullMatch(text_bad) == false);
482 }
483
484 // A meta-quoted string, interpreted as a pattern, should always match
485 // the original unquoted string.
486 static void TestQuoteMeta(string unquoted, RE_Options options = RE_Options()) {
487   string quoted = RE::QuoteMeta(unquoted);
488   RE re(quoted, options);
489   CHECK(re.FullMatch(unquoted));
490 }
491
492 // A string containing meaningful regexp characters, which is then meta-
493 // quoted, should not generally match a string the unquoted string does.
494 static void NegativeTestQuoteMeta(string unquoted, string should_not_match,
495                                   RE_Options options = RE_Options()) {
496   string quoted = RE::QuoteMeta(unquoted);
497   RE re(quoted, options);
498   CHECK(!re.FullMatch(should_not_match));
499 }
500
501 // Tests that quoted meta characters match their original strings,
502 // and that a few things that shouldn't match indeed do not.
503 static void TestQuotaMetaSimple() {
504   TestQuoteMeta("foo");
505   TestQuoteMeta("foo.bar");
506   TestQuoteMeta("foo\\.bar");
507   TestQuoteMeta("[1-9]");
508   TestQuoteMeta("1.5-2.0?");
509   TestQuoteMeta("\\d");
510   TestQuoteMeta("Who doesn't like ice cream?");
511   TestQuoteMeta("((a|b)c?d*e+[f-h]i)");
512   TestQuoteMeta("((?!)xxx).*yyy");
513   TestQuoteMeta("([");
514   TestQuoteMeta(string("foo\0bar", 7));
515 }
516
517 static void TestQuoteMetaSimpleNegative() {
518   NegativeTestQuoteMeta("foo", "bar");
519   NegativeTestQuoteMeta("...", "bar");
520   NegativeTestQuoteMeta("\\.", ".");
521   NegativeTestQuoteMeta("\\.", "..");
522   NegativeTestQuoteMeta("(a)", "a");
523   NegativeTestQuoteMeta("(a|b)", "a");
524   NegativeTestQuoteMeta("(a|b)", "(a)");
525   NegativeTestQuoteMeta("(a|b)", "a|b");
526   NegativeTestQuoteMeta("[0-9]", "0");
527   NegativeTestQuoteMeta("[0-9]", "0-9");
528   NegativeTestQuoteMeta("[0-9]", "[9]");
529   NegativeTestQuoteMeta("((?!)xxx)", "xxx");
530 }
531
532 static void TestQuoteMetaLatin1() {
533   TestQuoteMeta("3\xb2 = 9");
534 }
535
536 static void TestQuoteMetaUtf8() {
537 #ifdef SUPPORT_UTF8
538   TestQuoteMeta("Pl\xc3\xa1\x63ido Domingo", pcrecpp::UTF8());
539   TestQuoteMeta("xyz", pcrecpp::UTF8());            // No fancy utf8
540   TestQuoteMeta("\xc2\xb0", pcrecpp::UTF8());       // 2-byte utf8 (degree symbol)
541   TestQuoteMeta("27\xc2\xb0 degrees", pcrecpp::UTF8());  // As a middle character
542   TestQuoteMeta("\xe2\x80\xb3", pcrecpp::UTF8());   // 3-byte utf8 (double prime)
543   TestQuoteMeta("\xf0\x9d\x85\x9f", pcrecpp::UTF8()); // 4-byte utf8 (music note)
544   TestQuoteMeta("27\xc2\xb0"); // Interpreted as Latin-1, but should still work
545   NegativeTestQuoteMeta("27\xc2\xb0",               // 2-byte utf (degree symbol)
546                         "27\\\xc2\\\xb0",
547                         pcrecpp::UTF8());
548 #endif
549 }
550
551 static void TestQuoteMetaAll() {
552   printf("Testing QuoteMeta\n");
553   TestQuotaMetaSimple();
554   TestQuoteMetaSimpleNegative();
555   TestQuoteMetaLatin1();
556   TestQuoteMetaUtf8();
557 }
558
559 //
560 // Options tests contributed by
561 // Giuseppe Maxia, CTO, Stardata s.r.l.
562 // July 2005
563 //
564 static void GetOneOptionResult(
565                 const char *option_name,
566                 const char *regex,
567                 const char *str,
568                 RE_Options options,
569                 bool full,
570                 string expected) {
571
572   printf("Testing Option <%s>\n", option_name);
573   if(VERBOSE_TEST)
574     printf("/%s/ finds \"%s\" within \"%s\" \n",
575                     regex,
576                     expected.c_str(),
577                     str);
578   string captured("");
579   if (full)
580     RE(regex,options).FullMatch(str, &captured);
581   else
582     RE(regex,options).PartialMatch(str, &captured);
583   CHECK_EQ(captured, expected);
584 }
585
586 static void TestOneOption(
587                 const char *option_name,
588                 const char *regex,
589                 const char *str,
590                 RE_Options options,
591                 bool full,
592                 bool assertive = true) {
593
594   printf("Testing Option <%s>\n", option_name);
595   if (VERBOSE_TEST)
596     printf("'%s' %s /%s/ \n",
597                   str,
598                   (assertive? "matches" : "doesn't match"),
599                   regex);
600   if (assertive) {
601     if (full)
602       CHECK(RE(regex,options).FullMatch(str));
603     else
604       CHECK(RE(regex,options).PartialMatch(str));
605   } else {
606     if (full)
607       CHECK(!RE(regex,options).FullMatch(str));
608     else
609       CHECK(!RE(regex,options).PartialMatch(str));
610   }
611 }
612
613 static void Test_CASELESS() {
614   RE_Options options;
615   RE_Options options2;
616
617   options.set_caseless(true);
618   TestOneOption("CASELESS (class)",  "HELLO",    "hello", options, false);
619   TestOneOption("CASELESS (class2)", "HELLO",    "hello", options2.set_caseless(true), false);
620   TestOneOption("CASELESS (class)",  "^[A-Z]+$", "Hello", options, false);
621
622   TestOneOption("CASELESS (function)", "HELLO",    "hello", pcrecpp::CASELESS(), false);
623   TestOneOption("CASELESS (function)", "^[A-Z]+$", "Hello", pcrecpp::CASELESS(), false);
624   options.set_caseless(false);
625   TestOneOption("no CASELESS", "HELLO",    "hello", options, false, false);
626 }
627
628 static void Test_MULTILINE() {
629   RE_Options options;
630   RE_Options options2;
631   const char *str = "HELLO\n" "cruel\n" "world\n";
632
633   options.set_multiline(true);
634   TestOneOption("MULTILINE (class)",    "^cruel$", str, options, false);
635   TestOneOption("MULTILINE (class2)",   "^cruel$", str, options2.set_multiline(true), false);
636   TestOneOption("MULTILINE (function)", "^cruel$", str, pcrecpp::MULTILINE(), false);
637   options.set_multiline(false);
638   TestOneOption("no MULTILINE", "^cruel$", str, options, false, false);
639 }
640
641 static void Test_DOTALL() {
642   RE_Options options;
643   RE_Options options2;
644   const char *str = "HELLO\n" "cruel\n" "world";
645
646   options.set_dotall(true);
647   TestOneOption("DOTALL (class)",    "HELLO.*world", str, options, true);
648   TestOneOption("DOTALL (class2)",   "HELLO.*world", str, options2.set_dotall(true), true);
649   TestOneOption("DOTALL (function)",    "HELLO.*world", str, pcrecpp::DOTALL(), true);
650   options.set_dotall(false);
651   TestOneOption("no DOTALL", "HELLO.*world", str, options, true, false);
652 }
653
654 static void Test_DOLLAR_ENDONLY() {
655   RE_Options options;
656   RE_Options options2;
657   const char *str = "HELLO world\n";
658
659   TestOneOption("no DOLLAR_ENDONLY", "world$", str, options, false);
660   options.set_dollar_endonly(true);
661   TestOneOption("DOLLAR_ENDONLY 1",    "world$", str, options, false, false);
662   TestOneOption("DOLLAR_ENDONLY 2",    "world$", str, options2.set_dollar_endonly(true), false, false);
663 }
664
665 static void Test_EXTRA() {
666   RE_Options options;
667   const char *str = "HELLO";
668
669   options.set_extra(true);
670   TestOneOption("EXTRA 1", "\\HELL\\O", str, options, true, false );
671   TestOneOption("EXTRA 2", "\\HELL\\O", str, RE_Options().set_extra(true), true, false );
672   options.set_extra(false);
673   TestOneOption("no EXTRA", "\\HELL\\O", str, options, true );
674 }
675
676 static void Test_EXTENDED() {
677   RE_Options options;
678   RE_Options options2;
679   const char *str = "HELLO world";
680
681   options.set_extended(true);
682   TestOneOption("EXTENDED (class)",    "HELLO world", str, options, false, false);
683   TestOneOption("EXTENDED (class2)",   "HELLO world", str, options2.set_extended(true), false, false);
684   TestOneOption("EXTENDED (class)",
685                     "^ HE L{2} O "
686                     "\\s+        "
687                     "\\w+ $      ",
688                     str,
689                     options,
690                     false);
691
692   TestOneOption("EXTENDED (function)",    "HELLO world", str, pcrecpp::EXTENDED(), false, false);
693   TestOneOption("EXTENDED (function)",
694                     "^ HE L{2} O "
695                     "\\s+        "
696                     "\\w+ $      ",
697                     str,
698                     pcrecpp::EXTENDED(),
699                     false);
700
701   options.set_extended(false);
702   TestOneOption("no EXTENDED", "HELLO world", str, options, false);
703 }
704
705 static void Test_NO_AUTO_CAPTURE() {
706   RE_Options options;
707   const char *str = "HELLO world";
708   string captured;
709
710   printf("Testing Option <no NO_AUTO_CAPTURE>\n");
711   if (VERBOSE_TEST)
712     printf("parentheses capture text\n");
713   RE re("(world|universe)$", options);
714   CHECK(re.Extract("\\1", str , &captured));
715   CHECK_EQ(captured, "world");
716   options.set_no_auto_capture(true);
717   printf("testing Option <NO_AUTO_CAPTURE>\n");
718   if (VERBOSE_TEST)
719     printf("parentheses do not capture text\n");
720   re.Extract("\\1",str, &captured );
721   CHECK_EQ(captured, "world");
722 }
723
724 static void Test_UNGREEDY() {
725   RE_Options options;
726   const char *str = "HELLO, 'this' is the 'world'";
727
728   options.set_ungreedy(true);
729   GetOneOptionResult("UNGREEDY 1", "('.*')", str, options, false, "'this'" );
730   GetOneOptionResult("UNGREEDY 2", "('.*')", str, RE_Options().set_ungreedy(true), false, "'this'" );
731   GetOneOptionResult("UNGREEDY", "('.*?')", str, options, false, "'this' is the 'world'" );
732
733   options.set_ungreedy(false);
734   GetOneOptionResult("no UNGREEDY", "('.*')", str, options, false, "'this' is the 'world'" );
735   GetOneOptionResult("no UNGREEDY", "('.*?')", str, options, false, "'this'" );
736 }
737
738 static void Test_all_options() {
739   const char *str = "HELLO\n" "cruel\n" "world";
740   RE_Options options;
741   options.set_all_options(PCRE_CASELESS | PCRE_DOTALL);
742
743   TestOneOption("all_options (CASELESS|DOTALL)", "^hello.*WORLD", str , options, false);
744   options.set_all_options(0);
745   TestOneOption("all_options (0)", "^hello.*WORLD", str , options, false, false);
746   options.set_all_options(PCRE_MULTILINE | PCRE_EXTENDED);
747
748   TestOneOption("all_options (MULTILINE|EXTENDED)", " ^ c r u e l $ ", str, options, false);
749   TestOneOption("all_options (MULTILINE|EXTENDED) with constructor",
750                   " ^ c r u e l $ ",
751                   str,
752                   RE_Options(PCRE_MULTILINE | PCRE_EXTENDED),
753                   false);
754
755   TestOneOption("all_options (MULTILINE|EXTENDED) with concatenation",
756                   " ^ c r u e l $ ",
757                   str,
758                   RE_Options()
759                        .set_multiline(true)
760                        .set_extended(true),
761                   false);
762
763   options.set_all_options(0);
764   TestOneOption("all_options (0)", "^ c r u e l $", str, options, false, false);
765
766 }
767
768 static void TestOptions() {
769   printf("Testing Options\n");
770   Test_CASELESS();
771   Test_MULTILINE();
772   Test_DOTALL();
773   Test_DOLLAR_ENDONLY();
774   Test_EXTENDED();
775   Test_NO_AUTO_CAPTURE();
776   Test_UNGREEDY();
777   Test_EXTRA();
778   Test_all_options();
779 }
780
781 static void TestConstructors() {
782   printf("Testing constructors\n");
783
784   RE_Options options;
785   options.set_dotall(true);
786   const char *str = "HELLO\n" "cruel\n" "world";
787
788   RE orig("HELLO.*world", options);
789   CHECK(orig.FullMatch(str));
790
791   RE copy1(orig);
792   CHECK(copy1.FullMatch(str));
793
794   RE copy2("not a match");
795   CHECK(!copy2.FullMatch(str));
796   copy2 = copy1;
797   CHECK(copy2.FullMatch(str));
798   copy2 = orig;
799   CHECK(copy2.FullMatch(str));
800
801   // Make sure when we assign to ourselves, nothing bad happens
802   orig = orig;
803   copy1 = copy1;
804   copy2 = copy2;
805   CHECK(orig.FullMatch(str));
806   CHECK(copy1.FullMatch(str));
807   CHECK(copy2.FullMatch(str));
808 }
809
810 int main(int argc, char** argv) {
811   // Treat any flag as --help
812   if (argc > 1 && argv[1][0] == '-') {
813     printf("Usage: %s [timing1|timing2|timing3 num-iters]\n"
814            "       If 'timingX ###' is specified, run the given timing test\n"
815            "       with the given number of iterations, rather than running\n"
816            "       the default corectness test.\n", argv[0]);
817     return 0;
818   }
819
820   if (argc > 1) {
821     if ( argc == 2 || atoi(argv[2]) == 0) {
822       printf("timing mode needs a num-iters argument\n");
823       return 1;
824     }
825     if (!strcmp(argv[1], "timing1"))
826       Timing1(atoi(argv[2]));
827     else if (!strcmp(argv[1], "timing2"))
828       Timing2(atoi(argv[2]));
829     else if (!strcmp(argv[1], "timing3"))
830       Timing3(atoi(argv[2]));
831     else
832       printf("Unknown argument '%s'\n", argv[1]);
833     return 0;
834   }
835
836   printf("PCRE C++ wrapper tests\n");
837   printf("Testing FullMatch\n");
838
839   int i;
840   string s;
841
842   /***** FullMatch with no args *****/
843
844   CHECK(RE("h.*o").FullMatch("hello"));
845   CHECK(!RE("h.*o").FullMatch("othello"));     // Must be anchored at front
846   CHECK(!RE("h.*o").FullMatch("hello!"));      // Must be anchored at end
847   CHECK(RE("a*").FullMatch("aaaa"));           // Fullmatch with normal op
848   CHECK(RE("a*?").FullMatch("aaaa"));          // Fullmatch with nongreedy op
849   CHECK(RE("a*?\\z").FullMatch("aaaa"));       // Two unusual ops
850
851   /***** FullMatch with args *****/
852
853   // Zero-arg
854   CHECK(RE("\\d+").FullMatch("1001"));
855
856   // Single-arg
857   CHECK(RE("(\\d+)").FullMatch("1001",   &i));
858   CHECK_EQ(i, 1001);
859   CHECK(RE("(-?\\d+)").FullMatch("-123", &i));
860   CHECK_EQ(i, -123);
861   CHECK(!RE("()\\d+").FullMatch("10", &i));
862   CHECK(!RE("(\\d+)").FullMatch("1234567890123456789012345678901234567890",
863                                 &i));
864
865   // Digits surrounding integer-arg
866   CHECK(RE("1(\\d*)4").FullMatch("1234", &i));
867   CHECK_EQ(i, 23);
868   CHECK(RE("(\\d)\\d+").FullMatch("1234", &i));
869   CHECK_EQ(i, 1);
870   CHECK(RE("(-\\d)\\d+").FullMatch("-1234", &i));
871   CHECK_EQ(i, -1);
872   CHECK(RE("(\\d)").PartialMatch("1234", &i));
873   CHECK_EQ(i, 1);
874   CHECK(RE("(-\\d)").PartialMatch("-1234", &i));
875   CHECK_EQ(i, -1);
876
877   // String-arg
878   CHECK(RE("h(.*)o").FullMatch("hello", &s));
879   CHECK_EQ(s, string("ell"));
880
881   // StringPiece-arg
882   StringPiece sp;
883   CHECK(RE("(\\w+):(\\d+)").FullMatch("ruby:1234", &sp, &i));
884   CHECK_EQ(sp.size(), 4);
885   CHECK(memcmp(sp.data(), "ruby", 4) == 0);
886   CHECK_EQ(i, 1234);
887
888   // Multi-arg
889   CHECK(RE("(\\w+):(\\d+)").FullMatch("ruby:1234", &s, &i));
890   CHECK_EQ(s, string("ruby"));
891   CHECK_EQ(i, 1234);
892
893   // Ignore non-void* NULL arg
894   CHECK(RE("he(.*)lo").FullMatch("hello", (char*)NULL));
895   CHECK(RE("h(.*)o").FullMatch("hello", (string*)NULL));
896   CHECK(RE("h(.*)o").FullMatch("hello", (StringPiece*)NULL));
897   CHECK(RE("(.*)").FullMatch("1234", (int*)NULL));
898 #ifdef HAVE_LONG_LONG
899   CHECK(RE("(.*)").FullMatch("1234567890123456", (long long*)NULL));
900 #endif
901   CHECK(RE("(.*)").FullMatch("123.4567890123456", (double*)NULL));
902   CHECK(RE("(.*)").FullMatch("123.4567890123456", (float*)NULL));
903
904   // Fail on non-void* NULL arg if the match doesn't parse for the given type.
905   CHECK(!RE("h(.*)lo").FullMatch("hello", &s, (char*)NULL));
906   CHECK(!RE("(.*)").FullMatch("hello", (int*)NULL));
907   CHECK(!RE("(.*)").FullMatch("1234567890123456", (int*)NULL));
908   CHECK(!RE("(.*)").FullMatch("hello", (double*)NULL));
909   CHECK(!RE("(.*)").FullMatch("hello", (float*)NULL));
910
911   // Ignored arg
912   CHECK(RE("(\\w+)(:)(\\d+)").FullMatch("ruby:1234", &s, (void*)NULL, &i));
913   CHECK_EQ(s, string("ruby"));
914   CHECK_EQ(i, 1234);
915
916   // Type tests
917   {
918     char c;
919     CHECK(RE("(H)ello").FullMatch("Hello", &c));
920     CHECK_EQ(c, 'H');
921   }
922   {
923     unsigned char c;
924     CHECK(RE("(H)ello").FullMatch("Hello", &c));
925     CHECK_EQ(c, static_cast<unsigned char>('H'));
926   }
927   {
928     short v;
929     CHECK(RE("(-?\\d+)").FullMatch("100",     &v));    CHECK_EQ(v, 100);
930     CHECK(RE("(-?\\d+)").FullMatch("-100",    &v));    CHECK_EQ(v, -100);
931     CHECK(RE("(-?\\d+)").FullMatch("32767",   &v));    CHECK_EQ(v, 32767);
932     CHECK(RE("(-?\\d+)").FullMatch("-32768",  &v));    CHECK_EQ(v, -32768);
933     CHECK(!RE("(-?\\d+)").FullMatch("-32769", &v));
934     CHECK(!RE("(-?\\d+)").FullMatch("32768",  &v));
935   }
936   {
937     unsigned short v;
938     CHECK(RE("(\\d+)").FullMatch("100",     &v));    CHECK_EQ(v, 100);
939     CHECK(RE("(\\d+)").FullMatch("32767",   &v));    CHECK_EQ(v, 32767);
940     CHECK(RE("(\\d+)").FullMatch("65535",   &v));    CHECK_EQ(v, 65535);
941     CHECK(!RE("(\\d+)").FullMatch("65536",  &v));
942   }
943   {
944     int v;
945     static const int max_value = 0x7fffffff;
946     static const int min_value = -max_value - 1;
947     CHECK(RE("(-?\\d+)").FullMatch("100",         &v)); CHECK_EQ(v, 100);
948     CHECK(RE("(-?\\d+)").FullMatch("-100",        &v)); CHECK_EQ(v, -100);
949     CHECK(RE("(-?\\d+)").FullMatch("2147483647",  &v)); CHECK_EQ(v, max_value);
950     CHECK(RE("(-?\\d+)").FullMatch("-2147483648", &v)); CHECK_EQ(v, min_value);
951     CHECK(!RE("(-?\\d+)").FullMatch("-2147483649", &v));
952     CHECK(!RE("(-?\\d+)").FullMatch("2147483648",  &v));
953   }
954   {
955     unsigned int v;
956     static const unsigned int max_value = 0xfffffffful;
957     CHECK(RE("(\\d+)").FullMatch("100",         &v)); CHECK_EQ(v, 100);
958     CHECK(RE("(\\d+)").FullMatch("4294967295",  &v)); CHECK_EQ(v, max_value);
959     CHECK(!RE("(\\d+)").FullMatch("4294967296", &v));
960   }
961 #ifdef HAVE_LONG_LONG
962 # if defined(__MINGW__) || defined(__MINGW32__)
963 #   define LLD "%I64d"
964 #   define LLU "%I64u"
965 # else
966 #   define LLD "%lld"
967 #   define LLU "%llu"
968 # endif
969   {
970     long long v;
971     static const long long max_value = 0x7fffffffffffffffLL;
972     static const long long min_value = -max_value - 1;
973     char buf[32];  // definitely big enough for a long long
974
975     CHECK(RE("(-?\\d+)").FullMatch("100", &v)); CHECK_EQ(v, 100);
976     CHECK(RE("(-?\\d+)").FullMatch("-100",&v)); CHECK_EQ(v, -100);
977
978     sprintf(buf, LLD, max_value);
979     CHECK(RE("(-?\\d+)").FullMatch(buf,&v)); CHECK_EQ(v, max_value);
980
981     sprintf(buf, LLD, min_value);
982     CHECK(RE("(-?\\d+)").FullMatch(buf,&v)); CHECK_EQ(v, min_value);
983
984     sprintf(buf, LLD, max_value);
985     assert(buf[strlen(buf)-1] != '9');
986     buf[strlen(buf)-1]++;
987     CHECK(!RE("(-?\\d+)").FullMatch(buf, &v));
988
989     sprintf(buf, LLD, min_value);
990     assert(buf[strlen(buf)-1] != '9');
991     buf[strlen(buf)-1]++;
992     CHECK(!RE("(-?\\d+)").FullMatch(buf, &v));
993   }
994 #endif
995 #if defined HAVE_UNSIGNED_LONG_LONG && defined HAVE_LONG_LONG
996   {
997     unsigned long long v;
998     long long v2;
999     static const unsigned long long max_value = 0xffffffffffffffffULL;
1000     char buf[32];  // definitely big enough for a unsigned long long
1001
1002     CHECK(RE("(-?\\d+)").FullMatch("100",&v)); CHECK_EQ(v, 100);
1003     CHECK(RE("(-?\\d+)").FullMatch("-100",&v2)); CHECK_EQ(v2, -100);
1004
1005     sprintf(buf, LLU, max_value);
1006     CHECK(RE("(-?\\d+)").FullMatch(buf,&v)); CHECK_EQ(v, max_value);
1007
1008     assert(buf[strlen(buf)-1] != '9');
1009     buf[strlen(buf)-1]++;
1010     CHECK(!RE("(-?\\d+)").FullMatch(buf, &v));
1011   }
1012 #endif
1013   {
1014     float v;
1015     CHECK(RE("(.*)").FullMatch("100", &v));
1016     CHECK(RE("(.*)").FullMatch("-100.", &v));
1017     CHECK(RE("(.*)").FullMatch("1e23", &v));
1018   }
1019   {
1020     double v;
1021     CHECK(RE("(.*)").FullMatch("100", &v));
1022     CHECK(RE("(.*)").FullMatch("-100.", &v));
1023     CHECK(RE("(.*)").FullMatch("1e23", &v));
1024   }
1025
1026   // Check that matching is fully anchored
1027   CHECK(!RE("(\\d+)").FullMatch("x1001",  &i));
1028   CHECK(!RE("(\\d+)").FullMatch("1001x",  &i));
1029   CHECK(RE("x(\\d+)").FullMatch("x1001", &i)); CHECK_EQ(i, 1001);
1030   CHECK(RE("(\\d+)x").FullMatch("1001x", &i)); CHECK_EQ(i, 1001);
1031
1032   // Braces
1033   CHECK(RE("[0-9a-f+.-]{5,}").FullMatch("0abcd"));
1034   CHECK(RE("[0-9a-f+.-]{5,}").FullMatch("0abcde"));
1035   CHECK(!RE("[0-9a-f+.-]{5,}").FullMatch("0abc"));
1036
1037   // Complicated RE
1038   CHECK(RE("foo|bar|[A-Z]").FullMatch("foo"));
1039   CHECK(RE("foo|bar|[A-Z]").FullMatch("bar"));
1040   CHECK(RE("foo|bar|[A-Z]").FullMatch("X"));
1041   CHECK(!RE("foo|bar|[A-Z]").FullMatch("XY"));
1042
1043   // Check full-match handling (needs '$' tacked on internally)
1044   CHECK(RE("fo|foo").FullMatch("fo"));
1045   CHECK(RE("fo|foo").FullMatch("foo"));
1046   CHECK(RE("fo|foo$").FullMatch("fo"));
1047   CHECK(RE("fo|foo$").FullMatch("foo"));
1048   CHECK(RE("foo$").FullMatch("foo"));
1049   CHECK(!RE("foo\\$").FullMatch("foo$bar"));
1050   CHECK(!RE("fo|bar").FullMatch("fox"));
1051
1052   // Uncomment the following if we change the handling of '$' to
1053   // prevent it from matching a trailing newline
1054   if (false) {
1055     // Check that we don't get bitten by pcre's special handling of a
1056     // '\n' at the end of the string matching '$'
1057     CHECK(!RE("foo$").PartialMatch("foo\n"));
1058   }
1059
1060   // Number of args
1061   int a[16];
1062   CHECK(RE("").FullMatch(""));
1063
1064   memset(a, 0, sizeof(0));
1065   CHECK(RE("(\\d){1}").FullMatch("1",
1066                                  &a[0]));
1067   CHECK_EQ(a[0], 1);
1068
1069   memset(a, 0, sizeof(0));
1070   CHECK(RE("(\\d)(\\d)").FullMatch("12",
1071                                    &a[0],  &a[1]));
1072   CHECK_EQ(a[0], 1);
1073   CHECK_EQ(a[1], 2);
1074
1075   memset(a, 0, sizeof(0));
1076   CHECK(RE("(\\d)(\\d)(\\d)").FullMatch("123",
1077                                         &a[0],  &a[1],  &a[2]));
1078   CHECK_EQ(a[0], 1);
1079   CHECK_EQ(a[1], 2);
1080   CHECK_EQ(a[2], 3);
1081
1082   memset(a, 0, sizeof(0));
1083   CHECK(RE("(\\d)(\\d)(\\d)(\\d)").FullMatch("1234",
1084                                              &a[0],  &a[1],  &a[2],  &a[3]));
1085   CHECK_EQ(a[0], 1);
1086   CHECK_EQ(a[1], 2);
1087   CHECK_EQ(a[2], 3);
1088   CHECK_EQ(a[3], 4);
1089
1090   memset(a, 0, sizeof(0));
1091   CHECK(RE("(\\d)(\\d)(\\d)(\\d)(\\d)").FullMatch("12345",
1092                                                   &a[0],  &a[1],  &a[2],
1093                                                   &a[3],  &a[4]));
1094   CHECK_EQ(a[0], 1);
1095   CHECK_EQ(a[1], 2);
1096   CHECK_EQ(a[2], 3);
1097   CHECK_EQ(a[3], 4);
1098   CHECK_EQ(a[4], 5);
1099
1100   memset(a, 0, sizeof(0));
1101   CHECK(RE("(\\d)(\\d)(\\d)(\\d)(\\d)(\\d)").FullMatch("123456",
1102                                                        &a[0],  &a[1],  &a[2],
1103                                                        &a[3],  &a[4],  &a[5]));
1104   CHECK_EQ(a[0], 1);
1105   CHECK_EQ(a[1], 2);
1106   CHECK_EQ(a[2], 3);
1107   CHECK_EQ(a[3], 4);
1108   CHECK_EQ(a[4], 5);
1109   CHECK_EQ(a[5], 6);
1110
1111   memset(a, 0, sizeof(0));
1112   CHECK(RE("(\\d)(\\d)(\\d)(\\d)(\\d)(\\d)(\\d)").FullMatch("1234567",
1113                                                             &a[0],  &a[1],  &a[2],  &a[3],
1114                                                             &a[4],  &a[5],  &a[6]));
1115   CHECK_EQ(a[0], 1);
1116   CHECK_EQ(a[1], 2);
1117   CHECK_EQ(a[2], 3);
1118   CHECK_EQ(a[3], 4);
1119   CHECK_EQ(a[4], 5);
1120   CHECK_EQ(a[5], 6);
1121   CHECK_EQ(a[6], 7);
1122
1123   memset(a, 0, sizeof(0));
1124   CHECK(RE("(\\d)(\\d)(\\d)(\\d)(\\d)(\\d)(\\d)(\\d)"
1125            "(\\d)(\\d)(\\d)(\\d)(\\d)(\\d)(\\d)(\\d)").FullMatch(
1126                "1234567890123456",
1127                &a[0],  &a[1],  &a[2],  &a[3],
1128                &a[4],  &a[5],  &a[6],  &a[7],
1129                &a[8],  &a[9],  &a[10], &a[11],
1130                &a[12], &a[13], &a[14], &a[15]));
1131   CHECK_EQ(a[0], 1);
1132   CHECK_EQ(a[1], 2);
1133   CHECK_EQ(a[2], 3);
1134   CHECK_EQ(a[3], 4);
1135   CHECK_EQ(a[4], 5);
1136   CHECK_EQ(a[5], 6);
1137   CHECK_EQ(a[6], 7);
1138   CHECK_EQ(a[7], 8);
1139   CHECK_EQ(a[8], 9);
1140   CHECK_EQ(a[9], 0);
1141   CHECK_EQ(a[10], 1);
1142   CHECK_EQ(a[11], 2);
1143   CHECK_EQ(a[12], 3);
1144   CHECK_EQ(a[13], 4);
1145   CHECK_EQ(a[14], 5);
1146   CHECK_EQ(a[15], 6);
1147
1148   /***** PartialMatch *****/
1149
1150   printf("Testing PartialMatch\n");
1151
1152   CHECK(RE("h.*o").PartialMatch("hello"));
1153   CHECK(RE("h.*o").PartialMatch("othello"));
1154   CHECK(RE("h.*o").PartialMatch("hello!"));
1155   CHECK(RE("((((((((((((((((((((x))))))))))))))))))))").PartialMatch("x"));
1156
1157   /***** other tests *****/
1158
1159   RadixTests();
1160   TestReplace();
1161   TestExtract();
1162   TestConsume();
1163   TestFindAndConsume();
1164   TestQuoteMetaAll();
1165   TestMatchNumberPeculiarity();
1166
1167   // Check the pattern() accessor
1168   {
1169     const string kPattern = "http://([^/]+)/.*";
1170     const RE re(kPattern);
1171     CHECK_EQ(kPattern, re.pattern());
1172   }
1173
1174   // Check RE error field.
1175   {
1176     RE re("foo");
1177     CHECK(re.error().empty());  // Must have no error
1178   }
1179
1180 #ifdef SUPPORT_UTF8
1181   // Check UTF-8 handling
1182   {
1183     printf("Testing UTF-8 handling\n");
1184
1185     // Three Japanese characters (nihongo)
1186     const unsigned char utf8_string[] = {
1187          0xe6, 0x97, 0xa5, // 65e5
1188          0xe6, 0x9c, 0xac, // 627c
1189          0xe8, 0xaa, 0x9e, // 8a9e
1190          0
1191     };
1192     const unsigned char utf8_pattern[] = {
1193          '.',
1194          0xe6, 0x9c, 0xac, // 627c
1195          '.',
1196          0
1197     };
1198
1199     // Both should match in either mode, bytes or UTF-8
1200     RE re_test1(".........");
1201     CHECK(re_test1.FullMatch(utf8_string));
1202     RE re_test2("...", pcrecpp::UTF8());
1203     CHECK(re_test2.FullMatch(utf8_string));
1204
1205     // Check that '.' matches one byte or UTF-8 character
1206     // according to the mode.
1207     string ss;
1208     RE re_test3("(.)");
1209     CHECK(re_test3.PartialMatch(utf8_string, &ss));
1210     CHECK_EQ(ss, string("\xe6"));
1211     RE re_test4("(.)", pcrecpp::UTF8());
1212     CHECK(re_test4.PartialMatch(utf8_string, &ss));
1213     CHECK_EQ(ss, string("\xe6\x97\xa5"));
1214
1215     // Check that string matches itself in either mode
1216     RE re_test5(utf8_string);
1217     CHECK(re_test5.FullMatch(utf8_string));
1218     RE re_test6(utf8_string, pcrecpp::UTF8());
1219     CHECK(re_test6.FullMatch(utf8_string));
1220
1221     // Check that pattern matches string only in UTF8 mode
1222     RE re_test7(utf8_pattern);
1223     CHECK(!re_test7.FullMatch(utf8_string));
1224     RE re_test8(utf8_pattern, pcrecpp::UTF8());
1225     CHECK(re_test8.FullMatch(utf8_string));
1226   }
1227
1228   // Check that ungreedy, UTF8 regular expressions don't match when they
1229   // oughtn't -- see bug 82246.
1230   {
1231     // This code always worked.
1232     const char* pattern = "\\w+X";
1233     const string target = "a aX";
1234     RE match_sentence(pattern);
1235     RE match_sentence_re(pattern, pcrecpp::UTF8());
1236
1237     CHECK(!match_sentence.FullMatch(target));
1238     CHECK(!match_sentence_re.FullMatch(target));
1239   }
1240
1241   {
1242     const char* pattern = "(?U)\\w+X";
1243     const string target = "a aX";
1244     RE match_sentence(pattern);
1245     RE match_sentence_re(pattern, pcrecpp::UTF8());
1246
1247     CHECK(!match_sentence.FullMatch(target));
1248     CHECK(!match_sentence_re.FullMatch(target));
1249   }
1250 #endif  /* def SUPPORT_UTF8 */
1251
1252   printf("Testing error reporting\n");
1253
1254   { RE re("a\\1"); CHECK(!re.error().empty()); }
1255   {
1256     RE re("a[x");
1257     CHECK(!re.error().empty());
1258   }
1259   {
1260     RE re("a[z-a]");
1261     CHECK(!re.error().empty());
1262   }
1263   {
1264     RE re("a[[:foobar:]]");
1265     CHECK(!re.error().empty());
1266   }
1267   {
1268     RE re("a(b");
1269     CHECK(!re.error().empty());
1270   }
1271   {
1272     RE re("a\\");
1273     CHECK(!re.error().empty());
1274   }
1275
1276   // Test that recursion is stopped
1277   TestRecursion();
1278
1279   // Test Options
1280   if (getenv("VERBOSE_TEST") != NULL)
1281     VERBOSE_TEST  = true;
1282   TestOptions();
1283
1284   // Test the constructors
1285   TestConstructors();
1286
1287   // Done
1288   printf("OK\n");
1289
1290   return 0;
1291 }