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