ceph/src/rapidjson/test/unittest/regextest.cpp

   1 // Tencent is pleased to support the open source community by making RapidJSON available.
   2 //
   3 // Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
   4 //
   5 // Licensed under the MIT License (the "License"); you may not use this file except
   6 // in compliance with the License. You may obtain a copy of the License at
   7 //
   8 // http://opensource.org/licenses/MIT
   9 //
  10 // Unless required by applicable law or agreed to in writing, software distributed
  11 // under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
  12 // CONDITIONS OF ANY KIND, either express or implied. See the License for the
  13 // specific language governing permissions and limitations under the License.
  14
  15 #include "unittest.h"
  16 #include "rapidjson/internal/regex.h"
  17
  18 using namespace rapidjson::internal;
  19
  20 TEST(Regex, Single) {
  21     Regex re("a");
  22     ASSERT_TRUE(re.IsValid());
  23     EXPECT_TRUE(re.Match("a"));
  24     EXPECT_FALSE(re.Match(""));
  25     EXPECT_FALSE(re.Match("b"));
  26 }
  27
  28 TEST(Regex, Concatenation) {
  29     Regex re("abc");
  30     ASSERT_TRUE(re.IsValid());
  31     EXPECT_TRUE(re.Match("abc"));
  32     EXPECT_FALSE(re.Match(""));
  33     EXPECT_FALSE(re.Match("a"));
  34     EXPECT_FALSE(re.Match("b"));
  35     EXPECT_FALSE(re.Match("ab"));
  36     EXPECT_FALSE(re.Match("abcd"));
  37 }
  38
  39 TEST(Regex, Alternation1) {
  40     Regex re("abab|abbb");
  41     ASSERT_TRUE(re.IsValid());
  42     EXPECT_TRUE(re.Match("abab"));
  43     EXPECT_TRUE(re.Match("abbb"));
  44     EXPECT_FALSE(re.Match(""));
  45     EXPECT_FALSE(re.Match("ab"));
  46     EXPECT_FALSE(re.Match("ababa"));
  47     EXPECT_FALSE(re.Match("abb"));
  48     EXPECT_FALSE(re.Match("abbbb"));
  49 }
  50
  51 TEST(Regex, Alternation2) {
  52     Regex re("a|b|c");
  53     ASSERT_TRUE(re.IsValid());
  54     EXPECT_TRUE(re.Match("a"));
  55     EXPECT_TRUE(re.Match("b"));
  56     EXPECT_TRUE(re.Match("c"));
  57     EXPECT_FALSE(re.Match(""));
  58     EXPECT_FALSE(re.Match("aa"));
  59     EXPECT_FALSE(re.Match("ab"));
  60 }
  61
  62 TEST(Regex, Parenthesis1) {
  63     Regex re("(ab)c");
  64     ASSERT_TRUE(re.IsValid());
  65     EXPECT_TRUE(re.Match("abc"));
  66     EXPECT_FALSE(re.Match(""));
  67     EXPECT_FALSE(re.Match("a"));
  68     EXPECT_FALSE(re.Match("b"));
  69     EXPECT_FALSE(re.Match("ab"));
  70     EXPECT_FALSE(re.Match("abcd"));
  71 }
  72
  73 TEST(Regex, Parenthesis2) {
  74     Regex re("a(bc)");
  75     ASSERT_TRUE(re.IsValid());
  76     EXPECT_TRUE(re.Match("abc"));
  77     EXPECT_FALSE(re.Match(""));
  78     EXPECT_FALSE(re.Match("a"));
  79     EXPECT_FALSE(re.Match("b"));
  80     EXPECT_FALSE(re.Match("ab"));
  81     EXPECT_FALSE(re.Match("abcd"));
  82 }
  83
  84 TEST(Regex, Parenthesis3) {
  85     Regex re("(a|b)(c|d)");
  86     ASSERT_TRUE(re.IsValid());
  87     EXPECT_TRUE(re.Match("ac"));
  88     EXPECT_TRUE(re.Match("ad"));
  89     EXPECT_TRUE(re.Match("bc"));
  90     EXPECT_TRUE(re.Match("bd"));
  91     EXPECT_FALSE(re.Match(""));
  92     EXPECT_FALSE(re.Match("ab"));
  93     EXPECT_FALSE(re.Match("cd"));
  94 }
  95
  96 TEST(Regex, ZeroOrOne1) {
  97     Regex re("a?");
  98     ASSERT_TRUE(re.IsValid());
  99     EXPECT_TRUE(re.Match(""));
 100     EXPECT_TRUE(re.Match("a"));
 101     EXPECT_FALSE(re.Match("aa"));
 102 }
 103
 104 TEST(Regex, ZeroOrOne2) {
 105     Regex re("a?b");
 106     ASSERT_TRUE(re.IsValid());
 107     EXPECT_TRUE(re.Match("b"));
 108     EXPECT_TRUE(re.Match("ab"));
 109     EXPECT_FALSE(re.Match("a"));
 110     EXPECT_FALSE(re.Match("aa"));
 111     EXPECT_FALSE(re.Match("bb"));
 112     EXPECT_FALSE(re.Match("ba"));
 113 }
 114
 115 TEST(Regex, ZeroOrOne3) {
 116     Regex re("ab?");
 117     ASSERT_TRUE(re.IsValid());
 118     EXPECT_TRUE(re.Match("a"));
 119     EXPECT_TRUE(re.Match("ab"));
 120     EXPECT_FALSE(re.Match("b"));
 121     EXPECT_FALSE(re.Match("aa"));
 122     EXPECT_FALSE(re.Match("bb"));
 123     EXPECT_FALSE(re.Match("ba"));
 124 }
 125
 126 TEST(Regex, ZeroOrOne4) {
 127     Regex re("a?b?");
 128     ASSERT_TRUE(re.IsValid());
 129     EXPECT_TRUE(re.Match(""));
 130     EXPECT_TRUE(re.Match("a"));
 131     EXPECT_TRUE(re.Match("b"));
 132     EXPECT_TRUE(re.Match("ab"));
 133     EXPECT_FALSE(re.Match("aa"));
 134     EXPECT_FALSE(re.Match("bb"));
 135     EXPECT_FALSE(re.Match("ba"));
 136     EXPECT_FALSE(re.Match("abc"));
 137 }
 138
 139 TEST(Regex, ZeroOrOne5) {
 140     Regex re("a(ab)?b");
 141     ASSERT_TRUE(re.IsValid());
 142     EXPECT_TRUE(re.Match("ab"));
 143     EXPECT_TRUE(re.Match("aabb"));
 144     EXPECT_FALSE(re.Match("aab"));
 145     EXPECT_FALSE(re.Match("abb"));
 146 }
 147
 148 TEST(Regex, ZeroOrMore1) {
 149     Regex re("a*");
 150     ASSERT_TRUE(re.IsValid());
 151     EXPECT_TRUE(re.Match(""));
 152     EXPECT_TRUE(re.Match("a"));
 153     EXPECT_TRUE(re.Match("aa"));
 154     EXPECT_FALSE(re.Match("b"));
 155     EXPECT_FALSE(re.Match("ab"));
 156 }
 157
 158 TEST(Regex, ZeroOrMore2) {
 159     Regex re("a*b");
 160     ASSERT_TRUE(re.IsValid());
 161     EXPECT_TRUE(re.Match("b"));
 162     EXPECT_TRUE(re.Match("ab"));
 163     EXPECT_TRUE(re.Match("aab"));
 164     EXPECT_FALSE(re.Match(""));
 165     EXPECT_FALSE(re.Match("bb"));
 166 }
 167
 168 TEST(Regex, ZeroOrMore3) {
 169     Regex re("a*b*");
 170     ASSERT_TRUE(re.IsValid());
 171     EXPECT_TRUE(re.Match(""));
 172     EXPECT_TRUE(re.Match("a"));
 173     EXPECT_TRUE(re.Match("aa"));
 174     EXPECT_TRUE(re.Match("b"));
 175     EXPECT_TRUE(re.Match("bb"));
 176     EXPECT_TRUE(re.Match("ab"));
 177     EXPECT_TRUE(re.Match("aabb"));
 178     EXPECT_FALSE(re.Match("ba"));
 179 }
 180
 181 TEST(Regex, ZeroOrMore4) {
 182     Regex re("a(ab)*b");
 183     ASSERT_TRUE(re.IsValid());
 184     EXPECT_TRUE(re.Match("ab"));
 185     EXPECT_TRUE(re.Match("aabb"));
 186     EXPECT_TRUE(re.Match("aababb"));
 187     EXPECT_FALSE(re.Match(""));
 188     EXPECT_FALSE(re.Match("aa"));
 189 }
 190
 191 TEST(Regex, OneOrMore1) {
 192     Regex re("a+");
 193     ASSERT_TRUE(re.IsValid());
 194     EXPECT_TRUE(re.Match("a"));
 195     EXPECT_TRUE(re.Match("aa"));
 196     EXPECT_FALSE(re.Match(""));
 197     EXPECT_FALSE(re.Match("b"));
 198     EXPECT_FALSE(re.Match("ab"));
 199 }
 200
 201 TEST(Regex, OneOrMore2) {
 202     Regex re("a+b");
 203     ASSERT_TRUE(re.IsValid());
 204     EXPECT_TRUE(re.Match("ab"));
 205     EXPECT_TRUE(re.Match("aab"));
 206     EXPECT_FALSE(re.Match(""));
 207     EXPECT_FALSE(re.Match("b"));
 208 }
 209
 210 TEST(Regex, OneOrMore3) {
 211     Regex re("a+b+");
 212     ASSERT_TRUE(re.IsValid());
 213     EXPECT_TRUE(re.Match("ab"));
 214     EXPECT_TRUE(re.Match("aab"));
 215     EXPECT_TRUE(re.Match("abb"));
 216     EXPECT_TRUE(re.Match("aabb"));
 217     EXPECT_FALSE(re.Match(""));
 218     EXPECT_FALSE(re.Match("b"));
 219     EXPECT_FALSE(re.Match("ba"));
 220 }
 221
 222 TEST(Regex, OneOrMore4) {
 223     Regex re("a(ab)+b");
 224     ASSERT_TRUE(re.IsValid());
 225     EXPECT_TRUE(re.Match("aabb"));
 226     EXPECT_TRUE(re.Match("aababb"));
 227     EXPECT_FALSE(re.Match(""));
 228     EXPECT_FALSE(re.Match("ab"));
 229 }
 230
 231 TEST(Regex, QuantifierExact1) {
 232     Regex re("ab{3}c");
 233     ASSERT_TRUE(re.IsValid());
 234     EXPECT_TRUE(re.Match("abbbc"));
 235     EXPECT_FALSE(re.Match("ac"));
 236     EXPECT_FALSE(re.Match("abc"));
 237     EXPECT_FALSE(re.Match("abbc"));
 238     EXPECT_FALSE(re.Match("abbbbc"));
 239 }
 240
 241 TEST(Regex, QuantifierExact2) {
 242     Regex re("a(bc){3}d");
 243     ASSERT_TRUE(re.IsValid());
 244     EXPECT_TRUE(re.Match("abcbcbcd"));
 245     EXPECT_FALSE(re.Match("ad"));
 246     EXPECT_FALSE(re.Match("abcd"));
 247     EXPECT_FALSE(re.Match("abcbcd"));
 248     EXPECT_FALSE(re.Match("abcbcbcbcd"));
 249 }
 250
 251 TEST(Regex, QuantifierExact3) {
 252     Regex re("a(b|c){3}d");
 253     ASSERT_TRUE(re.IsValid());
 254     EXPECT_TRUE(re.Match("abbbd"));
 255     EXPECT_TRUE(re.Match("acccd"));
 256     EXPECT_TRUE(re.Match("abcbd"));
 257     EXPECT_FALSE(re.Match("ad"));
 258     EXPECT_FALSE(re.Match("abbd"));
 259     EXPECT_FALSE(re.Match("accccd"));
 260     EXPECT_FALSE(re.Match("abbbbd"));
 261 }
 262
 263 TEST(Regex, QuantifierMin1) {
 264     Regex re("ab{3,}c");
 265     ASSERT_TRUE(re.IsValid());
 266     EXPECT_TRUE(re.Match("abbbc"));
 267     EXPECT_TRUE(re.Match("abbbbc"));
 268     EXPECT_TRUE(re.Match("abbbbbc"));
 269     EXPECT_FALSE(re.Match("ac"));
 270     EXPECT_FALSE(re.Match("abc"));
 271     EXPECT_FALSE(re.Match("abbc"));
 272 }
 273
 274 TEST(Regex, QuantifierMin2) {
 275     Regex re("a(bc){3,}d");
 276     ASSERT_TRUE(re.IsValid());
 277     EXPECT_TRUE(re.Match("abcbcbcd"));
 278     EXPECT_TRUE(re.Match("abcbcbcbcd"));
 279     EXPECT_FALSE(re.Match("ad"));
 280     EXPECT_FALSE(re.Match("abcd"));
 281     EXPECT_FALSE(re.Match("abcbcd"));
 282 }
 283
 284 TEST(Regex, QuantifierMin3) {
 285     Regex re("a(b|c){3,}d");
 286     ASSERT_TRUE(re.IsValid());
 287     EXPECT_TRUE(re.Match("abbbd"));
 288     EXPECT_TRUE(re.Match("acccd"));
 289     EXPECT_TRUE(re.Match("abcbd"));
 290     EXPECT_TRUE(re.Match("accccd"));
 291     EXPECT_TRUE(re.Match("abbbbd"));
 292     EXPECT_FALSE(re.Match("ad"));
 293     EXPECT_FALSE(re.Match("abbd"));
 294 }
 295
 296 TEST(Regex, QuantifierMinMax1) {
 297     Regex re("ab{3,5}c");
 298     ASSERT_TRUE(re.IsValid());
 299     EXPECT_TRUE(re.Match("abbbc"));
 300     EXPECT_TRUE(re.Match("abbbbc"));
 301     EXPECT_TRUE(re.Match("abbbbbc"));
 302     EXPECT_FALSE(re.Match("ac"));
 303     EXPECT_FALSE(re.Match("abc"));
 304     EXPECT_FALSE(re.Match("abbc"));
 305     EXPECT_FALSE(re.Match("abbbbbbc"));
 306 }
 307
 308 TEST(Regex, QuantifierMinMax2) {
 309     Regex re("a(bc){3,5}d");
 310     ASSERT_TRUE(re.IsValid());
 311     EXPECT_TRUE(re.Match("abcbcbcd"));
 312     EXPECT_TRUE(re.Match("abcbcbcbcd"));
 313     EXPECT_TRUE(re.Match("abcbcbcbcbcd"));
 314     EXPECT_FALSE(re.Match("ad"));
 315     EXPECT_FALSE(re.Match("abcd"));
 316     EXPECT_FALSE(re.Match("abcbcd"));
 317     EXPECT_FALSE(re.Match("abcbcbcbcbcbcd"));
 318 }
 319
 320 TEST(Regex, QuantifierMinMax3) {
 321     Regex re("a(b|c){3,5}d");
 322     ASSERT_TRUE(re.IsValid());
 323     EXPECT_TRUE(re.Match("abbbd"));
 324     EXPECT_TRUE(re.Match("acccd"));
 325     EXPECT_TRUE(re.Match("abcbd"));
 326     EXPECT_TRUE(re.Match("accccd"));
 327     EXPECT_TRUE(re.Match("abbbbd"));
 328     EXPECT_TRUE(re.Match("acccccd"));
 329     EXPECT_TRUE(re.Match("abbbbbd"));
 330     EXPECT_FALSE(re.Match("ad"));
 331     EXPECT_FALSE(re.Match("abbd"));
 332     EXPECT_FALSE(re.Match("accccccd"));
 333     EXPECT_FALSE(re.Match("abbbbbbd"));
 334 }
 335
 336 // Issue538
 337 TEST(Regex, QuantifierMinMax4) {
 338     Regex re("a(b|c){0,3}d");
 339     ASSERT_TRUE(re.IsValid());
 340     EXPECT_TRUE(re.Match("ad"));
 341     EXPECT_TRUE(re.Match("abd"));
 342     EXPECT_TRUE(re.Match("acd"));
 343     EXPECT_TRUE(re.Match("abbd"));
 344     EXPECT_TRUE(re.Match("accd"));
 345     EXPECT_TRUE(re.Match("abcd"));
 346     EXPECT_TRUE(re.Match("abbbd"));
 347     EXPECT_TRUE(re.Match("acccd"));
 348     EXPECT_FALSE(re.Match("abbbbd"));
 349     EXPECT_FALSE(re.Match("add"));
 350     EXPECT_FALSE(re.Match("accccd"));
 351     EXPECT_FALSE(re.Match("abcbcd"));
 352 }
 353
 354 // Issue538
 355 TEST(Regex, QuantifierMinMax5) {
 356     Regex re("a(b|c){0,}d");
 357     ASSERT_TRUE(re.IsValid());
 358     EXPECT_TRUE(re.Match("ad"));
 359     EXPECT_TRUE(re.Match("abd"));
 360     EXPECT_TRUE(re.Match("acd"));
 361     EXPECT_TRUE(re.Match("abbd"));
 362     EXPECT_TRUE(re.Match("accd"));
 363     EXPECT_TRUE(re.Match("abcd"));
 364     EXPECT_TRUE(re.Match("abbbd"));
 365     EXPECT_TRUE(re.Match("acccd"));
 366     EXPECT_TRUE(re.Match("abbbbd"));
 367     EXPECT_TRUE(re.Match("accccd"));
 368     EXPECT_TRUE(re.Match("abcbcd"));
 369     EXPECT_FALSE(re.Match("add"));
 370     EXPECT_FALSE(re.Match("aad"));
 371 }
 372
 373 #define EURO "\xE2\x82\xAC" // "\xE2\x82\xAC" is UTF-8 sequence of Euro sign U+20AC
 374
 375 TEST(Regex, Unicode) {
 376     Regex re("a" EURO "+b");
 377     ASSERT_TRUE(re.IsValid());
 378     EXPECT_TRUE(re.Match("a" EURO "b"));
 379     EXPECT_TRUE(re.Match("a" EURO EURO "b"));
 380     EXPECT_FALSE(re.Match("a?b"));
 381     EXPECT_FALSE(re.Match("a" EURO "\xAC" "b")); // unaware of UTF-8 will match
 382 }
 383
 384 TEST(Regex, AnyCharacter) {
 385     Regex re(".");
 386     ASSERT_TRUE(re.IsValid());
 387     EXPECT_TRUE(re.Match("a"));
 388     EXPECT_TRUE(re.Match("b"));
 389     EXPECT_TRUE(re.Match(EURO));
 390     EXPECT_FALSE(re.Match(""));
 391     EXPECT_FALSE(re.Match("aa"));
 392 }
 393
 394 TEST(Regex, CharacterRange1) {
 395     Regex re("[abc]");
 396     ASSERT_TRUE(re.IsValid());
 397     EXPECT_TRUE(re.Match("a"));
 398     EXPECT_TRUE(re.Match("b"));
 399     EXPECT_TRUE(re.Match("c"));
 400     EXPECT_FALSE(re.Match(""));
 401     EXPECT_FALSE(re.Match("`"));
 402     EXPECT_FALSE(re.Match("d"));
 403     EXPECT_FALSE(re.Match("aa"));
 404 }
 405
 406 TEST(Regex, CharacterRange2) {
 407     Regex re("[^abc]");
 408     ASSERT_TRUE(re.IsValid());
 409     EXPECT_TRUE(re.Match("`"));
 410     EXPECT_TRUE(re.Match("d"));
 411     EXPECT_FALSE(re.Match("a"));
 412     EXPECT_FALSE(re.Match("b"));
 413     EXPECT_FALSE(re.Match("c"));
 414     EXPECT_FALSE(re.Match(""));
 415     EXPECT_FALSE(re.Match("aa"));
 416 }
 417
 418 TEST(Regex, CharacterRange3) {
 419     Regex re("[a-c]");
 420     ASSERT_TRUE(re.IsValid());
 421     EXPECT_TRUE(re.Match("a"));
 422     EXPECT_TRUE(re.Match("b"));
 423     EXPECT_TRUE(re.Match("c"));
 424     EXPECT_FALSE(re.Match(""));
 425     EXPECT_FALSE(re.Match("`"));
 426     EXPECT_FALSE(re.Match("d"));
 427     EXPECT_FALSE(re.Match("aa"));
 428 }
 429
 430 TEST(Regex, CharacterRange4) {
 431     Regex re("[^a-c]");
 432     ASSERT_TRUE(re.IsValid());
 433     EXPECT_TRUE(re.Match("`"));
 434     EXPECT_TRUE(re.Match("d"));
 435     EXPECT_FALSE(re.Match("a"));
 436     EXPECT_FALSE(re.Match("b"));
 437     EXPECT_FALSE(re.Match("c"));
 438     EXPECT_FALSE(re.Match(""));
 439     EXPECT_FALSE(re.Match("aa"));
 440 }
 441
 442 TEST(Regex, CharacterRange5) {
 443     Regex re("[-]");
 444     ASSERT_TRUE(re.IsValid());
 445     EXPECT_TRUE(re.Match("-"));
 446     EXPECT_FALSE(re.Match(""));
 447     EXPECT_FALSE(re.Match("a"));
 448 }
 449
 450 TEST(Regex, CharacterRange6) {
 451     Regex re("[a-]");
 452     ASSERT_TRUE(re.IsValid());
 453     EXPECT_TRUE(re.Match("a"));
 454     EXPECT_TRUE(re.Match("-"));
 455     EXPECT_FALSE(re.Match(""));
 456     EXPECT_FALSE(re.Match("`"));
 457     EXPECT_FALSE(re.Match("b"));
 458 }
 459
 460 TEST(Regex, CharacterRange7) {
 461     Regex re("[-a]");
 462     ASSERT_TRUE(re.IsValid());
 463     EXPECT_TRUE(re.Match("a"));
 464     EXPECT_TRUE(re.Match("-"));
 465     EXPECT_FALSE(re.Match(""));
 466     EXPECT_FALSE(re.Match("`"));
 467     EXPECT_FALSE(re.Match("b"));
 468 }
 469
 470 TEST(Regex, CharacterRange8) {
 471     Regex re("[a-zA-Z0-9]*");
 472     ASSERT_TRUE(re.IsValid());
 473     EXPECT_TRUE(re.Match("Milo"));
 474     EXPECT_TRUE(re.Match("MT19937"));
 475     EXPECT_TRUE(re.Match("43"));
 476     EXPECT_FALSE(re.Match("a_b"));
 477     EXPECT_FALSE(re.Match("!"));
 478 }
 479
 480 TEST(Regex, Search) {
 481     Regex re("abc");
 482     ASSERT_TRUE(re.IsValid());
 483     EXPECT_TRUE(re.Search("abc"));
 484     EXPECT_TRUE(re.Search("_abc"));
 485     EXPECT_TRUE(re.Search("abc_"));
 486     EXPECT_TRUE(re.Search("_abc_"));
 487     EXPECT_TRUE(re.Search("__abc__"));
 488     EXPECT_TRUE(re.Search("abcabc"));
 489     EXPECT_FALSE(re.Search("a"));
 490     EXPECT_FALSE(re.Search("ab"));
 491     EXPECT_FALSE(re.Search("bc"));
 492     EXPECT_FALSE(re.Search("cba"));
 493 }
 494
 495 TEST(Regex, Search_BeginAnchor) {
 496     Regex re("^abc");
 497     ASSERT_TRUE(re.IsValid());
 498     EXPECT_TRUE(re.Search("abc"));
 499     EXPECT_TRUE(re.Search("abc_"));
 500     EXPECT_TRUE(re.Search("abcabc"));
 501     EXPECT_FALSE(re.Search("_abc"));
 502     EXPECT_FALSE(re.Search("_abc_"));
 503     EXPECT_FALSE(re.Search("a"));
 504     EXPECT_FALSE(re.Search("ab"));
 505     EXPECT_FALSE(re.Search("bc"));
 506     EXPECT_FALSE(re.Search("cba"));
 507 }
 508
 509 TEST(Regex, Search_EndAnchor) {
 510     Regex re("abc$");
 511     ASSERT_TRUE(re.IsValid());
 512     EXPECT_TRUE(re.Search("abc"));
 513     EXPECT_TRUE(re.Search("_abc"));
 514     EXPECT_TRUE(re.Search("abcabc"));
 515     EXPECT_FALSE(re.Search("abc_"));
 516     EXPECT_FALSE(re.Search("_abc_"));
 517     EXPECT_FALSE(re.Search("a"));
 518     EXPECT_FALSE(re.Search("ab"));
 519     EXPECT_FALSE(re.Search("bc"));
 520     EXPECT_FALSE(re.Search("cba"));
 521 }
 522
 523 TEST(Regex, Search_BothAnchor) {
 524     Regex re("^abc$");
 525     ASSERT_TRUE(re.IsValid());
 526     EXPECT_TRUE(re.Search("abc"));
 527     EXPECT_FALSE(re.Search(""));
 528     EXPECT_FALSE(re.Search("a"));
 529     EXPECT_FALSE(re.Search("b"));
 530     EXPECT_FALSE(re.Search("ab"));
 531     EXPECT_FALSE(re.Search("abcd"));
 532 }
 533
 534 TEST(Regex, Escape) {
 535     const char* s = "\\^\\$\\|\\(\\)\\?\\*\\+\\.\\[\\]\\{\\}\\\\\\f\\n\\r\\t\\v[\\b][\\[][\\]]";
 536     Regex re(s);
 537     ASSERT_TRUE(re.IsValid());
 538     EXPECT_TRUE(re.Match("^$|()?*+.[]{}\\\x0C\n\r\t\x0B\b[]"));
 539     EXPECT_FALSE(re.Match(s)); // Not escaping
 540 }
 541
 542 TEST(Regex, Invalid) {
 543 #define TEST_INVALID(s) \
 544     {\
 545         Regex re(s);\
 546         EXPECT_FALSE(re.IsValid());\
 547     }
 548
 549     TEST_INVALID("");
 550     TEST_INVALID("a|");
 551     TEST_INVALID("()");
 552     TEST_INVALID(")");
 553     TEST_INVALID("(a))");
 554     TEST_INVALID("(a|)");
 555     TEST_INVALID("(a||b)");
 556     TEST_INVALID("(|b)");
 557     TEST_INVALID("?");
 558     TEST_INVALID("*");
 559     TEST_INVALID("+");
 560     TEST_INVALID("{");
 561     TEST_INVALID("{}");
 562     TEST_INVALID("a{a}");
 563     TEST_INVALID("a{0}");
 564     TEST_INVALID("a{-1}");
 565     TEST_INVALID("a{}");
 566     // TEST_INVALID("a{0,}");   // Support now
 567     TEST_INVALID("a{,0}");
 568     TEST_INVALID("a{1,0}");
 569     TEST_INVALID("a{-1,0}");
 570     TEST_INVALID("a{-1,1}");
 571     TEST_INVALID("a{4294967296}"); // overflow of unsigned
 572     TEST_INVALID("a{1a}");
 573     TEST_INVALID("[");
 574     TEST_INVALID("[]");
 575     TEST_INVALID("[^]");
 576     TEST_INVALID("[\\a]");
 577     TEST_INVALID("\\a");
 578
 579 #undef TEST_INVALID
 580 }
 581
 582 TEST(Regex, Issue538) {
 583     Regex re("^[0-9]+(\\\\.[0-9]+){0,2}");
 584     EXPECT_TRUE(re.IsValid());
 585 }
 586
 587 TEST(Regex, Issue583) {
 588     Regex re("[0-9]{99999}");
 589     ASSERT_TRUE(re.IsValid());
 590 }
 591
 592 #undef EURO