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