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