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