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