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