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