Annotation of embedaddon/pcre/pcrecpp_unittest.cc, revision 1.1
1.1 ! misho 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: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to pcrecpp_unittest.cc CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / pcre