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::extended)));
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::extended)));
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::extended)));
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::extended)));
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::extended),
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::extended)));
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::extended)));
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::extended)));
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::extended)));
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::extended)));
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::extended)));
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::extended)));
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::extended)));
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::extended)));
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::extended)));
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::extended)));
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::extended)));
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::extended)));
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::extended)));
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::extended)));
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::extended)));
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::extended)));
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::extended)));
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::extended)));
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::extended)));
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::extended)));
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::extended)));
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::extended)));
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::extended)));
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::extended)));
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::extended)));
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::extended)));
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::extended | 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::extended)));
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::extended)));
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("-(.*),\\1-", std::regex_constants::extended)));
490 assert(m.size() == 2);
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 assert(m.length(1) == 2);
501 assert(m.position(1) == 1);
502 assert(m.str(1) == "ab");
503 }
504 {
505 std::cmatch m;
506 const char s[] = "-ab,ab-";
507 assert(std::regex_search(s, m, std::regex("-.*,.*-", std::regex_constants::extended)));
508 assert(m.size() == 1);
509 assert(!m.prefix().matched);
510 assert(m.prefix().first == s);
511 assert(m.prefix().second == m[0].first);
512 assert(!m.suffix().matched);
513 assert(m.suffix().first == m[0].second);
514 assert(m.suffix().second == m[0].second);
515 assert(m.length(0) >= 0 && static_cast<std::size_t>(m.length(0)) == std::char_traits<char>::length(s));
516 assert(m.position(0) == 0);
517 assert(m.str(0) == s);
518 }
519 {
520 std::cmatch m;
521 const char s[] = "a";
522 assert(std::regex_search(s, m, std::regex("^[a]$",
523 std::regex_constants::extended)));
524 assert(m.size() == 1);
525 assert(!m.prefix().matched);
526 assert(m.prefix().first == s);
527 assert(m.prefix().second == m[0].first);
528 assert(!m.suffix().matched);
529 assert(m.suffix().first == m[0].second);
530 assert(m.suffix().second == m[0].second);
531 assert(m.length(0) == 1);
532 assert(m.position(0) == 0);
533 assert(m.str(0) == "a");
534 }
535 {
536 std::cmatch m;
537 const char s[] = "a";
538 assert(std::regex_search(s, m, std::regex("^[ab]$",
539 std::regex_constants::extended)));
540 assert(m.size() == 1);
541 assert(!m.prefix().matched);
542 assert(m.prefix().first == s);
543 assert(m.prefix().second == m[0].first);
544 assert(!m.suffix().matched);
545 assert(m.suffix().first == m[0].second);
546 assert(m.suffix().second == m[0].second);
547 assert(m.length(0) == 1);
548 assert(m.position(0) == 0);
549 assert(m.str(0) == "a");
550 }
551 {
552 std::cmatch m;
553 const char s[] = "c";
554 assert(std::regex_search(s, m, std::regex("^[a-f]$",
555 std::regex_constants::extended)));
556 assert(m.size() == 1);
557 assert(!m.prefix().matched);
558 assert(m.prefix().first == s);
559 assert(m.prefix().second == m[0].first);
560 assert(!m.suffix().matched);
561 assert(m.suffix().first == m[0].second);
562 assert(m.suffix().second == m[0].second);
563 assert(m.length(0) == 1);
564 assert(m.position(0) == 0);
565 assert(m.str(0) == s);
566 }
567 {
568 std::cmatch m;
569 const char s[] = "g";
570 assert(!std::regex_search(s, m, std::regex("^[a-f]$",
571 std::regex_constants::extended)));
572 assert(m.size() == 0);
573 }
574 {
575 std::cmatch m;
576 const char s[] = "Iraqi";
577 assert(std::regex_search(s, m, std::regex("q[^u]",
578 std::regex_constants::extended)));
579 assert(m.size() == 1);
580 assert(m.prefix().matched);
581 assert(m.prefix().first == s);
582 assert(m.prefix().second == m[0].first);
583 assert(!m.suffix().matched);
584 assert(m.suffix().first == m[0].second);
585 assert(m.suffix().second == m[0].second);
586 assert(m.length(0) == 2);
587 assert(m.position(0) == 3);
588 assert(m.str(0) == "qi");
589 }
590 {
591 std::cmatch m;
592 const char s[] = "Iraq";
593 assert(!std::regex_search(s, m, std::regex("q[^u]",
594 std::regex_constants::extended)));
595 assert(m.size() == 0);
596 }
597 {
598 std::cmatch m;
599 const char s[] = "AmB";
600 assert(std::regex_search(s, m, std::regex("A[[:lower:]]B",
601 std::regex_constants::extended)));
602 assert(m.size() == 1);
603 assert(!m.prefix().matched);
604 assert(m.prefix().first == s);
605 assert(m.prefix().second == m[0].first);
606 assert(!m.suffix().matched);
607 assert(m.suffix().first == m[0].second);
608 assert(m.suffix().second == m[0].second);
609 assert(m.length(0) >= 0 && static_cast<std::size_t>(m.length(0)) == std::char_traits<char>::length(s));
610 assert(m.position(0) == 0);
611 assert(m.str(0) == s);
612 }
613 {
614 std::cmatch m;
615 const char s[] = "AMB";
616 assert(!std::regex_search(s, m, std::regex("A[[:lower:]]B",
617 std::regex_constants::extended)));
618 assert(m.size() == 0);
619 }
620 {
621 std::cmatch m;
622 const char s[] = "AMB";
623 assert(std::regex_search(s, m, std::regex("A[^[:lower:]]B",
624 std::regex_constants::extended)));
625 assert(m.size() == 1);
626 assert(!m.prefix().matched);
627 assert(m.prefix().first == s);
628 assert(m.prefix().second == m[0].first);
629 assert(!m.suffix().matched);
630 assert(m.suffix().first == m[0].second);
631 assert(m.suffix().second == m[0].second);
632 assert(m.length(0) >= 0 && static_cast<std::size_t>(m.length(0)) == std::char_traits<char>::length(s));
633 assert(m.position(0) == 0);
634 assert(m.str(0) == s);
635 }
636 {
637 std::cmatch m;
638 const char s[] = "AmB";
639 assert(!std::regex_search(s, m, std::regex("A[^[:lower:]]B",
640 std::regex_constants::extended)));
641 assert(m.size() == 0);
642 }
643 {
644 std::cmatch m;
645 const char s[] = "A5B";
646 assert(!std::regex_search(s, m, std::regex("A[^[:lower:]0-9]B",
647 std::regex_constants::extended)));
648 assert(m.size() == 0);
649 }
650 {
651 std::cmatch m;
652 const char s[] = "A?B";
653 assert(std::regex_search(s, m, std::regex("A[^[:lower:]0-9]B",
654 std::regex_constants::extended)));
655 assert(m.size() == 1);
656 assert(!m.prefix().matched);
657 assert(m.prefix().first == s);
658 assert(m.prefix().second == m[0].first);
659 assert(!m.suffix().matched);
660 assert(m.suffix().first == m[0].second);
661 assert(m.suffix().second == m[0].second);
662 assert(m.length(0) >= 0 && static_cast<std::size_t>(m.length(0)) == std::char_traits<char>::length(s));
663 assert(m.position(0) == 0);
664 assert(m.str(0) == s);
665 }
666 {
667 std::cmatch m;
668 const char s[] = "-";
669 assert(std::regex_search(s, m, std::regex("[a[.hyphen.]z]",
670 std::regex_constants::extended)));
671 assert(m.size() == 1);
672 assert(!m.prefix().matched);
673 assert(m.prefix().first == s);
674 assert(m.prefix().second == m[0].first);
675 assert(!m.suffix().matched);
676 assert(m.suffix().first == m[0].second);
677 assert(m.suffix().second == m[0].second);
678 assert(m.length(0) >= 0 && static_cast<std::size_t>(m.length(0)) == std::char_traits<char>::length(s));
679 assert(m.position(0) == 0);
680 assert(m.str(0) == s);
681 }
682 {
683 std::cmatch m;
684 const char s[] = "z";
685 assert(std::regex_search(s, m, std::regex("[a[.hyphen.]z]",
686 std::regex_constants::extended)));
687 assert(m.size() == 1);
688 assert(!m.prefix().matched);
689 assert(m.prefix().first == s);
690 assert(m.prefix().second == m[0].first);
691 assert(!m.suffix().matched);
692 assert(m.suffix().first == m[0].second);
693 assert(m.suffix().second == m[0].second);
694 assert(m.length(0) >= 0 && static_cast<std::size_t>(m.length(0)) == std::char_traits<char>::length(s));
695 assert(m.position(0) == 0);
696 assert(m.str(0) == s);
697 }
698 {
699 std::cmatch m;
700 const char s[] = "m";
701 assert(!std::regex_search(s, m, std::regex("[a[.hyphen.]z]",
702 std::regex_constants::extended)));
703 assert(m.size() == 0);
704 }
705 {
706 std::cmatch m;
707 const char s[] = "01a45cef9";
708 assert(std::regex_search(s, m, std::regex("[ace1-9]*",
709 std::regex_constants::extended)));
710 assert(m.size() == 1);
711 assert(!m.prefix().matched);
712 assert(m.prefix().first == s);
713 assert(m.prefix().second == m[0].first);
714 assert(m.suffix().matched);
715 assert(m.suffix().first == m[0].second);
716 assert(m.suffix().second == s + std::char_traits<char>::length(s));
717 assert(m.length(0) == 0);
718 assert(m.position(0) == 0);
719 assert(m.str(0) == "");
720 }
721 {
722 std::cmatch m;
723 const char s[] = "01a45cef9";
724 assert(std::regex_search(s, m, std::regex("[ace1-9]+",
725 std::regex_constants::extended)));
726 assert(m.size() == 1);
727 assert(m.prefix().matched);
728 assert(m.prefix().first == s);
729 assert(m.prefix().second == m[0].first);
730 assert(m.suffix().matched);
731 assert(m.suffix().first == m[0].second);
732 assert(m.suffix().second == s + std::char_traits<char>::length(s));
733 assert(m.length(0) == 6);
734 assert(m.position(0) == 1);
735 assert(m.str(0) == "1a45ce");
736 }
737 {
738 const char r[] = "^[-+]?[0-9]+[CF]$";
739 std::ptrdiff_t sr = std::char_traits<char>::length(r);
740 typedef forward_iterator<const char*> FI;
741 typedef bidirectional_iterator<const char*> BI;
742 std::regex regex(FI(r), FI(r+sr), std::regex_constants::extended);
743 std::match_results<BI> m;
744 const char s[] = "-40C";
745 std::ptrdiff_t ss = std::char_traits<char>::length(s);
746 assert(std::regex_search(BI(s), BI(s+ss), m, regex));
747 assert(m.size() == 1);
748 assert(!m.prefix().matched);
749 assert(m.prefix().first == BI(s));
750 assert(m.prefix().second == m[0].first);
751 assert(!m.suffix().matched);
752 assert(m.suffix().first == m[0].second);
753 assert(m.suffix().second == m[0].second);
754 assert(m.length(0) == 4);
755 assert(m.position(0) == 0);
756 assert(m.str(0) == s);
757 }
758
759 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
760 {
761 std::wcmatch m;
762 const wchar_t s[] = L"a";
763 assert(std::regex_search(s, m, std::wregex(L"a", std::regex_constants::extended)));
764 assert(m.size() == 1);
765 assert(!m.empty());
766 assert(!m.prefix().matched);
767 assert(m.prefix().first == s);
768 assert(m.prefix().second == m[0].first);
769 assert(!m.suffix().matched);
770 assert(m.suffix().first == m[0].second);
771 assert(m.suffix().second == s+1);
772 assert(m.length(0) == 1);
773 assert(m.position(0) == 0);
774 assert(m.str(0) == L"a");
775 }
776 {
777 std::wcmatch m;
778 const wchar_t s[] = L"ab";
779 assert(std::regex_search(s, m, std::wregex(L"ab", std::regex_constants::extended)));
780 assert(m.size() == 1);
781 assert(!m.prefix().matched);
782 assert(m.prefix().first == s);
783 assert(m.prefix().second == m[0].first);
784 assert(!m.suffix().matched);
785 assert(m.suffix().first == m[0].second);
786 assert(m.suffix().second == s+2);
787 assert(m.length(0) == 2);
788 assert(m.position(0) == 0);
789 assert(m.str(0) == L"ab");
790 }
791 {
792 std::wcmatch m;
793 const wchar_t s[] = L"ab";
794 assert(!std::regex_search(s, m, std::wregex(L"ba", std::regex_constants::extended)));
795 assert(m.size() == 0);
796 assert(m.empty());
797 }
798 {
799 std::wcmatch m;
800 const wchar_t s[] = L"aab";
801 assert(std::regex_search(s, m, std::wregex(L"ab", std::regex_constants::extended)));
802 assert(m.size() == 1);
803 assert(m.prefix().matched);
804 assert(m.prefix().first == s);
805 assert(m.prefix().second == m[0].first);
806 assert(!m.suffix().matched);
807 assert(m.suffix().first == m[0].second);
808 assert(m.suffix().second == s+3);
809 assert(m.length(0) == 2);
810 assert(m.position(0) == 1);
811 assert(m.str(0) == L"ab");
812 }
813 {
814 std::wcmatch m;
815 const wchar_t s[] = L"aab";
816 assert(!std::regex_search(s, m, std::wregex(L"ab", std::regex_constants::extended),
817 std::regex_constants::match_continuous));
818 assert(m.size() == 0);
819 }
820 {
821 std::wcmatch m;
822 const wchar_t s[] = L"abcd";
823 assert(std::regex_search(s, m, std::wregex(L"bc", std::regex_constants::extended)));
824 assert(m.size() == 1);
825 assert(m.prefix().matched);
826 assert(m.prefix().first == s);
827 assert(m.prefix().second == m[0].first);
828 assert(m.suffix().matched);
829 assert(m.suffix().first == m[0].second);
830 assert(m.suffix().second == s+4);
831 assert(m.length(0) == 2);
832 assert(m.position(0) == 1);
833 assert(m.str(0) == L"bc");
834 }
835 {
836 std::wcmatch m;
837 const wchar_t s[] = L"abbc";
838 assert(std::regex_search(s, m, std::wregex(L"ab*c", std::regex_constants::extended)));
839 assert(m.size() == 1);
840 assert(!m.prefix().matched);
841 assert(m.prefix().first == s);
842 assert(m.prefix().second == m[0].first);
843 assert(!m.suffix().matched);
844 assert(m.suffix().first == m[0].second);
845 assert(m.suffix().second == s+4);
846 assert(m.length(0) == 4);
847 assert(m.position(0) == 0);
848 assert(m.str(0) == s);
849 }
850 {
851 std::wcmatch m;
852 const wchar_t s[] = L"ababc";
853 assert(std::regex_search(s, m, std::wregex(L"(ab)*c", std::regex_constants::extended)));
854 assert(m.size() == 2);
855 assert(!m.prefix().matched);
856 assert(m.prefix().first == s);
857 assert(m.prefix().second == m[0].first);
858 assert(!m.suffix().matched);
859 assert(m.suffix().first == m[0].second);
860 assert(m.suffix().second == s+5);
861 assert(m.length(0) == 5);
862 assert(m.position(0) == 0);
863 assert(m.str(0) == s);
864 assert(m.length(1) == 2);
865 assert(m.position(1) == 2);
866 assert(m.str(1) == L"ab");
867 }
868 {
869 std::wcmatch m;
870 const wchar_t s[] = L"abcdefghijk";
871 assert(std::regex_search(s, m, std::wregex(L"cd((e)fg)hi",
872 std::regex_constants::extended)));
873 assert(m.size() == 3);
874 assert(m.prefix().matched);
875 assert(m.prefix().first == s);
876 assert(m.prefix().second == m[0].first);
877 assert(m.suffix().matched);
878 assert(m.suffix().first == m[0].second);
879 assert(m.suffix().second == s+std::regex_traits<wchar_t>::length(s));
880 assert(m.length(0) == 7);
881 assert(m.position(0) == 2);
882 assert(m.str(0) == L"cdefghi");
883 assert(m.length(1) == 3);
884 assert(m.position(1) == 4);
885 assert(m.str(1) == L"efg");
886 assert(m.length(2) == 1);
887 assert(m.position(2) == 4);
888 assert(m.str(2) == L"e");
889 }
890 {
891 std::wcmatch m;
892 const wchar_t s[] = L"abc";
893 assert(std::regex_search(s, m, std::wregex(L"^abc", std::regex_constants::extended)));
894 assert(m.size() == 1);
895 assert(!m.prefix().matched);
896 assert(m.prefix().first == s);
897 assert(m.prefix().second == m[0].first);
898 assert(!m.suffix().matched);
899 assert(m.suffix().first == m[0].second);
900 assert(m.suffix().second == s+3);
901 assert(m.length(0) == 3);
902 assert(m.position(0) == 0);
903 assert(m.str(0) == s);
904 }
905 {
906 std::wcmatch m;
907 const wchar_t s[] = L"abcd";
908 assert(std::regex_search(s, m, std::wregex(L"^abc", std::regex_constants::extended)));
909 assert(m.size() == 1);
910 assert(!m.prefix().matched);
911 assert(m.prefix().first == s);
912 assert(m.prefix().second == m[0].first);
913 assert(m.suffix().matched);
914 assert(m.suffix().first == m[0].second);
915 assert(m.suffix().second == s+4);
916 assert(m.length(0) == 3);
917 assert(m.position(0) == 0);
918 assert(m.str(0) == L"abc");
919 }
920 {
921 std::wcmatch m;
922 const wchar_t s[] = L"aabc";
923 assert(!std::regex_search(s, m, std::wregex(L"^abc", std::regex_constants::extended)));
924 assert(m.size() == 0);
925 }
926 {
927 std::wcmatch m;
928 const wchar_t s[] = L"abc";
929 assert(std::regex_search(s, m, std::wregex(L"abc$", std::regex_constants::extended)));
930 assert(m.size() == 1);
931 assert(!m.prefix().matched);
932 assert(m.prefix().first == s);
933 assert(m.prefix().second == m[0].first);
934 assert(!m.suffix().matched);
935 assert(m.suffix().first == m[0].second);
936 assert(m.suffix().second == s+3);
937 assert(m.length(0) == 3);
938 assert(m.position(0) == 0);
939 assert(m.str(0) == s);
940 }
941 {
942 std::wcmatch m;
943 const wchar_t s[] = L"efabc";
944 assert(std::regex_search(s, m, std::wregex(L"abc$", std::regex_constants::extended)));
945 assert(m.size() == 1);
946 assert(m.prefix().matched);
947 assert(m.prefix().first == s);
948 assert(m.prefix().second == m[0].first);
949 assert(!m.suffix().matched);
950 assert(m.suffix().first == m[0].second);
951 assert(m.suffix().second == s+5);
952 assert(m.length(0) == 3);
953 assert(m.position(0) == 2);
954 assert(m.str(0) == s+2);
955 }
956 {
957 std::wcmatch m;
958 const wchar_t s[] = L"efabcg";
959 assert(!std::regex_search(s, m, std::wregex(L"abc$", std::regex_constants::extended)));
960 assert(m.size() == 0);
961 }
962 {
963 std::wcmatch m;
964 const wchar_t s[] = L"abc";
965 assert(std::regex_search(s, m, std::wregex(L"a.c", std::regex_constants::extended)));
966 assert(m.size() == 1);
967 assert(!m.prefix().matched);
968 assert(m.prefix().first == s);
969 assert(m.prefix().second == m[0].first);
970 assert(!m.suffix().matched);
971 assert(m.suffix().first == m[0].second);
972 assert(m.suffix().second == s+3);
973 assert(m.length(0) == 3);
974 assert(m.position(0) == 0);
975 assert(m.str(0) == s);
976 }
977 {
978 std::wcmatch m;
979 const wchar_t s[] = L"acc";
980 assert(std::regex_search(s, m, std::wregex(L"a.c", std::regex_constants::extended)));
981 assert(m.size() == 1);
982 assert(!m.prefix().matched);
983 assert(m.prefix().first == s);
984 assert(m.prefix().second == m[0].first);
985 assert(!m.suffix().matched);
986 assert(m.suffix().first == m[0].second);
987 assert(m.suffix().second == s+3);
988 assert(m.length(0) == 3);
989 assert(m.position(0) == 0);
990 assert(m.str(0) == s);
991 }
992 {
993 std::wcmatch m;
994 const wchar_t s[] = L"acc";
995 assert(std::regex_search(s, m, std::wregex(L"a.c", std::regex_constants::extended)));
996 assert(m.size() == 1);
997 assert(!m.prefix().matched);
998 assert(m.prefix().first == s);
999 assert(m.prefix().second == m[0].first);
1000 assert(!m.suffix().matched);
1001 assert(m.suffix().first == m[0].second);
1002 assert(m.suffix().second == s+3);
1003 assert(m.length(0) == 3);
1004 assert(m.position(0) == 0);
1005 assert(m.str(0) == s);
1006 }
1007 {
1008 std::wcmatch m;
1009 const wchar_t s[] = L"abcdef";
1010 assert(std::regex_search(s, m, std::wregex(L"(.*).*", std::regex_constants::extended)));
1011 assert(m.size() == 2);
1012 assert(!m.prefix().matched);
1013 assert(m.prefix().first == s);
1014 assert(m.prefix().second == m[0].first);
1015 assert(!m.suffix().matched);
1016 assert(m.suffix().first == m[0].second);
1017 assert(m.suffix().second == s+6);
1018 assert(m.length(0) == 6);
1019 assert(m.position(0) == 0);
1020 assert(m.str(0) == s);
1021 assert(m.length(1) == 6);
1022 assert(m.position(1) == 0);
1023 assert(m.str(1) == s);
1024 }
1025 {
1026 std::wcmatch m;
1027 const wchar_t s[] = L"bc";
1028 assert(std::regex_search(s, m, std::wregex(L"(a*)*", std::regex_constants::extended)));
1029 assert(m.size() == 2);
1030 assert(!m.prefix().matched);
1031 assert(m.prefix().first == s);
1032 assert(m.prefix().second == m[0].first);
1033 assert(m.suffix().matched);
1034 assert(m.suffix().first == m[0].second);
1035 assert(m.suffix().second == s+2);
1036 assert(m.length(0) == 0);
1037 assert(m.position(0) == 0);
1038 assert(m.str(0) == L"");
1039 assert(m.length(1) == 0);
1040 assert(m.position(1) == 0);
1041 assert(m.str(1) == L"");
1042 }
1043 {
1044 std::wcmatch m;
1045 const wchar_t s[] = L"abbc";
1046 assert(!std::regex_search(s, m, std::wregex(L"ab{3,5}c", std::regex_constants::extended)));
1047 assert(m.size() == 0);
1048 }
1049 {
1050 std::wcmatch m;
1051 const wchar_t s[] = L"abbbc";
1052 assert(std::regex_search(s, m, std::wregex(L"ab{3,5}c", std::regex_constants::extended)));
1053 assert(m.size() == 1);
1054 assert(!m.prefix().matched);
1055 assert(m.prefix().first == s);
1056 assert(m.prefix().second == m[0].first);
1057 assert(!m.suffix().matched);
1058 assert(m.suffix().first == m[0].second);
1059 assert(m.suffix().second == m[0].second);
1060 assert(m.length(0) >= 0 && static_cast<std::size_t>(m.length(0)) == std::char_traits<wchar_t>::length(s));
1061 assert(m.position(0) == 0);
1062 assert(m.str(0) == s);
1063 }
1064 {
1065 std::wcmatch m;
1066 const wchar_t s[] = L"abbbbc";
1067 assert(std::regex_search(s, m, std::wregex(L"ab{3,5}c", std::regex_constants::extended)));
1068 assert(m.size() == 1);
1069 assert(!m.prefix().matched);
1070 assert(m.prefix().first == s);
1071 assert(m.prefix().second == m[0].first);
1072 assert(!m.suffix().matched);
1073 assert(m.suffix().first == m[0].second);
1074 assert(m.suffix().second == m[0].second);
1075 assert(m.length(0) >= 0 && static_cast<std::size_t>(m.length(0)) == std::char_traits<wchar_t>::length(s));
1076 assert(m.position(0) == 0);
1077 assert(m.str(0) == s);
1078 }
1079 {
1080 std::wcmatch m;
1081 const wchar_t s[] = L"abbbbbc";
1082 assert(std::regex_search(s, m, std::wregex(L"ab{3,5}c", std::regex_constants::extended)));
1083 assert(m.size() == 1);
1084 assert(!m.prefix().matched);
1085 assert(m.prefix().first == s);
1086 assert(m.prefix().second == m[0].first);
1087 assert(!m.suffix().matched);
1088 assert(m.suffix().first == m[0].second);
1089 assert(m.suffix().second == m[0].second);
1090 assert(m.length(0) >= 0 && static_cast<std::size_t>(m.length(0)) == std::char_traits<wchar_t>::length(s));
1091 assert(m.position(0) == 0);
1092 assert(m.str(0) == s);
1093 }
1094 {
1095 std::wcmatch m;
1096 const wchar_t s[] = L"adefc";
1097 assert(!std::regex_search(s, m, std::wregex(L"ab{3,5}c", std::regex_constants::extended)));
1098 assert(m.size() == 0);
1099 }
1100 {
1101 std::wcmatch m;
1102 const wchar_t s[] = L"abbbbbbc";
1103 assert(!std::regex_search(s, m, std::wregex(L"ab{3,5}c", std::regex_constants::extended)));
1104 assert(m.size() == 0);
1105 }
1106 {
1107 std::wcmatch m;
1108 const wchar_t s[] = L"adec";
1109 assert(!std::regex_search(s, m, std::wregex(L"a.{3,5}c", std::regex_constants::extended)));
1110 assert(m.size() == 0);
1111 }
1112 {
1113 std::wcmatch m;
1114 const wchar_t s[] = L"adefc";
1115 assert(std::regex_search(s, m, std::wregex(L"a.{3,5}c", std::regex_constants::extended)));
1116 assert(m.size() == 1);
1117 assert(!m.prefix().matched);
1118 assert(m.prefix().first == s);
1119 assert(m.prefix().second == m[0].first);
1120 assert(!m.suffix().matched);
1121 assert(m.suffix().first == m[0].second);
1122 assert(m.suffix().second == m[0].second);
1123 assert(m.length(0) >= 0 && static_cast<std::size_t>(m.length(0)) == std::char_traits<wchar_t>::length(s));
1124 assert(m.position(0) == 0);
1125 assert(m.str(0) == s);
1126 }
1127 {
1128 std::wcmatch m;
1129 const wchar_t s[] = L"adefgc";
1130 assert(std::regex_search(s, m, std::wregex(L"a.{3,5}c", std::regex_constants::extended)));
1131 assert(m.size() == 1);
1132 assert(!m.prefix().matched);
1133 assert(m.prefix().first == s);
1134 assert(m.prefix().second == m[0].first);
1135 assert(!m.suffix().matched);
1136 assert(m.suffix().first == m[0].second);
1137 assert(m.suffix().second == m[0].second);
1138 assert(m.length(0) >= 0 && static_cast<std::size_t>(m.length(0)) == std::char_traits<wchar_t>::length(s));
1139 assert(m.position(0) == 0);
1140 assert(m.str(0) == s);
1141 }
1142 {
1143 std::wcmatch m;
1144 const wchar_t s[] = L"adefghc";
1145 assert(std::regex_search(s, m, std::wregex(L"a.{3,5}c", std::regex_constants::extended)));
1146 assert(m.size() == 1);
1147 assert(!m.prefix().matched);
1148 assert(m.prefix().first == s);
1149 assert(m.prefix().second == m[0].first);
1150 assert(!m.suffix().matched);
1151 assert(m.suffix().first == m[0].second);
1152 assert(m.suffix().second == m[0].second);
1153 assert(m.length(0) >= 0 && static_cast<std::size_t>(m.length(0)) == std::char_traits<wchar_t>::length(s));
1154 assert(m.position(0) == 0);
1155 assert(m.str(0) == s);
1156 }
1157 {
1158 std::wcmatch m;
1159 const wchar_t s[] = L"adefghic";
1160 assert(!std::regex_search(s, m, std::wregex(L"a.{3,5}c", std::regex_constants::extended)));
1161 assert(m.size() == 0);
1162 }
1163 {
1164 std::wcmatch m;
1165 const wchar_t s[] = L"tournament";
1166 assert(std::regex_search(s, m, std::wregex(L"tour|to|tournament",
1167 std::regex_constants::extended)));
1168 assert(m.size() == 1);
1169 assert(!m.prefix().matched);
1170 assert(m.prefix().first == s);
1171 assert(m.prefix().second == m[0].first);
1172 assert(!m.suffix().matched);
1173 assert(m.suffix().first == m[0].second);
1174 assert(m.suffix().second == m[0].second);
1175 assert(m.length(0) >= 0 && static_cast<std::size_t>(m.length(0)) == std::char_traits<wchar_t>::length(s));
1176 assert(m.position(0) == 0);
1177 assert(m.str(0) == s);
1178 }
1179 {
1180 std::wcmatch m;
1181 const wchar_t s[] = L"tournamenttotour";
1182 assert(std::regex_search(s, m, std::wregex(L"(tour|to|tournament)+",
1183 std::regex_constants::extended | std::regex_constants::nosubs)));
1184 assert(m.size() == 1);
1185 assert(!m.prefix().matched);
1186 assert(m.prefix().first == s);
1187 assert(m.prefix().second == m[0].first);
1188 assert(!m.suffix().matched);
1189 assert(m.suffix().first == m[0].second);
1190 assert(m.suffix().second == m[0].second);
1191 assert(m.length(0) >= 0 && static_cast<std::size_t>(m.length(0)) == std::char_traits<wchar_t>::length(s));
1192 assert(m.position(0) == 0);
1193 assert(m.str(0) == s);
1194 }
1195 {
1196 std::wcmatch m;
1197 const wchar_t s[] = L"ttotour";
1198 assert(std::regex_search(s, m, std::wregex(L"(tour|to|t)+",
1199 std::regex_constants::extended)));
1200 assert(m.size() == 2);
1201 assert(!m.prefix().matched);
1202 assert(m.prefix().first == s);
1203 assert(m.prefix().second == m[0].first);
1204 assert(!m.suffix().matched);
1205 assert(m.suffix().first == m[0].second);
1206 assert(m.suffix().second == m[0].second);
1207 assert(m.length(0) >= 0 && static_cast<std::size_t>(m.length(0)) == std::char_traits<wchar_t>::length(s));
1208 assert(m.position(0) == 0);
1209 assert(m.str(0) == s);
1210 assert(m.length(1) == 4);
1211 assert(m.position(1) == 3);
1212 assert(m.str(1) == L"tour");
1213 }
1214 {
1215 std::wcmatch m;
1216 const wchar_t s[] = L"-ab,ab-";
1217 assert(!std::regex_search(s, m, std::wregex(L"-(.*),\1-", std::regex_constants::extended)));
1218 assert(m.size() == 0);
1219 }
1220 {
1221 std::wcmatch m;
1222 const wchar_t s[] = L"-ab,ab-";
1223 assert(std::regex_search(s, m, std::wregex(L"-(.*),\\1-", std::regex_constants::extended)));
1224 assert(m.size() == 2);
1225 assert(!m.prefix().matched);
1226 assert(m.prefix().first == s);
1227 assert(m.prefix().second == m[0].first);
1228 assert(!m.suffix().matched);
1229 assert(m.suffix().first == m[0].second);
1230 assert(m.suffix().second == m[0].second);
1231 assert(m.length(0) >= 0 && static_cast<std::size_t>(m.length(0)) == std::char_traits<wchar_t>::length(s));
1232 assert(m.position(0) == 0);
1233 assert(m.str(0) == s);
1234 assert(m.length(1) == 2);
1235 assert(m.position(1) == 1);
1236 assert(m.str(1) == L"ab");
1237 }
1238 {
1239 std::wcmatch m;
1240 const wchar_t s[] = L"-ab,ab-";
1241 assert(std::regex_search(s, m, std::wregex(L"-.*,.*-", std::regex_constants::extended)));
1242 assert(m.size() == 1);
1243 assert(!m.prefix().matched);
1244 assert(m.prefix().first == s);
1245 assert(m.prefix().second == m[0].first);
1246 assert(!m.suffix().matched);
1247 assert(m.suffix().first == m[0].second);
1248 assert(m.suffix().second == m[0].second);
1249 assert(m.length(0) >= 0 && static_cast<std::size_t>(m.length(0)) == std::char_traits<wchar_t>::length(s));
1250 assert(m.position(0) == 0);
1251 assert(m.str(0) == s);
1252 }
1253 {
1254 std::wcmatch m;
1255 const wchar_t s[] = L"a";
1256 assert(std::regex_search(s, m, std::wregex(L"^[a]$",
1257 std::regex_constants::extended)));
1258 assert(m.size() == 1);
1259 assert(!m.prefix().matched);
1260 assert(m.prefix().first == s);
1261 assert(m.prefix().second == m[0].first);
1262 assert(!m.suffix().matched);
1263 assert(m.suffix().first == m[0].second);
1264 assert(m.suffix().second == m[0].second);
1265 assert(m.length(0) == 1);
1266 assert(m.position(0) == 0);
1267 assert(m.str(0) == L"a");
1268 }
1269 {
1270 std::wcmatch m;
1271 const wchar_t s[] = L"a";
1272 assert(std::regex_search(s, m, std::wregex(L"^[ab]$",
1273 std::regex_constants::extended)));
1274 assert(m.size() == 1);
1275 assert(!m.prefix().matched);
1276 assert(m.prefix().first == s);
1277 assert(m.prefix().second == m[0].first);
1278 assert(!m.suffix().matched);
1279 assert(m.suffix().first == m[0].second);
1280 assert(m.suffix().second == m[0].second);
1281 assert(m.length(0) == 1);
1282 assert(m.position(0) == 0);
1283 assert(m.str(0) == L"a");
1284 }
1285 {
1286 std::wcmatch m;
1287 const wchar_t s[] = L"c";
1288 assert(std::regex_search(s, m, std::wregex(L"^[a-f]$",
1289 std::regex_constants::extended)));
1290 assert(m.size() == 1);
1291 assert(!m.prefix().matched);
1292 assert(m.prefix().first == s);
1293 assert(m.prefix().second == m[0].first);
1294 assert(!m.suffix().matched);
1295 assert(m.suffix().first == m[0].second);
1296 assert(m.suffix().second == m[0].second);
1297 assert(m.length(0) == 1);
1298 assert(m.position(0) == 0);
1299 assert(m.str(0) == s);
1300 }
1301 {
1302 std::wcmatch m;
1303 const wchar_t s[] = L"g";
1304 assert(!std::regex_search(s, m, std::wregex(L"^[a-f]$",
1305 std::regex_constants::extended)));
1306 assert(m.size() == 0);
1307 }
1308 {
1309 std::wcmatch m;
1310 const wchar_t s[] = L"Iraqi";
1311 assert(std::regex_search(s, m, std::wregex(L"q[^u]",
1312 std::regex_constants::extended)));
1313 assert(m.size() == 1);
1314 assert(m.prefix().matched);
1315 assert(m.prefix().first == s);
1316 assert(m.prefix().second == m[0].first);
1317 assert(!m.suffix().matched);
1318 assert(m.suffix().first == m[0].second);
1319 assert(m.suffix().second == m[0].second);
1320 assert(m.length(0) == 2);
1321 assert(m.position(0) == 3);
1322 assert(m.str(0) == L"qi");
1323 }
1324 {
1325 std::wcmatch m;
1326 const wchar_t s[] = L"Iraq";
1327 assert(!std::regex_search(s, m, std::wregex(L"q[^u]",
1328 std::regex_constants::extended)));
1329 assert(m.size() == 0);
1330 }
1331 {
1332 std::wcmatch m;
1333 const wchar_t s[] = L"AmB";
1334 assert(std::regex_search(s, m, std::wregex(L"A[[:lower:]]B",
1335 std::regex_constants::extended)));
1336 assert(m.size() == 1);
1337 assert(!m.prefix().matched);
1338 assert(m.prefix().first == s);
1339 assert(m.prefix().second == m[0].first);
1340 assert(!m.suffix().matched);
1341 assert(m.suffix().first == m[0].second);
1342 assert(m.suffix().second == m[0].second);
1343 assert(m.length(0) >= 0 && static_cast<std::size_t>(m.length(0)) == std::char_traits<wchar_t>::length(s));
1344 assert(m.position(0) == 0);
1345 assert(m.str(0) == s);
1346 }
1347 {
1348 std::wcmatch m;
1349 const wchar_t s[] = L"AMB";
1350 assert(!std::regex_search(s, m, std::wregex(L"A[[:lower:]]B",
1351 std::regex_constants::extended)));
1352 assert(m.size() == 0);
1353 }
1354 {
1355 std::wcmatch m;
1356 const wchar_t s[] = L"AMB";
1357 assert(std::regex_search(s, m, std::wregex(L"A[^[:lower:]]B",
1358 std::regex_constants::extended)));
1359 assert(m.size() == 1);
1360 assert(!m.prefix().matched);
1361 assert(m.prefix().first == s);
1362 assert(m.prefix().second == m[0].first);
1363 assert(!m.suffix().matched);
1364 assert(m.suffix().first == m[0].second);
1365 assert(m.suffix().second == m[0].second);
1366 assert(m.length(0) >= 0 && static_cast<std::size_t>(m.length(0)) == std::char_traits<wchar_t>::length(s));
1367 assert(m.position(0) == 0);
1368 assert(m.str(0) == s);
1369 }
1370 {
1371 std::wcmatch m;
1372 const wchar_t s[] = L"AmB";
1373 assert(!std::regex_search(s, m, std::wregex(L"A[^[:lower:]]B",
1374 std::regex_constants::extended)));
1375 assert(m.size() == 0);
1376 }
1377 {
1378 std::wcmatch m;
1379 const wchar_t s[] = L"A5B";
1380 assert(!std::regex_search(s, m, std::wregex(L"A[^[:lower:]0-9]B",
1381 std::regex_constants::extended)));
1382 assert(m.size() == 0);
1383 }
1384 {
1385 std::wcmatch m;
1386 const wchar_t s[] = L"A?B";
1387 assert(std::regex_search(s, m, std::wregex(L"A[^[:lower:]0-9]B",
1388 std::regex_constants::extended)));
1389 assert(m.size() == 1);
1390 assert(!m.prefix().matched);
1391 assert(m.prefix().first == s);
1392 assert(m.prefix().second == m[0].first);
1393 assert(!m.suffix().matched);
1394 assert(m.suffix().first == m[0].second);
1395 assert(m.suffix().second == m[0].second);
1396 assert(m.length(0) >= 0 && static_cast<std::size_t>(m.length(0)) == std::char_traits<wchar_t>::length(s));
1397 assert(m.position(0) == 0);
1398 assert(m.str(0) == s);
1399 }
1400 {
1401 std::wcmatch m;
1402 const wchar_t s[] = L"-";
1403 assert(std::regex_search(s, m, std::wregex(L"[a[.hyphen.]z]",
1404 std::regex_constants::extended)));
1405 assert(m.size() == 1);
1406 assert(!m.prefix().matched);
1407 assert(m.prefix().first == s);
1408 assert(m.prefix().second == m[0].first);
1409 assert(!m.suffix().matched);
1410 assert(m.suffix().first == m[0].second);
1411 assert(m.suffix().second == m[0].second);
1412 assert(m.length(0) >= 0 && static_cast<std::size_t>(m.length(0)) == std::char_traits<wchar_t>::length(s));
1413 assert(m.position(0) == 0);
1414 assert(m.str(0) == s);
1415 }
1416 {
1417 std::wcmatch m;
1418 const wchar_t s[] = L"z";
1419 assert(std::regex_search(s, m, std::wregex(L"[a[.hyphen.]z]",
1420 std::regex_constants::extended)));
1421 assert(m.size() == 1);
1422 assert(!m.prefix().matched);
1423 assert(m.prefix().first == s);
1424 assert(m.prefix().second == m[0].first);
1425 assert(!m.suffix().matched);
1426 assert(m.suffix().first == m[0].second);
1427 assert(m.suffix().second == m[0].second);
1428 assert(m.length(0) >= 0 && static_cast<std::size_t>(m.length(0)) == std::char_traits<wchar_t>::length(s));
1429 assert(m.position(0) == 0);
1430 assert(m.str(0) == s);
1431 }
1432 {
1433 std::wcmatch m;
1434 const wchar_t s[] = L"m";
1435 assert(!std::regex_search(s, m, std::wregex(L"[a[.hyphen.]z]",
1436 std::regex_constants::extended)));
1437 assert(m.size() == 0);
1438 }
1439 {
1440 std::wcmatch m;
1441 const wchar_t s[] = L"01a45cef9";
1442 assert(std::regex_search(s, m, std::wregex(L"[ace1-9]*",
1443 std::regex_constants::extended)));
1444 assert(m.size() == 1);
1445 assert(!m.prefix().matched);
1446 assert(m.prefix().first == s);
1447 assert(m.prefix().second == m[0].first);
1448 assert(m.suffix().matched);
1449 assert(m.suffix().first == m[0].second);
1450 assert(m.suffix().second == s + std::char_traits<wchar_t>::length(s));
1451 assert(m.length(0) == 0);
1452 assert(m.position(0) == 0);
1453 assert(m.str(0) == L"");
1454 }
1455 {
1456 std::wcmatch m;
1457 const wchar_t s[] = L"01a45cef9";
1458 assert(std::regex_search(s, m, std::wregex(L"[ace1-9]+",
1459 std::regex_constants::extended)));
1460 assert(m.size() == 1);
1461 assert(m.prefix().matched);
1462 assert(m.prefix().first == s);
1463 assert(m.prefix().second == m[0].first);
1464 assert(m.suffix().matched);
1465 assert(m.suffix().first == m[0].second);
1466 assert(m.suffix().second == s + std::char_traits<wchar_t>::length(s));
1467 assert(m.length(0) == 6);
1468 assert(m.position(0) == 1);
1469 assert(m.str(0) == L"1a45ce");
1470 }
1471 {
1472 const wchar_t r[] = L"^[-+]?[0-9]+[CF]$";
1473 std::ptrdiff_t sr = std::char_traits<wchar_t>::length(r);
1474 typedef forward_iterator<const wchar_t*> FI;
1475 typedef bidirectional_iterator<const wchar_t*> BI;
1476 std::wregex regex(FI(r), FI(r+sr), std::regex_constants::extended);
1477 std::match_results<BI> m;
1478 const wchar_t s[] = L"-40C";
1479 std::ptrdiff_t ss = std::char_traits<wchar_t>::length(s);
1480 assert(std::regex_search(BI(s), BI(s+ss), m, regex));
1481 assert(m.size() == 1);
1482 assert(!m.prefix().matched);
1483 assert(m.prefix().first == BI(s));
1484 assert(m.prefix().second == m[0].first);
1485 assert(!m.suffix().matched);
1486 assert(m.suffix().first == m[0].second);
1487 assert(m.suffix().second == m[0].second);
1488 assert(m.length(0) == 4);
1489 assert(m.position(0) == 0);
1490 assert(m.str(0) == s);
1491 }
1492 #endif // TEST_HAS_NO_WIDE_CHARACTERS
1493
1494 return 0;
1495 }
1496