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