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