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 // <regex>
10
11 // template <class BidirectionalIterator, class Allocator, class charT,
12 // class traits>
13 // bool regex_match(BidirectionalIterator first, BidirectionalIterator last,
14 // match_results<BidirectionalIterator, Allocator>& m,
15 // const basic_regex<charT, traits>& e,
16 // regex_constants::match_flag_type flags
17 // = 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_match(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_match(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_match(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_match(s, m, std::regex("ab", std::regex_constants::awk)));
68 assert(m.size() == 0);
69 }
70 {
71 std::cmatch m;
72 const char s[] = "aab";
73 assert(!std::regex_match(s, m, std::regex("ab", std::regex_constants::awk),
74 std::regex_constants::match_continuous));
75 assert(m.size() == 0);
76 }
77 {
78 std::cmatch m;
79 const char s[] = "abcd";
80 assert(!std::regex_match(s, m, std::regex("bc", std::regex_constants::awk)));
81 assert(m.size() == 0);
82 }
83 {
84 std::cmatch m;
85 const char s[] = "abbc";
86 assert(std::regex_match(s, m, std::regex("ab*c", std::regex_constants::awk)));
87 assert(m.size() == 1);
88 assert(!m.prefix().matched);
89 assert(m.prefix().first == s);
90 assert(m.prefix().second == m[0].first);
91 assert(!m.suffix().matched);
92 assert(m.suffix().first == m[0].second);
93 assert(m.suffix().second == s+4);
94 assert(m.length(0) == 4);
95 assert(m.position(0) == 0);
96 assert(m.str(0) == s);
97 }
98 {
99 std::cmatch m;
100 const char s[] = "ababc";
101 assert(std::regex_match(s, m, std::regex("(ab)*c", std::regex_constants::awk)));
102 assert(m.size() == 2);
103 assert(!m.prefix().matched);
104 assert(m.prefix().first == s);
105 assert(m.prefix().second == m[0].first);
106 assert(!m.suffix().matched);
107 assert(m.suffix().first == m[0].second);
108 assert(m.suffix().second == s+5);
109 assert(m.length(0) == 5);
110 assert(m.position(0) == 0);
111 assert(m.str(0) == s);
112 assert(m.length(1) == 2);
113 assert(m.position(1) == 2);
114 assert(m.str(1) == "ab");
115 }
116 {
117 std::cmatch m;
118 const char s[] = "abcdefghijk";
119 assert(!std::regex_match(s, m, std::regex("cd((e)fg)hi",
120 std::regex_constants::awk)));
121 assert(m.size() == 0);
122 }
123 {
124 std::cmatch m;
125 const char s[] = "abc";
126 assert(std::regex_match(s, m, std::regex("^abc", std::regex_constants::awk)));
127 assert(m.size() == 1);
128 assert(!m.prefix().matched);
129 assert(m.prefix().first == s);
130 assert(m.prefix().second == m[0].first);
131 assert(!m.suffix().matched);
132 assert(m.suffix().first == m[0].second);
133 assert(m.suffix().second == s+3);
134 assert(m.length(0) == 3);
135 assert(m.position(0) == 0);
136 assert(m.str(0) == s);
137 }
138 {
139 std::cmatch m;
140 const char s[] = "abcd";
141 assert(!std::regex_match(s, m, std::regex("^abc", std::regex_constants::awk)));
142 assert(m.size() == 0);
143 }
144 {
145 std::cmatch m;
146 const char s[] = "aabc";
147 assert(!std::regex_match(s, m, std::regex("^abc", std::regex_constants::awk)));
148 assert(m.size() == 0);
149 }
150 {
151 std::cmatch m;
152 const char s[] = "abc";
153 assert(std::regex_match(s, m, std::regex("abc$", std::regex_constants::awk)));
154 assert(m.size() == 1);
155 assert(!m.prefix().matched);
156 assert(m.prefix().first == s);
157 assert(m.prefix().second == m[0].first);
158 assert(!m.suffix().matched);
159 assert(m.suffix().first == m[0].second);
160 assert(m.suffix().second == s+3);
161 assert(m.length(0) == 3);
162 assert(m.position(0) == 0);
163 assert(m.str(0) == s);
164 }
165 {
166 std::cmatch m;
167 const char s[] = "efabc";
168 assert(!std::regex_match(s, m, std::regex("abc$", std::regex_constants::awk)));
169 assert(m.size() == 0);
170 }
171 {
172 std::cmatch m;
173 const char s[] = "efabcg";
174 assert(!std::regex_match(s, m, std::regex("abc$", std::regex_constants::awk)));
175 assert(m.size() == 0);
176 }
177 {
178 std::cmatch m;
179 const char s[] = "abc";
180 assert(std::regex_match(s, m, std::regex("a.c", std::regex_constants::awk)));
181 assert(m.size() == 1);
182 assert(!m.prefix().matched);
183 assert(m.prefix().first == s);
184 assert(m.prefix().second == m[0].first);
185 assert(!m.suffix().matched);
186 assert(m.suffix().first == m[0].second);
187 assert(m.suffix().second == s+3);
188 assert(m.length(0) == 3);
189 assert(m.position(0) == 0);
190 assert(m.str(0) == s);
191 }
192 {
193 std::cmatch m;
194 const char s[] = "acc";
195 assert(std::regex_match(s, m, std::regex("a.c", 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[] = "acc";
210 assert(std::regex_match(s, m, std::regex("a.c", 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+3);
218 assert(m.length(0) == 3);
219 assert(m.position(0) == 0);
220 assert(m.str(0) == s);
221 }
222 {
223 std::cmatch m;
224 const char s[] = "abcdef";
225 assert(std::regex_match(s, m, std::regex("(.*).*", std::regex_constants::awk)));
226 assert(m.size() == 2);
227 assert(!m.prefix().matched);
228 assert(m.prefix().first == s);
229 assert(m.prefix().second == m[0].first);
230 assert(!m.suffix().matched);
231 assert(m.suffix().first == m[0].second);
232 assert(m.suffix().second == s+6);
233 assert(m.length(0) == 6);
234 assert(m.position(0) == 0);
235 assert(m.str(0) == s);
236 assert(m.length(1) == 6);
237 assert(m.position(1) == 0);
238 assert(m.str(1) == s);
239 }
240 {
241 std::cmatch m;
242 const char s[] = "bc";
243 assert(!std::regex_match(s, m, std::regex("(a*)*", std::regex_constants::awk)));
244 assert(m.size() == 0);
245 }
246 {
247 std::cmatch m;
248 const char s[] = "abbc";
249 assert(!std::regex_match(s, m, std::regex("ab{3,5}c", std::regex_constants::awk)));
250 assert(m.size() == 0);
251 }
252 {
253 std::cmatch m;
254 const char s[] = "abbbc";
255 assert(std::regex_match(s, m, std::regex("ab{3,5}c", std::regex_constants::awk)));
256 assert(m.size() == 1);
257 assert(!m.prefix().matched);
258 assert(m.prefix().first == s);
259 assert(m.prefix().second == m[0].first);
260 assert(!m.suffix().matched);
261 assert(m.suffix().first == m[0].second);
262 assert(m.suffix().second == m[0].second);
263 assert((std::size_t)m.length(0) == std::char_traits<char>::length(s));
264 assert(m.position(0) == 0);
265 assert(m.str(0) == s);
266 }
267 {
268 std::cmatch m;
269 const char s[] = "abbbbc";
270 assert(std::regex_match(s, m, std::regex("ab{3,5}c", std::regex_constants::awk)));
271 assert(m.size() == 1);
272 assert(!m.prefix().matched);
273 assert(m.prefix().first == s);
274 assert(m.prefix().second == m[0].first);
275 assert(!m.suffix().matched);
276 assert(m.suffix().first == m[0].second);
277 assert(m.suffix().second == m[0].second);
278 assert((std::size_t)m.length(0) == std::char_traits<char>::length(s));
279 assert(m.position(0) == 0);
280 assert(m.str(0) == s);
281 }
282 {
283 std::cmatch m;
284 const char s[] = "abbbbbc";
285 assert(std::regex_match(s, m, std::regex("ab{3,5}c", std::regex_constants::awk)));
286 assert(m.size() == 1);
287 assert(!m.prefix().matched);
288 assert(m.prefix().first == s);
289 assert(m.prefix().second == m[0].first);
290 assert(!m.suffix().matched);
291 assert(m.suffix().first == m[0].second);
292 assert(m.suffix().second == m[0].second);
293 assert((std::size_t)m.length(0) == std::char_traits<char>::length(s));
294 assert(m.position(0) == 0);
295 assert(m.str(0) == s);
296 }
297 {
298 std::cmatch m;
299 const char s[] = "adefc";
300 assert(!std::regex_match(s, m, std::regex("ab{3,5}c", std::regex_constants::awk)));
301 assert(m.size() == 0);
302 }
303 {
304 std::cmatch m;
305 const char s[] = "abbbbbbc";
306 assert(!std::regex_match(s, m, std::regex("ab{3,5}c", std::regex_constants::awk)));
307 assert(m.size() == 0);
308 }
309 {
310 std::cmatch m;
311 const char s[] = "adec";
312 assert(!std::regex_match(s, m, std::regex("a.{3,5}c", std::regex_constants::awk)));
313 assert(m.size() == 0);
314 }
315 {
316 std::cmatch m;
317 const char s[] = "adefc";
318 assert(std::regex_match(s, m, std::regex("a.{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((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[] = "adefgc";
333 assert(std::regex_match(s, m, std::regex("a.{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((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[] = "adefghc";
348 assert(std::regex_match(s, m, std::regex("a.{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((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[] = "adefghic";
363 assert(!std::regex_match(s, m, std::regex("a.{3,5}c", std::regex_constants::awk)));
364 assert(m.size() == 0);
365 }
366 {
367 std::cmatch m;
368 const char s[] = "tournament";
369 assert(std::regex_match(s, m, std::regex("tour|to|tournament",
370 std::regex_constants::awk)));
371 assert(m.size() == 1);
372 assert(!m.prefix().matched);
373 assert(m.prefix().first == s);
374 assert(m.prefix().second == m[0].first);
375 assert(!m.suffix().matched);
376 assert(m.suffix().first == m[0].second);
377 assert(m.suffix().second == m[0].second);
378 assert((std::size_t)m.length(0) == std::char_traits<char>::length(s));
379 assert(m.position(0) == 0);
380 assert(m.str(0) == s);
381 }
382 {
383 std::cmatch m;
384 const char s[] = "tournamenttotour";
385 assert(std::regex_match(s, m, std::regex("(tour|to|tournament)+",
386 std::regex_constants::awk | std::regex_constants::nosubs)));
387 assert(m.size() == 1);
388 assert(!m.prefix().matched);
389 assert(m.prefix().first == s);
390 assert(m.prefix().second == m[0].first);
391 assert(!m.suffix().matched);
392 assert(m.suffix().first == m[0].second);
393 assert(m.suffix().second == m[0].second);
394 assert((std::size_t)m.length(0) == std::char_traits<char>::length(s));
395 assert(m.position(0) == 0);
396 assert(m.str(0) == s);
397 }
398 {
399 std::cmatch m;
400 const char s[] = "ttotour";
401 assert(std::regex_match(s, m, std::regex("(tour|to|t)+",
402 std::regex_constants::awk)));
403 assert(m.size() == 2);
404 assert(!m.prefix().matched);
405 assert(m.prefix().first == s);
406 assert(m.prefix().second == m[0].first);
407 assert(!m.suffix().matched);
408 assert(m.suffix().first == m[0].second);
409 assert(m.suffix().second == m[0].second);
410 assert((std::size_t)m.length(0) == std::char_traits<char>::length(s));
411 assert(m.position(0) == 0);
412 assert(m.str(0) == s);
413 assert(m.length(1) == 4);
414 assert(m.position(1) == 3);
415 assert(m.str(1) == "tour");
416 }
417 {
418 std::cmatch m;
419 const char s[] = "-ab,ab-";
420 assert(!std::regex_match(s, m, std::regex("-(.*),\1-", std::regex_constants::awk)));
421 assert(m.size() == 0);
422 }
423 {
424 std::cmatch m;
425 const char s[] = "-ab,ab-";
426 assert(std::regex_match(s, m, std::regex("-.*,.*-", std::regex_constants::awk)));
427 assert(m.size() == 1);
428 assert(!m.prefix().matched);
429 assert(m.prefix().first == s);
430 assert(m.prefix().second == m[0].first);
431 assert(!m.suffix().matched);
432 assert(m.suffix().first == m[0].second);
433 assert(m.suffix().second == m[0].second);
434 assert((std::size_t)m.length(0) == std::char_traits<char>::length(s));
435 assert(m.position(0) == 0);
436 assert(m.str(0) == s);
437 }
438 {
439 std::cmatch m;
440 const char s[] = "a";
441 assert(std::regex_match(s, m, std::regex("^[a]$",
442 std::regex_constants::awk)));
443 assert(m.size() == 1);
444 assert(!m.prefix().matched);
445 assert(m.prefix().first == s);
446 assert(m.prefix().second == m[0].first);
447 assert(!m.suffix().matched);
448 assert(m.suffix().first == m[0].second);
449 assert(m.suffix().second == m[0].second);
450 assert(m.length(0) == 1);
451 assert(m.position(0) == 0);
452 assert(m.str(0) == "a");
453 }
454 {
455 std::cmatch m;
456 const char s[] = "a";
457 assert(std::regex_match(s, m, std::regex("^[ab]$",
458 std::regex_constants::awk)));
459 assert(m.size() == 1);
460 assert(!m.prefix().matched);
461 assert(m.prefix().first == s);
462 assert(m.prefix().second == m[0].first);
463 assert(!m.suffix().matched);
464 assert(m.suffix().first == m[0].second);
465 assert(m.suffix().second == m[0].second);
466 assert(m.length(0) == 1);
467 assert(m.position(0) == 0);
468 assert(m.str(0) == "a");
469 }
470 {
471 std::cmatch m;
472 const char s[] = "c";
473 assert(std::regex_match(s, m, std::regex("^[a-f]$",
474 std::regex_constants::awk)));
475 assert(m.size() == 1);
476 assert(!m.prefix().matched);
477 assert(m.prefix().first == s);
478 assert(m.prefix().second == m[0].first);
479 assert(!m.suffix().matched);
480 assert(m.suffix().first == m[0].second);
481 assert(m.suffix().second == m[0].second);
482 assert(m.length(0) == 1);
483 assert(m.position(0) == 0);
484 assert(m.str(0) == s);
485 }
486 {
487 std::cmatch m;
488 const char s[] = "g";
489 assert(!std::regex_match(s, m, std::regex("^[a-f]$",
490 std::regex_constants::awk)));
491 assert(m.size() == 0);
492 }
493 {
494 std::cmatch m;
495 const char s[] = "Iraqi";
496 assert(!std::regex_match(s, m, std::regex("q[^u]",
497 std::regex_constants::awk)));
498 assert(m.size() == 0);
499 }
500 {
501 std::cmatch m;
502 const char s[] = "Iraq";
503 assert(!std::regex_match(s, m, std::regex("q[^u]",
504 std::regex_constants::awk)));
505 assert(m.size() == 0);
506 }
507 {
508 std::cmatch m;
509 const char s[] = "AmB";
510 assert(std::regex_match(s, m, std::regex("A[[:lower:]]B",
511 std::regex_constants::awk)));
512 assert(m.size() == 1);
513 assert(!m.prefix().matched);
514 assert(m.prefix().first == s);
515 assert(m.prefix().second == m[0].first);
516 assert(!m.suffix().matched);
517 assert(m.suffix().first == m[0].second);
518 assert(m.suffix().second == m[0].second);
519 assert((std::size_t)m.length(0) == std::char_traits<char>::length(s));
520 assert(m.position(0) == 0);
521 assert(m.str(0) == s);
522 }
523 {
524 std::cmatch m;
525 const char s[] = "AMB";
526 assert(!std::regex_match(s, m, std::regex("A[[:lower:]]B",
527 std::regex_constants::awk)));
528 assert(m.size() == 0);
529 }
530 {
531 std::cmatch m;
532 const char s[] = "AMB";
533 assert(std::regex_match(s, m, std::regex("A[^[:lower:]]B",
534 std::regex_constants::awk)));
535 assert(m.size() == 1);
536 assert(!m.prefix().matched);
537 assert(m.prefix().first == s);
538 assert(m.prefix().second == m[0].first);
539 assert(!m.suffix().matched);
540 assert(m.suffix().first == m[0].second);
541 assert(m.suffix().second == m[0].second);
542 assert((std::size_t)m.length(0) == std::char_traits<char>::length(s));
543 assert(m.position(0) == 0);
544 assert(m.str(0) == s);
545 }
546 {
547 std::cmatch m;
548 const char s[] = "AmB";
549 assert(!std::regex_match(s, m, std::regex("A[^[:lower:]]B",
550 std::regex_constants::awk)));
551 assert(m.size() == 0);
552 }
553 {
554 std::cmatch m;
555 const char s[] = "A5B";
556 assert(!std::regex_match(s, m, std::regex("A[^[:lower:]0-9]B",
557 std::regex_constants::awk)));
558 assert(m.size() == 0);
559 }
560 {
561 std::cmatch m;
562 const char s[] = "A?B";
563 assert(std::regex_match(s, m, std::regex("A[^[:lower:]0-9]B",
564 std::regex_constants::awk)));
565 assert(m.size() == 1);
566 assert(!m.prefix().matched);
567 assert(m.prefix().first == s);
568 assert(m.prefix().second == m[0].first);
569 assert(!m.suffix().matched);
570 assert(m.suffix().first == m[0].second);
571 assert(m.suffix().second == m[0].second);
572 assert((std::size_t)m.length(0) == std::char_traits<char>::length(s));
573 assert(m.position(0) == 0);
574 assert(m.str(0) == s);
575 }
576 {
577 std::cmatch m;
578 const char s[] = "-";
579 assert(std::regex_match(s, m, std::regex("[a[.hyphen.]z]",
580 std::regex_constants::awk)));
581 assert(m.size() == 1);
582 assert(!m.prefix().matched);
583 assert(m.prefix().first == s);
584 assert(m.prefix().second == m[0].first);
585 assert(!m.suffix().matched);
586 assert(m.suffix().first == m[0].second);
587 assert(m.suffix().second == m[0].second);
588 assert((std::size_t)m.length(0) == std::char_traits<char>::length(s));
589 assert(m.position(0) == 0);
590 assert(m.str(0) == s);
591 }
592 {
593 std::cmatch m;
594 const char s[] = "z";
595 assert(std::regex_match(s, m, std::regex("[a[.hyphen.]z]",
596 std::regex_constants::awk)));
597 assert(m.size() == 1);
598 assert(!m.prefix().matched);
599 assert(m.prefix().first == s);
600 assert(m.prefix().second == m[0].first);
601 assert(!m.suffix().matched);
602 assert(m.suffix().first == m[0].second);
603 assert(m.suffix().second == m[0].second);
604 assert((std::size_t)m.length(0) == std::char_traits<char>::length(s));
605 assert(m.position(0) == 0);
606 assert(m.str(0) == s);
607 }
608 {
609 std::cmatch m;
610 const char s[] = "m";
611 assert(!std::regex_match(s, m, std::regex("[a[.hyphen.]z]",
612 std::regex_constants::awk)));
613 assert(m.size() == 0);
614 }
615 {
616 std::cmatch m;
617 const char s[] = "01a45cef9";
618 assert(!std::regex_match(s, m, std::regex("[ace1-9]*",
619 std::regex_constants::awk)));
620 assert(m.size() == 0);
621 }
622 {
623 std::cmatch m;
624 const char s[] = "01a45cef9";
625 assert(!std::regex_match(s, m, std::regex("[ace1-9]+",
626 std::regex_constants::awk)));
627 assert(m.size() == 0);
628 }
629 {
630 const char r[] = "^[-+]?[0-9]+[CF]$";
631 std::ptrdiff_t sr = std::char_traits<char>::length(r);
632 typedef forward_iterator<const char*> FI;
633 typedef bidirectional_iterator<const char*> BI;
634 std::regex regex(FI(r), FI(r+sr), std::regex_constants::awk);
635 std::match_results<BI> m;
636 const char s[] = "-40C";
637 std::ptrdiff_t ss = std::char_traits<char>::length(s);
638 assert(std::regex_match(BI(s), BI(s+ss), m, regex));
639 assert(m.size() == 1);
640 assert(!m.prefix().matched);
641 assert(m.prefix().first == BI(s));
642 assert(m.prefix().second == m[0].first);
643 assert(!m.suffix().matched);
644 assert(m.suffix().first == m[0].second);
645 assert(m.suffix().second == m[0].second);
646 assert((std::size_t)m.length(0) == 4);
647 assert(m.position(0) == 0);
648 assert(m.str(0) == s);
649 }
650 {
651 std::cmatch m;
652 const char s[] = "\n\n\n";
653 assert(std::regex_match(s, m, std::regex("[\\n]+",
654 std::regex_constants::awk)));
655 assert(m.size() == 1);
656 assert(!m.prefix().matched);
657 assert(m.prefix().first == s);
658 assert(m.prefix().second == m[0].first);
659 assert(!m.suffix().matched);
660 assert(m.suffix().first == m[0].second);
661 assert(m.suffix().second == s + std::char_traits<char>::length(s));
662 assert((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 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
668 {
669 std::wcmatch m;
670 const wchar_t s[] = L"a";
671 assert(std::regex_match(s, m, std::wregex(L"a", std::regex_constants::awk)));
672 assert(m.size() == 1);
673 assert(!m.empty());
674 assert(!m.prefix().matched);
675 assert(m.prefix().first == s);
676 assert(m.prefix().second == m[0].first);
677 assert(!m.suffix().matched);
678 assert(m.suffix().first == m[0].second);
679 assert(m.suffix().second == s+1);
680 assert((std::size_t)m.length(0) == 1);
681 assert(m.position(0) == 0);
682 assert(m.str(0) == L"a");
683 }
684 {
685 std::wcmatch m;
686 const wchar_t s[] = L"ab";
687 assert(std::regex_match(s, m, std::wregex(L"ab", std::regex_constants::awk)));
688 assert(m.size() == 1);
689 assert(!m.prefix().matched);
690 assert(m.prefix().first == s);
691 assert(m.prefix().second == m[0].first);
692 assert(!m.suffix().matched);
693 assert(m.suffix().first == m[0].second);
694 assert(m.suffix().second == s+2);
695 assert((std::size_t)m.length(0) == 2);
696 assert(m.position(0) == 0);
697 assert(m.str(0) == L"ab");
698 }
699 {
700 std::wcmatch m;
701 const wchar_t s[] = L"ab";
702 assert(!std::regex_match(s, m, std::wregex(L"ba", std::regex_constants::awk)));
703 assert(m.size() == 0);
704 assert(m.empty());
705 }
706 {
707 std::wcmatch m;
708 const wchar_t s[] = L"aab";
709 assert(!std::regex_match(s, m, std::wregex(L"ab", std::regex_constants::awk)));
710 assert(m.size() == 0);
711 }
712 {
713 std::wcmatch m;
714 const wchar_t s[] = L"aab";
715 assert(!std::regex_match(s, m, std::wregex(L"ab", std::regex_constants::awk),
716 std::regex_constants::match_continuous));
717 assert(m.size() == 0);
718 }
719 {
720 std::wcmatch m;
721 const wchar_t s[] = L"abcd";
722 assert(!std::regex_match(s, m, std::wregex(L"bc", std::regex_constants::awk)));
723 assert(m.size() == 0);
724 }
725 {
726 std::wcmatch m;
727 const wchar_t s[] = L"abbc";
728 assert(std::regex_match(s, m, std::wregex(L"ab*c", std::regex_constants::awk)));
729 assert(m.size() == 1);
730 assert(!m.prefix().matched);
731 assert(m.prefix().first == 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 == s+4);
736 assert(m.length(0) == 4);
737 assert(m.position(0) == 0);
738 assert(m.str(0) == s);
739 }
740 {
741 std::wcmatch m;
742 const wchar_t s[] = L"ababc";
743 assert(std::regex_match(s, m, std::wregex(L"(ab)*c", std::regex_constants::awk)));
744 assert(m.size() == 2);
745 assert(!m.prefix().matched);
746 assert(m.prefix().first == s);
747 assert(m.prefix().second == m[0].first);
748 assert(!m.suffix().matched);
749 assert(m.suffix().first == m[0].second);
750 assert(m.suffix().second == s+5);
751 assert(m.length(0) == 5);
752 assert(m.position(0) == 0);
753 assert(m.str(0) == s);
754 assert(m.length(1) == 2);
755 assert(m.position(1) == 2);
756 assert(m.str(1) == L"ab");
757 }
758 {
759 std::wcmatch m;
760 const wchar_t s[] = L"abcdefghijk";
761 assert(!std::regex_match(s, m, std::wregex(L"cd((e)fg)hi",
762 std::regex_constants::awk)));
763 assert(m.size() == 0);
764 }
765 {
766 std::wcmatch m;
767 const wchar_t s[] = L"abc";
768 assert(std::regex_match(s, m, std::wregex(L"^abc", std::regex_constants::awk)));
769 assert(m.size() == 1);
770 assert(!m.prefix().matched);
771 assert(m.prefix().first == s);
772 assert(m.prefix().second == m[0].first);
773 assert(!m.suffix().matched);
774 assert(m.suffix().first == m[0].second);
775 assert(m.suffix().second == s+3);
776 assert(m.length(0) == 3);
777 assert(m.position(0) == 0);
778 assert(m.str(0) == s);
779 }
780 {
781 std::wcmatch m;
782 const wchar_t s[] = L"abcd";
783 assert(!std::regex_match(s, m, std::wregex(L"^abc", std::regex_constants::awk)));
784 assert(m.size() == 0);
785 }
786 {
787 std::wcmatch m;
788 const wchar_t s[] = L"aabc";
789 assert(!std::regex_match(s, m, std::wregex(L"^abc", std::regex_constants::awk)));
790 assert(m.size() == 0);
791 }
792 {
793 std::wcmatch m;
794 const wchar_t s[] = L"abc";
795 assert(std::regex_match(s, m, std::wregex(L"abc$", std::regex_constants::awk)));
796 assert(m.size() == 1);
797 assert(!m.prefix().matched);
798 assert(m.prefix().first == s);
799 assert(m.prefix().second == m[0].first);
800 assert(!m.suffix().matched);
801 assert(m.suffix().first == m[0].second);
802 assert(m.suffix().second == s+3);
803 assert(m.length(0) == 3);
804 assert(m.position(0) == 0);
805 assert(m.str(0) == s);
806 }
807 {
808 std::wcmatch m;
809 const wchar_t s[] = L"efabc";
810 assert(!std::regex_match(s, m, std::wregex(L"abc$", std::regex_constants::awk)));
811 assert(m.size() == 0);
812 }
813 {
814 std::wcmatch m;
815 const wchar_t s[] = L"efabcg";
816 assert(!std::regex_match(s, m, std::wregex(L"abc$", std::regex_constants::awk)));
817 assert(m.size() == 0);
818 }
819 {
820 std::wcmatch m;
821 const wchar_t s[] = L"abc";
822 assert(std::regex_match(s, m, std::wregex(L"a.c", std::regex_constants::awk)));
823 assert(m.size() == 1);
824 assert(!m.prefix().matched);
825 assert(m.prefix().first == s);
826 assert(m.prefix().second == m[0].first);
827 assert(!m.suffix().matched);
828 assert(m.suffix().first == m[0].second);
829 assert(m.suffix().second == s+3);
830 assert(m.length(0) == 3);
831 assert(m.position(0) == 0);
832 assert(m.str(0) == s);
833 }
834 {
835 std::wcmatch m;
836 const wchar_t s[] = L"acc";
837 assert(std::regex_match(s, m, std::wregex(L"a.c", std::regex_constants::awk)));
838 assert(m.size() == 1);
839 assert(!m.prefix().matched);
840 assert(m.prefix().first == s);
841 assert(m.prefix().second == m[0].first);
842 assert(!m.suffix().matched);
843 assert(m.suffix().first == m[0].second);
844 assert(m.suffix().second == s+3);
845 assert(m.length(0) == 3);
846 assert(m.position(0) == 0);
847 assert(m.str(0) == s);
848 }
849 {
850 std::wcmatch m;
851 const wchar_t s[] = L"acc";
852 assert(std::regex_match(s, m, std::wregex(L"a.c", std::regex_constants::awk)));
853 assert(m.size() == 1);
854 assert(!m.prefix().matched);
855 assert(m.prefix().first == s);
856 assert(m.prefix().second == m[0].first);
857 assert(!m.suffix().matched);
858 assert(m.suffix().first == m[0].second);
859 assert(m.suffix().second == s+3);
860 assert(m.length(0) == 3);
861 assert(m.position(0) == 0);
862 assert(m.str(0) == s);
863 }
864 {
865 std::wcmatch m;
866 const wchar_t s[] = L"abcdef";
867 assert(std::regex_match(s, m, std::wregex(L"(.*).*", std::regex_constants::awk)));
868 assert(m.size() == 2);
869 assert(!m.prefix().matched);
870 assert(m.prefix().first == s);
871 assert(m.prefix().second == m[0].first);
872 assert(!m.suffix().matched);
873 assert(m.suffix().first == m[0].second);
874 assert(m.suffix().second == s+6);
875 assert(m.length(0) == 6);
876 assert(m.position(0) == 0);
877 assert(m.str(0) == s);
878 assert(m.length(1) == 6);
879 assert(m.position(1) == 0);
880 assert(m.str(1) == s);
881 }
882 {
883 std::wcmatch m;
884 const wchar_t s[] = L"bc";
885 assert(!std::regex_match(s, m, std::wregex(L"(a*)*", std::regex_constants::awk)));
886 assert(m.size() == 0);
887 }
888 {
889 std::wcmatch m;
890 const wchar_t s[] = L"abbc";
891 assert(!std::regex_match(s, m, std::wregex(L"ab{3,5}c", std::regex_constants::awk)));
892 assert(m.size() == 0);
893 }
894 {
895 std::wcmatch m;
896 const wchar_t s[] = L"abbbc";
897 assert(std::regex_match(s, m, std::wregex(L"ab{3,5}c", std::regex_constants::awk)));
898 assert(m.size() == 1);
899 assert(!m.prefix().matched);
900 assert(m.prefix().first == s);
901 assert(m.prefix().second == m[0].first);
902 assert(!m.suffix().matched);
903 assert(m.suffix().first == m[0].second);
904 assert(m.suffix().second == m[0].second);
905 assert((std::size_t)m.length(0) == std::char_traits<wchar_t>::length(s));
906 assert(m.position(0) == 0);
907 assert(m.str(0) == s);
908 }
909 {
910 std::wcmatch m;
911 const wchar_t s[] = L"abbbbc";
912 assert(std::regex_match(s, m, std::wregex(L"ab{3,5}c", std::regex_constants::awk)));
913 assert(m.size() == 1);
914 assert(!m.prefix().matched);
915 assert(m.prefix().first == s);
916 assert(m.prefix().second == m[0].first);
917 assert(!m.suffix().matched);
918 assert(m.suffix().first == m[0].second);
919 assert(m.suffix().second == m[0].second);
920 assert((std::size_t)m.length(0) == std::char_traits<wchar_t>::length(s));
921 assert(m.position(0) == 0);
922 assert(m.str(0) == s);
923 }
924 {
925 std::wcmatch m;
926 const wchar_t s[] = L"abbbbbc";
927 assert(std::regex_match(s, m, std::wregex(L"ab{3,5}c", 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 == m[0].second);
935 assert((std::size_t)m.length(0) == std::char_traits<wchar_t>::length(s));
936 assert(m.position(0) == 0);
937 assert(m.str(0) == s);
938 }
939 {
940 std::wcmatch m;
941 const wchar_t s[] = L"adefc";
942 assert(!std::regex_match(s, m, std::wregex(L"ab{3,5}c", std::regex_constants::awk)));
943 assert(m.size() == 0);
944 }
945 {
946 std::wcmatch m;
947 const wchar_t s[] = L"abbbbbbc";
948 assert(!std::regex_match(s, m, std::wregex(L"ab{3,5}c", std::regex_constants::awk)));
949 assert(m.size() == 0);
950 }
951 {
952 std::wcmatch m;
953 const wchar_t s[] = L"adec";
954 assert(!std::regex_match(s, m, std::wregex(L"a.{3,5}c", std::regex_constants::awk)));
955 assert(m.size() == 0);
956 }
957 {
958 std::wcmatch m;
959 const wchar_t s[] = L"adefc";
960 assert(std::regex_match(s, m, std::wregex(L"a.{3,5}c", std::regex_constants::awk)));
961 assert(m.size() == 1);
962 assert(!m.prefix().matched);
963 assert(m.prefix().first == s);
964 assert(m.prefix().second == m[0].first);
965 assert(!m.suffix().matched);
966 assert(m.suffix().first == m[0].second);
967 assert(m.suffix().second == m[0].second);
968 assert((std::size_t)m.length(0) == std::char_traits<wchar_t>::length(s));
969 assert(m.position(0) == 0);
970 assert(m.str(0) == s);
971 }
972 {
973 std::wcmatch m;
974 const wchar_t s[] = L"adefgc";
975 assert(std::regex_match(s, m, std::wregex(L"a.{3,5}c", std::regex_constants::awk)));
976 assert(m.size() == 1);
977 assert(!m.prefix().matched);
978 assert(m.prefix().first == s);
979 assert(m.prefix().second == m[0].first);
980 assert(!m.suffix().matched);
981 assert(m.suffix().first == m[0].second);
982 assert(m.suffix().second == m[0].second);
983 assert((std::size_t)m.length(0) == std::char_traits<wchar_t>::length(s));
984 assert(m.position(0) == 0);
985 assert(m.str(0) == s);
986 }
987 {
988 std::wcmatch m;
989 const wchar_t s[] = L"adefghc";
990 assert(std::regex_match(s, m, std::wregex(L"a.{3,5}c", std::regex_constants::awk)));
991 assert(m.size() == 1);
992 assert(!m.prefix().matched);
993 assert(m.prefix().first == s);
994 assert(m.prefix().second == m[0].first);
995 assert(!m.suffix().matched);
996 assert(m.suffix().first == m[0].second);
997 assert(m.suffix().second == m[0].second);
998 assert((std::size_t)m.length(0) == std::char_traits<wchar_t>::length(s));
999 assert(m.position(0) == 0);
1000 assert(m.str(0) == s);
1001 }
1002 {
1003 std::wcmatch m;
1004 const wchar_t s[] = L"adefghic";
1005 assert(!std::regex_match(s, m, std::wregex(L"a.{3,5}c", std::regex_constants::awk)));
1006 assert(m.size() == 0);
1007 }
1008 {
1009 std::wcmatch m;
1010 const wchar_t s[] = L"tournament";
1011 assert(std::regex_match(s, m, std::wregex(L"tour|to|tournament",
1012 std::regex_constants::awk)));
1013 assert(m.size() == 1);
1014 assert(!m.prefix().matched);
1015 assert(m.prefix().first == s);
1016 assert(m.prefix().second == m[0].first);
1017 assert(!m.suffix().matched);
1018 assert(m.suffix().first == m[0].second);
1019 assert(m.suffix().second == m[0].second);
1020 assert((std::size_t)m.length(0) == std::char_traits<wchar_t>::length(s));
1021 assert(m.position(0) == 0);
1022 assert(m.str(0) == s);
1023 }
1024 {
1025 std::wcmatch m;
1026 const wchar_t s[] = L"tournamenttotour";
1027 assert(std::regex_match(s, m, std::wregex(L"(tour|to|tournament)+",
1028 std::regex_constants::awk | std::regex_constants::nosubs)));
1029 assert(m.size() == 1);
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 == m[0].second);
1036 assert((std::size_t)m.length(0) == std::char_traits<wchar_t>::length(s));
1037 assert(m.position(0) == 0);
1038 assert(m.str(0) == s);
1039 }
1040 {
1041 std::wcmatch m;
1042 const wchar_t s[] = L"ttotour";
1043 assert(std::regex_match(s, m, std::wregex(L"(tour|to|t)+",
1044 std::regex_constants::awk)));
1045 assert(m.size() == 2);
1046 assert(!m.prefix().matched);
1047 assert(m.prefix().first == s);
1048 assert(m.prefix().second == m[0].first);
1049 assert(!m.suffix().matched);
1050 assert(m.suffix().first == m[0].second);
1051 assert(m.suffix().second == m[0].second);
1052 assert((std::size_t)m.length(0) == std::char_traits<wchar_t>::length(s));
1053 assert(m.position(0) == 0);
1054 assert(m.str(0) == s);
1055 assert(m.length(1) == 4);
1056 assert(m.position(1) == 3);
1057 assert(m.str(1) == L"tour");
1058 }
1059 {
1060 std::wcmatch m;
1061 const wchar_t s[] = L"-ab,ab-";
1062 assert(!std::regex_match(s, m, std::wregex(L"-(.*),\1-", std::regex_constants::awk)));
1063 assert(m.size() == 0);
1064 }
1065 {
1066 std::wcmatch m;
1067 const wchar_t s[] = L"-ab,ab-";
1068 assert(std::regex_match(s, m, std::wregex(L"-.*,.*-", std::regex_constants::awk)));
1069 assert(m.size() == 1);
1070 assert(!m.prefix().matched);
1071 assert(m.prefix().first == s);
1072 assert(m.prefix().second == m[0].first);
1073 assert(!m.suffix().matched);
1074 assert(m.suffix().first == m[0].second);
1075 assert(m.suffix().second == m[0].second);
1076 assert((std::size_t)m.length(0) == std::char_traits<wchar_t>::length(s));
1077 assert(m.position(0) == 0);
1078 assert(m.str(0) == s);
1079 }
1080 {
1081 std::wcmatch m;
1082 const wchar_t s[] = L"a";
1083 assert(std::regex_match(s, m, std::wregex(L"^[a]$",
1084 std::regex_constants::awk)));
1085 assert(m.size() == 1);
1086 assert(!m.prefix().matched);
1087 assert(m.prefix().first == s);
1088 assert(m.prefix().second == m[0].first);
1089 assert(!m.suffix().matched);
1090 assert(m.suffix().first == m[0].second);
1091 assert(m.suffix().second == m[0].second);
1092 assert(m.length(0) == 1);
1093 assert(m.position(0) == 0);
1094 assert(m.str(0) == L"a");
1095 }
1096 {
1097 std::wcmatch m;
1098 const wchar_t s[] = L"a";
1099 assert(std::regex_match(s, m, std::wregex(L"^[ab]$",
1100 std::regex_constants::awk)));
1101 assert(m.size() == 1);
1102 assert(!m.prefix().matched);
1103 assert(m.prefix().first == s);
1104 assert(m.prefix().second == m[0].first);
1105 assert(!m.suffix().matched);
1106 assert(m.suffix().first == m[0].second);
1107 assert(m.suffix().second == m[0].second);
1108 assert(m.length(0) == 1);
1109 assert(m.position(0) == 0);
1110 assert(m.str(0) == L"a");
1111 }
1112 {
1113 std::wcmatch m;
1114 const wchar_t s[] = L"c";
1115 assert(std::regex_match(s, m, std::wregex(L"^[a-f]$",
1116 std::regex_constants::awk)));
1117 assert(m.size() == 1);
1118 assert(!m.prefix().matched);
1119 assert(m.prefix().first == s);
1120 assert(m.prefix().second == m[0].first);
1121 assert(!m.suffix().matched);
1122 assert(m.suffix().first == m[0].second);
1123 assert(m.suffix().second == m[0].second);
1124 assert(m.length(0) == 1);
1125 assert(m.position(0) == 0);
1126 assert(m.str(0) == s);
1127 }
1128 {
1129 std::wcmatch m;
1130 const wchar_t s[] = L"g";
1131 assert(!std::regex_match(s, m, std::wregex(L"^[a-f]$",
1132 std::regex_constants::awk)));
1133 assert(m.size() == 0);
1134 }
1135 {
1136 std::wcmatch m;
1137 const wchar_t s[] = L"Iraqi";
1138 assert(!std::regex_match(s, m, std::wregex(L"q[^u]",
1139 std::regex_constants::awk)));
1140 assert(m.size() == 0);
1141 }
1142 {
1143 std::wcmatch m;
1144 const wchar_t s[] = L"Iraq";
1145 assert(!std::regex_match(s, m, std::wregex(L"q[^u]",
1146 std::regex_constants::awk)));
1147 assert(m.size() == 0);
1148 }
1149 {
1150 std::wcmatch m;
1151 const wchar_t s[] = L"AmB";
1152 assert(std::regex_match(s, m, std::wregex(L"A[[:lower:]]B",
1153 std::regex_constants::awk)));
1154 assert(m.size() == 1);
1155 assert(!m.prefix().matched);
1156 assert(m.prefix().first == s);
1157 assert(m.prefix().second == m[0].first);
1158 assert(!m.suffix().matched);
1159 assert(m.suffix().first == m[0].second);
1160 assert(m.suffix().second == m[0].second);
1161 assert((std::size_t)m.length(0) == std::char_traits<wchar_t>::length(s));
1162 assert(m.position(0) == 0);
1163 assert(m.str(0) == s);
1164 }
1165 {
1166 std::wcmatch m;
1167 const wchar_t s[] = L"AMB";
1168 assert(!std::regex_match(s, m, std::wregex(L"A[[:lower:]]B",
1169 std::regex_constants::awk)));
1170 assert(m.size() == 0);
1171 }
1172 {
1173 std::wcmatch m;
1174 const wchar_t s[] = L"AMB";
1175 assert(std::regex_match(s, m, std::wregex(L"A[^[:lower:]]B",
1176 std::regex_constants::awk)));
1177 assert(m.size() == 1);
1178 assert(!m.prefix().matched);
1179 assert(m.prefix().first == s);
1180 assert(m.prefix().second == m[0].first);
1181 assert(!m.suffix().matched);
1182 assert(m.suffix().first == m[0].second);
1183 assert(m.suffix().second == m[0].second);
1184 assert((std::size_t)m.length(0) == std::char_traits<wchar_t>::length(s));
1185 assert(m.position(0) == 0);
1186 assert(m.str(0) == s);
1187 }
1188 {
1189 std::wcmatch m;
1190 const wchar_t s[] = L"AmB";
1191 assert(!std::regex_match(s, m, std::wregex(L"A[^[:lower:]]B",
1192 std::regex_constants::awk)));
1193 assert(m.size() == 0);
1194 }
1195 {
1196 std::wcmatch m;
1197 const wchar_t s[] = L"A5B";
1198 assert(!std::regex_match(s, m, std::wregex(L"A[^[:lower:]0-9]B",
1199 std::regex_constants::awk)));
1200 assert(m.size() == 0);
1201 }
1202 {
1203 std::wcmatch m;
1204 const wchar_t s[] = L"A?B";
1205 assert(std::regex_match(s, m, std::wregex(L"A[^[:lower:]0-9]B",
1206 std::regex_constants::awk)));
1207 assert(m.size() == 1);
1208 assert(!m.prefix().matched);
1209 assert(m.prefix().first == s);
1210 assert(m.prefix().second == m[0].first);
1211 assert(!m.suffix().matched);
1212 assert(m.suffix().first == m[0].second);
1213 assert(m.suffix().second == m[0].second);
1214 assert((std::size_t)m.length(0) == std::char_traits<wchar_t>::length(s));
1215 assert(m.position(0) == 0);
1216 assert(m.str(0) == s);
1217 }
1218 {
1219 std::wcmatch m;
1220 const wchar_t s[] = L"-";
1221 assert(std::regex_match(s, m, std::wregex(L"[a[.hyphen.]z]",
1222 std::regex_constants::awk)));
1223 assert(m.size() == 1);
1224 assert(!m.prefix().matched);
1225 assert(m.prefix().first == s);
1226 assert(m.prefix().second == m[0].first);
1227 assert(!m.suffix().matched);
1228 assert(m.suffix().first == m[0].second);
1229 assert(m.suffix().second == m[0].second);
1230 assert((std::size_t)m.length(0) == std::char_traits<wchar_t>::length(s));
1231 assert(m.position(0) == 0);
1232 assert(m.str(0) == s);
1233 }
1234 {
1235 std::wcmatch m;
1236 const wchar_t s[] = L"z";
1237 assert(std::regex_match(s, m, std::wregex(L"[a[.hyphen.]z]",
1238 std::regex_constants::awk)));
1239 assert(m.size() == 1);
1240 assert(!m.prefix().matched);
1241 assert(m.prefix().first == s);
1242 assert(m.prefix().second == m[0].first);
1243 assert(!m.suffix().matched);
1244 assert(m.suffix().first == m[0].second);
1245 assert(m.suffix().second == m[0].second);
1246 assert((std::size_t)m.length(0) == std::char_traits<wchar_t>::length(s));
1247 assert(m.position(0) == 0);
1248 assert(m.str(0) == s);
1249 }
1250 {
1251 std::wcmatch m;
1252 const wchar_t s[] = L"m";
1253 assert(!std::regex_match(s, m, std::wregex(L"[a[.hyphen.]z]",
1254 std::regex_constants::awk)));
1255 assert(m.size() == 0);
1256 }
1257 {
1258 std::wcmatch m;
1259 const wchar_t s[] = L"01a45cef9";
1260 assert(!std::regex_match(s, m, std::wregex(L"[ace1-9]*",
1261 std::regex_constants::awk)));
1262 assert(m.size() == 0);
1263 }
1264 {
1265 std::wcmatch m;
1266 const wchar_t s[] = L"01a45cef9";
1267 assert(!std::regex_match(s, m, std::wregex(L"[ace1-9]+",
1268 std::regex_constants::awk)));
1269 assert(m.size() == 0);
1270 }
1271 {
1272 const wchar_t r[] = L"^[-+]?[0-9]+[CF]$";
1273 std::ptrdiff_t sr = std::char_traits<wchar_t>::length(r);
1274 typedef forward_iterator<const wchar_t*> FI;
1275 typedef bidirectional_iterator<const wchar_t*> BI;
1276 std::wregex regex(FI(r), FI(r+sr), std::regex_constants::awk);
1277 std::match_results<BI> m;
1278 const wchar_t s[] = L"-40C";
1279 std::ptrdiff_t ss = std::char_traits<wchar_t>::length(s);
1280 assert(std::regex_match(BI(s), BI(s+ss), m, regex));
1281 assert(m.size() == 1);
1282 assert(!m.prefix().matched);
1283 assert(m.prefix().first == BI(s));
1284 assert(m.prefix().second == m[0].first);
1285 assert(!m.suffix().matched);
1286 assert(m.suffix().first == m[0].second);
1287 assert(m.suffix().second == m[0].second);
1288 assert(m.length(0) == 4);
1289 assert(m.position(0) == 0);
1290 assert(m.str(0) == s);
1291 }
1292 {
1293 std::wcmatch m;
1294 const wchar_t s[] = L"\n\n\n";
1295 assert(std::regex_match(s, m, std::wregex(L"[\\n]+",
1296 std::regex_constants::awk)));
1297 assert(m.size() == 1);
1298 assert(!m.prefix().matched);
1299 assert(m.prefix().first == s);
1300 assert(m.prefix().second == m[0].first);
1301 assert(!m.suffix().matched);
1302 assert(m.suffix().first == m[0].second);
1303 assert(m.suffix().second == s + std::char_traits<wchar_t>::length(s));
1304 assert((std::size_t)m.length(0) == std::char_traits<wchar_t>::length(s));
1305 assert(m.position(0) == 0);
1306 assert(m.str(0) == s);
1307 }
1308 #endif // TEST_HAS_NO_WIDE_CHARACTERS
1309 return 0;
1310 }
1311