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