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