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