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