Gitiles
Code Review Sign In
gerrit-public.fairphone.software / toolchain / llvm-project / f7109438ea0f742fc39a6d7ba4dfa8ae7336b174 / . / libcxx / test / re / re.alg / re.alg.search / extended.pass.cpp
blob: a5a3ccef4c402030a380b8a9d4dddddf37caf882 [file] [log] [blame]
Howard Hinnantc1198c32010-07-16 19:08:36 +0000[diff] [blame]1//===----------------------------------------------------------------------===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9
10// <regex>
11
12// template <class BidirectionalIterator, class Allocator, class charT, class traits>
13// bool
14// regex_search(BidirectionalIterator first, BidirectionalIterator last,
15// match_results<BidirectionalIterator, Allocator>& m,
16// const basic_regex<charT, traits>& e,
17// regex_constants::match_flag_type flags = regex_constants::match_default);
18
19#include <regex>
20#include <cassert>
21
22#include "../../iterators.h"
23
24int main()
25{
26 {
27 std::cmatch m;
28 const char s[] = "a";
29 assert(std::regex_search(s, m, std::regex("a", std::regex_constants::extended)));
30 assert(m.size() == 1);
31 assert(!m.empty());
32 assert(!m.prefix().matched);
33 assert(m.prefix().first == s);
34 assert(m.prefix().second == m[0].first);
35 assert(!m.suffix().matched);
36 assert(m.suffix().first == m[0].second);
37 assert(m.suffix().second == s+1);
38 assert(m.length(0) == 1);
39 assert(m.position(0) == 0);
40 assert(m.str(0) == "a");
41 }
42 {
43 std::cmatch m;
44 const char s[] = "ab";
45 assert(std::regex_search(s, m, std::regex("ab", std::regex_constants::extended)));
46 assert(m.size() == 1);
47 assert(!m.prefix().matched);
48 assert(m.prefix().first == s);
49 assert(m.prefix().second == m[0].first);
50 assert(!m.suffix().matched);
51 assert(m.suffix().first == m[0].second);
52 assert(m.suffix().second == s+2);
53 assert(m.length(0) == 2);
54 assert(m.position(0) == 0);
55 assert(m.str(0) == "ab");
56 }
57 {
58 std::cmatch m;
59 const char s[] = "ab";
60 assert(!std::regex_search(s, m, std::regex("ba", std::regex_constants::extended)));
61 assert(m.size() == 0);
62 assert(m.empty());
63 }
64 {
65 std::cmatch m;
66 const char s[] = "aab";
67 assert(std::regex_search(s, m, std::regex("ab", std::regex_constants::extended)));
68 assert(m.size() == 1);
69 assert(m.prefix().matched);
70 assert(m.prefix().first == s);
71 assert(m.prefix().second == m[0].first);
72 assert(!m.suffix().matched);
73 assert(m.suffix().first == m[0].second);
74 assert(m.suffix().second == s+3);
75 assert(m.length(0) == 2);
76 assert(m.position(0) == 1);
77 assert(m.str(0) == "ab");
78 }
79 {
80 std::cmatch m;
81 const char s[] = "aab";
82 assert(!std::regex_search(s, m, std::regex("ab", std::regex_constants::extended),
83 std::regex_constants::match_continuous));
84 assert(m.size() == 0);
85 }
86 {
87 std::cmatch m;
88 const char s[] = "abcd";
89 assert(std::regex_search(s, m, std::regex("bc", std::regex_constants::extended)));
90 assert(m.size() == 1);
91 assert(m.prefix().matched);
92 assert(m.prefix().first == s);
93 assert(m.prefix().second == m[0].first);
94 assert(m.suffix().matched);
95 assert(m.suffix().first == m[0].second);
96 assert(m.suffix().second == s+4);
97 assert(m.length(0) == 2);
98 assert(m.position(0) == 1);
99 assert(m.str(0) == "bc");
100 }
101 {
102 std::cmatch m;
103 const char s[] = "abbc";
104 assert(std::regex_search(s, m, std::regex("ab*c", std::regex_constants::extended)));
105 assert(m.size() == 1);
106 assert(!m.prefix().matched);
107 assert(m.prefix().first == s);
108 assert(m.prefix().second == m[0].first);
109 assert(!m.suffix().matched);
110 assert(m.suffix().first == m[0].second);
111 assert(m.suffix().second == s+4);
112 assert(m.length(0) == 4);
113 assert(m.position(0) == 0);
114 assert(m.str(0) == s);
115 }
116 {
117 std::cmatch m;
118 const char s[] = "ababc";
119 assert(std::regex_search(s, m, std::regex("(ab)*c", std::regex_constants::extended)));
120 assert(m.size() == 2);
121 assert(!m.prefix().matched);
122 assert(m.prefix().first == s);
123 assert(m.prefix().second == m[0].first);
124 assert(!m.suffix().matched);
125 assert(m.suffix().first == m[0].second);
126 assert(m.suffix().second == s+5);
127 assert(m.length(0) == 5);
128 assert(m.position(0) == 0);
129 assert(m.str(0) == s);
130 assert(m.length(1) == 2);
131 assert(m.position(1) == 2);
132 assert(m.str(1) == "ab");
133 }
134 {
135 std::cmatch m;
136 const char s[] = "abcdefghijk";
137 assert(std::regex_search(s, m, std::regex("cd((e)fg)hi",
138 std::regex_constants::extended)));
139 assert(m.size() == 3);
140 assert(m.prefix().matched);
141 assert(m.prefix().first == s);
142 assert(m.prefix().second == m[0].first);
143 assert(m.suffix().matched);
144 assert(m.suffix().first == m[0].second);
145 assert(m.suffix().second == s+std::regex_traits<char>::length(s));
146 assert(m.length(0) == 7);
147 assert(m.position(0) == 2);
148 assert(m.str(0) == "cdefghi");
149 assert(m.length(1) == 3);
150 assert(m.position(1) == 4);
151 assert(m.str(1) == "efg");
152 assert(m.length(2) == 1);
153 assert(m.position(2) == 4);
154 assert(m.str(2) == "e");
155 }
156 {
157 std::cmatch m;
158 const char s[] = "abc";
159 assert(std::regex_search(s, m, std::regex("^abc", std::regex_constants::extended)));
160 assert(m.size() == 1);
161 assert(!m.prefix().matched);
162 assert(m.prefix().first == s);
163 assert(m.prefix().second == m[0].first);
164 assert(!m.suffix().matched);
165 assert(m.suffix().first == m[0].second);
166 assert(m.suffix().second == s+3);
167 assert(m.length(0) == 3);
168 assert(m.position(0) == 0);
169 assert(m.str(0) == s);
170 }
171 {
172 std::cmatch m;
173 const char s[] = "abcd";
174 assert(std::regex_search(s, m, std::regex("^abc", std::regex_constants::extended)));
175 assert(m.size() == 1);
176 assert(!m.prefix().matched);
177 assert(m.prefix().first == s);
178 assert(m.prefix().second == m[0].first);
179 assert(m.suffix().matched);
180 assert(m.suffix().first == m[0].second);
181 assert(m.suffix().second == s+4);
182 assert(m.length(0) == 3);
183 assert(m.position(0) == 0);
184 assert(m.str(0) == "abc");
185 }
186 {
187 std::cmatch m;
188 const char s[] = "aabc";
189 assert(!std::regex_search(s, m, std::regex("^abc", std::regex_constants::extended)));
190 assert(m.size() == 0);
191 }
192 {
193 std::cmatch m;
194 const char s[] = "abc";
195 assert(std::regex_search(s, m, std::regex("abc$", std::regex_constants::extended)));
196 assert(m.size() == 1);
197 assert(!m.prefix().matched);
198 assert(m.prefix().first == s);
199 assert(m.prefix().second == m[0].first);
200 assert(!m.suffix().matched);
201 assert(m.suffix().first == m[0].second);
202 assert(m.suffix().second == s+3);
203 assert(m.length(0) == 3);
204 assert(m.position(0) == 0);
205 assert(m.str(0) == s);
206 }
207 {
208 std::cmatch m;
209 const char s[] = "efabc";
210 assert(std::regex_search(s, m, std::regex("abc$", std::regex_constants::extended)));
211 assert(m.size() == 1);
212 assert(m.prefix().matched);
213 assert(m.prefix().first == s);
214 assert(m.prefix().second == m[0].first);
215 assert(!m.suffix().matched);
216 assert(m.suffix().first == m[0].second);
217 assert(m.suffix().second == s+5);
218 assert(m.length(0) == 3);
219 assert(m.position(0) == 2);
220 assert(m.str(0) == s+2);
221 }
222 {
223 std::cmatch m;
224 const char s[] = "efabcg";
225 assert(!std::regex_search(s, m, std::regex("abc$", std::regex_constants::extended)));
226 assert(m.size() == 0);
227 }
228 {
229 std::cmatch m;
230 const char s[] = "abc";
231 assert(std::regex_search(s, m, std::regex("a.c", std::regex_constants::extended)));
232 assert(m.size() == 1);
233 assert(!m.prefix().matched);
234 assert(m.prefix().first == s);
235 assert(m.prefix().second == m[0].first);
236 assert(!m.suffix().matched);
237 assert(m.suffix().first == m[0].second);
238 assert(m.suffix().second == s+3);
239 assert(m.length(0) == 3);
240 assert(m.position(0) == 0);
241 assert(m.str(0) == s);
242 }
243 {
244 std::cmatch m;
245 const char s[] = "acc";
246 assert(std::regex_search(s, m, std::regex("a.c", std::regex_constants::extended)));
247 assert(m.size() == 1);
248 assert(!m.prefix().matched);
249 assert(m.prefix().first == s);
250 assert(m.prefix().second == m[0].first);
251 assert(!m.suffix().matched);
252 assert(m.suffix().first == m[0].second);
253 assert(m.suffix().second == s+3);
254 assert(m.length(0) == 3);
255 assert(m.position(0) == 0);
256 assert(m.str(0) == s);
257 }
258 {
259 std::cmatch m;
260 const char s[] = "acc";
261 assert(std::regex_search(s, m, std::regex("a.c", std::regex_constants::extended)));
262 assert(m.size() == 1);
263 assert(!m.prefix().matched);
264 assert(m.prefix().first == s);
265 assert(m.prefix().second == m[0].first);
266 assert(!m.suffix().matched);
267 assert(m.suffix().first == m[0].second);
268 assert(m.suffix().second == s+3);
269 assert(m.length(0) == 3);
270 assert(m.position(0) == 0);
271 assert(m.str(0) == s);
272 }
273 {
274 std::cmatch m;
275 const char s[] = "abcdef";
276 assert(std::regex_search(s, m, std::regex("(.*).*", std::regex_constants::extended)));
277 assert(m.size() == 2);
278 assert(!m.prefix().matched);
279 assert(m.prefix().first == s);
280 assert(m.prefix().second == m[0].first);
281 assert(!m.suffix().matched);
282 assert(m.suffix().first == m[0].second);
283 assert(m.suffix().second == s+6);
284 assert(m.length(0) == 6);
285 assert(m.position(0) == 0);
286 assert(m.str(0) == s);
287 assert(m.length(1) == 6);
288 assert(m.position(1) == 0);
289 assert(m.str(1) == s);
290 }
291 {
292 std::cmatch m;
293 const char s[] = "bc";
294 assert(std::regex_search(s, m, std::regex("(a*)*", std::regex_constants::extended)));
295 assert(m.size() == 2);
296 assert(!m.prefix().matched);
297 assert(m.prefix().first == s);
298 assert(m.prefix().second == m[0].first);
299 assert(m.suffix().matched);
300 assert(m.suffix().first == m[0].second);
301 assert(m.suffix().second == s+2);
302 assert(m.length(0) == 0);
303 assert(m.position(0) == 0);
304 assert(m.str(0) == "");
305 assert(m.length(1) == 0);
306 assert(m.position(1) == 0);
307 assert(m.str(1) == "");
308 }
309 {
310 std::cmatch m;
311 const char s[] = "abbc";
312 assert(!std::regex_search(s, m, std::regex("ab{3,5}c", std::regex_constants::extended)));
313 assert(m.size() == 0);
314 }
315 {
316 std::cmatch m;
317 const char s[] = "abbbc";
318 assert(std::regex_search(s, m, std::regex("ab{3,5}c", std::regex_constants::extended)));
319 assert(m.size() == 1);
320 assert(!m.prefix().matched);
321 assert(m.prefix().first == s);
322 assert(m.prefix().second == m[0].first);
323 assert(!m.suffix().matched);
324 assert(m.suffix().first == m[0].second);
325 assert(m.suffix().second == m[0].second);
Howard Hinnantb762bea2010-07-22 14:12:20 +0000[diff] [blame]326 assert(m.length(0) == std::char_traits<char>::length(s));
Howard Hinnantc1198c32010-07-16 19:08:36 +0000[diff] [blame]327 assert(m.position(0) == 0);
328 assert(m.str(0) == s);
329 }
330 {
331 std::cmatch m;
332 const char s[] = "abbbbc";
333 assert(std::regex_search(s, m, std::regex("ab{3,5}c", std::regex_constants::extended)));
334 assert(m.size() == 1);
335 assert(!m.prefix().matched);
336 assert(m.prefix().first == s);
337 assert(m.prefix().second == m[0].first);
338 assert(!m.suffix().matched);
339 assert(m.suffix().first == m[0].second);
340 assert(m.suffix().second == m[0].second);
Howard Hinnantb762bea2010-07-22 14:12:20 +0000[diff] [blame]341 assert(m.length(0) == std::char_traits<char>::length(s));
Howard Hinnantc1198c32010-07-16 19:08:36 +0000[diff] [blame]342 assert(m.position(0) == 0);
343 assert(m.str(0) == s);
344 }
345 {
346 std::cmatch m;
347 const char s[] = "abbbbbc";
348 assert(std::regex_search(s, m, std::regex("ab{3,5}c", std::regex_constants::extended)));
349 assert(m.size() == 1);
350 assert(!m.prefix().matched);
351 assert(m.prefix().first == s);
352 assert(m.prefix().second == m[0].first);
353 assert(!m.suffix().matched);
354 assert(m.suffix().first == m[0].second);
355 assert(m.suffix().second == m[0].second);
Howard Hinnantb762bea2010-07-22 14:12:20 +0000[diff] [blame]356 assert(m.length(0) == std::char_traits<char>::length(s));
Howard Hinnantc1198c32010-07-16 19:08:36 +0000[diff] [blame]357 assert(m.position(0) == 0);
358 assert(m.str(0) == s);
359 }
360 {
361 std::cmatch m;
362 const char s[] = "adefc";
363 assert(!std::regex_search(s, m, std::regex("ab{3,5}c", std::regex_constants::extended)));
364 assert(m.size() == 0);
365 }
366 {
367 std::cmatch m;
368 const char s[] = "abbbbbbc";
369 assert(!std::regex_search(s, m, std::regex("ab{3,5}c", std::regex_constants::extended)));
370 assert(m.size() == 0);
371 }
372 {
373 std::cmatch m;
374 const char s[] = "adec";
375 assert(!std::regex_search(s, m, std::regex("a.{3,5}c", std::regex_constants::extended)));
376 assert(m.size() == 0);
377 }
378 {
379 std::cmatch m;
380 const char s[] = "adefc";
381 assert(std::regex_search(s, m, std::regex("a.{3,5}c", std::regex_constants::extended)));
382 assert(m.size() == 1);
383 assert(!m.prefix().matched);
384 assert(m.prefix().first == s);
385 assert(m.prefix().second == m[0].first);
386 assert(!m.suffix().matched);
387 assert(m.suffix().first == m[0].second);
388 assert(m.suffix().second == m[0].second);
Howard Hinnantb762bea2010-07-22 14:12:20 +0000[diff] [blame]389 assert(m.length(0) == std::char_traits<char>::length(s));
Howard Hinnantc1198c32010-07-16 19:08:36 +0000[diff] [blame]390 assert(m.position(0) == 0);
391 assert(m.str(0) == s);
392 }
393 {
394 std::cmatch m;
395 const char s[] = "adefgc";
396 assert(std::regex_search(s, m, std::regex("a.{3,5}c", std::regex_constants::extended)));
397 assert(m.size() == 1);
398 assert(!m.prefix().matched);
399 assert(m.prefix().first == s);
400 assert(m.prefix().second == m[0].first);
401 assert(!m.suffix().matched);
402 assert(m.suffix().first == m[0].second);
403 assert(m.suffix().second == m[0].second);
Howard Hinnantb762bea2010-07-22 14:12:20 +0000[diff] [blame]404 assert(m.length(0) == std::char_traits<char>::length(s));
Howard Hinnantc1198c32010-07-16 19:08:36 +0000[diff] [blame]405 assert(m.position(0) == 0);
406 assert(m.str(0) == s);
407 }
408 {
409 std::cmatch m;
410 const char s[] = "adefghc";
411 assert(std::regex_search(s, m, std::regex("a.{3,5}c", std::regex_constants::extended)));
412 assert(m.size() == 1);
413 assert(!m.prefix().matched);
414 assert(m.prefix().first == s);
415 assert(m.prefix().second == m[0].first);
416 assert(!m.suffix().matched);
417 assert(m.suffix().first == m[0].second);
418 assert(m.suffix().second == m[0].second);
Howard Hinnantb762bea2010-07-22 14:12:20 +0000[diff] [blame]419 assert(m.length(0) == std::char_traits<char>::length(s));
Howard Hinnantc1198c32010-07-16 19:08:36 +0000[diff] [blame]420 assert(m.position(0) == 0);
421 assert(m.str(0) == s);
422 }
423 {
424 std::cmatch m;
425 const char s[] = "adefghic";
426 assert(!std::regex_search(s, m, std::regex("a.{3,5}c", std::regex_constants::extended)));
427 assert(m.size() == 0);
428 }
429 {
430 std::cmatch m;
431 const char s[] = "tournament";
432 assert(std::regex_search(s, m, std::regex("tour|to|tournament",
433 std::regex_constants::extended)));
434 assert(m.size() == 1);
435 assert(!m.prefix().matched);
436 assert(m.prefix().first == s);
437 assert(m.prefix().second == m[0].first);
438 assert(!m.suffix().matched);
439 assert(m.suffix().first == m[0].second);
440 assert(m.suffix().second == m[0].second);
Howard Hinnantb762bea2010-07-22 14:12:20 +0000[diff] [blame]441 assert(m.length(0) == std::char_traits<char>::length(s));
Howard Hinnantc1198c32010-07-16 19:08:36 +0000[diff] [blame]442 assert(m.position(0) == 0);
443 assert(m.str(0) == s);
444 }
Howard Hinnantb762bea2010-07-22 14:12:20 +0000[diff] [blame]445 {
446 std::cmatch m;
447 const char s[] = "tournamenttotour";
448 assert(std::regex_search(s, m, std::regex("(tour|to|tournament)+",
449 std::regex_constants::extended | std::regex_constants::nosubs)));
450 assert(m.size() == 1);
451 assert(!m.prefix().matched);
452 assert(m.prefix().first == s);
453 assert(m.prefix().second == m[0].first);
454 assert(!m.suffix().matched);
455 assert(m.suffix().first == m[0].second);
456 assert(m.suffix().second == m[0].second);
457 assert(m.length(0) == std::char_traits<char>::length(s));
458 assert(m.position(0) == 0);
459 assert(m.str(0) == s);
460 }
461 {
462 std::cmatch m;
463 const char s[] = "ttotour";
464 assert(std::regex_search(s, m, std::regex("(tour|to|t)+",
465 std::regex_constants::extended)));
466 assert(m.size() == 2);
467 assert(!m.prefix().matched);
468 assert(m.prefix().first == s);
469 assert(m.prefix().second == m[0].first);
470 assert(!m.suffix().matched);
471 assert(m.suffix().first == m[0].second);
472 assert(m.suffix().second == m[0].second);
473 assert(m.length(0) == std::char_traits<char>::length(s));
474 assert(m.position(0) == 0);
475 assert(m.str(0) == s);
476 assert(m.length(1) == 4);
477 assert(m.position(1) == 3);
478 assert(m.str(1) == "tour");
479 }
Howard Hinnantf7109432010-07-22 17:53:24 +0000[diff] [blame^]480 {
481 std::cmatch m;
482 const char s[] = "-ab,ab-";
483 assert(!std::regex_search(s, m, std::regex("-(.*),\1-", std::regex_constants::extended)));
484 assert(m.size() == 0);
485 }
486 {
487 std::cmatch m;
488 const char s[] = "-ab,ab-";
489 assert(std::regex_search(s, m, std::regex("-.*,.*-", std::regex_constants::extended)));
490 assert(m.size() == 1);
491 assert(!m.prefix().matched);
492 assert(m.prefix().first == s);
493 assert(m.prefix().second == m[0].first);
494 assert(!m.suffix().matched);
495 assert(m.suffix().first == m[0].second);
496 assert(m.suffix().second == m[0].second);
497 assert(m.length(0) == std::char_traits<char>::length(s));
498 assert(m.position(0) == 0);
499 assert(m.str(0) == s);
500 }
501 {
502 std::cmatch m;
503 const char s[] = "a";
504 assert(std::regex_search(s, m, std::regex("^[a]$",
505 std::regex_constants::extended)));
506 assert(m.size() == 1);
507 assert(!m.prefix().matched);
508 assert(m.prefix().first == s);
509 assert(m.prefix().second == m[0].first);
510 assert(!m.suffix().matched);
511 assert(m.suffix().first == m[0].second);
512 assert(m.suffix().second == m[0].second);
513 assert(m.length(0) == 1);
514 assert(m.position(0) == 0);
515 assert(m.str(0) == "a");
516 }
517 {
518 std::cmatch m;
519 const char s[] = "a";
520 assert(std::regex_search(s, m, std::regex("^[ab]$",
521 std::regex_constants::extended)));
522 assert(m.size() == 1);
523 assert(!m.prefix().matched);
524 assert(m.prefix().first == s);
525 assert(m.prefix().second == m[0].first);
526 assert(!m.suffix().matched);
527 assert(m.suffix().first == m[0].second);
528 assert(m.suffix().second == m[0].second);
529 assert(m.length(0) == 1);
530 assert(m.position(0) == 0);
531 assert(m.str(0) == "a");
532 }
533 {
534 std::cmatch m;
535 const char s[] = "c";
536 assert(std::regex_search(s, m, std::regex("^[a-f]$",
537 std::regex_constants::extended)));
538 assert(m.size() == 1);
539 assert(!m.prefix().matched);
540 assert(m.prefix().first == s);
541 assert(m.prefix().second == m[0].first);
542 assert(!m.suffix().matched);
543 assert(m.suffix().first == m[0].second);
544 assert(m.suffix().second == m[0].second);
545 assert(m.length(0) == 1);
546 assert(m.position(0) == 0);
547 assert(m.str(0) == s);
548 }
549 {
550 std::cmatch m;
551 const char s[] = "g";
552 assert(!std::regex_search(s, m, std::regex("^[a-f]$",
553 std::regex_constants::extended)));
554 assert(m.size() == 0);
555 }
556 {
557 std::cmatch m;
558 const char s[] = "Iraqi";
559 assert(std::regex_search(s, m, std::regex("q[^u]",
560 std::regex_constants::extended)));
561 assert(m.size() == 1);
562 assert(m.prefix().matched);
563 assert(m.prefix().first == s);
564 assert(m.prefix().second == m[0].first);
565 assert(!m.suffix().matched);
566 assert(m.suffix().first == m[0].second);
567 assert(m.suffix().second == m[0].second);
568 assert(m.length(0) == 2);
569 assert(m.position(0) == 3);
570 assert(m.str(0) == "qi");
571 }
572 {
573 std::cmatch m;
574 const char s[] = "Iraq";
575 assert(!std::regex_search(s, m, std::regex("q[^u]",
576 std::regex_constants::extended)));
577 assert(m.size() == 0);
578 }
579 {
580 std::cmatch m;
581 const char s[] = "AmB";
582 assert(std::regex_search(s, m, std::regex("A[[:lower:]]B",
583 std::regex_constants::extended)));
584 assert(m.size() == 1);
585 assert(!m.prefix().matched);
586 assert(m.prefix().first == s);
587 assert(m.prefix().second == m[0].first);
588 assert(!m.suffix().matched);
589 assert(m.suffix().first == m[0].second);
590 assert(m.suffix().second == m[0].second);
591 assert(m.length(0) == std::char_traits<char>::length(s));
592 assert(m.position(0) == 0);
593 assert(m.str(0) == s);
594 }
595 {
596 std::cmatch m;
597 const char s[] = "AMB";
598 assert(!std::regex_search(s, m, std::regex("A[[:lower:]]B",
599 std::regex_constants::extended)));
600 assert(m.size() == 0);
601 }
602 {
603 std::cmatch m;
604 const char s[] = "AMB";
605 assert(std::regex_search(s, m, std::regex("A[^[:lower:]]B",
606 std::regex_constants::extended)));
607 assert(m.size() == 1);
608 assert(!m.prefix().matched);
609 assert(m.prefix().first == s);
610 assert(m.prefix().second == m[0].first);
611 assert(!m.suffix().matched);
612 assert(m.suffix().first == m[0].second);
613 assert(m.suffix().second == m[0].second);
614 assert(m.length(0) == std::char_traits<char>::length(s));
615 assert(m.position(0) == 0);
616 assert(m.str(0) == s);
617 }
618 {
619 std::cmatch m;
620 const char s[] = "AmB";
621 assert(!std::regex_search(s, m, std::regex("A[^[:lower:]]B",
622 std::regex_constants::extended)));
623 assert(m.size() == 0);
624 }
625 {
626 std::cmatch m;
627 const char s[] = "A5B";
628 assert(!std::regex_search(s, m, std::regex("A[^[:lower:]0-9]B",
629 std::regex_constants::extended)));
630 assert(m.size() == 0);
631 }
632 {
633 std::cmatch m;
634 const char s[] = "A?B";
635 assert(std::regex_search(s, m, std::regex("A[^[:lower:]0-9]B",
636 std::regex_constants::extended)));
637 assert(m.size() == 1);
638 assert(!m.prefix().matched);
639 assert(m.prefix().first == s);
640 assert(m.prefix().second == m[0].first);
641 assert(!m.suffix().matched);
642 assert(m.suffix().first == m[0].second);
643 assert(m.suffix().second == m[0].second);
644 assert(m.length(0) == std::char_traits<char>::length(s));
645 assert(m.position(0) == 0);
646 assert(m.str(0) == s);
647 }
648 {
649 std::cmatch m;
650 const char s[] = "-";
651 assert(std::regex_search(s, m, std::regex("[a[.hyphen.]z]",
652 std::regex_constants::extended)));
653 assert(m.size() == 1);
654 assert(!m.prefix().matched);
655 assert(m.prefix().first == s);
656 assert(m.prefix().second == m[0].first);
657 assert(!m.suffix().matched);
658 assert(m.suffix().first == m[0].second);
659 assert(m.suffix().second == m[0].second);
660 assert(m.length(0) == std::char_traits<char>::length(s));
661 assert(m.position(0) == 0);
662 assert(m.str(0) == s);
663 }
664 {
665 std::cmatch m;
666 const char s[] = "z";
667 assert(std::regex_search(s, m, std::regex("[a[.hyphen.]z]",
668 std::regex_constants::extended)));
669 assert(m.size() == 1);
670 assert(!m.prefix().matched);
671 assert(m.prefix().first == s);
672 assert(m.prefix().second == m[0].first);
673 assert(!m.suffix().matched);
674 assert(m.suffix().first == m[0].second);
675 assert(m.suffix().second == m[0].second);
676 assert(m.length(0) == std::char_traits<char>::length(s));
677 assert(m.position(0) == 0);
678 assert(m.str(0) == s);
679 }
680 {
681 std::cmatch m;
682 const char s[] = "m";
683 assert(!std::regex_search(s, m, std::regex("[a[.hyphen.]z]",
684 std::regex_constants::extended)));
685 assert(m.size() == 0);
686 }
687 std::locale::global(std::locale("cs_CZ.ISO8859-2"));
688 {
689 std::cmatch m;
690 const char s[] = "m";
691 assert(std::regex_search(s, m, std::regex("[a[=M=]z]",
692 std::regex_constants::extended)));
693 assert(m.size() == 1);
694 assert(!m.prefix().matched);
695 assert(m.prefix().first == s);
696 assert(m.prefix().second == m[0].first);
697 assert(!m.suffix().matched);
698 assert(m.suffix().first == m[0].second);
699 assert(m.suffix().second == m[0].second);
700 assert(m.length(0) == std::char_traits<char>::length(s));
701 assert(m.position(0) == 0);
702 assert(m.str(0) == s);
703 }
704 {
705 std::cmatch m;
706 const char s[] = "Ch";
707 assert(std::regex_search(s, m, std::regex("[a[.ch.]z]",
708 std::regex_constants::extended | std::regex_constants::icase)));
709 assert(m.size() == 1);
710 assert(!m.prefix().matched);
711 assert(m.prefix().first == s);
712 assert(m.prefix().second == m[0].first);
713 assert(!m.suffix().matched);
714 assert(m.suffix().first == m[0].second);
715 assert(m.suffix().second == m[0].second);
716 assert(m.length(0) == std::char_traits<char>::length(s));
717 assert(m.position(0) == 0);
718 assert(m.str(0) == s);
719 }
720 std::locale::global(std::locale("C"));
721 {
722 std::cmatch m;
723 const char s[] = "m";
724 assert(!std::regex_search(s, m, std::regex("[a[=M=]z]",
725 std::regex_constants::extended)));
726 assert(m.size() == 0);
727 }
728 {
729 std::cmatch m;
730 const char s[] = "01a45cef9";
731 assert(std::regex_search(s, m, std::regex("[ace1-9]*",
732 std::regex_constants::extended)));
733 assert(m.size() == 1);
734 assert(m.prefix().matched);
735 assert(m.prefix().first == s);
736 assert(m.prefix().second == m[0].first);
737 assert(m.suffix().matched);
738 assert(m.suffix().first == m[0].second);
739 assert(m.suffix().second == s + std::char_traits<char>::length(s));
740 assert(m.length(0) == 6);
741 assert(m.position(0) == 1);
742 assert(m.str(0) == "1a45ce");
743 }
744 {
745 const char r[] = "^[-+]?[0-9]+[CF]$";
746 std::ptrdiff_t sr = std::char_traits<char>::length(r);
747 typedef forward_iterator<const char*> FI;
748 typedef bidirectional_iterator<const char*> BI;
749 std::regex regex(FI(r), FI(r+sr), std::regex_constants::extended);
750 std::match_results<BI> m;
751 const char s[] = "-40C";
752 std::ptrdiff_t ss = std::char_traits<char>::length(s);
753 assert(std::regex_search(BI(s), BI(s+ss), m, regex));
754 assert(m.size() == 1);
755 assert(!m.prefix().matched);
756 assert(m.prefix().first == BI(s));
757 assert(m.prefix().second == m[0].first);
758 assert(!m.suffix().matched);
759 assert(m.suffix().first == m[0].second);
760 assert(m.suffix().second == m[0].second);
761 assert(m.length(0) == 4);
762 assert(m.position(0) == 0);
763 assert(m.str(0) == s);
764 }
765
766 {
767 std::wcmatch m;
768 const wchar_t s[] = L"a";
769 assert(std::regex_search(s, m, std::wregex(L"a", std::regex_constants::extended)));
770 assert(m.size() == 1);
771 assert(!m.empty());
772 assert(!m.prefix().matched);
773 assert(m.prefix().first == s);
774 assert(m.prefix().second == m[0].first);
775 assert(!m.suffix().matched);
776 assert(m.suffix().first == m[0].second);
777 assert(m.suffix().second == s+1);
778 assert(m.length(0) == 1);
779 assert(m.position(0) == 0);
780 assert(m.str(0) == L"a");
781 }
782 {
783 std::wcmatch m;
784 const wchar_t s[] = L"ab";
785 assert(std::regex_search(s, m, std::wregex(L"ab", std::regex_constants::extended)));
786 assert(m.size() == 1);
787 assert(!m.prefix().matched);
788 assert(m.prefix().first == s);
789 assert(m.prefix().second == m[0].first);
790 assert(!m.suffix().matched);
791 assert(m.suffix().first == m[0].second);
792 assert(m.suffix().second == s+2);
793 assert(m.length(0) == 2);
794 assert(m.position(0) == 0);
795 assert(m.str(0) == L"ab");
796 }
797 {
798 std::wcmatch m;
799 const wchar_t s[] = L"ab";
800 assert(!std::regex_search(s, m, std::wregex(L"ba", std::regex_constants::extended)));
801 assert(m.size() == 0);
802 assert(m.empty());
803 }
804 {
805 std::wcmatch m;
806 const wchar_t s[] = L"aab";
807 assert(std::regex_search(s, m, std::wregex(L"ab", std::regex_constants::extended)));
808 assert(m.size() == 1);
809 assert(m.prefix().matched);
810 assert(m.prefix().first == s);
811 assert(m.prefix().second == m[0].first);
812 assert(!m.suffix().matched);
813 assert(m.suffix().first == m[0].second);
814 assert(m.suffix().second == s+3);
815 assert(m.length(0) == 2);
816 assert(m.position(0) == 1);
817 assert(m.str(0) == L"ab");
818 }
819 {
820 std::wcmatch m;
821 const wchar_t s[] = L"aab";
822 assert(!std::regex_search(s, m, std::wregex(L"ab", std::regex_constants::extended),
823 std::regex_constants::match_continuous));
824 assert(m.size() == 0);
825 }
826 {
827 std::wcmatch m;
828 const wchar_t s[] = L"abcd";
829 assert(std::regex_search(s, m, std::wregex(L"bc", std::regex_constants::extended)));
830 assert(m.size() == 1);
831 assert(m.prefix().matched);
832 assert(m.prefix().first == s);
833 assert(m.prefix().second == m[0].first);
834 assert(m.suffix().matched);
835 assert(m.suffix().first == m[0].second);
836 assert(m.suffix().second == s+4);
837 assert(m.length(0) == 2);
838 assert(m.position(0) == 1);
839 assert(m.str(0) == L"bc");
840 }
841 {
842 std::wcmatch m;
843 const wchar_t s[] = L"abbc";
844 assert(std::regex_search(s, m, std::wregex(L"ab*c", std::regex_constants::extended)));
845 assert(m.size() == 1);
846 assert(!m.prefix().matched);
847 assert(m.prefix().first == s);
848 assert(m.prefix().second == m[0].first);
849 assert(!m.suffix().matched);
850 assert(m.suffix().first == m[0].second);
851 assert(m.suffix().second == s+4);
852 assert(m.length(0) == 4);
853 assert(m.position(0) == 0);
854 assert(m.str(0) == s);
855 }
856 {
857 std::wcmatch m;
858 const wchar_t s[] = L"ababc";
859 assert(std::regex_search(s, m, std::wregex(L"(ab)*c", std::regex_constants::extended)));
860 assert(m.size() == 2);
861 assert(!m.prefix().matched);
862 assert(m.prefix().first == s);
863 assert(m.prefix().second == m[0].first);
864 assert(!m.suffix().matched);
865 assert(m.suffix().first == m[0].second);
866 assert(m.suffix().second == s+5);
867 assert(m.length(0) == 5);
868 assert(m.position(0) == 0);
869 assert(m.str(0) == s);
870 assert(m.length(1) == 2);
871 assert(m.position(1) == 2);
872 assert(m.str(1) == L"ab");
873 }
874 {
875 std::wcmatch m;
876 const wchar_t s[] = L"abcdefghijk";
877 assert(std::regex_search(s, m, std::wregex(L"cd((e)fg)hi",
878 std::regex_constants::extended)));
879 assert(m.size() == 3);
880 assert(m.prefix().matched);
881 assert(m.prefix().first == s);
882 assert(m.prefix().second == m[0].first);
883 assert(m.suffix().matched);
884 assert(m.suffix().first == m[0].second);
885 assert(m.suffix().second == s+std::regex_traits<wchar_t>::length(s));
886 assert(m.length(0) == 7);
887 assert(m.position(0) == 2);
888 assert(m.str(0) == L"cdefghi");
889 assert(m.length(1) == 3);
890 assert(m.position(1) == 4);
891 assert(m.str(1) == L"efg");
892 assert(m.length(2) == 1);
893 assert(m.position(2) == 4);
894 assert(m.str(2) == L"e");
895 }
896 {
897 std::wcmatch m;
898 const wchar_t s[] = L"abc";
899 assert(std::regex_search(s, m, std::wregex(L"^abc", std::regex_constants::extended)));
900 assert(m.size() == 1);
901 assert(!m.prefix().matched);
902 assert(m.prefix().first == s);
903 assert(m.prefix().second == m[0].first);
904 assert(!m.suffix().matched);
905 assert(m.suffix().first == m[0].second);
906 assert(m.suffix().second == s+3);
907 assert(m.length(0) == 3);
908 assert(m.position(0) == 0);
909 assert(m.str(0) == s);
910 }
911 {
912 std::wcmatch m;
913 const wchar_t s[] = L"abcd";
914 assert(std::regex_search(s, m, std::wregex(L"^abc", std::regex_constants::extended)));
915 assert(m.size() == 1);
916 assert(!m.prefix().matched);
917 assert(m.prefix().first == s);
918 assert(m.prefix().second == m[0].first);
919 assert(m.suffix().matched);
920 assert(m.suffix().first == m[0].second);
921 assert(m.suffix().second == s+4);
922 assert(m.length(0) == 3);
923 assert(m.position(0) == 0);
924 assert(m.str(0) == L"abc");
925 }
926 {
927 std::wcmatch m;
928 const wchar_t s[] = L"aabc";
929 assert(!std::regex_search(s, m, std::wregex(L"^abc", std::regex_constants::extended)));
930 assert(m.size() == 0);
931 }
932 {
933 std::wcmatch m;
934 const wchar_t s[] = L"abc";
935 assert(std::regex_search(s, m, std::wregex(L"abc$", std::regex_constants::extended)));
936 assert(m.size() == 1);
937 assert(!m.prefix().matched);
938 assert(m.prefix().first == s);
939 assert(m.prefix().second == m[0].first);
940 assert(!m.suffix().matched);
941 assert(m.suffix().first == m[0].second);
942 assert(m.suffix().second == s+3);
943 assert(m.length(0) == 3);
944 assert(m.position(0) == 0);
945 assert(m.str(0) == s);
946 }
947 {
948 std::wcmatch m;
949 const wchar_t s[] = L"efabc";
950 assert(std::regex_search(s, m, std::wregex(L"abc$", std::regex_constants::extended)));
951 assert(m.size() == 1);
952 assert(m.prefix().matched);
953 assert(m.prefix().first == s);
954 assert(m.prefix().second == m[0].first);
955 assert(!m.suffix().matched);
956 assert(m.suffix().first == m[0].second);
957 assert(m.suffix().second == s+5);
958 assert(m.length(0) == 3);
959 assert(m.position(0) == 2);
960 assert(m.str(0) == s+2);
961 }
962 {
963 std::wcmatch m;
964 const wchar_t s[] = L"efabcg";
965 assert(!std::regex_search(s, m, std::wregex(L"abc$", std::regex_constants::extended)));
966 assert(m.size() == 0);
967 }
968 {
969 std::wcmatch m;
970 const wchar_t s[] = L"abc";
971 assert(std::regex_search(s, m, std::wregex(L"a.c", std::regex_constants::extended)));
972 assert(m.size() == 1);
973 assert(!m.prefix().matched);
974 assert(m.prefix().first == s);
975 assert(m.prefix().second == m[0].first);
976 assert(!m.suffix().matched);
977 assert(m.suffix().first == m[0].second);
978 assert(m.suffix().second == s+3);
979 assert(m.length(0) == 3);
980 assert(m.position(0) == 0);
981 assert(m.str(0) == s);
982 }
983 {
984 std::wcmatch m;
985 const wchar_t s[] = L"acc";
986 assert(std::regex_search(s, m, std::wregex(L"a.c", std::regex_constants::extended)));
987 assert(m.size() == 1);
988 assert(!m.prefix().matched);
989 assert(m.prefix().first == s);
990 assert(m.prefix().second == m[0].first);
991 assert(!m.suffix().matched);
992 assert(m.suffix().first == m[0].second);
993 assert(m.suffix().second == s+3);
994 assert(m.length(0) == 3);
995 assert(m.position(0) == 0);
996 assert(m.str(0) == s);
997 }
998 {
999 std::wcmatch m;
1000 const wchar_t s[] = L"acc";
1001 assert(std::regex_search(s, m, std::wregex(L"a.c", std::regex_constants::extended)));
1002 assert(m.size() == 1);
1003 assert(!m.prefix().matched);
1004 assert(m.prefix().first == s);
1005 assert(m.prefix().second == m[0].first);
1006 assert(!m.suffix().matched);
1007 assert(m.suffix().first == m[0].second);
1008 assert(m.suffix().second == s+3);
1009 assert(m.length(0) == 3);
1010 assert(m.position(0) == 0);
1011 assert(m.str(0) == s);
1012 }
1013 {
1014 std::wcmatch m;
1015 const wchar_t s[] = L"abcdef";
1016 assert(std::regex_search(s, m, std::wregex(L"(.*).*", std::regex_constants::extended)));
1017 assert(m.size() == 2);
1018 assert(!m.prefix().matched);
1019 assert(m.prefix().first == s);
1020 assert(m.prefix().second == m[0].first);
1021 assert(!m.suffix().matched);
1022 assert(m.suffix().first == m[0].second);
1023 assert(m.suffix().second == s+6);
1024 assert(m.length(0) == 6);
1025 assert(m.position(0) == 0);
1026 assert(m.str(0) == s);
1027 assert(m.length(1) == 6);
1028 assert(m.position(1) == 0);
1029 assert(m.str(1) == s);
1030 }
1031 {
1032 std::wcmatch m;
1033 const wchar_t s[] = L"bc";
1034 assert(std::regex_search(s, m, std::wregex(L"(a*)*", std::regex_constants::extended)));
1035 assert(m.size() == 2);
1036 assert(!m.prefix().matched);
1037 assert(m.prefix().first == s);
1038 assert(m.prefix().second == m[0].first);
1039 assert(m.suffix().matched);
1040 assert(m.suffix().first == m[0].second);
1041 assert(m.suffix().second == s+2);
1042 assert(m.length(0) == 0);
1043 assert(m.position(0) == 0);
1044 assert(m.str(0) == L"");
1045 assert(m.length(1) == 0);
1046 assert(m.position(1) == 0);
1047 assert(m.str(1) == L"");
1048 }
1049 {
1050 std::wcmatch m;
1051 const wchar_t s[] = L"abbc";
1052 assert(!std::regex_search(s, m, std::wregex(L"ab{3,5}c", std::regex_constants::extended)));
1053 assert(m.size() == 0);
1054 }
1055 {
1056 std::wcmatch m;
1057 const wchar_t s[] = L"abbbc";
1058 assert(std::regex_search(s, m, std::wregex(L"ab{3,5}c", std::regex_constants::extended)));
1059 assert(m.size() == 1);
1060 assert(!m.prefix().matched);
1061 assert(m.prefix().first == s);
1062 assert(m.prefix().second == m[0].first);
1063 assert(!m.suffix().matched);
1064 assert(m.suffix().first == m[0].second);
1065 assert(m.suffix().second == m[0].second);
1066 assert(m.length(0) == std::char_traits<wchar_t>::length(s));
1067 assert(m.position(0) == 0);
1068 assert(m.str(0) == s);
1069 }
1070 {
1071 std::wcmatch m;
1072 const wchar_t s[] = L"abbbbc";
1073 assert(std::regex_search(s, m, std::wregex(L"ab{3,5}c", std::regex_constants::extended)));
1074 assert(m.size() == 1);
1075 assert(!m.prefix().matched);
1076 assert(m.prefix().first == s);
1077 assert(m.prefix().second == m[0].first);
1078 assert(!m.suffix().matched);
1079 assert(m.suffix().first == m[0].second);
1080 assert(m.suffix().second == m[0].second);
1081 assert(m.length(0) == std::char_traits<wchar_t>::length(s));
1082 assert(m.position(0) == 0);
1083 assert(m.str(0) == s);
1084 }
1085 {
1086 std::wcmatch m;
1087 const wchar_t s[] = L"abbbbbc";
1088 assert(std::regex_search(s, m, std::wregex(L"ab{3,5}c", std::regex_constants::extended)));
1089 assert(m.size() == 1);
1090 assert(!m.prefix().matched);
1091 assert(m.prefix().first == s);
1092 assert(m.prefix().second == m[0].first);
1093 assert(!m.suffix().matched);
1094 assert(m.suffix().first == m[0].second);
1095 assert(m.suffix().second == m[0].second);
1096 assert(m.length(0) == std::char_traits<wchar_t>::length(s));
1097 assert(m.position(0) == 0);
1098 assert(m.str(0) == s);
1099 }
1100 {
1101 std::wcmatch m;
1102 const wchar_t s[] = L"adefc";
1103 assert(!std::regex_search(s, m, std::wregex(L"ab{3,5}c", std::regex_constants::extended)));
1104 assert(m.size() == 0);
1105 }
1106 {
1107 std::wcmatch m;
1108 const wchar_t s[] = L"abbbbbbc";
1109 assert(!std::regex_search(s, m, std::wregex(L"ab{3,5}c", std::regex_constants::extended)));
1110 assert(m.size() == 0);
1111 }
1112 {
1113 std::wcmatch m;
1114 const wchar_t s[] = L"adec";
1115 assert(!std::regex_search(s, m, std::wregex(L"a.{3,5}c", std::regex_constants::extended)));
1116 assert(m.size() == 0);
1117 }
1118 {
1119 std::wcmatch m;
1120 const wchar_t s[] = L"adefc";
1121 assert(std::regex_search(s, m, std::wregex(L"a.{3,5}c", std::regex_constants::extended)));
1122 assert(m.size() == 1);
1123 assert(!m.prefix().matched);
1124 assert(m.prefix().first == s);
1125 assert(m.prefix().second == m[0].first);
1126 assert(!m.suffix().matched);
1127 assert(m.suffix().first == m[0].second);
1128 assert(m.suffix().second == m[0].second);
1129 assert(m.length(0) == std::char_traits<wchar_t>::length(s));
1130 assert(m.position(0) == 0);
1131 assert(m.str(0) == s);
1132 }
1133 {
1134 std::wcmatch m;
1135 const wchar_t s[] = L"adefgc";
1136 assert(std::regex_search(s, m, std::wregex(L"a.{3,5}c", std::regex_constants::extended)));
1137 assert(m.size() == 1);
1138 assert(!m.prefix().matched);
1139 assert(m.prefix().first == s);
1140 assert(m.prefix().second == m[0].first);
1141 assert(!m.suffix().matched);
1142 assert(m.suffix().first == m[0].second);
1143 assert(m.suffix().second == m[0].second);
1144 assert(m.length(0) == std::char_traits<wchar_t>::length(s));
1145 assert(m.position(0) == 0);
1146 assert(m.str(0) == s);
1147 }
1148 {
1149 std::wcmatch m;
1150 const wchar_t s[] = L"adefghc";
1151 assert(std::regex_search(s, m, std::wregex(L"a.{3,5}c", std::regex_constants::extended)));
1152 assert(m.size() == 1);
1153 assert(!m.prefix().matched);
1154 assert(m.prefix().first == s);
1155 assert(m.prefix().second == m[0].first);
1156 assert(!m.suffix().matched);
1157 assert(m.suffix().first == m[0].second);
1158 assert(m.suffix().second == m[0].second);
1159 assert(m.length(0) == std::char_traits<wchar_t>::length(s));
1160 assert(m.position(0) == 0);
1161 assert(m.str(0) == s);
1162 }
1163 {
1164 std::wcmatch m;
1165 const wchar_t s[] = L"adefghic";
1166 assert(!std::regex_search(s, m, std::wregex(L"a.{3,5}c", std::regex_constants::extended)));
1167 assert(m.size() == 0);
1168 }
1169 {
1170 std::wcmatch m;
1171 const wchar_t s[] = L"tournament";
1172 assert(std::regex_search(s, m, std::wregex(L"tour|to|tournament",
1173 std::regex_constants::extended)));
1174 assert(m.size() == 1);
1175 assert(!m.prefix().matched);
1176 assert(m.prefix().first == s);
1177 assert(m.prefix().second == m[0].first);
1178 assert(!m.suffix().matched);
1179 assert(m.suffix().first == m[0].second);
1180 assert(m.suffix().second == m[0].second);
1181 assert(m.length(0) == std::char_traits<wchar_t>::length(s));
1182 assert(m.position(0) == 0);
1183 assert(m.str(0) == s);
1184 }
1185 {
1186 std::wcmatch m;
1187 const wchar_t s[] = L"tournamenttotour";
1188 assert(std::regex_search(s, m, std::wregex(L"(tour|to|tournament)+",
1189 std::regex_constants::extended | std::regex_constants::nosubs)));
1190 assert(m.size() == 1);
1191 assert(!m.prefix().matched);
1192 assert(m.prefix().first == s);
1193 assert(m.prefix().second == m[0].first);
1194 assert(!m.suffix().matched);
1195 assert(m.suffix().first == m[0].second);
1196 assert(m.suffix().second == m[0].second);
1197 assert(m.length(0) == std::char_traits<wchar_t>::length(s));
1198 assert(m.position(0) == 0);
1199 assert(m.str(0) == s);
1200 }
1201 {
1202 std::wcmatch m;
1203 const wchar_t s[] = L"ttotour";
1204 assert(std::regex_search(s, m, std::wregex(L"(tour|to|t)+",
1205 std::regex_constants::extended)));
1206 assert(m.size() == 2);
1207 assert(!m.prefix().matched);
1208 assert(m.prefix().first == s);
1209 assert(m.prefix().second == m[0].first);
1210 assert(!m.suffix().matched);
1211 assert(m.suffix().first == m[0].second);
1212 assert(m.suffix().second == m[0].second);
1213 assert(m.length(0) == std::char_traits<wchar_t>::length(s));
1214 assert(m.position(0) == 0);
1215 assert(m.str(0) == s);
1216 assert(m.length(1) == 4);
1217 assert(m.position(1) == 3);
1218 assert(m.str(1) == L"tour");
1219 }
1220 {
1221 std::wcmatch m;
1222 const wchar_t s[] = L"-ab,ab-";
1223 assert(!std::regex_search(s, m, std::wregex(L"-(.*),\1-", std::regex_constants::extended)));
1224 assert(m.size() == 0);
1225 }
1226 {
1227 std::wcmatch m;
1228 const wchar_t s[] = L"-ab,ab-";
1229 assert(std::regex_search(s, m, std::wregex(L"-.*,.*-", std::regex_constants::extended)));
1230 assert(m.size() == 1);
1231 assert(!m.prefix().matched);
1232 assert(m.prefix().first == s);
1233 assert(m.prefix().second == m[0].first);
1234 assert(!m.suffix().matched);
1235 assert(m.suffix().first == m[0].second);
1236 assert(m.suffix().second == m[0].second);
1237 assert(m.length(0) == std::char_traits<wchar_t>::length(s));
1238 assert(m.position(0) == 0);
1239 assert(m.str(0) == s);
1240 }
1241 {
1242 std::wcmatch m;
1243 const wchar_t s[] = L"a";
1244 assert(std::regex_search(s, m, std::wregex(L"^[a]$",
1245 std::regex_constants::extended)));
1246 assert(m.size() == 1);
1247 assert(!m.prefix().matched);
1248 assert(m.prefix().first == s);
1249 assert(m.prefix().second == m[0].first);
1250 assert(!m.suffix().matched);
1251 assert(m.suffix().first == m[0].second);
1252 assert(m.suffix().second == m[0].second);
1253 assert(m.length(0) == 1);
1254 assert(m.position(0) == 0);
1255 assert(m.str(0) == L"a");
1256 }
1257 {
1258 std::wcmatch m;
1259 const wchar_t s[] = L"a";
1260 assert(std::regex_search(s, m, std::wregex(L"^[ab]$",
1261 std::regex_constants::extended)));
1262 assert(m.size() == 1);
1263 assert(!m.prefix().matched);
1264 assert(m.prefix().first == s);
1265 assert(m.prefix().second == m[0].first);
1266 assert(!m.suffix().matched);
1267 assert(m.suffix().first == m[0].second);
1268 assert(m.suffix().second == m[0].second);
1269 assert(m.length(0) == 1);
1270 assert(m.position(0) == 0);
1271 assert(m.str(0) == L"a");
1272 }
1273 {
1274 std::wcmatch m;
1275 const wchar_t s[] = L"c";
1276 assert(std::regex_search(s, m, std::wregex(L"^[a-f]$",
1277 std::regex_constants::extended)));
1278 assert(m.size() == 1);
1279 assert(!m.prefix().matched);
1280 assert(m.prefix().first == s);
1281 assert(m.prefix().second == m[0].first);
1282 assert(!m.suffix().matched);
1283 assert(m.suffix().first == m[0].second);
1284 assert(m.suffix().second == m[0].second);
1285 assert(m.length(0) == 1);
1286 assert(m.position(0) == 0);
1287 assert(m.str(0) == s);
1288 }
1289 {
1290 std::wcmatch m;
1291 const wchar_t s[] = L"g";
1292 assert(!std::regex_search(s, m, std::wregex(L"^[a-f]$",
1293 std::regex_constants::extended)));
1294 assert(m.size() == 0);
1295 }
1296 {
1297 std::wcmatch m;
1298 const wchar_t s[] = L"Iraqi";
1299 assert(std::regex_search(s, m, std::wregex(L"q[^u]",
1300 std::regex_constants::extended)));
1301 assert(m.size() == 1);
1302 assert(m.prefix().matched);
1303 assert(m.prefix().first == s);
1304 assert(m.prefix().second == m[0].first);
1305 assert(!m.suffix().matched);
1306 assert(m.suffix().first == m[0].second);
1307 assert(m.suffix().second == m[0].second);
1308 assert(m.length(0) == 2);
1309 assert(m.position(0) == 3);
1310 assert(m.str(0) == L"qi");
1311 }
1312 {
1313 std::wcmatch m;
1314 const wchar_t s[] = L"Iraq";
1315 assert(!std::regex_search(s, m, std::wregex(L"q[^u]",
1316 std::regex_constants::extended)));
1317 assert(m.size() == 0);
1318 }
1319 {
1320 std::wcmatch m;
1321 const wchar_t s[] = L"AmB";
1322 assert(std::regex_search(s, m, std::wregex(L"A[[:lower:]]B",
1323 std::regex_constants::extended)));
1324 assert(m.size() == 1);
1325 assert(!m.prefix().matched);
1326 assert(m.prefix().first == s);
1327 assert(m.prefix().second == m[0].first);
1328 assert(!m.suffix().matched);
1329 assert(m.suffix().first == m[0].second);
1330 assert(m.suffix().second == m[0].second);
1331 assert(m.length(0) == std::char_traits<wchar_t>::length(s));
1332 assert(m.position(0) == 0);
1333 assert(m.str(0) == s);
1334 }
1335 {
1336 std::wcmatch m;
1337 const wchar_t s[] = L"AMB";
1338 assert(!std::regex_search(s, m, std::wregex(L"A[[:lower:]]B",
1339 std::regex_constants::extended)));
1340 assert(m.size() == 0);
1341 }
1342 {
1343 std::wcmatch m;
1344 const wchar_t s[] = L"AMB";
1345 assert(std::regex_search(s, m, std::wregex(L"A[^[:lower:]]B",
1346 std::regex_constants::extended)));
1347 assert(m.size() == 1);
1348 assert(!m.prefix().matched);
1349 assert(m.prefix().first == s);
1350 assert(m.prefix().second == m[0].first);
1351 assert(!m.suffix().matched);
1352 assert(m.suffix().first == m[0].second);
1353 assert(m.suffix().second == m[0].second);
1354 assert(m.length(0) == std::char_traits<wchar_t>::length(s));
1355 assert(m.position(0) == 0);
1356 assert(m.str(0) == s);
1357 }
1358 {
1359 std::wcmatch m;
1360 const wchar_t s[] = L"AmB";
1361 assert(!std::regex_search(s, m, std::wregex(L"A[^[:lower:]]B",
1362 std::regex_constants::extended)));
1363 assert(m.size() == 0);
1364 }
1365 {
1366 std::wcmatch m;
1367 const wchar_t s[] = L"A5B";
1368 assert(!std::regex_search(s, m, std::wregex(L"A[^[:lower:]0-9]B",
1369 std::regex_constants::extended)));
1370 assert(m.size() == 0);
1371 }
1372 {
1373 std::wcmatch m;
1374 const wchar_t s[] = L"A?B";
1375 assert(std::regex_search(s, m, std::wregex(L"A[^[:lower:]0-9]B",
1376 std::regex_constants::extended)));
1377 assert(m.size() == 1);
1378 assert(!m.prefix().matched);
1379 assert(m.prefix().first == s);
1380 assert(m.prefix().second == m[0].first);
1381 assert(!m.suffix().matched);
1382 assert(m.suffix().first == m[0].second);
1383 assert(m.suffix().second == m[0].second);
1384 assert(m.length(0) == std::char_traits<wchar_t>::length(s));
1385 assert(m.position(0) == 0);
1386 assert(m.str(0) == s);
1387 }
1388 {
1389 std::wcmatch m;
1390 const wchar_t s[] = L"-";
1391 assert(std::regex_search(s, m, std::wregex(L"[a[.hyphen.]z]",
1392 std::regex_constants::extended)));
1393 assert(m.size() == 1);
1394 assert(!m.prefix().matched);
1395 assert(m.prefix().first == s);
1396 assert(m.prefix().second == m[0].first);
1397 assert(!m.suffix().matched);
1398 assert(m.suffix().first == m[0].second);
1399 assert(m.suffix().second == m[0].second);
1400 assert(m.length(0) == std::char_traits<wchar_t>::length(s));
1401 assert(m.position(0) == 0);
1402 assert(m.str(0) == s);
1403 }
1404 {
1405 std::wcmatch m;
1406 const wchar_t s[] = L"z";
1407 assert(std::regex_search(s, m, std::wregex(L"[a[.hyphen.]z]",
1408 std::regex_constants::extended)));
1409 assert(m.size() == 1);
1410 assert(!m.prefix().matched);
1411 assert(m.prefix().first == s);
1412 assert(m.prefix().second == m[0].first);
1413 assert(!m.suffix().matched);
1414 assert(m.suffix().first == m[0].second);
1415 assert(m.suffix().second == m[0].second);
1416 assert(m.length(0) == std::char_traits<wchar_t>::length(s));
1417 assert(m.position(0) == 0);
1418 assert(m.str(0) == s);
1419 }
1420 {
1421 std::wcmatch m;
1422 const wchar_t s[] = L"m";
1423 assert(!std::regex_search(s, m, std::wregex(L"[a[.hyphen.]z]",
1424 std::regex_constants::extended)));
1425 assert(m.size() == 0);
1426 }
1427 std::locale::global(std::locale("cs_CZ.ISO8859-2"));
1428 {
1429 std::wcmatch m;
1430 const wchar_t s[] = L"m";
1431 assert(std::regex_search(s, m, std::wregex(L"[a[=M=]z]",
1432 std::regex_constants::extended)));
1433 assert(m.size() == 1);
1434 assert(!m.prefix().matched);
1435 assert(m.prefix().first == s);
1436 assert(m.prefix().second == m[0].first);
1437 assert(!m.suffix().matched);
1438 assert(m.suffix().first == m[0].second);
1439 assert(m.suffix().second == m[0].second);
1440 assert(m.length(0) == std::char_traits<wchar_t>::length(s));
1441 assert(m.position(0) == 0);
1442 assert(m.str(0) == s);
1443 }
1444 {
1445 std::wcmatch m;
1446 const wchar_t s[] = L"Ch";
1447 assert(std::regex_search(s, m, std::wregex(L"[a[.ch.]z]",
1448 std::regex_constants::extended | std::regex_constants::icase)));
1449 assert(m.size() == 1);
1450 assert(!m.prefix().matched);
1451 assert(m.prefix().first == s);
1452 assert(m.prefix().second == m[0].first);
1453 assert(!m.suffix().matched);
1454 assert(m.suffix().first == m[0].second);
1455 assert(m.suffix().second == m[0].second);
1456 assert(m.length(0) == std::char_traits<wchar_t>::length(s));
1457 assert(m.position(0) == 0);
1458 assert(m.str(0) == s);
1459 }
1460 std::locale::global(std::locale("C"));
1461 {
1462 std::wcmatch m;
1463 const wchar_t s[] = L"m";
1464 assert(!std::regex_search(s, m, std::wregex(L"[a[=M=]z]",
1465 std::regex_constants::extended)));
1466 assert(m.size() == 0);
1467 }
1468 {
1469 std::wcmatch m;
1470 const wchar_t s[] = L"01a45cef9";
1471 assert(std::regex_search(s, m, std::wregex(L"[ace1-9]*",
1472 std::regex_constants::extended)));
1473 assert(m.size() == 1);
1474 assert(m.prefix().matched);
1475 assert(m.prefix().first == s);
1476 assert(m.prefix().second == m[0].first);
1477 assert(m.suffix().matched);
1478 assert(m.suffix().first == m[0].second);
1479 assert(m.suffix().second == s + std::char_traits<wchar_t>::length(s));
1480 assert(m.length(0) == 6);
1481 assert(m.position(0) == 1);
1482 assert(m.str(0) == L"1a45ce");
1483 }
1484 {
1485 const wchar_t r[] = L"^[-+]?[0-9]+[CF]$";
1486 std::ptrdiff_t sr = std::char_traits<wchar_t>::length(r);
1487 typedef forward_iterator<const wchar_t*> FI;
1488 typedef bidirectional_iterator<const wchar_t*> BI;
1489 std::wregex regex(FI(r), FI(r+sr), std::regex_constants::extended);
1490 std::match_results<BI> m;
1491 const wchar_t s[] = L"-40C";
1492 std::ptrdiff_t ss = std::char_traits<wchar_t>::length(s);
1493 assert(std::regex_search(BI(s), BI(s+ss), m, regex));
1494 assert(m.size() == 1);
1495 assert(!m.prefix().matched);
1496 assert(m.prefix().first == BI(s));
1497 assert(m.prefix().second == m[0].first);
1498 assert(!m.suffix().matched);
1499 assert(m.suffix().first == m[0].second);
1500 assert(m.suffix().second == m[0].second);
1501 assert(m.length(0) == 4);
1502 assert(m.position(0) == 0);
1503 assert(m.str(0) == s);
1504 }
Howard Hinnantc1198c32010-07-16 19:08:36 +0000[diff] [blame]1505}