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