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