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