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