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