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
main(int,char **)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<std::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<std::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<std::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<std::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<std::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<std::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<std::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<std::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<std::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<std::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<std::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<std::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<std::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<std::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<std::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<std::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<std::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<std::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<std::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<std::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<std::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<std::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<std::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<std::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<std::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<std::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<std::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<std::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<std::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<std::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<std::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<std::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