Wire Sysio Wire Sysion 1.0.0
Loading...
Searching...
No Matches
Macros | Functions
regextest.cpp File Reference
#include "unittest.h"
#include "rapidjson/internal/regex.h"
Include dependency graph for regextest.cpp:

Go to the source code of this file.

Macros

#define EURO   "\xE2\x82\xAC"
 
#define TEST_INVALID(s)
 

Functions

 TEST (Regex, Single)
 
 TEST (Regex, Concatenation)
 
 TEST (Regex, Alternation1)
 
 TEST (Regex, Alternation2)
 
 TEST (Regex, Parenthesis1)
 
 TEST (Regex, Parenthesis2)
 
 TEST (Regex, Parenthesis3)
 
 TEST (Regex, ZeroOrOne1)
 
 TEST (Regex, ZeroOrOne2)
 
 TEST (Regex, ZeroOrOne3)
 
 TEST (Regex, ZeroOrOne4)
 
 TEST (Regex, ZeroOrOne5)
 
 TEST (Regex, ZeroOrMore1)
 
 TEST (Regex, ZeroOrMore2)
 
 TEST (Regex, ZeroOrMore3)
 
 TEST (Regex, ZeroOrMore4)
 
 TEST (Regex, OneOrMore1)
 
 TEST (Regex, OneOrMore2)
 
 TEST (Regex, OneOrMore3)
 
 TEST (Regex, OneOrMore4)
 
 TEST (Regex, QuantifierExact1)
 
 TEST (Regex, QuantifierExact2)
 
 TEST (Regex, QuantifierExact3)
 
 TEST (Regex, QuantifierMin1)
 
 TEST (Regex, QuantifierMin2)
 
 TEST (Regex, QuantifierMin3)
 
 TEST (Regex, QuantifierMinMax1)
 
 TEST (Regex, QuantifierMinMax2)
 
 TEST (Regex, QuantifierMinMax3)
 
 TEST (Regex, QuantifierMinMax4)
 
 TEST (Regex, QuantifierMinMax5)
 
 TEST (Regex, Unicode)
 
 TEST (Regex, AnyCharacter)
 
 TEST (Regex, CharacterRange1)
 
 TEST (Regex, CharacterRange2)
 
 TEST (Regex, CharacterRange3)
 
 TEST (Regex, CharacterRange4)
 
 TEST (Regex, CharacterRange5)
 
 TEST (Regex, CharacterRange6)
 
 TEST (Regex, CharacterRange7)
 
 TEST (Regex, CharacterRange8)
 
 TEST (Regex, Search)
 
 TEST (Regex, Search_BeginAnchor)
 
 TEST (Regex, Search_EndAnchor)
 
 TEST (Regex, Search_BothAnchor)
 
 TEST (Regex, Escape)
 
 TEST (Regex, Invalid)
 
 TEST (Regex, Issue538)
 
 TEST (Regex, Issue583)
 

Macro Definition Documentation

◆ EURO

#define EURO   "\xE2\x82\xAC"

Definition at line 404 of file regextest.cpp.

◆ TEST_INVALID

#define TEST_INVALID ( s)
Value:
{\
Regex re(s);\
EXPECT_FALSE(re.IsValid());\
}
s
char * s
Definition yubihsm_pkcs11.c:524

Function Documentation

◆ TEST() [1/49]

TEST ( Regex ,
Alternation1  )

Definition at line 41 of file regextest.cpp.

41 {
42 Regex re("abab|abbb");
43 ASSERT_TRUE(re.IsValid());
44 RegexSearch rs(re);
45 EXPECT_TRUE(rs.Match("abab"));
46 EXPECT_TRUE(rs.Match("abbb"));
47 EXPECT_FALSE(rs.Match(""));
48 EXPECT_FALSE(rs.Match("ab"));
49 EXPECT_FALSE(rs.Match("ababa"));
50 EXPECT_FALSE(rs.Match("abb"));
51 EXPECT_FALSE(rs.Match("abbbb"));
52}
EXPECT_TRUE
#define EXPECT_TRUE(condition)
Definition gtest.h:1895
ASSERT_TRUE
#define ASSERT_TRUE(condition)
Definition gtest.h:1901
EXPECT_FALSE
#define EXPECT_FALSE(condition)
Definition gtest.h:1898
internal::RegexSearch
GenericRegexSearch< Regex > RegexSearch
Definition regex.h:727
internal::Regex
GenericRegex< UTF8<> > Regex
Definition regex.h:726

◆ TEST() [2/49]

TEST ( Regex ,
Alternation2  )

Definition at line 54 of file regextest.cpp.

54 {
55 Regex re("a|b|c");
56 ASSERT_TRUE(re.IsValid());
57 RegexSearch rs(re);
58 EXPECT_TRUE(rs.Match("a"));
59 EXPECT_TRUE(rs.Match("b"));
60 EXPECT_TRUE(rs.Match("c"));
61 EXPECT_FALSE(rs.Match(""));
62 EXPECT_FALSE(rs.Match("aa"));
63 EXPECT_FALSE(rs.Match("ab"));
64}

◆ TEST() [3/49]

TEST ( Regex ,
AnyCharacter  )

Definition at line 416 of file regextest.cpp.

416 {
417 Regex re(".");
418 ASSERT_TRUE(re.IsValid());
419 RegexSearch rs(re);
420 EXPECT_TRUE(rs.Match("a"));
421 EXPECT_TRUE(rs.Match("b"));
422 EXPECT_TRUE(rs.Match(EURO));
423 EXPECT_FALSE(rs.Match(""));
424 EXPECT_FALSE(rs.Match("aa"));
425}
EURO
#define EURO
Definition regextest.cpp:404

◆ TEST() [4/49]

TEST ( Regex ,
CharacterRange1  )

Definition at line 427 of file regextest.cpp.

427 {
428 Regex re("[abc]");
429 ASSERT_TRUE(re.IsValid());
430 RegexSearch rs(re);
431 EXPECT_TRUE(rs.Match("a"));
432 EXPECT_TRUE(rs.Match("b"));
433 EXPECT_TRUE(rs.Match("c"));
434 EXPECT_FALSE(rs.Match(""));
435 EXPECT_FALSE(rs.Match("`"));
436 EXPECT_FALSE(rs.Match("d"));
437 EXPECT_FALSE(rs.Match("aa"));
438}

◆ TEST() [5/49]

TEST ( Regex ,
CharacterRange2  )

Definition at line 440 of file regextest.cpp.

440 {
441 Regex re("[^abc]");
442 ASSERT_TRUE(re.IsValid());
443 RegexSearch rs(re);
444 EXPECT_TRUE(rs.Match("`"));
445 EXPECT_TRUE(rs.Match("d"));
446 EXPECT_FALSE(rs.Match("a"));
447 EXPECT_FALSE(rs.Match("b"));
448 EXPECT_FALSE(rs.Match("c"));
449 EXPECT_FALSE(rs.Match(""));
450 EXPECT_FALSE(rs.Match("aa"));
451}

◆ TEST() [6/49]

TEST ( Regex ,
CharacterRange3  )

Definition at line 453 of file regextest.cpp.

453 {
454 Regex re("[a-c]");
455 ASSERT_TRUE(re.IsValid());
456 RegexSearch rs(re);
457 EXPECT_TRUE(rs.Match("a"));
458 EXPECT_TRUE(rs.Match("b"));
459 EXPECT_TRUE(rs.Match("c"));
460 EXPECT_FALSE(rs.Match(""));
461 EXPECT_FALSE(rs.Match("`"));
462 EXPECT_FALSE(rs.Match("d"));
463 EXPECT_FALSE(rs.Match("aa"));
464}

◆ TEST() [7/49]

TEST ( Regex ,
CharacterRange4  )

Definition at line 466 of file regextest.cpp.

466 {
467 Regex re("[^a-c]");
468 ASSERT_TRUE(re.IsValid());
469 RegexSearch rs(re);
470 EXPECT_TRUE(rs.Match("`"));
471 EXPECT_TRUE(rs.Match("d"));
472 EXPECT_FALSE(rs.Match("a"));
473 EXPECT_FALSE(rs.Match("b"));
474 EXPECT_FALSE(rs.Match("c"));
475 EXPECT_FALSE(rs.Match(""));
476 EXPECT_FALSE(rs.Match("aa"));
477}

◆ TEST() [8/49]

TEST ( Regex ,
CharacterRange5  )

Definition at line 479 of file regextest.cpp.

479 {
480 Regex re("[-]");
481 ASSERT_TRUE(re.IsValid());
482 RegexSearch rs(re);
483 EXPECT_TRUE(rs.Match("-"));
484 EXPECT_FALSE(rs.Match(""));
485 EXPECT_FALSE(rs.Match("a"));
486}

◆ TEST() [9/49]

TEST ( Regex ,
CharacterRange6  )

Definition at line 488 of file regextest.cpp.

488 {
489 Regex re("[a-]");
490 ASSERT_TRUE(re.IsValid());
491 RegexSearch rs(re);
492 EXPECT_TRUE(rs.Match("a"));
493 EXPECT_TRUE(rs.Match("-"));
494 EXPECT_FALSE(rs.Match(""));
495 EXPECT_FALSE(rs.Match("`"));
496 EXPECT_FALSE(rs.Match("b"));
497}

◆ TEST() [10/49]

TEST ( Regex ,
CharacterRange7  )

Definition at line 499 of file regextest.cpp.

499 {
500 Regex re("[-a]");
501 ASSERT_TRUE(re.IsValid());
502 RegexSearch rs(re);
503 EXPECT_TRUE(rs.Match("a"));
504 EXPECT_TRUE(rs.Match("-"));
505 EXPECT_FALSE(rs.Match(""));
506 EXPECT_FALSE(rs.Match("`"));
507 EXPECT_FALSE(rs.Match("b"));
508}

◆ TEST() [11/49]

TEST ( Regex ,
CharacterRange8  )

Definition at line 510 of file regextest.cpp.

510 {
511 Regex re("[a-zA-Z0-9]*");
512 ASSERT_TRUE(re.IsValid());
513 RegexSearch rs(re);
514 EXPECT_TRUE(rs.Match("Milo"));
515 EXPECT_TRUE(rs.Match("MT19937"));
516 EXPECT_TRUE(rs.Match("43"));
517 EXPECT_FALSE(rs.Match("a_b"));
518 EXPECT_FALSE(rs.Match("!"));
519}

◆ TEST() [12/49]

TEST ( Regex ,
Concatenation  )

Definition at line 29 of file regextest.cpp.

29 {
30 Regex re("abc");
31 ASSERT_TRUE(re.IsValid());
32 RegexSearch rs(re);
33 EXPECT_TRUE(rs.Match("abc"));
34 EXPECT_FALSE(rs.Match(""));
35 EXPECT_FALSE(rs.Match("a"));
36 EXPECT_FALSE(rs.Match("b"));
37 EXPECT_FALSE(rs.Match("ab"));
38 EXPECT_FALSE(rs.Match("abcd"));
39}

◆ TEST() [13/49]

TEST ( Regex ,
Escape  )

Definition at line 579 of file regextest.cpp.

579 {
580 const char* s = "\\^\\$\\|\\(\\)\\?\\*\\+\\.\\[\\]\\{\\}\\\\\\f\\n\\r\\t\\v[\\b][\\[][\\]]";
581 Regex re(s);
582 ASSERT_TRUE(re.IsValid());
583 RegexSearch rs(re);
584 EXPECT_TRUE(rs.Match("^$|()?*+.[]{}\\\x0C\n\r\t\x0B\b[]"));
585 EXPECT_FALSE(rs.Match(s)); // Not escaping
586}

◆ TEST() [14/49]

TEST ( Regex ,
Invalid  )

Definition at line 588 of file regextest.cpp.

588 {
589#define TEST_INVALID(s) \
590 {\
591 Regex re(s);\
592 EXPECT_FALSE(re.IsValid());\
593 }
594
595 TEST_INVALID("");
596 TEST_INVALID("a|");
597 TEST_INVALID("()");
598 TEST_INVALID("(");
599 TEST_INVALID(")");
600 TEST_INVALID("(a))");
601 TEST_INVALID("(a|)");
602 TEST_INVALID("(a||b)");
603 TEST_INVALID("(|b)");
604 TEST_INVALID("?");
605 TEST_INVALID("*");
606 TEST_INVALID("+");
607 TEST_INVALID("{");
608 TEST_INVALID("{}");
609 TEST_INVALID("a{a}");
610 TEST_INVALID("a{0}");
611 TEST_INVALID("a{-1}");
612 TEST_INVALID("a{}");
613 // TEST_INVALID("a{0,}"); // Support now
614 TEST_INVALID("a{,0}");
615 TEST_INVALID("a{1,0}");
616 TEST_INVALID("a{-1,0}");
617 TEST_INVALID("a{-1,1}");
618 TEST_INVALID("a{4294967296}"); // overflow of unsigned
619 TEST_INVALID("a{1a}");
620 TEST_INVALID("[");
621 TEST_INVALID("[]");
622 TEST_INVALID("[^]");
623 TEST_INVALID("[\\a]");
624 TEST_INVALID("\\a");
625
626#undef TEST_INVALID
627}
TEST_INVALID
#define TEST_INVALID(s)

◆ TEST() [15/49]

TEST ( Regex ,
Issue538  )

Definition at line 629 of file regextest.cpp.

629 {
630 Regex re("^[0-9]+(\\\\.[0-9]+){0,2}");
631 EXPECT_TRUE(re.IsValid());
632}

◆ TEST() [16/49]

TEST ( Regex ,
Issue583  )

Definition at line 634 of file regextest.cpp.

634 {
635 Regex re("[0-9]{99999}");
636 ASSERT_TRUE(re.IsValid());
637}

◆ TEST() [17/49]

TEST ( Regex ,
OneOrMore1  )

Definition at line 207 of file regextest.cpp.

207 {
208 Regex re("a+");
209 ASSERT_TRUE(re.IsValid());
210 RegexSearch rs(re);
211 EXPECT_TRUE(rs.Match("a"));
212 EXPECT_TRUE(rs.Match("aa"));
213 EXPECT_FALSE(rs.Match(""));
214 EXPECT_FALSE(rs.Match("b"));
215 EXPECT_FALSE(rs.Match("ab"));
216}

◆ TEST() [18/49]

TEST ( Regex ,
OneOrMore2  )

Definition at line 218 of file regextest.cpp.

218 {
219 Regex re("a+b");
220 ASSERT_TRUE(re.IsValid());
221 RegexSearch rs(re);
222 EXPECT_TRUE(rs.Match("ab"));
223 EXPECT_TRUE(rs.Match("aab"));
224 EXPECT_FALSE(rs.Match(""));
225 EXPECT_FALSE(rs.Match("b"));
226}

◆ TEST() [19/49]

TEST ( Regex ,
OneOrMore3  )

Definition at line 228 of file regextest.cpp.

228 {
229 Regex re("a+b+");
230 ASSERT_TRUE(re.IsValid());
231 RegexSearch rs(re);
232 EXPECT_TRUE(rs.Match("ab"));
233 EXPECT_TRUE(rs.Match("aab"));
234 EXPECT_TRUE(rs.Match("abb"));
235 EXPECT_TRUE(rs.Match("aabb"));
236 EXPECT_FALSE(rs.Match(""));
237 EXPECT_FALSE(rs.Match("b"));
238 EXPECT_FALSE(rs.Match("ba"));
239}

◆ TEST() [20/49]

TEST ( Regex ,
OneOrMore4  )

Definition at line 241 of file regextest.cpp.

241 {
242 Regex re("a(ab)+b");
243 ASSERT_TRUE(re.IsValid());
244 RegexSearch rs(re);
245 EXPECT_TRUE(rs.Match("aabb"));
246 EXPECT_TRUE(rs.Match("aababb"));
247 EXPECT_FALSE(rs.Match(""));
248 EXPECT_FALSE(rs.Match("ab"));
249}

◆ TEST() [21/49]

TEST ( Regex ,
Parenthesis1  )

Definition at line 66 of file regextest.cpp.

66 {
67 Regex re("(ab)c");
68 ASSERT_TRUE(re.IsValid());
69 RegexSearch rs(re);
70 EXPECT_TRUE(rs.Match("abc"));
71 EXPECT_FALSE(rs.Match(""));
72 EXPECT_FALSE(rs.Match("a"));
73 EXPECT_FALSE(rs.Match("b"));
74 EXPECT_FALSE(rs.Match("ab"));
75 EXPECT_FALSE(rs.Match("abcd"));
76}

◆ TEST() [22/49]

TEST ( Regex ,
Parenthesis2  )

Definition at line 78 of file regextest.cpp.

78 {
79 Regex re("a(bc)");
80 ASSERT_TRUE(re.IsValid());
81 RegexSearch rs(re);
82 EXPECT_TRUE(rs.Match("abc"));
83 EXPECT_FALSE(rs.Match(""));
84 EXPECT_FALSE(rs.Match("a"));
85 EXPECT_FALSE(rs.Match("b"));
86 EXPECT_FALSE(rs.Match("ab"));
87 EXPECT_FALSE(rs.Match("abcd"));
88}

◆ TEST() [23/49]

TEST ( Regex ,
Parenthesis3  )

Definition at line 90 of file regextest.cpp.

90 {
91 Regex re("(a|b)(c|d)");
92 ASSERT_TRUE(re.IsValid());
93 RegexSearch rs(re);
94 EXPECT_TRUE(rs.Match("ac"));
95 EXPECT_TRUE(rs.Match("ad"));
96 EXPECT_TRUE(rs.Match("bc"));
97 EXPECT_TRUE(rs.Match("bd"));
98 EXPECT_FALSE(rs.Match(""));
99 EXPECT_FALSE(rs.Match("ab"));
100 EXPECT_FALSE(rs.Match("cd"));
101}

◆ TEST() [24/49]

TEST ( Regex ,
QuantifierExact1  )

Definition at line 251 of file regextest.cpp.

251 {
252 Regex re("ab{3}c");
253 ASSERT_TRUE(re.IsValid());
254 RegexSearch rs(re);
255 EXPECT_TRUE(rs.Match("abbbc"));
256 EXPECT_FALSE(rs.Match("ac"));
257 EXPECT_FALSE(rs.Match("abc"));
258 EXPECT_FALSE(rs.Match("abbc"));
259 EXPECT_FALSE(rs.Match("abbbbc"));
260}

◆ TEST() [25/49]

TEST ( Regex ,
QuantifierExact2  )

Definition at line 262 of file regextest.cpp.

262 {
263 Regex re("a(bc){3}d");
264 ASSERT_TRUE(re.IsValid());
265 RegexSearch rs(re);
266 EXPECT_TRUE(rs.Match("abcbcbcd"));
267 EXPECT_FALSE(rs.Match("ad"));
268 EXPECT_FALSE(rs.Match("abcd"));
269 EXPECT_FALSE(rs.Match("abcbcd"));
270 EXPECT_FALSE(rs.Match("abcbcbcbcd"));
271}

◆ TEST() [26/49]

TEST ( Regex ,
QuantifierExact3  )

Definition at line 273 of file regextest.cpp.

273 {
274 Regex re("a(b|c){3}d");
275 ASSERT_TRUE(re.IsValid());
276 RegexSearch rs(re);
277 EXPECT_TRUE(rs.Match("abbbd"));
278 EXPECT_TRUE(rs.Match("acccd"));
279 EXPECT_TRUE(rs.Match("abcbd"));
280 EXPECT_FALSE(rs.Match("ad"));
281 EXPECT_FALSE(rs.Match("abbd"));
282 EXPECT_FALSE(rs.Match("accccd"));
283 EXPECT_FALSE(rs.Match("abbbbd"));
284}

◆ TEST() [27/49]

TEST ( Regex ,
QuantifierMin1  )

Definition at line 286 of file regextest.cpp.

286 {
287 Regex re("ab{3,}c");
288 ASSERT_TRUE(re.IsValid());
289 RegexSearch rs(re);
290 EXPECT_TRUE(rs.Match("abbbc"));
291 EXPECT_TRUE(rs.Match("abbbbc"));
292 EXPECT_TRUE(rs.Match("abbbbbc"));
293 EXPECT_FALSE(rs.Match("ac"));
294 EXPECT_FALSE(rs.Match("abc"));
295 EXPECT_FALSE(rs.Match("abbc"));
296}

◆ TEST() [28/49]

TEST ( Regex ,
QuantifierMin2  )

Definition at line 298 of file regextest.cpp.

298 {
299 Regex re("a(bc){3,}d");
300 ASSERT_TRUE(re.IsValid());
301 RegexSearch rs(re);
302 EXPECT_TRUE(rs.Match("abcbcbcd"));
303 EXPECT_TRUE(rs.Match("abcbcbcbcd"));
304 EXPECT_FALSE(rs.Match("ad"));
305 EXPECT_FALSE(rs.Match("abcd"));
306 EXPECT_FALSE(rs.Match("abcbcd"));
307}

◆ TEST() [29/49]

TEST ( Regex ,
QuantifierMin3  )

Definition at line 309 of file regextest.cpp.

309 {
310 Regex re("a(b|c){3,}d");
311 ASSERT_TRUE(re.IsValid());
312 RegexSearch rs(re);
313 EXPECT_TRUE(rs.Match("abbbd"));
314 EXPECT_TRUE(rs.Match("acccd"));
315 EXPECT_TRUE(rs.Match("abcbd"));
316 EXPECT_TRUE(rs.Match("accccd"));
317 EXPECT_TRUE(rs.Match("abbbbd"));
318 EXPECT_FALSE(rs.Match("ad"));
319 EXPECT_FALSE(rs.Match("abbd"));
320}

◆ TEST() [30/49]

TEST ( Regex ,
QuantifierMinMax1  )

Definition at line 322 of file regextest.cpp.

322 {
323 Regex re("ab{3,5}c");
324 ASSERT_TRUE(re.IsValid());
325 RegexSearch rs(re);
326 EXPECT_TRUE(rs.Match("abbbc"));
327 EXPECT_TRUE(rs.Match("abbbbc"));
328 EXPECT_TRUE(rs.Match("abbbbbc"));
329 EXPECT_FALSE(rs.Match("ac"));
330 EXPECT_FALSE(rs.Match("abc"));
331 EXPECT_FALSE(rs.Match("abbc"));
332 EXPECT_FALSE(rs.Match("abbbbbbc"));
333}

◆ TEST() [31/49]

TEST ( Regex ,
QuantifierMinMax2  )

Definition at line 335 of file regextest.cpp.

335 {
336 Regex re("a(bc){3,5}d");
337 ASSERT_TRUE(re.IsValid());
338 RegexSearch rs(re);
339 EXPECT_TRUE(rs.Match("abcbcbcd"));
340 EXPECT_TRUE(rs.Match("abcbcbcbcd"));
341 EXPECT_TRUE(rs.Match("abcbcbcbcbcd"));
342 EXPECT_FALSE(rs.Match("ad"));
343 EXPECT_FALSE(rs.Match("abcd"));
344 EXPECT_FALSE(rs.Match("abcbcd"));
345 EXPECT_FALSE(rs.Match("abcbcbcbcbcbcd"));
346}

◆ TEST() [32/49]

TEST ( Regex ,
QuantifierMinMax3  )

Definition at line 348 of file regextest.cpp.

348 {
349 Regex re("a(b|c){3,5}d");
350 ASSERT_TRUE(re.IsValid());
351 RegexSearch rs(re);
352 EXPECT_TRUE(rs.Match("abbbd"));
353 EXPECT_TRUE(rs.Match("acccd"));
354 EXPECT_TRUE(rs.Match("abcbd"));
355 EXPECT_TRUE(rs.Match("accccd"));
356 EXPECT_TRUE(rs.Match("abbbbd"));
357 EXPECT_TRUE(rs.Match("acccccd"));
358 EXPECT_TRUE(rs.Match("abbbbbd"));
359 EXPECT_FALSE(rs.Match("ad"));
360 EXPECT_FALSE(rs.Match("abbd"));
361 EXPECT_FALSE(rs.Match("accccccd"));
362 EXPECT_FALSE(rs.Match("abbbbbbd"));
363}

◆ TEST() [33/49]

TEST ( Regex ,
QuantifierMinMax4  )

Definition at line 366 of file regextest.cpp.

366 {
367 Regex re("a(b|c){0,3}d");
368 ASSERT_TRUE(re.IsValid());
369 RegexSearch rs(re);
370 EXPECT_TRUE(rs.Match("ad"));
371 EXPECT_TRUE(rs.Match("abd"));
372 EXPECT_TRUE(rs.Match("acd"));
373 EXPECT_TRUE(rs.Match("abbd"));
374 EXPECT_TRUE(rs.Match("accd"));
375 EXPECT_TRUE(rs.Match("abcd"));
376 EXPECT_TRUE(rs.Match("abbbd"));
377 EXPECT_TRUE(rs.Match("acccd"));
378 EXPECT_FALSE(rs.Match("abbbbd"));
379 EXPECT_FALSE(rs.Match("add"));
380 EXPECT_FALSE(rs.Match("accccd"));
381 EXPECT_FALSE(rs.Match("abcbcd"));
382}

◆ TEST() [34/49]

TEST ( Regex ,
QuantifierMinMax5  )

Definition at line 385 of file regextest.cpp.

385 {
386 Regex re("a(b|c){0,}d");
387 ASSERT_TRUE(re.IsValid());
388 RegexSearch rs(re);
389 EXPECT_TRUE(rs.Match("ad"));
390 EXPECT_TRUE(rs.Match("abd"));
391 EXPECT_TRUE(rs.Match("acd"));
392 EXPECT_TRUE(rs.Match("abbd"));
393 EXPECT_TRUE(rs.Match("accd"));
394 EXPECT_TRUE(rs.Match("abcd"));
395 EXPECT_TRUE(rs.Match("abbbd"));
396 EXPECT_TRUE(rs.Match("acccd"));
397 EXPECT_TRUE(rs.Match("abbbbd"));
398 EXPECT_TRUE(rs.Match("accccd"));
399 EXPECT_TRUE(rs.Match("abcbcd"));
400 EXPECT_FALSE(rs.Match("add"));
401 EXPECT_FALSE(rs.Match("aad"));
402}

◆ TEST() [35/49]

TEST ( Regex ,
Search  )

Definition at line 521 of file regextest.cpp.

521 {
522 Regex re("abc");
523 ASSERT_TRUE(re.IsValid());
524 RegexSearch rs(re);
525 EXPECT_TRUE(rs.Search("abc"));
526 EXPECT_TRUE(rs.Search("_abc"));
527 EXPECT_TRUE(rs.Search("abc_"));
528 EXPECT_TRUE(rs.Search("_abc_"));
529 EXPECT_TRUE(rs.Search("__abc__"));
530 EXPECT_TRUE(rs.Search("abcabc"));
531 EXPECT_FALSE(rs.Search("a"));
532 EXPECT_FALSE(rs.Search("ab"));
533 EXPECT_FALSE(rs.Search("bc"));
534 EXPECT_FALSE(rs.Search("cba"));
535}

◆ TEST() [36/49]

TEST ( Regex ,
Search_BeginAnchor  )

Definition at line 537 of file regextest.cpp.

537 {
538 Regex re("^abc");
539 ASSERT_TRUE(re.IsValid());
540 RegexSearch rs(re);
541 EXPECT_TRUE(rs.Search("abc"));
542 EXPECT_TRUE(rs.Search("abc_"));
543 EXPECT_TRUE(rs.Search("abcabc"));
544 EXPECT_FALSE(rs.Search("_abc"));
545 EXPECT_FALSE(rs.Search("_abc_"));
546 EXPECT_FALSE(rs.Search("a"));
547 EXPECT_FALSE(rs.Search("ab"));
548 EXPECT_FALSE(rs.Search("bc"));
549 EXPECT_FALSE(rs.Search("cba"));
550}

◆ TEST() [37/49]

TEST ( Regex ,
Search_BothAnchor  )

Definition at line 567 of file regextest.cpp.

567 {
568 Regex re("^abc$");
569 ASSERT_TRUE(re.IsValid());
570 RegexSearch rs(re);
571 EXPECT_TRUE(rs.Search("abc"));
572 EXPECT_FALSE(rs.Search(""));
573 EXPECT_FALSE(rs.Search("a"));
574 EXPECT_FALSE(rs.Search("b"));
575 EXPECT_FALSE(rs.Search("ab"));
576 EXPECT_FALSE(rs.Search("abcd"));
577}

◆ TEST() [38/49]

TEST ( Regex ,
Search_EndAnchor  )

Definition at line 552 of file regextest.cpp.

552 {
553 Regex re("abc$");
554 ASSERT_TRUE(re.IsValid());
555 RegexSearch rs(re);
556 EXPECT_TRUE(rs.Search("abc"));
557 EXPECT_TRUE(rs.Search("_abc"));
558 EXPECT_TRUE(rs.Search("abcabc"));
559 EXPECT_FALSE(rs.Search("abc_"));
560 EXPECT_FALSE(rs.Search("_abc_"));
561 EXPECT_FALSE(rs.Search("a"));
562 EXPECT_FALSE(rs.Search("ab"));
563 EXPECT_FALSE(rs.Search("bc"));
564 EXPECT_FALSE(rs.Search("cba"));
565}

◆ TEST() [39/49]

TEST ( Regex ,
Single  )

Definition at line 20 of file regextest.cpp.

20 {
21 Regex re("a");
22 ASSERT_TRUE(re.IsValid());
23 RegexSearch rs(re);
24 EXPECT_TRUE(rs.Match("a"));
25 EXPECT_FALSE(rs.Match(""));
26 EXPECT_FALSE(rs.Match("b"));
27}

◆ TEST() [40/49]

TEST ( Regex ,
Unicode  )

Definition at line 406 of file regextest.cpp.

406 {
407 Regex re("a" EURO "+b");
408 ASSERT_TRUE(re.IsValid());
409 RegexSearch rs(re);
410 EXPECT_TRUE(rs.Match("a" EURO "b"));
411 EXPECT_TRUE(rs.Match("a" EURO EURO "b"));
412 EXPECT_FALSE(rs.Match("a?b"));
413 EXPECT_FALSE(rs.Match("a" EURO "\xAC" "b")); // unaware of UTF-8 will match
414}

◆ TEST() [41/49]

TEST ( Regex ,
ZeroOrMore1  )

Definition at line 160 of file regextest.cpp.

160 {
161 Regex re("a*");
162 ASSERT_TRUE(re.IsValid());
163 RegexSearch rs(re);
164 EXPECT_TRUE(rs.Match(""));
165 EXPECT_TRUE(rs.Match("a"));
166 EXPECT_TRUE(rs.Match("aa"));
167 EXPECT_FALSE(rs.Match("b"));
168 EXPECT_FALSE(rs.Match("ab"));
169}

◆ TEST() [42/49]

TEST ( Regex ,
ZeroOrMore2  )

Definition at line 171 of file regextest.cpp.

171 {
172 Regex re("a*b");
173 ASSERT_TRUE(re.IsValid());
174 RegexSearch rs(re);
175 EXPECT_TRUE(rs.Match("b"));
176 EXPECT_TRUE(rs.Match("ab"));
177 EXPECT_TRUE(rs.Match("aab"));
178 EXPECT_FALSE(rs.Match(""));
179 EXPECT_FALSE(rs.Match("bb"));
180}

◆ TEST() [43/49]

TEST ( Regex ,
ZeroOrMore3  )

Definition at line 182 of file regextest.cpp.

182 {
183 Regex re("a*b*");
184 ASSERT_TRUE(re.IsValid());
185 RegexSearch rs(re);
186 EXPECT_TRUE(rs.Match(""));
187 EXPECT_TRUE(rs.Match("a"));
188 EXPECT_TRUE(rs.Match("aa"));
189 EXPECT_TRUE(rs.Match("b"));
190 EXPECT_TRUE(rs.Match("bb"));
191 EXPECT_TRUE(rs.Match("ab"));
192 EXPECT_TRUE(rs.Match("aabb"));
193 EXPECT_FALSE(rs.Match("ba"));
194}

◆ TEST() [44/49]

TEST ( Regex ,
ZeroOrMore4  )

Definition at line 196 of file regextest.cpp.

196 {
197 Regex re("a(ab)*b");
198 ASSERT_TRUE(re.IsValid());
199 RegexSearch rs(re);
200 EXPECT_TRUE(rs.Match("ab"));
201 EXPECT_TRUE(rs.Match("aabb"));
202 EXPECT_TRUE(rs.Match("aababb"));
203 EXPECT_FALSE(rs.Match(""));
204 EXPECT_FALSE(rs.Match("aa"));
205}

◆ TEST() [45/49]

TEST ( Regex ,
ZeroOrOne1  )

Definition at line 103 of file regextest.cpp.

103 {
104 Regex re("a?");
105 ASSERT_TRUE(re.IsValid());
106 RegexSearch rs(re);
107 EXPECT_TRUE(rs.Match(""));
108 EXPECT_TRUE(rs.Match("a"));
109 EXPECT_FALSE(rs.Match("aa"));
110}

◆ TEST() [46/49]

TEST ( Regex ,
ZeroOrOne2  )

Definition at line 112 of file regextest.cpp.

112 {
113 Regex re("a?b");
114 ASSERT_TRUE(re.IsValid());
115 RegexSearch rs(re);
116 EXPECT_TRUE(rs.Match("b"));
117 EXPECT_TRUE(rs.Match("ab"));
118 EXPECT_FALSE(rs.Match("a"));
119 EXPECT_FALSE(rs.Match("aa"));
120 EXPECT_FALSE(rs.Match("bb"));
121 EXPECT_FALSE(rs.Match("ba"));
122}

◆ TEST() [47/49]

TEST ( Regex ,
ZeroOrOne3  )

Definition at line 124 of file regextest.cpp.

124 {
125 Regex re("ab?");
126 ASSERT_TRUE(re.IsValid());
127 RegexSearch rs(re);
128 EXPECT_TRUE(rs.Match("a"));
129 EXPECT_TRUE(rs.Match("ab"));
130 EXPECT_FALSE(rs.Match("b"));
131 EXPECT_FALSE(rs.Match("aa"));
132 EXPECT_FALSE(rs.Match("bb"));
133 EXPECT_FALSE(rs.Match("ba"));
134}

◆ TEST() [48/49]

TEST ( Regex ,
ZeroOrOne4  )

Definition at line 136 of file regextest.cpp.

136 {
137 Regex re("a?b?");
138 ASSERT_TRUE(re.IsValid());
139 RegexSearch rs(re);
140 EXPECT_TRUE(rs.Match(""));
141 EXPECT_TRUE(rs.Match("a"));
142 EXPECT_TRUE(rs.Match("b"));
143 EXPECT_TRUE(rs.Match("ab"));
144 EXPECT_FALSE(rs.Match("aa"));
145 EXPECT_FALSE(rs.Match("bb"));
146 EXPECT_FALSE(rs.Match("ba"));
147 EXPECT_FALSE(rs.Match("abc"));
148}

◆ TEST() [49/49]

TEST ( Regex ,
ZeroOrOne5  )

Definition at line 150 of file regextest.cpp.

150 {
151 Regex re("a(ab)?b");
152 ASSERT_TRUE(re.IsValid());
153 RegexSearch rs(re);
154 EXPECT_TRUE(rs.Match("ab"));
155 EXPECT_TRUE(rs.Match("aabb"));
156 EXPECT_FALSE(rs.Match("aab"));
157 EXPECT_FALSE(rs.Match("abb"));
158}