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