fixed adding file problem
[c11concurrency-benchmarks.git] / gdax-orderbook-hpp / demo / dependencies / rapidjson-1.1.0 / 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