ecma.pass.cpp (57712B)
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 // NetBSD does not support LC_COLLATE at the moment 11 // XFAIL: netbsd 12 13 // REQUIRES: locale.cs_CZ.ISO8859-2 14 15 // <regex> 16 17 // template <class BidirectionalIterator, class Allocator, class charT, class traits> 18 // bool 19 // regex_search(BidirectionalIterator first, BidirectionalIterator last, 20 // match_results<BidirectionalIterator, Allocator>& m, 21 // const basic_regex<charT, traits>& e, 22 // regex_constants::match_flag_type flags = regex_constants::match_default); 23 24 // TODO: investigation needed 25 // XFAIL: linux-gnu 26 27 #include <regex> 28 #include <cassert> 29 #include "test_macros.h" 30 #include "test_iterators.h" 31 32 #include "platform_support.h" // locale name macros 33 34 int main() 35 { 36 { 37 std::cmatch m; 38 const char s[] = "a"; 39 assert(std::regex_search(s, m, std::regex("a"))); 40 assert(m.size() == 1); 41 assert(!m.empty()); 42 assert(!m.prefix().matched); 43 assert(m.prefix().first == s); 44 assert(m.prefix().second == m[0].first); 45 assert(!m.suffix().matched); 46 assert(m.suffix().first == m[0].second); 47 assert(m.suffix().second == s+1); 48 assert(m.length(0) == 1); 49 assert(m.position(0) == 0); 50 assert(m.str(0) == "a"); 51 } 52 { 53 std::cmatch m; 54 const char s[] = "ab"; 55 assert(std::regex_search(s, m, std::regex("ab"))); 56 assert(m.size() == 1); 57 assert(!m.prefix().matched); 58 assert(m.prefix().first == s); 59 assert(m.prefix().second == m[0].first); 60 assert(!m.suffix().matched); 61 assert(m.suffix().first == m[0].second); 62 assert(m.suffix().second == s+2); 63 assert(m.length(0) == 2); 64 assert(m.position(0) == 0); 65 assert(m.str(0) == "ab"); 66 } 67 { 68 std::cmatch m; 69 const char s[] = "ab"; 70 assert(!std::regex_search(s, m, std::regex("ba"))); 71 assert(m.size() == 0); 72 assert(m.empty()); 73 } 74 { 75 std::cmatch m; 76 const char s[] = "aab"; 77 assert(std::regex_search(s, m, std::regex("ab"))); 78 assert(m.size() == 1); 79 assert(m.prefix().matched); 80 assert(m.prefix().first == s); 81 assert(m.prefix().second == m[0].first); 82 assert(!m.suffix().matched); 83 assert(m.suffix().first == m[0].second); 84 assert(m.suffix().second == s+3); 85 assert(m.length(0) == 2); 86 assert(m.position(0) == 1); 87 assert(m.str(0) == "ab"); 88 } 89 { 90 std::cmatch m; 91 const char s[] = "aab"; 92 assert(!std::regex_search(s, m, std::regex("ab"), 93 std::regex_constants::match_continuous)); 94 assert(m.size() == 0); 95 } 96 { 97 std::cmatch m; 98 const char s[] = "abcd"; 99 assert(std::regex_search(s, m, std::regex("bc"))); 100 assert(m.size() == 1); 101 assert(m.prefix().matched); 102 assert(m.prefix().first == s); 103 assert(m.prefix().second == m[0].first); 104 assert(m.suffix().matched); 105 assert(m.suffix().first == m[0].second); 106 assert(m.suffix().second == s+4); 107 assert(m.length(0) == 2); 108 assert(m.position(0) == 1); 109 assert(m.str(0) == "bc"); 110 } 111 { 112 std::cmatch m; 113 const char s[] = "abbc"; 114 assert(std::regex_search(s, m, std::regex("ab*c"))); 115 assert(m.size() == 1); 116 assert(!m.prefix().matched); 117 assert(m.prefix().first == s); 118 assert(m.prefix().second == m[0].first); 119 assert(!m.suffix().matched); 120 assert(m.suffix().first == m[0].second); 121 assert(m.suffix().second == s+4); 122 assert(m.length(0) == 4); 123 assert(m.position(0) == 0); 124 assert(m.str(0) == s); 125 } 126 { 127 std::cmatch m; 128 const char s[] = "ababc"; 129 assert(std::regex_search(s, m, std::regex("(ab)*c"))); 130 assert(m.size() == 2); 131 assert(!m.prefix().matched); 132 assert(m.prefix().first == s); 133 assert(m.prefix().second == m[0].first); 134 assert(!m.suffix().matched); 135 assert(m.suffix().first == m[0].second); 136 assert(m.suffix().second == s+5); 137 assert(m.length(0) == 5); 138 assert(m.position(0) == 0); 139 assert(m.str(0) == s); 140 assert(m.length(1) == 2); 141 assert(m.position(1) == 2); 142 assert(m.str(1) == "ab"); 143 } 144 { 145 std::cmatch m; 146 const char s[] = "abcdefghijk"; 147 assert(std::regex_search(s, m, std::regex("cd((e)fg)hi"))); 148 assert(m.size() == 3); 149 assert(m.prefix().matched); 150 assert(m.prefix().first == s); 151 assert(m.prefix().second == m[0].first); 152 assert(m.suffix().matched); 153 assert(m.suffix().first == m[0].second); 154 assert(m.suffix().second == s+std::regex_traits<char>::length(s)); 155 assert(m.length(0) == 7); 156 assert(m.position(0) == 2); 157 assert(m.str(0) == "cdefghi"); 158 assert(m.length(1) == 3); 159 assert(m.position(1) == 4); 160 assert(m.str(1) == "efg"); 161 assert(m.length(2) == 1); 162 assert(m.position(2) == 4); 163 assert(m.str(2) == "e"); 164 } 165 { 166 std::cmatch m; 167 const char s[] = "abc"; 168 assert(std::regex_search(s, m, std::regex("^abc"))); 169 assert(m.size() == 1); 170 assert(!m.prefix().matched); 171 assert(m.prefix().first == s); 172 assert(m.prefix().second == m[0].first); 173 assert(!m.suffix().matched); 174 assert(m.suffix().first == m[0].second); 175 assert(m.suffix().second == s+3); 176 assert(m.length(0) == 3); 177 assert(m.position(0) == 0); 178 assert(m.str(0) == s); 179 } 180 { 181 std::cmatch m; 182 const char s[] = "abcd"; 183 assert(std::regex_search(s, m, std::regex("^abc"))); 184 assert(m.size() == 1); 185 assert(!m.prefix().matched); 186 assert(m.prefix().first == s); 187 assert(m.prefix().second == m[0].first); 188 assert(m.suffix().matched); 189 assert(m.suffix().first == m[0].second); 190 assert(m.suffix().second == s+4); 191 assert(m.length(0) == 3); 192 assert(m.position(0) == 0); 193 assert(m.str(0) == "abc"); 194 } 195 { 196 std::cmatch m; 197 const char s[] = "aabc"; 198 assert(!std::regex_search(s, m, std::regex("^abc"))); 199 assert(m.size() == 0); 200 } 201 { 202 std::cmatch m; 203 const char s[] = "abc"; 204 assert(std::regex_search(s, m, std::regex("abc$"))); 205 assert(m.size() == 1); 206 assert(!m.prefix().matched); 207 assert(m.prefix().first == s); 208 assert(m.prefix().second == m[0].first); 209 assert(!m.suffix().matched); 210 assert(m.suffix().first == m[0].second); 211 assert(m.suffix().second == s+3); 212 assert(m.length(0) == 3); 213 assert(m.position(0) == 0); 214 assert(m.str(0) == s); 215 } 216 { 217 std::cmatch m; 218 const char s[] = "efabc"; 219 assert(std::regex_search(s, m, std::regex("abc$"))); 220 assert(m.size() == 1); 221 assert(m.prefix().matched); 222 assert(m.prefix().first == s); 223 assert(m.prefix().second == m[0].first); 224 assert(!m.suffix().matched); 225 assert(m.suffix().first == m[0].second); 226 assert(m.suffix().second == s+5); 227 assert(m.length(0) == 3); 228 assert(m.position(0) == 2); 229 assert(m.str(0) == s+2); 230 } 231 { 232 std::cmatch m; 233 const char s[] = "efabcg"; 234 assert(!std::regex_search(s, m, std::regex("abc$"))); 235 assert(m.size() == 0); 236 } 237 { 238 std::cmatch m; 239 const char s[] = "abc"; 240 assert(std::regex_search(s, m, std::regex("a.c"))); 241 assert(m.size() == 1); 242 assert(!m.prefix().matched); 243 assert(m.prefix().first == s); 244 assert(m.prefix().second == m[0].first); 245 assert(!m.suffix().matched); 246 assert(m.suffix().first == m[0].second); 247 assert(m.suffix().second == s+3); 248 assert(m.length(0) == 3); 249 assert(m.position(0) == 0); 250 assert(m.str(0) == s); 251 } 252 { 253 std::cmatch m; 254 const char s[] = "acc"; 255 assert(std::regex_search(s, m, std::regex("a.c"))); 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 == s+3); 263 assert(m.length(0) == 3); 264 assert(m.position(0) == 0); 265 assert(m.str(0) == s); 266 } 267 { 268 std::cmatch m; 269 const char s[] = "acc"; 270 assert(std::regex_search(s, m, std::regex("a.c"))); 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 == s+3); 278 assert(m.length(0) == 3); 279 assert(m.position(0) == 0); 280 assert(m.str(0) == s); 281 } 282 { 283 std::cmatch m; 284 const char s[] = "abcdef"; 285 assert(std::regex_search(s, m, std::regex("(.*).*"))); 286 assert(m.size() == 2); 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 == s+6); 293 assert(m.length(0) == 6); 294 assert(m.position(0) == 0); 295 assert(m.str(0) == s); 296 assert(m.length(1) == 6); 297 assert(m.position(1) == 0); 298 assert(m.str(1) == s); 299 } 300 { 301 std::cmatch m; 302 const char s[] = "bc"; 303 assert(std::regex_search(s, m, std::regex("(a*)*"))); 304 assert(m.size() == 2); 305 assert(!m.prefix().matched); 306 assert(m.prefix().first == s); 307 assert(m.prefix().second == m[0].first); 308 assert(m.suffix().matched); 309 assert(m.suffix().first == m[0].second); 310 assert(m.suffix().second == s+2); 311 assert(m.length(0) == 0); 312 assert(m.position(0) == 0); 313 assert(m.str(0) == ""); 314 assert(m.length(1) == 0); 315 assert(m.position(1) == 0); 316 assert(m.str(1) == ""); 317 } 318 { 319 std::cmatch m; 320 const char s[] = "abbc"; 321 assert(!std::regex_search(s, m, std::regex("ab{3,5}c"))); 322 assert(m.size() == 0); 323 } 324 { 325 std::cmatch m; 326 const char s[] = "abbbc"; 327 assert(std::regex_search(s, m, std::regex("ab{3,5}c"))); 328 assert(m.size() == 1); 329 assert(!m.prefix().matched); 330 assert(m.prefix().first == s); 331 assert(m.prefix().second == m[0].first); 332 assert(!m.suffix().matched); 333 assert(m.suffix().first == m[0].second); 334 assert(m.suffix().second == m[0].second); 335 assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<char>::length(s)); 336 assert(m.position(0) == 0); 337 assert(m.str(0) == s); 338 } 339 { 340 std::cmatch m; 341 const char s[] = "abbbbc"; 342 assert(std::regex_search(s, m, std::regex("ab{3,5}c"))); 343 assert(m.size() == 1); 344 assert(!m.prefix().matched); 345 assert(m.prefix().first == s); 346 assert(m.prefix().second == m[0].first); 347 assert(!m.suffix().matched); 348 assert(m.suffix().first == m[0].second); 349 assert(m.suffix().second == m[0].second); 350 assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<char>::length(s)); 351 assert(m.position(0) == 0); 352 assert(m.str(0) == s); 353 } 354 { 355 std::cmatch m; 356 const char s[] = "abbbbbc"; 357 assert(std::regex_search(s, m, std::regex("ab{3,5}c"))); 358 assert(m.size() == 1); 359 assert(!m.prefix().matched); 360 assert(m.prefix().first == s); 361 assert(m.prefix().second == m[0].first); 362 assert(!m.suffix().matched); 363 assert(m.suffix().first == m[0].second); 364 assert(m.suffix().second == m[0].second); 365 assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<char>::length(s)); 366 assert(m.position(0) == 0); 367 assert(m.str(0) == s); 368 } 369 { 370 std::cmatch m; 371 const char s[] = "adefc"; 372 assert(!std::regex_search(s, m, std::regex("ab{3,5}c"))); 373 assert(m.size() == 0); 374 } 375 { 376 std::cmatch m; 377 const char s[] = "abbbbbbc"; 378 assert(!std::regex_search(s, m, std::regex("ab{3,5}c"))); 379 assert(m.size() == 0); 380 } 381 { 382 std::cmatch m; 383 const char s[] = "adec"; 384 assert(!std::regex_search(s, m, std::regex("a.{3,5}c"))); 385 assert(m.size() == 0); 386 } 387 { 388 std::cmatch m; 389 const char s[] = "adefc"; 390 assert(std::regex_search(s, m, std::regex("a.{3,5}c"))); 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); 398 assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<char>::length(s)); 399 assert(m.position(0) == 0); 400 assert(m.str(0) == s); 401 } 402 { 403 std::cmatch m; 404 const char s[] = "adefgc"; 405 assert(std::regex_search(s, m, std::regex("a.{3,5}c"))); 406 assert(m.size() == 1); 407 assert(!m.prefix().matched); 408 assert(m.prefix().first == s); 409 assert(m.prefix().second == m[0].first); 410 assert(!m.suffix().matched); 411 assert(m.suffix().first == m[0].second); 412 assert(m.suffix().second == m[0].second); 413 assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<char>::length(s)); 414 assert(m.position(0) == 0); 415 assert(m.str(0) == s); 416 } 417 { 418 std::cmatch m; 419 const char s[] = "adefghc"; 420 assert(std::regex_search(s, m, std::regex("a.{3,5}c"))); 421 assert(m.size() == 1); 422 assert(!m.prefix().matched); 423 assert(m.prefix().first == s); 424 assert(m.prefix().second == m[0].first); 425 assert(!m.suffix().matched); 426 assert(m.suffix().first == m[0].second); 427 assert(m.suffix().second == m[0].second); 428 assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<char>::length(s)); 429 assert(m.position(0) == 0); 430 assert(m.str(0) == s); 431 } 432 { 433 std::cmatch m; 434 const char s[] = "adefghic"; 435 assert(!std::regex_search(s, m, std::regex("a.{3,5}c"))); 436 assert(m.size() == 0); 437 } 438 { 439 std::cmatch m; 440 const char s[] = "tournament"; 441 assert(std::regex_search(s, m, std::regex("tour|to|tournament"))); 442 assert(m.size() == 1); 443 assert(!m.prefix().matched); 444 assert(m.prefix().first == s); 445 assert(m.prefix().second == m[0].first); 446 assert(m.suffix().matched); 447 assert(m.suffix().first == m[0].second); 448 assert(m.suffix().second == s + std::char_traits<char>::length(s)); 449 assert(m.length(0) == 4); 450 assert(m.position(0) == 0); 451 assert(m.str(0) == "tour"); 452 } 453 { 454 std::cmatch m; 455 const char s[] = "tournamenttotour"; 456 assert(std::regex_search(s, m, std::regex("(tour|to|tournament)+", 457 std::regex_constants::nosubs))); 458 assert(m.size() == 1); 459 assert(!m.prefix().matched); 460 assert(m.prefix().first == s); 461 assert(m.prefix().second == m[0].first); 462 assert(m.suffix().matched); 463 assert(m.suffix().first == m[0].second); 464 assert(m.suffix().second == s + std::char_traits<char>::length(s)); 465 assert(m.length(0) == 4); 466 assert(m.position(0) == 0); 467 assert(m.str(0) == "tour"); 468 } 469 { 470 std::cmatch m; 471 const char s[] = "ttotour"; 472 assert(std::regex_search(s, m, std::regex("(tour|to|t)+"))); 473 assert(m.size() == 2); 474 assert(!m.prefix().matched); 475 assert(m.prefix().first == s); 476 assert(m.prefix().second == m[0].first); 477 assert(!m.suffix().matched); 478 assert(m.suffix().first == m[0].second); 479 assert(m.suffix().second == m[0].second); 480 assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<char>::length(s)); 481 assert(m.position(0) == 0); 482 assert(m.str(0) == s); 483 assert(m.length(1) == 4); 484 assert(m.position(1) == 3); 485 assert(m.str(1) == "tour"); 486 } 487 { 488 std::cmatch m; 489 const char s[] = "-ab,ab-"; 490 assert(!std::regex_search(s, m, std::regex("-(.*),\1-"))); 491 assert(m.size() == 0); 492 } 493 { 494 std::cmatch m; 495 const char s[] = "-ab,ab-"; 496 assert(std::regex_search(s, m, std::regex("-.*,.*-"))); 497 assert(m.size() == 1); 498 assert(!m.prefix().matched); 499 assert(m.prefix().first == s); 500 assert(m.prefix().second == m[0].first); 501 assert(!m.suffix().matched); 502 assert(m.suffix().first == m[0].second); 503 assert(m.suffix().second == m[0].second); 504 assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<char>::length(s)); 505 assert(m.position(0) == 0); 506 assert(m.str(0) == s); 507 } 508 { 509 std::cmatch m; 510 const char s[] = "a"; 511 assert(std::regex_search(s, m, std::regex("^[a]$"))); 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) == 1); 520 assert(m.position(0) == 0); 521 assert(m.str(0) == "a"); 522 } 523 { 524 std::cmatch m; 525 const char s[] = "a"; 526 assert(std::regex_search(s, m, std::regex("^[ab]$"))); 527 assert(m.size() == 1); 528 assert(!m.prefix().matched); 529 assert(m.prefix().first == s); 530 assert(m.prefix().second == m[0].first); 531 assert(!m.suffix().matched); 532 assert(m.suffix().first == m[0].second); 533 assert(m.suffix().second == m[0].second); 534 assert(m.length(0) == 1); 535 assert(m.position(0) == 0); 536 assert(m.str(0) == "a"); 537 } 538 { 539 std::cmatch m; 540 const char s[] = "c"; 541 assert(std::regex_search(s, m, std::regex("^[a-f]$"))); 542 assert(m.size() == 1); 543 assert(!m.prefix().matched); 544 assert(m.prefix().first == s); 545 assert(m.prefix().second == m[0].first); 546 assert(!m.suffix().matched); 547 assert(m.suffix().first == m[0].second); 548 assert(m.suffix().second == m[0].second); 549 assert(m.length(0) == 1); 550 assert(m.position(0) == 0); 551 assert(m.str(0) == s); 552 } 553 { 554 std::cmatch m; 555 const char s[] = "g"; 556 assert(!std::regex_search(s, m, std::regex("^[a-f]$"))); 557 assert(m.size() == 0); 558 } 559 { 560 std::cmatch m; 561 const char s[] = "Iraqi"; 562 assert(std::regex_search(s, m, std::regex("q[^u]"))); 563 assert(m.size() == 1); 564 assert(m.prefix().matched); 565 assert(m.prefix().first == s); 566 assert(m.prefix().second == m[0].first); 567 assert(!m.suffix().matched); 568 assert(m.suffix().first == m[0].second); 569 assert(m.suffix().second == m[0].second); 570 assert(m.length(0) == 2); 571 assert(m.position(0) == 3); 572 assert(m.str(0) == "qi"); 573 } 574 { 575 std::cmatch m; 576 const char s[] = "Iraq"; 577 assert(!std::regex_search(s, m, std::regex("q[^u]"))); 578 assert(m.size() == 0); 579 } 580 { 581 std::cmatch m; 582 const char s[] = "AmB"; 583 assert(std::regex_search(s, m, std::regex("A[[:lower:]]B"))); 584 assert(m.size() == 1); 585 assert(!m.prefix().matched); 586 assert(m.prefix().first == s); 587 assert(m.prefix().second == m[0].first); 588 assert(!m.suffix().matched); 589 assert(m.suffix().first == m[0].second); 590 assert(m.suffix().second == m[0].second); 591 assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<char>::length(s)); 592 assert(m.position(0) == 0); 593 assert(m.str(0) == s); 594 } 595 { 596 std::cmatch m; 597 const char s[] = "AMB"; 598 assert(!std::regex_search(s, m, std::regex("A[[:lower:]]B"))); 599 assert(m.size() == 0); 600 } 601 { 602 std::cmatch m; 603 const char s[] = "AMB"; 604 assert(std::regex_search(s, m, std::regex("A[^[:lower:]]B"))); 605 assert(m.size() == 1); 606 assert(!m.prefix().matched); 607 assert(m.prefix().first == s); 608 assert(m.prefix().second == m[0].first); 609 assert(!m.suffix().matched); 610 assert(m.suffix().first == m[0].second); 611 assert(m.suffix().second == m[0].second); 612 assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<char>::length(s)); 613 assert(m.position(0) == 0); 614 assert(m.str(0) == s); 615 } 616 { 617 std::cmatch m; 618 const char s[] = "AmB"; 619 assert(!std::regex_search(s, m, std::regex("A[^[:lower:]]B"))); 620 assert(m.size() == 0); 621 } 622 { 623 std::cmatch m; 624 const char s[] = "A5B"; 625 assert(!std::regex_search(s, m, std::regex("A[^[:lower:]0-9]B"))); 626 assert(m.size() == 0); 627 } 628 { 629 std::cmatch m; 630 const char s[] = "A?B"; 631 assert(std::regex_search(s, m, std::regex("A[^[:lower:]0-9]B"))); 632 assert(m.size() == 1); 633 assert(!m.prefix().matched); 634 assert(m.prefix().first == s); 635 assert(m.prefix().second == m[0].first); 636 assert(!m.suffix().matched); 637 assert(m.suffix().first == m[0].second); 638 assert(m.suffix().second == m[0].second); 639 assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<char>::length(s)); 640 assert(m.position(0) == 0); 641 assert(m.str(0) == s); 642 } 643 { 644 std::cmatch m; 645 const char s[] = "-"; 646 assert(std::regex_search(s, m, std::regex("[a[.hyphen.]z]"))); 647 assert(m.size() == 1); 648 assert(!m.prefix().matched); 649 assert(m.prefix().first == s); 650 assert(m.prefix().second == m[0].first); 651 assert(!m.suffix().matched); 652 assert(m.suffix().first == m[0].second); 653 assert(m.suffix().second == m[0].second); 654 assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<char>::length(s)); 655 assert(m.position(0) == 0); 656 assert(m.str(0) == s); 657 } 658 { 659 std::cmatch m; 660 const char s[] = "z"; 661 assert(std::regex_search(s, m, std::regex("[a[.hyphen.]z]"))); 662 assert(m.size() == 1); 663 assert(!m.prefix().matched); 664 assert(m.prefix().first == s); 665 assert(m.prefix().second == m[0].first); 666 assert(!m.suffix().matched); 667 assert(m.suffix().first == m[0].second); 668 assert(m.suffix().second == m[0].second); 669 assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<char>::length(s)); 670 assert(m.position(0) == 0); 671 assert(m.str(0) == s); 672 } 673 { 674 std::cmatch m; 675 const char s[] = "m"; 676 assert(!std::regex_search(s, m, std::regex("[a[.hyphen.]z]"))); 677 assert(m.size() == 0); 678 } 679 std::locale::global(std::locale(LOCALE_cs_CZ_ISO8859_2)); 680 { 681 std::cmatch m; 682 const char s[] = "m"; 683 assert(std::regex_search(s, m, std::regex("[a[=M=]z]"))); 684 assert(m.size() == 1); 685 assert(!m.prefix().matched); 686 assert(m.prefix().first == 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); 691 assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<char>::length(s)); 692 assert(m.position(0) == 0); 693 assert(m.str(0) == s); 694 } 695 { 696 std::cmatch m; 697 const char s[] = "Ch"; 698 assert(std::regex_search(s, m, std::regex("[a[.ch.]z]", 699 std::regex_constants::icase))); 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 == m[0].second); 707 assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<char>::length(s)); 708 assert(m.position(0) == 0); 709 assert(m.str(0) == s); 710 } 711 std::locale::global(std::locale("C")); 712 { 713 std::cmatch m; 714 const char s[] = "m"; 715 assert(!std::regex_search(s, m, std::regex("[a[=M=]z]"))); 716 assert(m.size() == 0); 717 } 718 { 719 std::cmatch m; 720 const char s[] = "01a45cef9"; 721 assert(std::regex_search(s, m, std::regex("[ace1-9]*"))); 722 assert(m.size() == 1); 723 assert(!m.prefix().matched); 724 assert(m.prefix().first == s); 725 assert(m.prefix().second == m[0].first); 726 assert(m.suffix().matched); 727 assert(m.suffix().first == m[0].second); 728 assert(m.suffix().second == s + std::char_traits<char>::length(s)); 729 assert(m.length(0) == 0); 730 assert(m.position(0) == 0); 731 assert(m.str(0) == ""); 732 } 733 { 734 std::cmatch m; 735 const char s[] = "01a45cef9"; 736 assert(std::regex_search(s, m, std::regex("[ace1-9]+"))); 737 assert(m.size() == 1); 738 assert(m.prefix().matched); 739 assert(m.prefix().first == s); 740 assert(m.prefix().second == m[0].first); 741 assert(m.suffix().matched); 742 assert(m.suffix().first == m[0].second); 743 assert(m.suffix().second == s + std::char_traits<char>::length(s)); 744 assert(m.length(0) == 6); 745 assert(m.position(0) == 1); 746 assert(m.str(0) == "1a45ce"); 747 } 748 { 749 const char r[] = "^[-+]?[0-9]+[CF]$"; 750 std::ptrdiff_t sr = std::char_traits<char>::length(r); 751 typedef forward_iterator<const char*> FI; 752 typedef bidirectional_iterator<const char*> BI; 753 std::regex regex(FI(r), FI(r+sr)); 754 std::match_results<BI> m; 755 const char s[] = "-40C"; 756 std::ptrdiff_t ss = std::char_traits<char>::length(s); 757 assert(std::regex_search(BI(s), BI(s+ss), m, regex)); 758 assert(m.size() == 1); 759 assert(!m.prefix().matched); 760 assert(m.prefix().first == BI(s)); 761 assert(m.prefix().second == m[0].first); 762 assert(!m.suffix().matched); 763 assert(m.suffix().first == m[0].second); 764 assert(m.suffix().second == m[0].second); 765 assert(m.length(0) == 4); 766 assert(m.position(0) == 0); 767 assert(m.str(0) == s); 768 } 769 { 770 std::cmatch m; 771 const char s[] = "Jeff Jeffs "; 772 assert(std::regex_search(s, m, std::regex("Jeff(?=s\\b)"))); 773 assert(m.size() == 1); 774 assert(m.prefix().matched); 775 assert(m.prefix().first == s); 776 assert(m.prefix().second == m[0].first); 777 assert(m.suffix().matched); 778 assert(m.suffix().first == m[0].second); 779 assert(m.suffix().second == s + std::char_traits<char>::length(s)); 780 assert(m.length(0) == 4); 781 assert(m.position(0) == 5); 782 assert(m.str(0) == "Jeff"); 783 } 784 { 785 std::cmatch m; 786 const char s[] = "Jeffs Jeff"; 787 assert(std::regex_search(s, m, std::regex("Jeff(?!s\\b)"))); 788 assert(m.size() == 1); 789 assert(m.prefix().matched); 790 assert(m.prefix().first == s); 791 assert(m.prefix().second == m[0].first); 792 assert(!m.suffix().matched); 793 assert(m.suffix().first == m[0].second); 794 assert(m.suffix().second == s + std::char_traits<char>::length(s)); 795 assert(m.length(0) == 4); 796 assert(m.position(0) == 6); 797 assert(m.str(0) == "Jeff"); 798 } 799 { 800 std::cmatch m; 801 const char s[] = "5%k"; 802 assert(std::regex_search(s, m, std::regex("\\d[\\W]k"))); 803 assert(m.size() == 1); 804 assert(!m.prefix().matched); 805 assert(m.prefix().first == s); 806 assert(m.prefix().second == m[0].first); 807 assert(!m.suffix().matched); 808 assert(m.suffix().first == m[0].second); 809 assert(m.suffix().second == s + std::char_traits<char>::length(s)); 810 assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<char>::length(s)); 811 assert(m.position(0) == 0); 812 assert(m.str(0) == s); 813 } 814 815 { 816 std::wcmatch m; 817 const wchar_t s[] = L"a"; 818 assert(std::regex_search(s, m, std::wregex(L"a"))); 819 assert(m.size() == 1); 820 assert(!m.empty()); 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+1); 827 assert(m.length(0) == 1); 828 assert(m.position(0) == 0); 829 assert(m.str(0) == L"a"); 830 } 831 { 832 std::wcmatch m; 833 const wchar_t s[] = L"ab"; 834 assert(std::regex_search(s, m, std::wregex(L"ab"))); 835 assert(m.size() == 1); 836 assert(!m.prefix().matched); 837 assert(m.prefix().first == s); 838 assert(m.prefix().second == m[0].first); 839 assert(!m.suffix().matched); 840 assert(m.suffix().first == m[0].second); 841 assert(m.suffix().second == s+2); 842 assert(m.length(0) == 2); 843 assert(m.position(0) == 0); 844 assert(m.str(0) == L"ab"); 845 } 846 { 847 std::wcmatch m; 848 const wchar_t s[] = L"ab"; 849 assert(!std::regex_search(s, m, std::wregex(L"ba"))); 850 assert(m.size() == 0); 851 assert(m.empty()); 852 } 853 { 854 std::wcmatch m; 855 const wchar_t s[] = L"aab"; 856 assert(std::regex_search(s, m, std::wregex(L"ab"))); 857 assert(m.size() == 1); 858 assert(m.prefix().matched); 859 assert(m.prefix().first == s); 860 assert(m.prefix().second == m[0].first); 861 assert(!m.suffix().matched); 862 assert(m.suffix().first == m[0].second); 863 assert(m.suffix().second == s+3); 864 assert(m.length(0) == 2); 865 assert(m.position(0) == 1); 866 assert(m.str(0) == L"ab"); 867 } 868 { 869 std::wcmatch m; 870 const wchar_t s[] = L"aab"; 871 assert(!std::regex_search(s, m, std::wregex(L"ab"), 872 std::regex_constants::match_continuous)); 873 assert(m.size() == 0); 874 } 875 { 876 std::wcmatch m; 877 const wchar_t s[] = L"abcd"; 878 assert(std::regex_search(s, m, std::wregex(L"bc"))); 879 assert(m.size() == 1); 880 assert(m.prefix().matched); 881 assert(m.prefix().first == s); 882 assert(m.prefix().second == m[0].first); 883 assert(m.suffix().matched); 884 assert(m.suffix().first == m[0].second); 885 assert(m.suffix().second == s+4); 886 assert(m.length(0) == 2); 887 assert(m.position(0) == 1); 888 assert(m.str(0) == L"bc"); 889 } 890 { 891 std::wcmatch m; 892 const wchar_t s[] = L"abbc"; 893 assert(std::regex_search(s, m, std::wregex(L"ab*c"))); 894 assert(m.size() == 1); 895 assert(!m.prefix().matched); 896 assert(m.prefix().first == s); 897 assert(m.prefix().second == m[0].first); 898 assert(!m.suffix().matched); 899 assert(m.suffix().first == m[0].second); 900 assert(m.suffix().second == s+4); 901 assert(m.length(0) == 4); 902 assert(m.position(0) == 0); 903 assert(m.str(0) == s); 904 } 905 { 906 std::wcmatch m; 907 const wchar_t s[] = L"ababc"; 908 assert(std::regex_search(s, m, std::wregex(L"(ab)*c"))); 909 assert(m.size() == 2); 910 assert(!m.prefix().matched); 911 assert(m.prefix().first == s); 912 assert(m.prefix().second == m[0].first); 913 assert(!m.suffix().matched); 914 assert(m.suffix().first == m[0].second); 915 assert(m.suffix().second == s+5); 916 assert(m.length(0) == 5); 917 assert(m.position(0) == 0); 918 assert(m.str(0) == s); 919 assert(m.length(1) == 2); 920 assert(m.position(1) == 2); 921 assert(m.str(1) == L"ab"); 922 } 923 { 924 std::wcmatch m; 925 const wchar_t s[] = L"abcdefghijk"; 926 assert(std::regex_search(s, m, std::wregex(L"cd((e)fg)hi"))); 927 assert(m.size() == 3); 928 assert(m.prefix().matched); 929 assert(m.prefix().first == s); 930 assert(m.prefix().second == m[0].first); 931 assert(m.suffix().matched); 932 assert(m.suffix().first == m[0].second); 933 assert(m.suffix().second == s+std::regex_traits<wchar_t>::length(s)); 934 assert(m.length(0) == 7); 935 assert(m.position(0) == 2); 936 assert(m.str(0) == L"cdefghi"); 937 assert(m.length(1) == 3); 938 assert(m.position(1) == 4); 939 assert(m.str(1) == L"efg"); 940 assert(m.length(2) == 1); 941 assert(m.position(2) == 4); 942 assert(m.str(2) == L"e"); 943 } 944 { 945 std::wcmatch m; 946 const wchar_t s[] = L"abc"; 947 assert(std::regex_search(s, m, std::wregex(L"^abc"))); 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 == s+3); 955 assert(m.length(0) == 3); 956 assert(m.position(0) == 0); 957 assert(m.str(0) == s); 958 } 959 { 960 std::wcmatch m; 961 const wchar_t s[] = L"abcd"; 962 assert(std::regex_search(s, m, std::wregex(L"^abc"))); 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 == s+4); 970 assert(m.length(0) == 3); 971 assert(m.position(0) == 0); 972 assert(m.str(0) == L"abc"); 973 } 974 { 975 std::wcmatch m; 976 const wchar_t s[] = L"aabc"; 977 assert(!std::regex_search(s, m, std::wregex(L"^abc"))); 978 assert(m.size() == 0); 979 } 980 { 981 std::wcmatch m; 982 const wchar_t s[] = L"abc"; 983 assert(std::regex_search(s, m, std::wregex(L"abc$"))); 984 assert(m.size() == 1); 985 assert(!m.prefix().matched); 986 assert(m.prefix().first == s); 987 assert(m.prefix().second == m[0].first); 988 assert(!m.suffix().matched); 989 assert(m.suffix().first == m[0].second); 990 assert(m.suffix().second == s+3); 991 assert(m.length(0) == 3); 992 assert(m.position(0) == 0); 993 assert(m.str(0) == s); 994 } 995 { 996 std::wcmatch m; 997 const wchar_t s[] = L"efabc"; 998 assert(std::regex_search(s, m, std::wregex(L"abc$"))); 999 assert(m.size() == 1); 1000 assert(m.prefix().matched); 1001 assert(m.prefix().first == s); 1002 assert(m.prefix().second == m[0].first); 1003 assert(!m.suffix().matched); 1004 assert(m.suffix().first == m[0].second); 1005 assert(m.suffix().second == s+5); 1006 assert(m.length(0) == 3); 1007 assert(m.position(0) == 2); 1008 assert(m.str(0) == s+2); 1009 } 1010 { 1011 std::wcmatch m; 1012 const wchar_t s[] = L"efabcg"; 1013 assert(!std::regex_search(s, m, std::wregex(L"abc$"))); 1014 assert(m.size() == 0); 1015 } 1016 { 1017 std::wcmatch m; 1018 const wchar_t s[] = L"abc"; 1019 assert(std::regex_search(s, m, std::wregex(L"a.c"))); 1020 assert(m.size() == 1); 1021 assert(!m.prefix().matched); 1022 assert(m.prefix().first == s); 1023 assert(m.prefix().second == m[0].first); 1024 assert(!m.suffix().matched); 1025 assert(m.suffix().first == m[0].second); 1026 assert(m.suffix().second == s+3); 1027 assert(m.length(0) == 3); 1028 assert(m.position(0) == 0); 1029 assert(m.str(0) == s); 1030 } 1031 { 1032 std::wcmatch m; 1033 const wchar_t s[] = L"acc"; 1034 assert(std::regex_search(s, m, std::wregex(L"a.c"))); 1035 assert(m.size() == 1); 1036 assert(!m.prefix().matched); 1037 assert(m.prefix().first == s); 1038 assert(m.prefix().second == m[0].first); 1039 assert(!m.suffix().matched); 1040 assert(m.suffix().first == m[0].second); 1041 assert(m.suffix().second == s+3); 1042 assert(m.length(0) == 3); 1043 assert(m.position(0) == 0); 1044 assert(m.str(0) == s); 1045 } 1046 { 1047 std::wcmatch m; 1048 const wchar_t s[] = L"acc"; 1049 assert(std::regex_search(s, m, std::wregex(L"a.c"))); 1050 assert(m.size() == 1); 1051 assert(!m.prefix().matched); 1052 assert(m.prefix().first == s); 1053 assert(m.prefix().second == m[0].first); 1054 assert(!m.suffix().matched); 1055 assert(m.suffix().first == m[0].second); 1056 assert(m.suffix().second == s+3); 1057 assert(m.length(0) == 3); 1058 assert(m.position(0) == 0); 1059 assert(m.str(0) == s); 1060 } 1061 { 1062 std::wcmatch m; 1063 const wchar_t s[] = L"abcdef"; 1064 assert(std::regex_search(s, m, std::wregex(L"(.*).*"))); 1065 assert(m.size() == 2); 1066 assert(!m.prefix().matched); 1067 assert(m.prefix().first == s); 1068 assert(m.prefix().second == m[0].first); 1069 assert(!m.suffix().matched); 1070 assert(m.suffix().first == m[0].second); 1071 assert(m.suffix().second == s+6); 1072 assert(m.length(0) == 6); 1073 assert(m.position(0) == 0); 1074 assert(m.str(0) == s); 1075 assert(m.length(1) == 6); 1076 assert(m.position(1) == 0); 1077 assert(m.str(1) == s); 1078 } 1079 { 1080 std::wcmatch m; 1081 const wchar_t s[] = L"bc"; 1082 assert(std::regex_search(s, m, std::wregex(L"(a*)*"))); 1083 assert(m.size() == 2); 1084 assert(!m.prefix().matched); 1085 assert(m.prefix().first == s); 1086 assert(m.prefix().second == m[0].first); 1087 assert(m.suffix().matched); 1088 assert(m.suffix().first == m[0].second); 1089 assert(m.suffix().second == s+2); 1090 assert(m.length(0) == 0); 1091 assert(m.position(0) == 0); 1092 assert(m.str(0) == L""); 1093 assert(m.length(1) == 0); 1094 assert(m.position(1) == 0); 1095 assert(m.str(1) == L""); 1096 } 1097 { 1098 std::wcmatch m; 1099 const wchar_t s[] = L"abbc"; 1100 assert(!std::regex_search(s, m, std::wregex(L"ab{3,5}c"))); 1101 assert(m.size() == 0); 1102 } 1103 { 1104 std::wcmatch m; 1105 const wchar_t s[] = L"abbbc"; 1106 assert(std::regex_search(s, m, std::wregex(L"ab{3,5}c"))); 1107 assert(m.size() == 1); 1108 assert(!m.prefix().matched); 1109 assert(m.prefix().first == s); 1110 assert(m.prefix().second == m[0].first); 1111 assert(!m.suffix().matched); 1112 assert(m.suffix().first == m[0].second); 1113 assert(m.suffix().second == m[0].second); 1114 assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<wchar_t>::length(s)); 1115 assert(m.position(0) == 0); 1116 assert(m.str(0) == s); 1117 } 1118 { 1119 std::wcmatch m; 1120 const wchar_t s[] = L"abbbbc"; 1121 assert(std::regex_search(s, m, std::wregex(L"ab{3,5}c"))); 1122 assert(m.size() == 1); 1123 assert(!m.prefix().matched); 1124 assert(m.prefix().first == s); 1125 assert(m.prefix().second == m[0].first); 1126 assert(!m.suffix().matched); 1127 assert(m.suffix().first == m[0].second); 1128 assert(m.suffix().second == m[0].second); 1129 assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<wchar_t>::length(s)); 1130 assert(m.position(0) == 0); 1131 assert(m.str(0) == s); 1132 } 1133 { 1134 std::wcmatch m; 1135 const wchar_t s[] = L"abbbbbc"; 1136 assert(std::regex_search(s, m, std::wregex(L"ab{3,5}c"))); 1137 assert(m.size() == 1); 1138 assert(!m.prefix().matched); 1139 assert(m.prefix().first == s); 1140 assert(m.prefix().second == m[0].first); 1141 assert(!m.suffix().matched); 1142 assert(m.suffix().first == m[0].second); 1143 assert(m.suffix().second == m[0].second); 1144 assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<wchar_t>::length(s)); 1145 assert(m.position(0) == 0); 1146 assert(m.str(0) == s); 1147 } 1148 { 1149 std::wcmatch m; 1150 const wchar_t s[] = L"adefc"; 1151 assert(!std::regex_search(s, m, std::wregex(L"ab{3,5}c"))); 1152 assert(m.size() == 0); 1153 } 1154 { 1155 std::wcmatch m; 1156 const wchar_t s[] = L"abbbbbbc"; 1157 assert(!std::regex_search(s, m, std::wregex(L"ab{3,5}c"))); 1158 assert(m.size() == 0); 1159 } 1160 { 1161 std::wcmatch m; 1162 const wchar_t s[] = L"adec"; 1163 assert(!std::regex_search(s, m, std::wregex(L"a.{3,5}c"))); 1164 assert(m.size() == 0); 1165 } 1166 { 1167 std::wcmatch m; 1168 const wchar_t s[] = L"adefc"; 1169 assert(std::regex_search(s, m, std::wregex(L"a.{3,5}c"))); 1170 assert(m.size() == 1); 1171 assert(!m.prefix().matched); 1172 assert(m.prefix().first == s); 1173 assert(m.prefix().second == m[0].first); 1174 assert(!m.suffix().matched); 1175 assert(m.suffix().first == m[0].second); 1176 assert(m.suffix().second == m[0].second); 1177 assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<wchar_t>::length(s)); 1178 assert(m.position(0) == 0); 1179 assert(m.str(0) == s); 1180 } 1181 { 1182 std::wcmatch m; 1183 const wchar_t s[] = L"adefgc"; 1184 assert(std::regex_search(s, m, std::wregex(L"a.{3,5}c"))); 1185 assert(m.size() == 1); 1186 assert(!m.prefix().matched); 1187 assert(m.prefix().first == s); 1188 assert(m.prefix().second == m[0].first); 1189 assert(!m.suffix().matched); 1190 assert(m.suffix().first == m[0].second); 1191 assert(m.suffix().second == m[0].second); 1192 assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<wchar_t>::length(s)); 1193 assert(m.position(0) == 0); 1194 assert(m.str(0) == s); 1195 } 1196 { 1197 std::wcmatch m; 1198 const wchar_t s[] = L"adefghc"; 1199 assert(std::regex_search(s, m, std::wregex(L"a.{3,5}c"))); 1200 assert(m.size() == 1); 1201 assert(!m.prefix().matched); 1202 assert(m.prefix().first == s); 1203 assert(m.prefix().second == m[0].first); 1204 assert(!m.suffix().matched); 1205 assert(m.suffix().first == m[0].second); 1206 assert(m.suffix().second == m[0].second); 1207 assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<wchar_t>::length(s)); 1208 assert(m.position(0) == 0); 1209 assert(m.str(0) == s); 1210 } 1211 { 1212 std::wcmatch m; 1213 const wchar_t s[] = L"adefghic"; 1214 assert(!std::regex_search(s, m, std::wregex(L"a.{3,5}c"))); 1215 assert(m.size() == 0); 1216 } 1217 { 1218 std::wcmatch m; 1219 const wchar_t s[] = L"tournament"; 1220 assert(std::regex_search(s, m, std::wregex(L"tour|to|tournament"))); 1221 assert(m.size() == 1); 1222 assert(!m.prefix().matched); 1223 assert(m.prefix().first == s); 1224 assert(m.prefix().second == m[0].first); 1225 assert(m.suffix().matched); 1226 assert(m.suffix().first == m[0].second); 1227 assert(m.suffix().second == s + std::char_traits<wchar_t>::length(s)); 1228 assert(m.length(0) == 4); 1229 assert(m.position(0) == 0); 1230 assert(m.str(0) == L"tour"); 1231 } 1232 { 1233 std::wcmatch m; 1234 const wchar_t s[] = L"tournamenttotour"; 1235 assert(std::regex_search(s, m, std::wregex(L"(tour|to|tournament)+", 1236 std::regex_constants::nosubs))); 1237 assert(m.size() == 1); 1238 assert(!m.prefix().matched); 1239 assert(m.prefix().first == s); 1240 assert(m.prefix().second == m[0].first); 1241 assert(m.suffix().matched); 1242 assert(m.suffix().first == m[0].second); 1243 assert(m.suffix().second == s + std::char_traits<wchar_t>::length(s)); 1244 assert(m.length(0) == 4); 1245 assert(m.position(0) == 0); 1246 assert(m.str(0) == L"tour"); 1247 } 1248 { 1249 std::wcmatch m; 1250 const wchar_t s[] = L"ttotour"; 1251 assert(std::regex_search(s, m, std::wregex(L"(tour|to|t)+"))); 1252 assert(m.size() == 2); 1253 assert(!m.prefix().matched); 1254 assert(m.prefix().first == s); 1255 assert(m.prefix().second == m[0].first); 1256 assert(!m.suffix().matched); 1257 assert(m.suffix().first == m[0].second); 1258 assert(m.suffix().second == m[0].second); 1259 assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<wchar_t>::length(s)); 1260 assert(m.position(0) == 0); 1261 assert(m.str(0) == s); 1262 assert(m.length(1) == 4); 1263 assert(m.position(1) == 3); 1264 assert(m.str(1) == L"tour"); 1265 } 1266 { 1267 std::wcmatch m; 1268 const wchar_t s[] = L"-ab,ab-"; 1269 assert(!std::regex_search(s, m, std::wregex(L"-(.*),\1-"))); 1270 assert(m.size() == 0); 1271 } 1272 { 1273 std::wcmatch m; 1274 const wchar_t s[] = L"-ab,ab-"; 1275 assert(std::regex_search(s, m, std::wregex(L"-.*,.*-"))); 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"a"; 1290 assert(std::regex_search(s, m, std::wregex(L"^[a]$"))); 1291 assert(m.size() == 1); 1292 assert(!m.prefix().matched); 1293 assert(m.prefix().first == s); 1294 assert(m.prefix().second == m[0].first); 1295 assert(!m.suffix().matched); 1296 assert(m.suffix().first == m[0].second); 1297 assert(m.suffix().second == m[0].second); 1298 assert(m.length(0) == 1); 1299 assert(m.position(0) == 0); 1300 assert(m.str(0) == L"a"); 1301 } 1302 { 1303 std::wcmatch m; 1304 const wchar_t s[] = L"a"; 1305 assert(std::regex_search(s, m, std::wregex(L"^[ab]$"))); 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); 1313 assert(m.length(0) == 1); 1314 assert(m.position(0) == 0); 1315 assert(m.str(0) == L"a"); 1316 } 1317 { 1318 std::wcmatch m; 1319 const wchar_t s[] = L"c"; 1320 assert(std::regex_search(s, m, std::wregex(L"^[a-f]$"))); 1321 assert(m.size() == 1); 1322 assert(!m.prefix().matched); 1323 assert(m.prefix().first == s); 1324 assert(m.prefix().second == m[0].first); 1325 assert(!m.suffix().matched); 1326 assert(m.suffix().first == m[0].second); 1327 assert(m.suffix().second == m[0].second); 1328 assert(m.length(0) == 1); 1329 assert(m.position(0) == 0); 1330 assert(m.str(0) == s); 1331 } 1332 { 1333 std::wcmatch m; 1334 const wchar_t s[] = L"g"; 1335 assert(!std::regex_search(s, m, std::wregex(L"^[a-f]$"))); 1336 assert(m.size() == 0); 1337 } 1338 { 1339 std::wcmatch m; 1340 const wchar_t s[] = L"Iraqi"; 1341 assert(std::regex_search(s, m, std::wregex(L"q[^u]"))); 1342 assert(m.size() == 1); 1343 assert(m.prefix().matched); 1344 assert(m.prefix().first == s); 1345 assert(m.prefix().second == m[0].first); 1346 assert(!m.suffix().matched); 1347 assert(m.suffix().first == m[0].second); 1348 assert(m.suffix().second == m[0].second); 1349 assert(m.length(0) == 2); 1350 assert(m.position(0) == 3); 1351 assert(m.str(0) == L"qi"); 1352 } 1353 { 1354 std::wcmatch m; 1355 const wchar_t s[] = L"Iraq"; 1356 assert(!std::regex_search(s, m, std::wregex(L"q[^u]"))); 1357 assert(m.size() == 0); 1358 } 1359 { 1360 std::wcmatch m; 1361 const wchar_t s[] = L"AmB"; 1362 assert(std::regex_search(s, m, std::wregex(L"A[[:lower:]]B"))); 1363 assert(m.size() == 1); 1364 assert(!m.prefix().matched); 1365 assert(m.prefix().first == s); 1366 assert(m.prefix().second == m[0].first); 1367 assert(!m.suffix().matched); 1368 assert(m.suffix().first == m[0].second); 1369 assert(m.suffix().second == m[0].second); 1370 assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<wchar_t>::length(s)); 1371 assert(m.position(0) == 0); 1372 assert(m.str(0) == s); 1373 } 1374 { 1375 std::wcmatch m; 1376 const wchar_t s[] = L"AMB"; 1377 assert(!std::regex_search(s, m, std::wregex(L"A[[:lower:]]B"))); 1378 assert(m.size() == 0); 1379 } 1380 { 1381 std::wcmatch m; 1382 const wchar_t s[] = L"AMB"; 1383 assert(std::regex_search(s, m, std::wregex(L"A[^[:lower:]]B"))); 1384 assert(m.size() == 1); 1385 assert(!m.prefix().matched); 1386 assert(m.prefix().first == s); 1387 assert(m.prefix().second == m[0].first); 1388 assert(!m.suffix().matched); 1389 assert(m.suffix().first == m[0].second); 1390 assert(m.suffix().second == m[0].second); 1391 assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<wchar_t>::length(s)); 1392 assert(m.position(0) == 0); 1393 assert(m.str(0) == s); 1394 } 1395 { 1396 std::wcmatch m; 1397 const wchar_t s[] = L"AmB"; 1398 assert(!std::regex_search(s, m, std::wregex(L"A[^[:lower:]]B"))); 1399 assert(m.size() == 0); 1400 } 1401 { 1402 std::wcmatch m; 1403 const wchar_t s[] = L"A5B"; 1404 assert(!std::regex_search(s, m, std::wregex(L"A[^[:lower:]0-9]B"))); 1405 assert(m.size() == 0); 1406 } 1407 { 1408 std::wcmatch m; 1409 const wchar_t s[] = L"A?B"; 1410 assert(std::regex_search(s, m, std::wregex(L"A[^[:lower:]0-9]B"))); 1411 assert(m.size() == 1); 1412 assert(!m.prefix().matched); 1413 assert(m.prefix().first == s); 1414 assert(m.prefix().second == m[0].first); 1415 assert(!m.suffix().matched); 1416 assert(m.suffix().first == m[0].second); 1417 assert(m.suffix().second == m[0].second); 1418 assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<wchar_t>::length(s)); 1419 assert(m.position(0) == 0); 1420 assert(m.str(0) == s); 1421 } 1422 { 1423 std::wcmatch m; 1424 const wchar_t s[] = L"-"; 1425 assert(std::regex_search(s, m, std::wregex(L"[a[.hyphen.]z]"))); 1426 assert(m.size() == 1); 1427 assert(!m.prefix().matched); 1428 assert(m.prefix().first == s); 1429 assert(m.prefix().second == m[0].first); 1430 assert(!m.suffix().matched); 1431 assert(m.suffix().first == m[0].second); 1432 assert(m.suffix().second == m[0].second); 1433 assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<wchar_t>::length(s)); 1434 assert(m.position(0) == 0); 1435 assert(m.str(0) == s); 1436 } 1437 { 1438 std::wcmatch m; 1439 const wchar_t s[] = L"z"; 1440 assert(std::regex_search(s, m, std::wregex(L"[a[.hyphen.]z]"))); 1441 assert(m.size() == 1); 1442 assert(!m.prefix().matched); 1443 assert(m.prefix().first == s); 1444 assert(m.prefix().second == m[0].first); 1445 assert(!m.suffix().matched); 1446 assert(m.suffix().first == m[0].second); 1447 assert(m.suffix().second == m[0].second); 1448 assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<wchar_t>::length(s)); 1449 assert(m.position(0) == 0); 1450 assert(m.str(0) == s); 1451 } 1452 { 1453 std::wcmatch m; 1454 const wchar_t s[] = L"m"; 1455 assert(!std::regex_search(s, m, std::wregex(L"[a[.hyphen.]z]"))); 1456 assert(m.size() == 0); 1457 } 1458 std::locale::global(std::locale(LOCALE_cs_CZ_ISO8859_2)); 1459 { 1460 std::wcmatch m; 1461 const wchar_t s[] = L"m"; 1462 assert(std::regex_search(s, m, std::wregex(L"[a[=M=]z]"))); 1463 assert(m.size() == 1); 1464 assert(!m.prefix().matched); 1465 assert(m.prefix().first == s); 1466 assert(m.prefix().second == m[0].first); 1467 assert(!m.suffix().matched); 1468 assert(m.suffix().first == m[0].second); 1469 assert(m.suffix().second == m[0].second); 1470 assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<wchar_t>::length(s)); 1471 assert(m.position(0) == 0); 1472 assert(m.str(0) == s); 1473 } 1474 { 1475 std::wcmatch m; 1476 const wchar_t s[] = L"Ch"; 1477 assert(std::regex_search(s, m, std::wregex(L"[a[.ch.]z]", 1478 std::regex_constants::icase))); 1479 assert(m.size() == 1); 1480 assert(!m.prefix().matched); 1481 assert(m.prefix().first == s); 1482 assert(m.prefix().second == m[0].first); 1483 assert(!m.suffix().matched); 1484 assert(m.suffix().first == m[0].second); 1485 assert(m.suffix().second == m[0].second); 1486 assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<wchar_t>::length(s)); 1487 assert(m.position(0) == 0); 1488 assert(m.str(0) == s); 1489 } 1490 std::locale::global(std::locale("C")); 1491 { 1492 std::wcmatch m; 1493 const wchar_t s[] = L"m"; 1494 assert(!std::regex_search(s, m, std::wregex(L"[a[=M=]z]"))); 1495 assert(m.size() == 0); 1496 } 1497 { 1498 std::wcmatch m; 1499 const wchar_t s[] = L"01a45cef9"; 1500 assert(std::regex_search(s, m, std::wregex(L"[ace1-9]*"))); 1501 assert(m.size() == 1); 1502 assert(!m.prefix().matched); 1503 assert(m.prefix().first == s); 1504 assert(m.prefix().second == m[0].first); 1505 assert(m.suffix().matched); 1506 assert(m.suffix().first == m[0].second); 1507 assert(m.suffix().second == s + std::char_traits<wchar_t>::length(s)); 1508 assert(m.length(0) == 0); 1509 assert(m.position(0) == 0); 1510 assert(m.str(0) == L""); 1511 } 1512 { 1513 std::wcmatch m; 1514 const wchar_t s[] = L"01a45cef9"; 1515 assert(std::regex_search(s, m, std::wregex(L"[ace1-9]+"))); 1516 assert(m.size() == 1); 1517 assert(m.prefix().matched); 1518 assert(m.prefix().first == s); 1519 assert(m.prefix().second == m[0].first); 1520 assert(m.suffix().matched); 1521 assert(m.suffix().first == m[0].second); 1522 assert(m.suffix().second == s + std::char_traits<wchar_t>::length(s)); 1523 assert(m.length(0) == 6); 1524 assert(m.position(0) == 1); 1525 assert(m.str(0) == L"1a45ce"); 1526 } 1527 { 1528 const wchar_t r[] = L"^[-+]?[0-9]+[CF]$"; 1529 std::ptrdiff_t sr = std::char_traits<wchar_t>::length(r); 1530 typedef forward_iterator<const wchar_t*> FI; 1531 typedef bidirectional_iterator<const wchar_t*> BI; 1532 std::wregex regex(FI(r), FI(r+sr)); 1533 std::match_results<BI> m; 1534 const wchar_t s[] = L"-40C"; 1535 std::ptrdiff_t ss = std::char_traits<wchar_t>::length(s); 1536 assert(std::regex_search(BI(s), BI(s+ss), m, regex)); 1537 assert(m.size() == 1); 1538 assert(!m.prefix().matched); 1539 assert(m.prefix().first == BI(s)); 1540 assert(m.prefix().second == m[0].first); 1541 assert(!m.suffix().matched); 1542 assert(m.suffix().first == m[0].second); 1543 assert(m.suffix().second == m[0].second); 1544 assert(m.length(0) == 4); 1545 assert(m.position(0) == 0); 1546 assert(m.str(0) == s); 1547 } 1548 { 1549 std::wcmatch m; 1550 const wchar_t s[] = L"Jeff Jeffs "; 1551 assert(std::regex_search(s, m, std::wregex(L"Jeff(?=s\\b)"))); 1552 assert(m.size() == 1); 1553 assert(m.prefix().matched); 1554 assert(m.prefix().first == s); 1555 assert(m.prefix().second == m[0].first); 1556 assert(m.suffix().matched); 1557 assert(m.suffix().first == m[0].second); 1558 assert(m.suffix().second == s + std::char_traits<wchar_t>::length(s)); 1559 assert(m.length(0) == 4); 1560 assert(m.position(0) == 5); 1561 assert(m.str(0) == L"Jeff"); 1562 } 1563 { 1564 std::wcmatch m; 1565 const wchar_t s[] = L"Jeffs Jeff"; 1566 assert(std::regex_search(s, m, std::wregex(L"Jeff(?!s\\b)"))); 1567 assert(m.size() == 1); 1568 assert(m.prefix().matched); 1569 assert(m.prefix().first == s); 1570 assert(m.prefix().second == m[0].first); 1571 assert(!m.suffix().matched); 1572 assert(m.suffix().first == m[0].second); 1573 assert(m.suffix().second == s + std::char_traits<wchar_t>::length(s)); 1574 assert(m.length(0) == 4); 1575 assert(m.position(0) == 6); 1576 assert(m.str(0) == L"Jeff"); 1577 } 1578 { 1579 std::wcmatch m; 1580 const wchar_t s[] = L"5%k"; 1581 assert(std::regex_search(s, m, std::wregex(L"\\d[\\W]k"))); 1582 assert(m.size() == 1); 1583 assert(!m.prefix().matched); 1584 assert(m.prefix().first == s); 1585 assert(m.prefix().second == m[0].first); 1586 assert(!m.suffix().matched); 1587 assert(m.suffix().first == m[0].second); 1588 assert(m.suffix().second == s + std::char_traits<wchar_t>::length(s)); 1589 assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<wchar_t>::length(s)); 1590 assert(m.position(0) == 0); 1591 assert(m.str(0) == s); 1592 } 1593 }