Electroneum
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());\
}

Function Documentation

◆ TEST() [1/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 }
#define EXPECT_TRUE(condition)
Definition: gtest.h:1859
GenericRegexSearch< Regex > RegexSearch
Definition: regex.h:719
GenericRegex< UTF8<> > Regex
Definition: regex.h:718
#define ASSERT_TRUE(condition)
Definition: gtest.h:1865
#define EXPECT_FALSE(condition)
Definition: gtest.h:1862

◆ TEST() [2/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 }
#define EXPECT_TRUE(condition)
Definition: gtest.h:1859
GenericRegexSearch< Regex > RegexSearch
Definition: regex.h:719
GenericRegex< UTF8<> > Regex
Definition: regex.h:718
#define ASSERT_TRUE(condition)
Definition: gtest.h:1865
#define EXPECT_FALSE(condition)
Definition: gtest.h:1862

◆ TEST() [3/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 }
#define EXPECT_TRUE(condition)
Definition: gtest.h:1859
GenericRegexSearch< Regex > RegexSearch
Definition: regex.h:719
GenericRegex< UTF8<> > Regex
Definition: regex.h:718
#define ASSERT_TRUE(condition)
Definition: gtest.h:1865
#define EXPECT_FALSE(condition)
Definition: gtest.h:1862

◆ TEST() [4/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 }
#define EXPECT_TRUE(condition)
Definition: gtest.h:1859
GenericRegexSearch< Regex > RegexSearch
Definition: regex.h:719
GenericRegex< UTF8<> > Regex
Definition: regex.h:718
#define ASSERT_TRUE(condition)
Definition: gtest.h:1865
#define EXPECT_FALSE(condition)
Definition: gtest.h:1862

◆ TEST() [5/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 }
#define EXPECT_TRUE(condition)
Definition: gtest.h:1859
GenericRegexSearch< Regex > RegexSearch
Definition: regex.h:719
GenericRegex< UTF8<> > Regex
Definition: regex.h:718
#define ASSERT_TRUE(condition)
Definition: gtest.h:1865
#define EXPECT_FALSE(condition)
Definition: gtest.h:1862

◆ TEST() [6/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 }
#define EXPECT_TRUE(condition)
Definition: gtest.h:1859
GenericRegexSearch< Regex > RegexSearch
Definition: regex.h:719
GenericRegex< UTF8<> > Regex
Definition: regex.h:718
#define ASSERT_TRUE(condition)
Definition: gtest.h:1865
#define EXPECT_FALSE(condition)
Definition: gtest.h:1862

◆ TEST() [7/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 }
#define EXPECT_TRUE(condition)
Definition: gtest.h:1859
GenericRegexSearch< Regex > RegexSearch
Definition: regex.h:719
GenericRegex< UTF8<> > Regex
Definition: regex.h:718
#define ASSERT_TRUE(condition)
Definition: gtest.h:1865
#define EXPECT_FALSE(condition)
Definition: gtest.h:1862

◆ TEST() [8/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 }
#define EXPECT_TRUE(condition)
Definition: gtest.h:1859
GenericRegexSearch< Regex > RegexSearch
Definition: regex.h:719
GenericRegex< UTF8<> > Regex
Definition: regex.h:718
#define ASSERT_TRUE(condition)
Definition: gtest.h:1865
#define EXPECT_FALSE(condition)
Definition: gtest.h:1862

◆ TEST() [9/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 }
#define EXPECT_TRUE(condition)
Definition: gtest.h:1859
GenericRegexSearch< Regex > RegexSearch
Definition: regex.h:719
GenericRegex< UTF8<> > Regex
Definition: regex.h:718
#define ASSERT_TRUE(condition)
Definition: gtest.h:1865
#define EXPECT_FALSE(condition)
Definition: gtest.h:1862

◆ TEST() [10/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 }
#define EXPECT_TRUE(condition)
Definition: gtest.h:1859
GenericRegexSearch< Regex > RegexSearch
Definition: regex.h:719
GenericRegex< UTF8<> > Regex
Definition: regex.h:718
#define ASSERT_TRUE(condition)
Definition: gtest.h:1865
#define EXPECT_FALSE(condition)
Definition: gtest.h:1862

◆ TEST() [11/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 }
#define EXPECT_TRUE(condition)
Definition: gtest.h:1859
GenericRegexSearch< Regex > RegexSearch
Definition: regex.h:719
GenericRegex< UTF8<> > Regex
Definition: regex.h:718
#define ASSERT_TRUE(condition)
Definition: gtest.h:1865
#define EXPECT_FALSE(condition)
Definition: gtest.h:1862

◆ TEST() [12/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 }
#define EXPECT_TRUE(condition)
Definition: gtest.h:1859
GenericRegexSearch< Regex > RegexSearch
Definition: regex.h:719
GenericRegex< UTF8<> > Regex
Definition: regex.h:718
#define ASSERT_TRUE(condition)
Definition: gtest.h:1865
#define EXPECT_FALSE(condition)
Definition: gtest.h:1862

◆ TEST() [13/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 }
#define EXPECT_TRUE(condition)
Definition: gtest.h:1859
GenericRegexSearch< Regex > RegexSearch
Definition: regex.h:719
GenericRegex< UTF8<> > Regex
Definition: regex.h:718
#define ASSERT_TRUE(condition)
Definition: gtest.h:1865
#define EXPECT_FALSE(condition)
Definition: gtest.h:1862

◆ TEST() [14/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 }
#define EXPECT_TRUE(condition)
Definition: gtest.h:1859
GenericRegexSearch< Regex > RegexSearch
Definition: regex.h:719
GenericRegex< UTF8<> > Regex
Definition: regex.h:718
#define ASSERT_TRUE(condition)
Definition: gtest.h:1865
#define EXPECT_FALSE(condition)
Definition: gtest.h:1862

◆ TEST() [15/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 }
#define EXPECT_TRUE(condition)
Definition: gtest.h:1859
GenericRegexSearch< Regex > RegexSearch
Definition: regex.h:719
GenericRegex< UTF8<> > Regex
Definition: regex.h:718
#define ASSERT_TRUE(condition)
Definition: gtest.h:1865
#define EXPECT_FALSE(condition)
Definition: gtest.h:1862

◆ TEST() [16/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 }
#define EXPECT_TRUE(condition)
Definition: gtest.h:1859
GenericRegexSearch< Regex > RegexSearch
Definition: regex.h:719
GenericRegex< UTF8<> > Regex
Definition: regex.h:718
#define ASSERT_TRUE(condition)
Definition: gtest.h:1865
#define EXPECT_FALSE(condition)
Definition: gtest.h:1862

◆ 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 }
#define EXPECT_TRUE(condition)
Definition: gtest.h:1859
GenericRegexSearch< Regex > RegexSearch
Definition: regex.h:719
GenericRegex< UTF8<> > Regex
Definition: regex.h:718
#define ASSERT_TRUE(condition)
Definition: gtest.h:1865
#define EXPECT_FALSE(condition)
Definition: gtest.h:1862

◆ 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 }
#define EXPECT_TRUE(condition)
Definition: gtest.h:1859
GenericRegexSearch< Regex > RegexSearch
Definition: regex.h:719
GenericRegex< UTF8<> > Regex
Definition: regex.h:718
#define ASSERT_TRUE(condition)
Definition: gtest.h:1865
#define EXPECT_FALSE(condition)
Definition: gtest.h:1862

◆ 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 }
#define EXPECT_TRUE(condition)
Definition: gtest.h:1859
GenericRegexSearch< Regex > RegexSearch
Definition: regex.h:719
GenericRegex< UTF8<> > Regex
Definition: regex.h:718
#define ASSERT_TRUE(condition)
Definition: gtest.h:1865
#define EXPECT_FALSE(condition)
Definition: gtest.h:1862

◆ 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 }
#define EXPECT_TRUE(condition)
Definition: gtest.h:1859
GenericRegexSearch< Regex > RegexSearch
Definition: regex.h:719
GenericRegex< UTF8<> > Regex
Definition: regex.h:718
#define ASSERT_TRUE(condition)
Definition: gtest.h:1865
#define EXPECT_FALSE(condition)
Definition: gtest.h:1862

◆ TEST() [21/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 }
#define EXPECT_TRUE(condition)
Definition: gtest.h:1859
GenericRegexSearch< Regex > RegexSearch
Definition: regex.h:719
GenericRegex< UTF8<> > Regex
Definition: regex.h:718
#define ASSERT_TRUE(condition)
Definition: gtest.h:1865
#define EXPECT_FALSE(condition)
Definition: gtest.h:1862

◆ TEST() [22/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 }
#define EXPECT_TRUE(condition)
Definition: gtest.h:1859
GenericRegexSearch< Regex > RegexSearch
Definition: regex.h:719
GenericRegex< UTF8<> > Regex
Definition: regex.h:718
#define ASSERT_TRUE(condition)
Definition: gtest.h:1865
#define EXPECT_FALSE(condition)
Definition: gtest.h:1862

◆ TEST() [23/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 }
#define EXPECT_TRUE(condition)
Definition: gtest.h:1859
GenericRegexSearch< Regex > RegexSearch
Definition: regex.h:719
GenericRegex< UTF8<> > Regex
Definition: regex.h:718
#define ASSERT_TRUE(condition)
Definition: gtest.h:1865
#define EXPECT_FALSE(condition)
Definition: gtest.h:1862

◆ TEST() [24/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 }
#define EXPECT_TRUE(condition)
Definition: gtest.h:1859
GenericRegexSearch< Regex > RegexSearch
Definition: regex.h:719
GenericRegex< UTF8<> > Regex
Definition: regex.h:718
#define ASSERT_TRUE(condition)
Definition: gtest.h:1865
#define EXPECT_FALSE(condition)
Definition: gtest.h:1862

◆ TEST() [25/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 }
#define EXPECT_TRUE(condition)
Definition: gtest.h:1859
GenericRegexSearch< Regex > RegexSearch
Definition: regex.h:719
GenericRegex< UTF8<> > Regex
Definition: regex.h:718
#define ASSERT_TRUE(condition)
Definition: gtest.h:1865
#define EXPECT_FALSE(condition)
Definition: gtest.h:1862

◆ TEST() [26/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 }
#define EXPECT_TRUE(condition)
Definition: gtest.h:1859
GenericRegexSearch< Regex > RegexSearch
Definition: regex.h:719
GenericRegex< UTF8<> > Regex
Definition: regex.h:718
#define ASSERT_TRUE(condition)
Definition: gtest.h:1865
#define EXPECT_FALSE(condition)
Definition: gtest.h:1862

◆ TEST() [27/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 }
#define EXPECT_TRUE(condition)
Definition: gtest.h:1859
GenericRegexSearch< Regex > RegexSearch
Definition: regex.h:719
GenericRegex< UTF8<> > Regex
Definition: regex.h:718
#define ASSERT_TRUE(condition)
Definition: gtest.h:1865
#define EXPECT_FALSE(condition)
Definition: gtest.h:1862

◆ TEST() [28/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 }
#define EXPECT_TRUE(condition)
Definition: gtest.h:1859
GenericRegexSearch< Regex > RegexSearch
Definition: regex.h:719
GenericRegex< UTF8<> > Regex
Definition: regex.h:718
#define ASSERT_TRUE(condition)
Definition: gtest.h:1865
#define EXPECT_FALSE(condition)
Definition: gtest.h:1862

◆ TEST() [29/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 }
#define EXPECT_TRUE(condition)
Definition: gtest.h:1859
GenericRegexSearch< Regex > RegexSearch
Definition: regex.h:719
GenericRegex< UTF8<> > Regex
Definition: regex.h:718
#define ASSERT_TRUE(condition)
Definition: gtest.h:1865
#define EXPECT_FALSE(condition)
Definition: gtest.h:1862

◆ TEST() [30/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 }
#define EXPECT_TRUE(condition)
Definition: gtest.h:1859
GenericRegexSearch< Regex > RegexSearch
Definition: regex.h:719
GenericRegex< UTF8<> > Regex
Definition: regex.h:718
#define ASSERT_TRUE(condition)
Definition: gtest.h:1865
#define EXPECT_FALSE(condition)
Definition: gtest.h:1862

◆ TEST() [31/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 }
#define EXPECT_TRUE(condition)
Definition: gtest.h:1859
GenericRegexSearch< Regex > RegexSearch
Definition: regex.h:719
GenericRegex< UTF8<> > Regex
Definition: regex.h:718
#define ASSERT_TRUE(condition)
Definition: gtest.h:1865
#define EXPECT_FALSE(condition)
Definition: gtest.h:1862

◆ TEST() [32/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 }
#define EXPECT_TRUE(condition)
Definition: gtest.h:1859
GenericRegexSearch< Regex > RegexSearch
Definition: regex.h:719
GenericRegex< UTF8<> > Regex
Definition: regex.h:718
#define ASSERT_TRUE(condition)
Definition: gtest.h:1865
#define EXPECT_FALSE(condition)
Definition: gtest.h:1862
#define EURO
Definition: regextest.cpp:404

◆ TEST() [33/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 }
#define EXPECT_TRUE(condition)
Definition: gtest.h:1859
GenericRegexSearch< Regex > RegexSearch
Definition: regex.h:719
GenericRegex< UTF8<> > Regex
Definition: regex.h:718
#define ASSERT_TRUE(condition)
Definition: gtest.h:1865
#define EXPECT_FALSE(condition)
Definition: gtest.h:1862
#define EURO
Definition: regextest.cpp:404

◆ TEST() [34/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 }
#define EXPECT_TRUE(condition)
Definition: gtest.h:1859
GenericRegexSearch< Regex > RegexSearch
Definition: regex.h:719
GenericRegex< UTF8<> > Regex
Definition: regex.h:718
#define ASSERT_TRUE(condition)
Definition: gtest.h:1865
#define EXPECT_FALSE(condition)
Definition: gtest.h:1862

◆ TEST() [35/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 }
#define EXPECT_TRUE(condition)
Definition: gtest.h:1859
GenericRegexSearch< Regex > RegexSearch
Definition: regex.h:719
GenericRegex< UTF8<> > Regex
Definition: regex.h:718
#define ASSERT_TRUE(condition)
Definition: gtest.h:1865
#define EXPECT_FALSE(condition)
Definition: gtest.h:1862

◆ TEST() [36/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 }
#define EXPECT_TRUE(condition)
Definition: gtest.h:1859
GenericRegexSearch< Regex > RegexSearch
Definition: regex.h:719
GenericRegex< UTF8<> > Regex
Definition: regex.h:718
#define ASSERT_TRUE(condition)
Definition: gtest.h:1865
#define EXPECT_FALSE(condition)
Definition: gtest.h:1862

◆ TEST() [37/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 }
#define EXPECT_TRUE(condition)
Definition: gtest.h:1859
GenericRegexSearch< Regex > RegexSearch
Definition: regex.h:719
GenericRegex< UTF8<> > Regex
Definition: regex.h:718
#define ASSERT_TRUE(condition)
Definition: gtest.h:1865
#define EXPECT_FALSE(condition)
Definition: gtest.h:1862

◆ TEST() [38/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 }
#define EXPECT_TRUE(condition)
Definition: gtest.h:1859
GenericRegexSearch< Regex > RegexSearch
Definition: regex.h:719
GenericRegex< UTF8<> > Regex
Definition: regex.h:718
#define ASSERT_TRUE(condition)
Definition: gtest.h:1865
#define EXPECT_FALSE(condition)
Definition: gtest.h:1862

◆ TEST() [39/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 }
#define EXPECT_TRUE(condition)
Definition: gtest.h:1859
GenericRegexSearch< Regex > RegexSearch
Definition: regex.h:719
GenericRegex< UTF8<> > Regex
Definition: regex.h:718
#define ASSERT_TRUE(condition)
Definition: gtest.h:1865
#define EXPECT_FALSE(condition)
Definition: gtest.h:1862

◆ TEST() [40/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 }
#define EXPECT_TRUE(condition)
Definition: gtest.h:1859
GenericRegexSearch< Regex > RegexSearch
Definition: regex.h:719
GenericRegex< UTF8<> > Regex
Definition: regex.h:718
#define ASSERT_TRUE(condition)
Definition: gtest.h:1865
#define EXPECT_FALSE(condition)
Definition: gtest.h:1862

◆ TEST() [41/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 }
#define EXPECT_TRUE(condition)
Definition: gtest.h:1859
GenericRegexSearch< Regex > RegexSearch
Definition: regex.h:719
GenericRegex< UTF8<> > Regex
Definition: regex.h:718
#define ASSERT_TRUE(condition)
Definition: gtest.h:1865
#define EXPECT_FALSE(condition)
Definition: gtest.h:1862

◆ TEST() [42/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 }
#define EXPECT_TRUE(condition)
Definition: gtest.h:1859
GenericRegexSearch< Regex > RegexSearch
Definition: regex.h:719
GenericRegex< UTF8<> > Regex
Definition: regex.h:718
#define ASSERT_TRUE(condition)
Definition: gtest.h:1865
#define EXPECT_FALSE(condition)
Definition: gtest.h:1862

◆ TEST() [43/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 }
#define EXPECT_TRUE(condition)
Definition: gtest.h:1859
GenericRegexSearch< Regex > RegexSearch
Definition: regex.h:719
GenericRegex< UTF8<> > Regex
Definition: regex.h:718
#define ASSERT_TRUE(condition)
Definition: gtest.h:1865
#define EXPECT_FALSE(condition)
Definition: gtest.h:1862

◆ TEST() [44/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 }
#define EXPECT_TRUE(condition)
Definition: gtest.h:1859
GenericRegexSearch< Regex > RegexSearch
Definition: regex.h:719
GenericRegex< UTF8<> > Regex
Definition: regex.h:718
#define ASSERT_TRUE(condition)
Definition: gtest.h:1865
#define EXPECT_FALSE(condition)
Definition: gtest.h:1862

◆ TEST() [45/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 }
#define EXPECT_TRUE(condition)
Definition: gtest.h:1859
GenericRegexSearch< Regex > RegexSearch
Definition: regex.h:719
GenericRegex< UTF8<> > Regex
Definition: regex.h:718
#define ASSERT_TRUE(condition)
Definition: gtest.h:1865
#define EXPECT_FALSE(condition)
Definition: gtest.h:1862

◆ TEST() [46/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 }
#define EXPECT_TRUE(condition)
Definition: gtest.h:1859
GenericRegexSearch< Regex > RegexSearch
Definition: regex.h:719
GenericRegex< UTF8<> > Regex
Definition: regex.h:718
#define ASSERT_TRUE(condition)
Definition: gtest.h:1865
#define EXPECT_FALSE(condition)
Definition: gtest.h:1862

◆ TEST() [47/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("(a))");
600  TEST_INVALID("(a|)");
601  TEST_INVALID("(a||b)");
602  TEST_INVALID("(|b)");
603  TEST_INVALID("?");
604  TEST_INVALID("*");
605  TEST_INVALID("+");
606  TEST_INVALID("{");
607  TEST_INVALID("{}");
608  TEST_INVALID("a{a}");
609  TEST_INVALID("a{0}");
610  TEST_INVALID("a{-1}");
611  TEST_INVALID("a{}");
612  // TEST_INVALID("a{0,}"); // Support now
613  TEST_INVALID("a{,0}");
614  TEST_INVALID("a{1,0}");
615  TEST_INVALID("a{-1,0}");
616  TEST_INVALID("a{-1,1}");
617  TEST_INVALID("a{4294967296}"); // overflow of unsigned
618  TEST_INVALID("a{1a}");
619  TEST_INVALID("[");
620  TEST_INVALID("[]");
621  TEST_INVALID("[^]");
622  TEST_INVALID("[\\a]");
623  TEST_INVALID("\\a");
624 
625 #undef TEST_INVALID
626 }
#define TEST_INVALID(s)

◆ TEST() [48/49]

TEST ( Regex  ,
Issue538   
)

Definition at line 628 of file regextest.cpp.

628  {
629  Regex re("^[0-9]+(\\\\.[0-9]+){0,2}");
630  EXPECT_TRUE(re.IsValid());
631 }
#define EXPECT_TRUE(condition)
Definition: gtest.h:1859
GenericRegex< UTF8<> > Regex
Definition: regex.h:718

◆ TEST() [49/49]

TEST ( Regex  ,
Issue583   
)

Definition at line 633 of file regextest.cpp.

633  {
634  Regex re("[0-9]{99999}");
635  ASSERT_TRUE(re.IsValid());
636 }
GenericRegex< UTF8<> > Regex
Definition: regex.h:718
#define ASSERT_TRUE(condition)
Definition: gtest.h:1865