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