1 //===----------------------------------------------------------------------===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is dual licensed under the MIT and the University of Illinois Open 6 // Source Licenses. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 10 // <regex> 11 12 // template <class BidirectionalIterator, class Allocator, class charT, class traits> 13 // bool 14 // 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 = regex_constants::match_default); 18 19 #include <regex> 20 #include <cassert> 21 22 #include "test_iterators.h" 23 24 int main() 25 { 26 { 27 std::cmatch m; 28 const char s[] = "a"; 29 assert(std::regex_match(s, m, std::regex("a", std::regex_constants::extended))); 30 assert(m.size() == 1); 31 assert(!m.empty()); 32 assert(!m.prefix().matched); 33 assert(m.prefix().first == s); 34 assert(m.prefix().second == m[0].first); 35 assert(!m.suffix().matched); 36 assert(m.suffix().first == m[0].second); 37 assert(m.suffix().second == s+1); 38 assert(m.length(0) == 1); 39 assert(m.position(0) == 0); 40 assert(m.str(0) == "a"); 41 } 42 { 43 std::cmatch m; 44 const char s[] = "ab"; 45 assert(std::regex_match(s, m, std::regex("ab", std::regex_constants::extended))); 46 assert(m.size() == 1); 47 assert(!m.prefix().matched); 48 assert(m.prefix().first == s); 49 assert(m.prefix().second == m[0].first); 50 assert(!m.suffix().matched); 51 assert(m.suffix().first == m[0].second); 52 assert(m.suffix().second == s+2); 53 assert(m.length(0) == 2); 54 assert(m.position(0) == 0); 55 assert(m.str(0) == "ab"); 56 } 57 { 58 std::cmatch m; 59 const char s[] = "ab"; 60 assert(!std::regex_match(s, m, std::regex("ba", std::regex_constants::extended))); 61 assert(m.size() == 0); 62 assert(m.empty()); 63 } 64 { 65 std::cmatch m; 66 const char s[] = "aab"; 67 assert(!std::regex_match(s, m, std::regex("ab", std::regex_constants::extended))); 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::extended), 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::extended))); 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::extended))); 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::extended))); 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::extended))); 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::extended))); 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::extended))); 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::extended))); 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::extended))); 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::extended))); 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::extended))); 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::extended))); 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::extended))); 196 assert(m.size() == 1); 197 assert(!m.prefix().matched); 198 assert(m.prefix().first == s); 199 assert(m.prefix().second == m[0].first); 200 assert(!m.suffix().matched); 201 assert(m.suffix().first == m[0].second); 202 assert(m.suffix().second == s+3); 203 assert(m.length(0) == 3); 204 assert(m.position(0) == 0); 205 assert(m.str(0) == s); 206 } 207 { 208 std::cmatch m; 209 const char s[] = "acc"; 210 assert(std::regex_match(s, m, std::regex("a.c", std::regex_constants::extended))); 211 assert(m.size() == 1); 212 assert(!m.prefix().matched); 213 assert(m.prefix().first == s); 214 assert(m.prefix().second == m[0].first); 215 assert(!m.suffix().matched); 216 assert(m.suffix().first == m[0].second); 217 assert(m.suffix().second == s+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::extended))); 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::extended))); 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::extended))); 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::extended))); 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(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::extended))); 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(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::extended))); 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(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::extended))); 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::extended))); 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::extended))); 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::extended))); 319 assert(m.size() == 1); 320 assert(!m.prefix().matched); 321 assert(m.prefix().first == s); 322 assert(m.prefix().second == m[0].first); 323 assert(!m.suffix().matched); 324 assert(m.suffix().first == m[0].second); 325 assert(m.suffix().second == m[0].second); 326 assert(m.length(0) == 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::extended))); 334 assert(m.size() == 1); 335 assert(!m.prefix().matched); 336 assert(m.prefix().first == s); 337 assert(m.prefix().second == m[0].first); 338 assert(!m.suffix().matched); 339 assert(m.suffix().first == m[0].second); 340 assert(m.suffix().second == m[0].second); 341 assert(m.length(0) == 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::extended))); 349 assert(m.size() == 1); 350 assert(!m.prefix().matched); 351 assert(m.prefix().first == s); 352 assert(m.prefix().second == m[0].first); 353 assert(!m.suffix().matched); 354 assert(m.suffix().first == m[0].second); 355 assert(m.suffix().second == m[0].second); 356 assert(m.length(0) == 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::extended))); 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::extended))); 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(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::extended | 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(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::extended))); 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(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::extended))); 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::extended))); 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(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::extended))); 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::extended))); 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::extended))); 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::extended))); 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::extended))); 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::extended))); 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::extended))); 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(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::extended))); 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::extended))); 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(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::extended))); 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::extended))); 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::extended))); 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(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::extended))); 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(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::extended))); 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(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::extended))); 613 assert(m.size() == 0); 614 } 615 std::locale::global(std::locale("cs_CZ.ISO8859-2")); 616 { 617 std::cmatch m; 618 const char s[] = "m"; 619 assert(std::regex_match(s, m, std::regex("[a[=M=]z]", 620 std::regex_constants::extended))); 621 assert(m.size() == 1); 622 assert(!m.prefix().matched); 623 assert(m.prefix().first == s); 624 assert(m.prefix().second == m[0].first); 625 assert(!m.suffix().matched); 626 assert(m.suffix().first == m[0].second); 627 assert(m.suffix().second == m[0].second); 628 assert(m.length(0) == std::char_traits<char>::length(s)); 629 assert(m.position(0) == 0); 630 assert(m.str(0) == s); 631 } 632 { 633 std::cmatch m; 634 const char s[] = "Ch"; 635 assert(std::regex_match(s, m, std::regex("[a[.ch.]z]", 636 std::regex_constants::extended | std::regex_constants::icase))); 637 assert(m.size() == 1); 638 assert(!m.prefix().matched); 639 assert(m.prefix().first == s); 640 assert(m.prefix().second == m[0].first); 641 assert(!m.suffix().matched); 642 assert(m.suffix().first == m[0].second); 643 assert(m.suffix().second == m[0].second); 644 assert(m.length(0) == std::char_traits<char>::length(s)); 645 assert(m.position(0) == 0); 646 assert(m.str(0) == s); 647 } 648 std::locale::global(std::locale("C")); 649 { 650 std::cmatch m; 651 const char s[] = "m"; 652 assert(!std::regex_match(s, m, std::regex("[a[=M=]z]", 653 std::regex_constants::extended))); 654 assert(m.size() == 0); 655 } 656 { 657 std::cmatch m; 658 const char s[] = "01a45cef9"; 659 assert(!std::regex_match(s, m, std::regex("[ace1-9]*", 660 std::regex_constants::extended))); 661 assert(m.size() == 0); 662 } 663 { 664 std::cmatch m; 665 const char s[] = "01a45cef9"; 666 assert(!std::regex_match(s, m, std::regex("[ace1-9]+", 667 std::regex_constants::extended))); 668 assert(m.size() == 0); 669 } 670 { 671 const char r[] = "^[-+]?[0-9]+[CF]$"; 672 std::ptrdiff_t sr = std::char_traits<char>::length(r); 673 typedef forward_iterator<const char*> FI; 674 typedef bidirectional_iterator<const char*> BI; 675 std::regex regex(FI(r), FI(r+sr), std::regex_constants::extended); 676 std::match_results<BI> m; 677 const char s[] = "-40C"; 678 std::ptrdiff_t ss = std::char_traits<char>::length(s); 679 assert(std::regex_match(BI(s), BI(s+ss), m, regex)); 680 assert(m.size() == 1); 681 assert(!m.prefix().matched); 682 assert(m.prefix().first == BI(s)); 683 assert(m.prefix().second == m[0].first); 684 assert(!m.suffix().matched); 685 assert(m.suffix().first == m[0].second); 686 assert(m.suffix().second == m[0].second); 687 assert(m.length(0) == 4); 688 assert(m.position(0) == 0); 689 assert(m.str(0) == s); 690 } 691 692 { 693 std::wcmatch m; 694 const wchar_t s[] = L"a"; 695 assert(std::regex_match(s, m, std::wregex(L"a", std::regex_constants::extended))); 696 assert(m.size() == 1); 697 assert(!m.empty()); 698 assert(!m.prefix().matched); 699 assert(m.prefix().first == s); 700 assert(m.prefix().second == m[0].first); 701 assert(!m.suffix().matched); 702 assert(m.suffix().first == m[0].second); 703 assert(m.suffix().second == s+1); 704 assert(m.length(0) == 1); 705 assert(m.position(0) == 0); 706 assert(m.str(0) == L"a"); 707 } 708 { 709 std::wcmatch m; 710 const wchar_t s[] = L"ab"; 711 assert(std::regex_match(s, m, std::wregex(L"ab", std::regex_constants::extended))); 712 assert(m.size() == 1); 713 assert(!m.prefix().matched); 714 assert(m.prefix().first == s); 715 assert(m.prefix().second == m[0].first); 716 assert(!m.suffix().matched); 717 assert(m.suffix().first == m[0].second); 718 assert(m.suffix().second == s+2); 719 assert(m.length(0) == 2); 720 assert(m.position(0) == 0); 721 assert(m.str(0) == L"ab"); 722 } 723 { 724 std::wcmatch m; 725 const wchar_t s[] = L"ab"; 726 assert(!std::regex_match(s, m, std::wregex(L"ba", std::regex_constants::extended))); 727 assert(m.size() == 0); 728 assert(m.empty()); 729 } 730 { 731 std::wcmatch m; 732 const wchar_t s[] = L"aab"; 733 assert(!std::regex_match(s, m, std::wregex(L"ab", std::regex_constants::extended))); 734 assert(m.size() == 0); 735 } 736 { 737 std::wcmatch m; 738 const wchar_t s[] = L"aab"; 739 assert(!std::regex_match(s, m, std::wregex(L"ab", std::regex_constants::extended), 740 std::regex_constants::match_continuous)); 741 assert(m.size() == 0); 742 } 743 { 744 std::wcmatch m; 745 const wchar_t s[] = L"abcd"; 746 assert(!std::regex_match(s, m, std::wregex(L"bc", std::regex_constants::extended))); 747 assert(m.size() == 0); 748 } 749 { 750 std::wcmatch m; 751 const wchar_t s[] = L"abbc"; 752 assert(std::regex_match(s, m, std::wregex(L"ab*c", std::regex_constants::extended))); 753 assert(m.size() == 1); 754 assert(!m.prefix().matched); 755 assert(m.prefix().first == s); 756 assert(m.prefix().second == m[0].first); 757 assert(!m.suffix().matched); 758 assert(m.suffix().first == m[0].second); 759 assert(m.suffix().second == s+4); 760 assert(m.length(0) == 4); 761 assert(m.position(0) == 0); 762 assert(m.str(0) == s); 763 } 764 { 765 std::wcmatch m; 766 const wchar_t s[] = L"ababc"; 767 assert(std::regex_match(s, m, std::wregex(L"(ab)*c", std::regex_constants::extended))); 768 assert(m.size() == 2); 769 assert(!m.prefix().matched); 770 assert(m.prefix().first == s); 771 assert(m.prefix().second == m[0].first); 772 assert(!m.suffix().matched); 773 assert(m.suffix().first == m[0].second); 774 assert(m.suffix().second == s+5); 775 assert(m.length(0) == 5); 776 assert(m.position(0) == 0); 777 assert(m.str(0) == s); 778 assert(m.length(1) == 2); 779 assert(m.position(1) == 2); 780 assert(m.str(1) == L"ab"); 781 } 782 { 783 std::wcmatch m; 784 const wchar_t s[] = L"abcdefghijk"; 785 assert(!std::regex_match(s, m, std::wregex(L"cd((e)fg)hi", 786 std::regex_constants::extended))); 787 assert(m.size() == 0); 788 } 789 { 790 std::wcmatch m; 791 const wchar_t s[] = L"abc"; 792 assert(std::regex_match(s, m, std::wregex(L"^abc", std::regex_constants::extended))); 793 assert(m.size() == 1); 794 assert(!m.prefix().matched); 795 assert(m.prefix().first == s); 796 assert(m.prefix().second == m[0].first); 797 assert(!m.suffix().matched); 798 assert(m.suffix().first == m[0].second); 799 assert(m.suffix().second == s+3); 800 assert(m.length(0) == 3); 801 assert(m.position(0) == 0); 802 assert(m.str(0) == s); 803 } 804 { 805 std::wcmatch m; 806 const wchar_t s[] = L"abcd"; 807 assert(!std::regex_match(s, m, std::wregex(L"^abc", std::regex_constants::extended))); 808 assert(m.size() == 0); 809 } 810 { 811 std::wcmatch m; 812 const wchar_t s[] = L"aabc"; 813 assert(!std::regex_match(s, m, std::wregex(L"^abc", std::regex_constants::extended))); 814 assert(m.size() == 0); 815 } 816 { 817 std::wcmatch m; 818 const wchar_t s[] = L"abc"; 819 assert(std::regex_match(s, m, std::wregex(L"abc$", std::regex_constants::extended))); 820 assert(m.size() == 1); 821 assert(!m.prefix().matched); 822 assert(m.prefix().first == s); 823 assert(m.prefix().second == m[0].first); 824 assert(!m.suffix().matched); 825 assert(m.suffix().first == m[0].second); 826 assert(m.suffix().second == s+3); 827 assert(m.length(0) == 3); 828 assert(m.position(0) == 0); 829 assert(m.str(0) == s); 830 } 831 { 832 std::wcmatch m; 833 const wchar_t s[] = L"efabc"; 834 assert(!std::regex_match(s, m, std::wregex(L"abc$", std::regex_constants::extended))); 835 assert(m.size() == 0); 836 } 837 { 838 std::wcmatch m; 839 const wchar_t s[] = L"efabcg"; 840 assert(!std::regex_match(s, m, std::wregex(L"abc$", std::regex_constants::extended))); 841 assert(m.size() == 0); 842 } 843 { 844 std::wcmatch m; 845 const wchar_t s[] = L"abc"; 846 assert(std::regex_match(s, m, std::wregex(L"a.c", std::regex_constants::extended))); 847 assert(m.size() == 1); 848 assert(!m.prefix().matched); 849 assert(m.prefix().first == s); 850 assert(m.prefix().second == m[0].first); 851 assert(!m.suffix().matched); 852 assert(m.suffix().first == m[0].second); 853 assert(m.suffix().second == s+3); 854 assert(m.length(0) == 3); 855 assert(m.position(0) == 0); 856 assert(m.str(0) == s); 857 } 858 { 859 std::wcmatch m; 860 const wchar_t s[] = L"acc"; 861 assert(std::regex_match(s, m, std::wregex(L"a.c", std::regex_constants::extended))); 862 assert(m.size() == 1); 863 assert(!m.prefix().matched); 864 assert(m.prefix().first == s); 865 assert(m.prefix().second == m[0].first); 866 assert(!m.suffix().matched); 867 assert(m.suffix().first == m[0].second); 868 assert(m.suffix().second == s+3); 869 assert(m.length(0) == 3); 870 assert(m.position(0) == 0); 871 assert(m.str(0) == s); 872 } 873 { 874 std::wcmatch m; 875 const wchar_t s[] = L"acc"; 876 assert(std::regex_match(s, m, std::wregex(L"a.c", std::regex_constants::extended))); 877 assert(m.size() == 1); 878 assert(!m.prefix().matched); 879 assert(m.prefix().first == s); 880 assert(m.prefix().second == m[0].first); 881 assert(!m.suffix().matched); 882 assert(m.suffix().first == m[0].second); 883 assert(m.suffix().second == s+3); 884 assert(m.length(0) == 3); 885 assert(m.position(0) == 0); 886 assert(m.str(0) == s); 887 } 888 { 889 std::wcmatch m; 890 const wchar_t s[] = L"abcdef"; 891 assert(std::regex_match(s, m, std::wregex(L"(.*).*", std::regex_constants::extended))); 892 assert(m.size() == 2); 893 assert(!m.prefix().matched); 894 assert(m.prefix().first == s); 895 assert(m.prefix().second == m[0].first); 896 assert(!m.suffix().matched); 897 assert(m.suffix().first == m[0].second); 898 assert(m.suffix().second == s+6); 899 assert(m.length(0) == 6); 900 assert(m.position(0) == 0); 901 assert(m.str(0) == s); 902 assert(m.length(1) == 6); 903 assert(m.position(1) == 0); 904 assert(m.str(1) == s); 905 } 906 { 907 std::wcmatch m; 908 const wchar_t s[] = L"bc"; 909 assert(!std::regex_match(s, m, std::wregex(L"(a*)*", std::regex_constants::extended))); 910 assert(m.size() == 0); 911 } 912 { 913 std::wcmatch m; 914 const wchar_t s[] = L"abbc"; 915 assert(!std::regex_match(s, m, std::wregex(L"ab{3,5}c", std::regex_constants::extended))); 916 assert(m.size() == 0); 917 } 918 { 919 std::wcmatch m; 920 const wchar_t s[] = L"abbbc"; 921 assert(std::regex_match(s, m, std::wregex(L"ab{3,5}c", std::regex_constants::extended))); 922 assert(m.size() == 1); 923 assert(!m.prefix().matched); 924 assert(m.prefix().first == s); 925 assert(m.prefix().second == m[0].first); 926 assert(!m.suffix().matched); 927 assert(m.suffix().first == m[0].second); 928 assert(m.suffix().second == m[0].second); 929 assert(m.length(0) == std::char_traits<wchar_t>::length(s)); 930 assert(m.position(0) == 0); 931 assert(m.str(0) == s); 932 } 933 { 934 std::wcmatch m; 935 const wchar_t s[] = L"abbbbc"; 936 assert(std::regex_match(s, m, std::wregex(L"ab{3,5}c", std::regex_constants::extended))); 937 assert(m.size() == 1); 938 assert(!m.prefix().matched); 939 assert(m.prefix().first == s); 940 assert(m.prefix().second == m[0].first); 941 assert(!m.suffix().matched); 942 assert(m.suffix().first == m[0].second); 943 assert(m.suffix().second == m[0].second); 944 assert(m.length(0) == std::char_traits<wchar_t>::length(s)); 945 assert(m.position(0) == 0); 946 assert(m.str(0) == s); 947 } 948 { 949 std::wcmatch m; 950 const wchar_t s[] = L"abbbbbc"; 951 assert(std::regex_match(s, m, std::wregex(L"ab{3,5}c", std::regex_constants::extended))); 952 assert(m.size() == 1); 953 assert(!m.prefix().matched); 954 assert(m.prefix().first == s); 955 assert(m.prefix().second == m[0].first); 956 assert(!m.suffix().matched); 957 assert(m.suffix().first == m[0].second); 958 assert(m.suffix().second == m[0].second); 959 assert(m.length(0) == std::char_traits<wchar_t>::length(s)); 960 assert(m.position(0) == 0); 961 assert(m.str(0) == s); 962 } 963 { 964 std::wcmatch m; 965 const wchar_t s[] = L"adefc"; 966 assert(!std::regex_match(s, m, std::wregex(L"ab{3,5}c", std::regex_constants::extended))); 967 assert(m.size() == 0); 968 } 969 { 970 std::wcmatch m; 971 const wchar_t s[] = L"abbbbbbc"; 972 assert(!std::regex_match(s, m, std::wregex(L"ab{3,5}c", std::regex_constants::extended))); 973 assert(m.size() == 0); 974 } 975 { 976 std::wcmatch m; 977 const wchar_t s[] = L"adec"; 978 assert(!std::regex_match(s, m, std::wregex(L"a.{3,5}c", std::regex_constants::extended))); 979 assert(m.size() == 0); 980 } 981 { 982 std::wcmatch m; 983 const wchar_t s[] = L"adefc"; 984 assert(std::regex_match(s, m, std::wregex(L"a.{3,5}c", std::regex_constants::extended))); 985 assert(m.size() == 1); 986 assert(!m.prefix().matched); 987 assert(m.prefix().first == s); 988 assert(m.prefix().second == m[0].first); 989 assert(!m.suffix().matched); 990 assert(m.suffix().first == m[0].second); 991 assert(m.suffix().second == m[0].second); 992 assert(m.length(0) == std::char_traits<wchar_t>::length(s)); 993 assert(m.position(0) == 0); 994 assert(m.str(0) == s); 995 } 996 { 997 std::wcmatch m; 998 const wchar_t s[] = L"adefgc"; 999 assert(std::regex_match(s, m, std::wregex(L"a.{3,5}c", std::regex_constants::extended))); 1000 assert(m.size() == 1); 1001 assert(!m.prefix().matched); 1002 assert(m.prefix().first == s); 1003 assert(m.prefix().second == m[0].first); 1004 assert(!m.suffix().matched); 1005 assert(m.suffix().first == m[0].second); 1006 assert(m.suffix().second == m[0].second); 1007 assert(m.length(0) == std::char_traits<wchar_t>::length(s)); 1008 assert(m.position(0) == 0); 1009 assert(m.str(0) == s); 1010 } 1011 { 1012 std::wcmatch m; 1013 const wchar_t s[] = L"adefghc"; 1014 assert(std::regex_match(s, m, std::wregex(L"a.{3,5}c", std::regex_constants::extended))); 1015 assert(m.size() == 1); 1016 assert(!m.prefix().matched); 1017 assert(m.prefix().first == s); 1018 assert(m.prefix().second == m[0].first); 1019 assert(!m.suffix().matched); 1020 assert(m.suffix().first == m[0].second); 1021 assert(m.suffix().second == m[0].second); 1022 assert(m.length(0) == std::char_traits<wchar_t>::length(s)); 1023 assert(m.position(0) == 0); 1024 assert(m.str(0) == s); 1025 } 1026 { 1027 std::wcmatch m; 1028 const wchar_t s[] = L"adefghic"; 1029 assert(!std::regex_match(s, m, std::wregex(L"a.{3,5}c", std::regex_constants::extended))); 1030 assert(m.size() == 0); 1031 } 1032 { 1033 std::wcmatch m; 1034 const wchar_t s[] = L"tournament"; 1035 assert(std::regex_match(s, m, std::wregex(L"tour|to|tournament", 1036 std::regex_constants::extended))); 1037 assert(m.size() == 1); 1038 assert(!m.prefix().matched); 1039 assert(m.prefix().first == s); 1040 assert(m.prefix().second == m[0].first); 1041 assert(!m.suffix().matched); 1042 assert(m.suffix().first == m[0].second); 1043 assert(m.suffix().second == m[0].second); 1044 assert(m.length(0) == std::char_traits<wchar_t>::length(s)); 1045 assert(m.position(0) == 0); 1046 assert(m.str(0) == s); 1047 } 1048 { 1049 std::wcmatch m; 1050 const wchar_t s[] = L"tournamenttotour"; 1051 assert(std::regex_match(s, m, std::wregex(L"(tour|to|tournament)+", 1052 std::regex_constants::extended | std::regex_constants::nosubs))); 1053 assert(m.size() == 1); 1054 assert(!m.prefix().matched); 1055 assert(m.prefix().first == s); 1056 assert(m.prefix().second == m[0].first); 1057 assert(!m.suffix().matched); 1058 assert(m.suffix().first == m[0].second); 1059 assert(m.suffix().second == m[0].second); 1060 assert(m.length(0) == std::char_traits<wchar_t>::length(s)); 1061 assert(m.position(0) == 0); 1062 assert(m.str(0) == s); 1063 } 1064 { 1065 std::wcmatch m; 1066 const wchar_t s[] = L"ttotour"; 1067 assert(std::regex_match(s, m, std::wregex(L"(tour|to|t)+", 1068 std::regex_constants::extended))); 1069 assert(m.size() == 2); 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(m.length(0) == std::char_traits<wchar_t>::length(s)); 1077 assert(m.position(0) == 0); 1078 assert(m.str(0) == s); 1079 assert(m.length(1) == 4); 1080 assert(m.position(1) == 3); 1081 assert(m.str(1) == L"tour"); 1082 } 1083 { 1084 std::wcmatch m; 1085 const wchar_t s[] = L"-ab,ab-"; 1086 assert(!std::regex_match(s, m, std::wregex(L"-(.*),\1-", std::regex_constants::extended))); 1087 assert(m.size() == 0); 1088 } 1089 { 1090 std::wcmatch m; 1091 const wchar_t s[] = L"-ab,ab-"; 1092 assert(std::regex_match(s, m, std::wregex(L"-.*,.*-", std::regex_constants::extended))); 1093 assert(m.size() == 1); 1094 assert(!m.prefix().matched); 1095 assert(m.prefix().first == s); 1096 assert(m.prefix().second == m[0].first); 1097 assert(!m.suffix().matched); 1098 assert(m.suffix().first == m[0].second); 1099 assert(m.suffix().second == m[0].second); 1100 assert(m.length(0) == std::char_traits<wchar_t>::length(s)); 1101 assert(m.position(0) == 0); 1102 assert(m.str(0) == s); 1103 } 1104 { 1105 std::wcmatch m; 1106 const wchar_t s[] = L"a"; 1107 assert(std::regex_match(s, m, std::wregex(L"^[a]$", 1108 std::regex_constants::extended))); 1109 assert(m.size() == 1); 1110 assert(!m.prefix().matched); 1111 assert(m.prefix().first == s); 1112 assert(m.prefix().second == m[0].first); 1113 assert(!m.suffix().matched); 1114 assert(m.suffix().first == m[0].second); 1115 assert(m.suffix().second == m[0].second); 1116 assert(m.length(0) == 1); 1117 assert(m.position(0) == 0); 1118 assert(m.str(0) == L"a"); 1119 } 1120 { 1121 std::wcmatch m; 1122 const wchar_t s[] = L"a"; 1123 assert(std::regex_match(s, m, std::wregex(L"^[ab]$", 1124 std::regex_constants::extended))); 1125 assert(m.size() == 1); 1126 assert(!m.prefix().matched); 1127 assert(m.prefix().first == s); 1128 assert(m.prefix().second == m[0].first); 1129 assert(!m.suffix().matched); 1130 assert(m.suffix().first == m[0].second); 1131 assert(m.suffix().second == m[0].second); 1132 assert(m.length(0) == 1); 1133 assert(m.position(0) == 0); 1134 assert(m.str(0) == L"a"); 1135 } 1136 { 1137 std::wcmatch m; 1138 const wchar_t s[] = L"c"; 1139 assert(std::regex_match(s, m, std::wregex(L"^[a-f]$", 1140 std::regex_constants::extended))); 1141 assert(m.size() == 1); 1142 assert(!m.prefix().matched); 1143 assert(m.prefix().first == s); 1144 assert(m.prefix().second == m[0].first); 1145 assert(!m.suffix().matched); 1146 assert(m.suffix().first == m[0].second); 1147 assert(m.suffix().second == m[0].second); 1148 assert(m.length(0) == 1); 1149 assert(m.position(0) == 0); 1150 assert(m.str(0) == s); 1151 } 1152 { 1153 std::wcmatch m; 1154 const wchar_t s[] = L"g"; 1155 assert(!std::regex_match(s, m, std::wregex(L"^[a-f]$", 1156 std::regex_constants::extended))); 1157 assert(m.size() == 0); 1158 } 1159 { 1160 std::wcmatch m; 1161 const wchar_t s[] = L"Iraqi"; 1162 assert(!std::regex_match(s, m, std::wregex(L"q[^u]", 1163 std::regex_constants::extended))); 1164 assert(m.size() == 0); 1165 } 1166 { 1167 std::wcmatch m; 1168 const wchar_t s[] = L"Iraq"; 1169 assert(!std::regex_match(s, m, std::wregex(L"q[^u]", 1170 std::regex_constants::extended))); 1171 assert(m.size() == 0); 1172 } 1173 { 1174 std::wcmatch m; 1175 const wchar_t s[] = L"AmB"; 1176 assert(std::regex_match(s, m, std::wregex(L"A[[:lower:]]B", 1177 std::regex_constants::extended))); 1178 assert(m.size() == 1); 1179 assert(!m.prefix().matched); 1180 assert(m.prefix().first == s); 1181 assert(m.prefix().second == m[0].first); 1182 assert(!m.suffix().matched); 1183 assert(m.suffix().first == m[0].second); 1184 assert(m.suffix().second == m[0].second); 1185 assert(m.length(0) == std::char_traits<wchar_t>::length(s)); 1186 assert(m.position(0) == 0); 1187 assert(m.str(0) == s); 1188 } 1189 { 1190 std::wcmatch m; 1191 const wchar_t s[] = L"AMB"; 1192 assert(!std::regex_match(s, m, std::wregex(L"A[[:lower:]]B", 1193 std::regex_constants::extended))); 1194 assert(m.size() == 0); 1195 } 1196 { 1197 std::wcmatch m; 1198 const wchar_t s[] = L"AMB"; 1199 assert(std::regex_match(s, m, std::wregex(L"A[^[:lower:]]B", 1200 std::regex_constants::extended))); 1201 assert(m.size() == 1); 1202 assert(!m.prefix().matched); 1203 assert(m.prefix().first == s); 1204 assert(m.prefix().second == m[0].first); 1205 assert(!m.suffix().matched); 1206 assert(m.suffix().first == m[0].second); 1207 assert(m.suffix().second == m[0].second); 1208 assert(m.length(0) == std::char_traits<wchar_t>::length(s)); 1209 assert(m.position(0) == 0); 1210 assert(m.str(0) == s); 1211 } 1212 { 1213 std::wcmatch m; 1214 const wchar_t s[] = L"AmB"; 1215 assert(!std::regex_match(s, m, std::wregex(L"A[^[:lower:]]B", 1216 std::regex_constants::extended))); 1217 assert(m.size() == 0); 1218 } 1219 { 1220 std::wcmatch m; 1221 const wchar_t s[] = L"A5B"; 1222 assert(!std::regex_match(s, m, std::wregex(L"A[^[:lower:]0-9]B", 1223 std::regex_constants::extended))); 1224 assert(m.size() == 0); 1225 } 1226 { 1227 std::wcmatch m; 1228 const wchar_t s[] = L"A?B"; 1229 assert(std::regex_match(s, m, std::wregex(L"A[^[:lower:]0-9]B", 1230 std::regex_constants::extended))); 1231 assert(m.size() == 1); 1232 assert(!m.prefix().matched); 1233 assert(m.prefix().first == s); 1234 assert(m.prefix().second == m[0].first); 1235 assert(!m.suffix().matched); 1236 assert(m.suffix().first == m[0].second); 1237 assert(m.suffix().second == m[0].second); 1238 assert(m.length(0) == std::char_traits<wchar_t>::length(s)); 1239 assert(m.position(0) == 0); 1240 assert(m.str(0) == s); 1241 } 1242 { 1243 std::wcmatch m; 1244 const wchar_t s[] = L"-"; 1245 assert(std::regex_match(s, m, std::wregex(L"[a[.hyphen.]z]", 1246 std::regex_constants::extended))); 1247 assert(m.size() == 1); 1248 assert(!m.prefix().matched); 1249 assert(m.prefix().first == s); 1250 assert(m.prefix().second == m[0].first); 1251 assert(!m.suffix().matched); 1252 assert(m.suffix().first == m[0].second); 1253 assert(m.suffix().second == m[0].second); 1254 assert(m.length(0) == std::char_traits<wchar_t>::length(s)); 1255 assert(m.position(0) == 0); 1256 assert(m.str(0) == s); 1257 } 1258 { 1259 std::wcmatch m; 1260 const wchar_t s[] = L"z"; 1261 assert(std::regex_match(s, m, std::wregex(L"[a[.hyphen.]z]", 1262 std::regex_constants::extended))); 1263 assert(m.size() == 1); 1264 assert(!m.prefix().matched); 1265 assert(m.prefix().first == s); 1266 assert(m.prefix().second == m[0].first); 1267 assert(!m.suffix().matched); 1268 assert(m.suffix().first == m[0].second); 1269 assert(m.suffix().second == m[0].second); 1270 assert(m.length(0) == std::char_traits<wchar_t>::length(s)); 1271 assert(m.position(0) == 0); 1272 assert(m.str(0) == s); 1273 } 1274 { 1275 std::wcmatch m; 1276 const wchar_t s[] = L"m"; 1277 assert(!std::regex_match(s, m, std::wregex(L"[a[.hyphen.]z]", 1278 std::regex_constants::extended))); 1279 assert(m.size() == 0); 1280 } 1281 std::locale::global(std::locale("cs_CZ.ISO8859-2")); 1282 { 1283 std::wcmatch m; 1284 const wchar_t s[] = L"m"; 1285 assert(std::regex_match(s, m, std::wregex(L"[a[=M=]z]", 1286 std::regex_constants::extended))); 1287 assert(m.size() == 1); 1288 assert(!m.prefix().matched); 1289 assert(m.prefix().first == s); 1290 assert(m.prefix().second == m[0].first); 1291 assert(!m.suffix().matched); 1292 assert(m.suffix().first == m[0].second); 1293 assert(m.suffix().second == m[0].second); 1294 assert(m.length(0) == std::char_traits<wchar_t>::length(s)); 1295 assert(m.position(0) == 0); 1296 assert(m.str(0) == s); 1297 } 1298 { 1299 std::wcmatch m; 1300 const wchar_t s[] = L"Ch"; 1301 assert(std::regex_match(s, m, std::wregex(L"[a[.ch.]z]", 1302 std::regex_constants::extended | std::regex_constants::icase))); 1303 assert(m.size() == 1); 1304 assert(!m.prefix().matched); 1305 assert(m.prefix().first == s); 1306 assert(m.prefix().second == m[0].first); 1307 assert(!m.suffix().matched); 1308 assert(m.suffix().first == m[0].second); 1309 assert(m.suffix().second == m[0].second); 1310 assert(m.length(0) == std::char_traits<wchar_t>::length(s)); 1311 assert(m.position(0) == 0); 1312 assert(m.str(0) == s); 1313 } 1314 std::locale::global(std::locale("C")); 1315 { 1316 std::wcmatch m; 1317 const wchar_t s[] = L"m"; 1318 assert(!std::regex_match(s, m, std::wregex(L"[a[=M=]z]", 1319 std::regex_constants::extended))); 1320 assert(m.size() == 0); 1321 } 1322 { 1323 std::wcmatch m; 1324 const wchar_t s[] = L"01a45cef9"; 1325 assert(!std::regex_match(s, m, std::wregex(L"[ace1-9]*", 1326 std::regex_constants::extended))); 1327 assert(m.size() == 0); 1328 } 1329 { 1330 std::wcmatch m; 1331 const wchar_t s[] = L"01a45cef9"; 1332 assert(!std::regex_match(s, m, std::wregex(L"[ace1-9]+", 1333 std::regex_constants::extended))); 1334 assert(m.size() == 0); 1335 } 1336 { 1337 const wchar_t r[] = L"^[-+]?[0-9]+[CF]$"; 1338 std::ptrdiff_t sr = std::char_traits<wchar_t>::length(r); 1339 typedef forward_iterator<const wchar_t*> FI; 1340 typedef bidirectional_iterator<const wchar_t*> BI; 1341 std::wregex regex(FI(r), FI(r+sr), std::regex_constants::extended); 1342 std::match_results<BI> m; 1343 const wchar_t s[] = L"-40C"; 1344 std::ptrdiff_t ss = std::char_traits<wchar_t>::length(s); 1345 assert(std::regex_match(BI(s), BI(s+ss), m, regex)); 1346 assert(m.size() == 1); 1347 assert(!m.prefix().matched); 1348 assert(m.prefix().first == BI(s)); 1349 assert(m.prefix().second == m[0].first); 1350 assert(!m.suffix().matched); 1351 assert(m.suffix().first == m[0].second); 1352 assert(m.suffix().second == m[0].second); 1353 assert(m.length(0) == 4); 1354 assert(m.position(0) == 0); 1355 assert(m.str(0) == s); 1356 } 1357 } 1358
