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 /* Disable locale specific tests on Android because Android's NDK does not 690 * support locales other than "C" and "POSIX". 691 * 692 * https://code.google.com/p/android/issues/detail?id=57313 693 */ 694 #if !defined(__ANDROID__) 695 std::locale::global(std::locale("cs_CZ.ISO8859-2")); 696 { 697 std::cmatch m; 698 const char s[] = "m"; 699 assert(std::regex_search(s, m, std::regex("[a[=M=]z]", 700 std::regex_constants::basic))); 701 assert(m.size() == 1); 702 assert(!m.prefix().matched); 703 assert(m.prefix().first == s); 704 assert(m.prefix().second == m[0].first); 705 assert(!m.suffix().matched); 706 assert(m.suffix().first == m[0].second); 707 assert(m.suffix().second == m[0].second); 708 assert(m.length(0) == std::char_traits<char>::length(s)); 709 assert(m.position(0) == 0); 710 assert(m.str(0) == s); 711 } 712 { 713 std::cmatch m; 714 const char s[] = "Ch"; 715 assert(std::regex_search(s, m, std::regex("[a[.ch.]z]", 716 std::regex_constants::basic | std::regex_constants::icase))); 717 assert(m.size() == 1); 718 assert(!m.prefix().matched); 719 assert(m.prefix().first == s); 720 assert(m.prefix().second == m[0].first); 721 assert(!m.suffix().matched); 722 assert(m.suffix().first == m[0].second); 723 assert(m.suffix().second == m[0].second); 724 assert(m.length(0) == std::char_traits<char>::length(s)); 725 assert(m.position(0) == 0); 726 assert(m.str(0) == s); 727 } 728 std::locale::global(std::locale("C")); 729 #endif 730 { 731 std::cmatch m; 732 const char s[] = "m"; 733 assert(!std::regex_search(s, m, std::regex("[a[=M=]z]", 734 std::regex_constants::basic))); 735 assert(m.size() == 0); 736 } 737 { 738 std::cmatch m; 739 const char s[] = "01a45cef9"; 740 assert(std::regex_search(s, m, std::regex("[ace1-9]*", 741 std::regex_constants::basic))); 742 assert(m.size() == 1); 743 assert(!m.prefix().matched); 744 assert(m.prefix().first == s); 745 assert(m.prefix().second == m[0].first); 746 assert(m.suffix().matched); 747 assert(m.suffix().first == m[0].second); 748 assert(m.suffix().second == s + std::char_traits<char>::length(s)); 749 assert(m.length(0) == 0); 750 assert(m.position(0) == 0); 751 assert(m.str(0) == ""); 752 } 753 { 754 std::cmatch m; 755 const char s[] = "01a45cef9"; 756 assert(std::regex_search(s, m, std::regex("[ace1-9]\\{1,\\}", 757 std::regex_constants::basic))); 758 assert(m.size() == 1); 759 assert(m.prefix().matched); 760 assert(m.prefix().first == 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 == s + std::char_traits<char>::length(s)); 765 assert(m.length(0) == 6); 766 assert(m.position(0) == 1); 767 assert(m.str(0) == "1a45ce"); 768 } 769 { 770 const char r[] = "^[-+]\\{0,1\\}[0-9]\\{1,\\}[CF]$"; 771 std::ptrdiff_t sr = std::char_traits<char>::length(r); 772 typedef forward_iterator<const char*> FI; 773 typedef bidirectional_iterator<const char*> BI; 774 std::regex regex(FI(r), FI(r+sr), std::regex_constants::basic); 775 std::match_results<BI> m; 776 const char s[] = "-40C"; 777 std::ptrdiff_t ss = std::char_traits<char>::length(s); 778 assert(std::regex_search(BI(s), BI(s+ss), m, regex)); 779 assert(m.size() == 1); 780 assert(!m.prefix().matched); 781 assert(m.prefix().first == BI(s)); 782 assert(m.prefix().second == m[0].first); 783 assert(!m.suffix().matched); 784 assert(m.suffix().first == m[0].second); 785 assert(m.suffix().second == m[0].second); 786 assert(m.length(0) == 4); 787 assert(m.position(0) == 0); 788 assert(m.str(0) == s); 789 } 790 791 { 792 std::wcmatch m; 793 assert(!std::regex_search(L"a", m, std::wregex())); 794 assert(m.size() == 0); 795 assert(m.empty()); 796 } 797 { 798 std::wcmatch m; 799 const wchar_t s[] = L"a"; 800 assert(std::regex_search(s, m, std::wregex(L"a", std::regex_constants::basic))); 801 assert(m.size() == 1); 802 assert(!m.empty()); 803 assert(!m.prefix().matched); 804 assert(m.prefix().first == s); 805 assert(m.prefix().second == m[0].first); 806 assert(!m.suffix().matched); 807 assert(m.suffix().first == m[0].second); 808 assert(m.suffix().second == s+1); 809 assert(m.length(0) == 1); 810 assert(m.position(0) == 0); 811 assert(m.str(0) == L"a"); 812 } 813 { 814 std::wcmatch m; 815 const wchar_t s[] = L"ab"; 816 assert(std::regex_search(s, m, std::wregex(L"ab", std::regex_constants::basic))); 817 assert(m.size() == 1); 818 assert(!m.prefix().matched); 819 assert(m.prefix().first == s); 820 assert(m.prefix().second == m[0].first); 821 assert(!m.suffix().matched); 822 assert(m.suffix().first == m[0].second); 823 assert(m.suffix().second == s+2); 824 assert(m.length(0) == 2); 825 assert(m.position(0) == 0); 826 assert(m.str(0) == L"ab"); 827 } 828 { 829 std::wcmatch m; 830 const wchar_t s[] = L"ab"; 831 assert(!std::regex_search(s, m, std::wregex(L"ba", std::regex_constants::basic))); 832 assert(m.size() == 0); 833 assert(m.empty()); 834 } 835 { 836 std::wcmatch m; 837 const wchar_t s[] = L"aab"; 838 assert(std::regex_search(s, m, std::wregex(L"ab", std::regex_constants::basic))); 839 assert(m.size() == 1); 840 assert(m.prefix().matched); 841 assert(m.prefix().first == s); 842 assert(m.prefix().second == m[0].first); 843 assert(!m.suffix().matched); 844 assert(m.suffix().first == m[0].second); 845 assert(m.suffix().second == s+3); 846 assert(m.length(0) == 2); 847 assert(m.position(0) == 1); 848 assert(m.str(0) == L"ab"); 849 } 850 { 851 std::wcmatch m; 852 const wchar_t s[] = L"aab"; 853 assert(!std::regex_search(s, m, std::wregex(L"ab", std::regex_constants::basic), 854 std::regex_constants::match_continuous)); 855 assert(m.size() == 0); 856 } 857 { 858 std::wcmatch m; 859 const wchar_t s[] = L"abcd"; 860 assert(std::regex_search(s, m, std::wregex(L"bc", std::regex_constants::basic))); 861 assert(m.size() == 1); 862 assert(m.prefix().matched); 863 assert(m.prefix().first == s); 864 assert(m.prefix().second == m[0].first); 865 assert(m.suffix().matched); 866 assert(m.suffix().first == m[0].second); 867 assert(m.suffix().second == s+4); 868 assert(m.length(0) == 2); 869 assert(m.position(0) == 1); 870 assert(m.str(0) == L"bc"); 871 } 872 { 873 std::wcmatch m; 874 const wchar_t s[] = L"abbc"; 875 assert(std::regex_search(s, m, std::wregex(L"ab*c", std::regex_constants::basic))); 876 assert(m.size() == 1); 877 assert(!m.prefix().matched); 878 assert(m.prefix().first == s); 879 assert(m.prefix().second == m[0].first); 880 assert(!m.suffix().matched); 881 assert(m.suffix().first == m[0].second); 882 assert(m.suffix().second == s+4); 883 assert(m.length(0) == 4); 884 assert(m.position(0) == 0); 885 assert(m.str(0) == s); 886 } 887 { 888 std::wcmatch m; 889 const wchar_t s[] = L"ababc"; 890 assert(std::regex_search(s, m, std::wregex(L"\\(ab\\)*c", std::regex_constants::basic))); 891 assert(m.size() == 2); 892 assert(!m.prefix().matched); 893 assert(m.prefix().first == s); 894 assert(m.prefix().second == m[0].first); 895 assert(!m.suffix().matched); 896 assert(m.suffix().first == m[0].second); 897 assert(m.suffix().second == s+5); 898 assert(m.length(0) == 5); 899 assert(m.position(0) == 0); 900 assert(m.str(0) == s); 901 assert(m.length(1) == 2); 902 assert(m.position(1) == 2); 903 assert(m.str(1) == L"ab"); 904 } 905 { 906 std::wcmatch m; 907 const wchar_t s[] = L"abcdefghijk"; 908 assert(std::regex_search(s, m, std::wregex(L"cd\\(\\(e\\)fg\\)hi", 909 std::regex_constants::basic))); 910 assert(m.size() == 3); 911 assert(m.prefix().matched); 912 assert(m.prefix().first == s); 913 assert(m.prefix().second == m[0].first); 914 assert(m.suffix().matched); 915 assert(m.suffix().first == m[0].second); 916 assert(m.suffix().second == s+std::regex_traits<wchar_t>::length(s)); 917 assert(m.length(0) == 7); 918 assert(m.position(0) == 2); 919 assert(m.str(0) == L"cdefghi"); 920 assert(m.length(1) == 3); 921 assert(m.position(1) == 4); 922 assert(m.str(1) == L"efg"); 923 assert(m.length(2) == 1); 924 assert(m.position(2) == 4); 925 assert(m.str(2) == L"e"); 926 } 927 { 928 std::wcmatch m; 929 const wchar_t s[] = L"abc"; 930 assert(std::regex_search(s, m, std::wregex(L"^abc", std::regex_constants::basic))); 931 assert(m.size() == 1); 932 assert(!m.prefix().matched); 933 assert(m.prefix().first == s); 934 assert(m.prefix().second == m[0].first); 935 assert(!m.suffix().matched); 936 assert(m.suffix().first == m[0].second); 937 assert(m.suffix().second == s+3); 938 assert(m.length(0) == 3); 939 assert(m.position(0) == 0); 940 assert(m.str(0) == s); 941 } 942 { 943 std::wcmatch m; 944 const wchar_t s[] = L"abcd"; 945 assert(std::regex_search(s, m, std::wregex(L"^abc", std::regex_constants::basic))); 946 assert(m.size() == 1); 947 assert(!m.prefix().matched); 948 assert(m.prefix().first == s); 949 assert(m.prefix().second == m[0].first); 950 assert(m.suffix().matched); 951 assert(m.suffix().first == m[0].second); 952 assert(m.suffix().second == s+4); 953 assert(m.length(0) == 3); 954 assert(m.position(0) == 0); 955 assert(m.str(0) == L"abc"); 956 } 957 { 958 std::wcmatch m; 959 const wchar_t s[] = L"aabc"; 960 assert(!std::regex_search(s, m, std::wregex(L"^abc", std::regex_constants::basic))); 961 assert(m.size() == 0); 962 } 963 { 964 std::wcmatch m; 965 const wchar_t s[] = L"abc"; 966 assert(std::regex_search(s, m, std::wregex(L"abc$", std::regex_constants::basic))); 967 assert(m.size() == 1); 968 assert(!m.prefix().matched); 969 assert(m.prefix().first == s); 970 assert(m.prefix().second == m[0].first); 971 assert(!m.suffix().matched); 972 assert(m.suffix().first == m[0].second); 973 assert(m.suffix().second == s+3); 974 assert(m.length(0) == 3); 975 assert(m.position(0) == 0); 976 assert(m.str(0) == s); 977 } 978 { 979 std::wcmatch m; 980 const wchar_t s[] = L"efabc"; 981 assert(std::regex_search(s, m, std::wregex(L"abc$", std::regex_constants::basic))); 982 assert(m.size() == 1); 983 assert(m.prefix().matched); 984 assert(m.prefix().first == s); 985 assert(m.prefix().second == m[0].first); 986 assert(!m.suffix().matched); 987 assert(m.suffix().first == m[0].second); 988 assert(m.suffix().second == s+5); 989 assert(m.length(0) == 3); 990 assert(m.position(0) == 2); 991 assert(m.str(0) == s+2); 992 } 993 { 994 std::wcmatch m; 995 const wchar_t s[] = L"efabcg"; 996 assert(!std::regex_search(s, m, std::wregex(L"abc$", std::regex_constants::basic))); 997 assert(m.size() == 0); 998 } 999 { 1000 std::wcmatch m; 1001 const wchar_t s[] = L"abc"; 1002 assert(std::regex_search(s, m, std::wregex(L"a.c", std::regex_constants::basic))); 1003 assert(m.size() == 1); 1004 assert(!m.prefix().matched); 1005 assert(m.prefix().first == s); 1006 assert(m.prefix().second == m[0].first); 1007 assert(!m.suffix().matched); 1008 assert(m.suffix().first == m[0].second); 1009 assert(m.suffix().second == s+3); 1010 assert(m.length(0) == 3); 1011 assert(m.position(0) == 0); 1012 assert(m.str(0) == s); 1013 } 1014 { 1015 std::wcmatch m; 1016 const wchar_t s[] = L"acc"; 1017 assert(std::regex_search(s, m, std::wregex(L"a.c", std::regex_constants::basic))); 1018 assert(m.size() == 1); 1019 assert(!m.prefix().matched); 1020 assert(m.prefix().first == s); 1021 assert(m.prefix().second == m[0].first); 1022 assert(!m.suffix().matched); 1023 assert(m.suffix().first == m[0].second); 1024 assert(m.suffix().second == s+3); 1025 assert(m.length(0) == 3); 1026 assert(m.position(0) == 0); 1027 assert(m.str(0) == s); 1028 } 1029 { 1030 std::wcmatch m; 1031 const wchar_t s[] = L"acc"; 1032 assert(std::regex_search(s, m, std::wregex(L"a.c", std::regex_constants::basic))); 1033 assert(m.size() == 1); 1034 assert(!m.prefix().matched); 1035 assert(m.prefix().first == s); 1036 assert(m.prefix().second == m[0].first); 1037 assert(!m.suffix().matched); 1038 assert(m.suffix().first == m[0].second); 1039 assert(m.suffix().second == s+3); 1040 assert(m.length(0) == 3); 1041 assert(m.position(0) == 0); 1042 assert(m.str(0) == s); 1043 } 1044 { 1045 std::wcmatch m; 1046 const wchar_t s[] = L"abcdef"; 1047 assert(std::regex_search(s, m, std::wregex(L"\\(.*\\).*", std::regex_constants::basic))); 1048 assert(m.size() == 2); 1049 assert(!m.prefix().matched); 1050 assert(m.prefix().first == s); 1051 assert(m.prefix().second == m[0].first); 1052 assert(!m.suffix().matched); 1053 assert(m.suffix().first == m[0].second); 1054 assert(m.suffix().second == s+6); 1055 assert(m.length(0) == 6); 1056 assert(m.position(0) == 0); 1057 assert(m.str(0) == s); 1058 assert(m.length(1) == 6); 1059 assert(m.position(1) == 0); 1060 assert(m.str(1) == s); 1061 } 1062 { 1063 std::wcmatch m; 1064 const wchar_t s[] = L"bc"; 1065 assert(std::regex_search(s, m, std::wregex(L"\\(a*\\)*", std::regex_constants::basic))); 1066 assert(m.size() == 2); 1067 assert(!m.prefix().matched); 1068 assert(m.prefix().first == s); 1069 assert(m.prefix().second == m[0].first); 1070 assert(m.suffix().matched); 1071 assert(m.suffix().first == m[0].second); 1072 assert(m.suffix().second == s+2); 1073 assert(m.length(0) == 0); 1074 assert(m.position(0) == 0); 1075 assert(m.str(0) == L""); 1076 assert(m.length(1) == 0); 1077 assert(m.position(1) == 0); 1078 assert(m.str(1) == L""); 1079 } 1080 { 1081 std::wcmatch m; 1082 const wchar_t s[] = L"abbc"; 1083 assert(!std::regex_search(s, m, std::wregex(L"ab\\{3,5\\}c", std::regex_constants::basic))); 1084 assert(m.size() == 0); 1085 } 1086 { 1087 std::wcmatch m; 1088 const wchar_t s[] = L"abbbc"; 1089 assert(std::regex_search(s, m, std::wregex(L"ab\\{3,5\\}c", std::regex_constants::basic))); 1090 assert(m.size() == 1); 1091 assert(!m.prefix().matched); 1092 assert(m.prefix().first == s); 1093 assert(m.prefix().second == m[0].first); 1094 assert(!m.suffix().matched); 1095 assert(m.suffix().first == m[0].second); 1096 assert(m.suffix().second == m[0].second); 1097 assert(m.length(0) == std::char_traits<wchar_t>::length(s)); 1098 assert(m.position(0) == 0); 1099 assert(m.str(0) == s); 1100 } 1101 { 1102 std::wcmatch m; 1103 const wchar_t s[] = L"abbbbc"; 1104 assert(std::regex_search(s, m, std::wregex(L"ab\\{3,5\\}c", std::regex_constants::basic))); 1105 assert(m.size() == 1); 1106 assert(!m.prefix().matched); 1107 assert(m.prefix().first == s); 1108 assert(m.prefix().second == m[0].first); 1109 assert(!m.suffix().matched); 1110 assert(m.suffix().first == m[0].second); 1111 assert(m.suffix().second == m[0].second); 1112 assert(m.length(0) == std::char_traits<wchar_t>::length(s)); 1113 assert(m.position(0) == 0); 1114 assert(m.str(0) == s); 1115 } 1116 { 1117 std::wcmatch m; 1118 const wchar_t s[] = L"abbbbbc"; 1119 assert(std::regex_search(s, m, std::wregex(L"ab\\{3,5\\}c", std::regex_constants::basic))); 1120 assert(m.size() == 1); 1121 assert(!m.prefix().matched); 1122 assert(m.prefix().first == s); 1123 assert(m.prefix().second == m[0].first); 1124 assert(!m.suffix().matched); 1125 assert(m.suffix().first == m[0].second); 1126 assert(m.suffix().second == m[0].second); 1127 assert(m.length(0) == std::char_traits<wchar_t>::length(s)); 1128 assert(m.position(0) == 0); 1129 assert(m.str(0) == s); 1130 } 1131 { 1132 std::wcmatch m; 1133 const wchar_t s[] = L"adefc"; 1134 assert(!std::regex_search(s, m, std::wregex(L"ab\\{3,5\\}c", std::regex_constants::basic))); 1135 assert(m.size() == 0); 1136 } 1137 { 1138 std::wcmatch m; 1139 const wchar_t s[] = L"abbbbbbc"; 1140 assert(!std::regex_search(s, m, std::wregex(L"ab\\{3,5\\}c", std::regex_constants::basic))); 1141 assert(m.size() == 0); 1142 } 1143 { 1144 std::wcmatch m; 1145 const wchar_t s[] = L"adec"; 1146 assert(!std::regex_search(s, m, std::wregex(L"a.\\{3,5\\}c", std::regex_constants::basic))); 1147 assert(m.size() == 0); 1148 } 1149 { 1150 std::wcmatch m; 1151 const wchar_t s[] = L"adefc"; 1152 assert(std::regex_search(s, m, std::wregex(L"a.\\{3,5\\}c", std::regex_constants::basic))); 1153 assert(m.size() == 1); 1154 assert(!m.prefix().matched); 1155 assert(m.prefix().first == s); 1156 assert(m.prefix().second == m[0].first); 1157 assert(!m.suffix().matched); 1158 assert(m.suffix().first == m[0].second); 1159 assert(m.suffix().second == m[0].second); 1160 assert(m.length(0) == std::char_traits<wchar_t>::length(s)); 1161 assert(m.position(0) == 0); 1162 assert(m.str(0) == s); 1163 } 1164 { 1165 std::wcmatch m; 1166 const wchar_t s[] = L"adefgc"; 1167 assert(std::regex_search(s, m, std::wregex(L"a.\\{3,5\\}c", std::regex_constants::basic))); 1168 assert(m.size() == 1); 1169 assert(!m.prefix().matched); 1170 assert(m.prefix().first == s); 1171 assert(m.prefix().second == m[0].first); 1172 assert(!m.suffix().matched); 1173 assert(m.suffix().first == m[0].second); 1174 assert(m.suffix().second == m[0].second); 1175 assert(m.length(0) == std::char_traits<wchar_t>::length(s)); 1176 assert(m.position(0) == 0); 1177 assert(m.str(0) == s); 1178 } 1179 { 1180 std::wcmatch m; 1181 const wchar_t s[] = L"adefghc"; 1182 assert(std::regex_search(s, m, std::wregex(L"a.\\{3,5\\}c", std::regex_constants::basic))); 1183 assert(m.size() == 1); 1184 assert(!m.prefix().matched); 1185 assert(m.prefix().first == s); 1186 assert(m.prefix().second == m[0].first); 1187 assert(!m.suffix().matched); 1188 assert(m.suffix().first == m[0].second); 1189 assert(m.suffix().second == m[0].second); 1190 assert(m.length(0) == std::char_traits<wchar_t>::length(s)); 1191 assert(m.position(0) == 0); 1192 assert(m.str(0) == s); 1193 } 1194 { 1195 std::wcmatch m; 1196 const wchar_t s[] = L"adefghic"; 1197 assert(!std::regex_search(s, m, std::wregex(L"a.\\{3,5\\}c", std::regex_constants::basic))); 1198 assert(m.size() == 0); 1199 } 1200 { 1201 std::wcmatch m; 1202 const wchar_t s[] = L"-ab,ab-"; 1203 assert(std::regex_search(s, m, std::wregex(L"-\\(.*\\),\\1-", std::regex_constants::basic))); 1204 assert(m.size() == 2); 1205 assert(!m.prefix().matched); 1206 assert(m.prefix().first == s); 1207 assert(m.prefix().second == m[0].first); 1208 assert(!m.suffix().matched); 1209 assert(m.suffix().first == m[0].second); 1210 assert(m.suffix().second == m[0].second); 1211 assert(m.length(0) == std::char_traits<wchar_t>::length(s)); 1212 assert(m.position(0) == 0); 1213 assert(m.str(0) == s); 1214 assert(m.length(1) == 2); 1215 assert(m.position(1) == 1); 1216 assert(m.str(1) == L"ab"); 1217 } 1218 { 1219 std::wcmatch m; 1220 const wchar_t s[] = L"ababbabb"; 1221 assert(std::regex_search(s, m, std::wregex(L"^\\(ab*\\)*\\1$", std::regex_constants::basic))); 1222 assert(m.size() == 2); 1223 assert(!m.prefix().matched); 1224 assert(m.prefix().first == s); 1225 assert(m.prefix().second == m[0].first); 1226 assert(!m.suffix().matched); 1227 assert(m.suffix().first == m[0].second); 1228 assert(m.suffix().second == m[0].second); 1229 assert(m.length(0) == std::char_traits<wchar_t>::length(s)); 1230 assert(m.position(0) == 0); 1231 assert(m.str(0) == s); 1232 assert(m.length(1) == 3); 1233 assert(m.position(1) == 2); 1234 assert(m.str(1) == L"abb"); 1235 } 1236 { 1237 std::wcmatch m; 1238 const wchar_t s[] = L"ababbab"; 1239 assert(!std::regex_search(s, m, std::wregex(L"^\\(ab*\\)*\\1$", std::regex_constants::basic))); 1240 assert(m.size() == 0); 1241 } 1242 { 1243 std::wcmatch m; 1244 const wchar_t s[] = L"aBAbbAbB"; 1245 assert(std::regex_search(s, m, std::wregex(L"^\\(Ab*\\)*\\1$", 1246 std::regex_constants::basic | std::regex_constants::icase))); 1247 assert(m.size() == 2); 1248 assert(!m.prefix().matched); 1249 assert(m.prefix().first == s); 1250 assert(m.prefix().second == m[0].first); 1251 assert(!m.suffix().matched); 1252 assert(m.suffix().first == m[0].second); 1253 assert(m.suffix().second == m[0].second); 1254 assert(m.length(0) == std::char_traits<wchar_t>::length(s)); 1255 assert(m.position(0) == 0); 1256 assert(m.str(0) == s); 1257 assert(m.length(1) == 3); 1258 assert(m.position(1) == 2); 1259 assert(m.str(1) == L"Abb"); 1260 } 1261 { 1262 std::wcmatch m; 1263 const wchar_t s[] = L"aBAbbAbB"; 1264 assert(!std::regex_search(s, m, std::wregex(L"^\\(Ab*\\)*\\1$", 1265 std::regex_constants::basic))); 1266 assert(m.size() == 0); 1267 } 1268 { 1269 std::wcmatch m; 1270 const wchar_t s[] = L"a"; 1271 assert(std::regex_search(s, m, std::wregex(L"^[a]$", 1272 std::regex_constants::basic))); 1273 assert(m.size() == 1); 1274 assert(!m.prefix().matched); 1275 assert(m.prefix().first == s); 1276 assert(m.prefix().second == m[0].first); 1277 assert(!m.suffix().matched); 1278 assert(m.suffix().first == m[0].second); 1279 assert(m.suffix().second == m[0].second); 1280 assert(m.length(0) == 1); 1281 assert(m.position(0) == 0); 1282 assert(m.str(0) == L"a"); 1283 } 1284 { 1285 std::wcmatch m; 1286 const wchar_t s[] = L"a"; 1287 assert(std::regex_search(s, m, std::wregex(L"^[ab]$", 1288 std::regex_constants::basic))); 1289 assert(m.size() == 1); 1290 assert(!m.prefix().matched); 1291 assert(m.prefix().first == s); 1292 assert(m.prefix().second == m[0].first); 1293 assert(!m.suffix().matched); 1294 assert(m.suffix().first == m[0].second); 1295 assert(m.suffix().second == m[0].second); 1296 assert(m.length(0) == 1); 1297 assert(m.position(0) == 0); 1298 assert(m.str(0) == L"a"); 1299 } 1300 { 1301 std::wcmatch m; 1302 const wchar_t s[] = L"c"; 1303 assert(std::regex_search(s, m, std::wregex(L"^[a-f]$", 1304 std::regex_constants::basic))); 1305 assert(m.size() == 1); 1306 assert(!m.prefix().matched); 1307 assert(m.prefix().first == s); 1308 assert(m.prefix().second == m[0].first); 1309 assert(!m.suffix().matched); 1310 assert(m.suffix().first == m[0].second); 1311 assert(m.suffix().second == m[0].second); 1312 assert(m.length(0) == 1); 1313 assert(m.position(0) == 0); 1314 assert(m.str(0) == s); 1315 } 1316 { 1317 std::wcmatch m; 1318 const wchar_t s[] = L"g"; 1319 assert(!std::regex_search(s, m, std::wregex(L"^[a-f]$", 1320 std::regex_constants::basic))); 1321 assert(m.size() == 0); 1322 } 1323 { 1324 std::wcmatch m; 1325 const wchar_t s[] = L"Iraqi"; 1326 assert(std::regex_search(s, m, std::wregex(L"q[^u]", 1327 std::regex_constants::basic))); 1328 assert(m.size() == 1); 1329 assert(m.prefix().matched); 1330 assert(m.prefix().first == s); 1331 assert(m.prefix().second == m[0].first); 1332 assert(!m.suffix().matched); 1333 assert(m.suffix().first == m[0].second); 1334 assert(m.suffix().second == m[0].second); 1335 assert(m.length(0) == 2); 1336 assert(m.position(0) == 3); 1337 assert(m.str(0) == L"qi"); 1338 } 1339 { 1340 std::wcmatch m; 1341 const wchar_t s[] = L"Iraq"; 1342 assert(!std::regex_search(s, m, std::wregex(L"q[^u]", 1343 std::regex_constants::basic))); 1344 assert(m.size() == 0); 1345 } 1346 { 1347 std::wcmatch m; 1348 const wchar_t s[] = L"AmB"; 1349 assert(std::regex_search(s, m, std::wregex(L"A[[:lower:]]B", 1350 std::regex_constants::basic))); 1351 assert(m.size() == 1); 1352 assert(!m.prefix().matched); 1353 assert(m.prefix().first == s); 1354 assert(m.prefix().second == m[0].first); 1355 assert(!m.suffix().matched); 1356 assert(m.suffix().first == m[0].second); 1357 assert(m.suffix().second == m[0].second); 1358 assert(m.length(0) == std::char_traits<wchar_t>::length(s)); 1359 assert(m.position(0) == 0); 1360 assert(m.str(0) == s); 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() == 0); 1368 } 1369 { 1370 std::wcmatch m; 1371 const wchar_t s[] = L"AMB"; 1372 assert(std::regex_search(s, m, std::wregex(L"A[^[:lower:]]B", 1373 std::regex_constants::basic))); 1374 assert(m.size() == 1); 1375 assert(!m.prefix().matched); 1376 assert(m.prefix().first == s); 1377 assert(m.prefix().second == m[0].first); 1378 assert(!m.suffix().matched); 1379 assert(m.suffix().first == m[0].second); 1380 assert(m.suffix().second == m[0].second); 1381 assert(m.length(0) == std::char_traits<wchar_t>::length(s)); 1382 assert(m.position(0) == 0); 1383 assert(m.str(0) == s); 1384 } 1385 { 1386 std::wcmatch m; 1387 const wchar_t s[] = L"AmB"; 1388 assert(!std::regex_search(s, m, std::wregex(L"A[^[:lower:]]B", 1389 std::regex_constants::basic))); 1390 assert(m.size() == 0); 1391 } 1392 { 1393 std::wcmatch m; 1394 const wchar_t s[] = L"A5B"; 1395 assert(!std::regex_search(s, m, std::wregex(L"A[^[:lower:]0-9]B", 1396 std::regex_constants::basic))); 1397 assert(m.size() == 0); 1398 } 1399 { 1400 std::wcmatch m; 1401 const wchar_t s[] = L"A?B"; 1402 assert(std::regex_search(s, m, std::wregex(L"A[^[:lower:]0-9]B", 1403 std::regex_constants::basic))); 1404 assert(m.size() == 1); 1405 assert(!m.prefix().matched); 1406 assert(m.prefix().first == s); 1407 assert(m.prefix().second == m[0].first); 1408 assert(!m.suffix().matched); 1409 assert(m.suffix().first == m[0].second); 1410 assert(m.suffix().second == m[0].second); 1411 assert(m.length(0) == std::char_traits<wchar_t>::length(s)); 1412 assert(m.position(0) == 0); 1413 assert(m.str(0) == s); 1414 } 1415 { 1416 std::wcmatch m; 1417 const wchar_t s[] = L"-"; 1418 assert(std::regex_search(s, m, std::wregex(L"[a[.hyphen.]z]", 1419 std::regex_constants::basic))); 1420 assert(m.size() == 1); 1421 assert(!m.prefix().matched); 1422 assert(m.prefix().first == s); 1423 assert(m.prefix().second == m[0].first); 1424 assert(!m.suffix().matched); 1425 assert(m.suffix().first == m[0].second); 1426 assert(m.suffix().second == m[0].second); 1427 assert(m.length(0) == std::char_traits<wchar_t>::length(s)); 1428 assert(m.position(0) == 0); 1429 assert(m.str(0) == s); 1430 } 1431 { 1432 std::wcmatch m; 1433 const wchar_t s[] = L"z"; 1434 assert(std::regex_search(s, m, std::wregex(L"[a[.hyphen.]z]", 1435 std::regex_constants::basic))); 1436 assert(m.size() == 1); 1437 assert(!m.prefix().matched); 1438 assert(m.prefix().first == s); 1439 assert(m.prefix().second == m[0].first); 1440 assert(!m.suffix().matched); 1441 assert(m.suffix().first == m[0].second); 1442 assert(m.suffix().second == m[0].second); 1443 assert(m.length(0) == std::char_traits<wchar_t>::length(s)); 1444 assert(m.position(0) == 0); 1445 assert(m.str(0) == s); 1446 } 1447 { 1448 std::wcmatch m; 1449 const wchar_t s[] = L"m"; 1450 assert(!std::regex_search(s, m, std::wregex(L"[a[.hyphen.]z]", 1451 std::regex_constants::basic))); 1452 assert(m.size() == 0); 1453 } 1454 /* Disable locale specific tests on Android because Android's NDK does not 1455 * support locales other than "C" and "POSIX". 1456 * 1457 * https://code.google.com/p/android/issues/detail?id=57313 1458 */ 1459 #if !defined(__ANDROID__) 1460 std::locale::global(std::locale("cs_CZ.ISO8859-2")); 1461 { 1462 std::wcmatch m; 1463 const wchar_t s[] = L"m"; 1464 assert(std::regex_search(s, m, std::wregex(L"[a[=M=]z]", 1465 std::regex_constants::basic))); 1466 assert(m.size() == 1); 1467 assert(!m.prefix().matched); 1468 assert(m.prefix().first == s); 1469 assert(m.prefix().second == m[0].first); 1470 assert(!m.suffix().matched); 1471 assert(m.suffix().first == m[0].second); 1472 assert(m.suffix().second == m[0].second); 1473 assert(m.length(0) == std::char_traits<wchar_t>::length(s)); 1474 assert(m.position(0) == 0); 1475 assert(m.str(0) == s); 1476 } 1477 { 1478 std::wcmatch m; 1479 const wchar_t s[] = L"Ch"; 1480 assert(std::regex_search(s, m, std::wregex(L"[a[.ch.]z]", 1481 std::regex_constants::basic | std::regex_constants::icase))); 1482 assert(m.size() == 1); 1483 assert(!m.prefix().matched); 1484 assert(m.prefix().first == s); 1485 assert(m.prefix().second == m[0].first); 1486 assert(!m.suffix().matched); 1487 assert(m.suffix().first == m[0].second); 1488 assert(m.suffix().second == m[0].second); 1489 assert(m.length(0) == std::char_traits<wchar_t>::length(s)); 1490 assert(m.position(0) == 0); 1491 assert(m.str(0) == s); 1492 } 1493 std::locale::global(std::locale("C")); 1494 #endif 1495 { 1496 std::wcmatch m; 1497 const wchar_t s[] = L"m"; 1498 assert(!std::regex_search(s, m, std::wregex(L"[a[=M=]z]", 1499 std::regex_constants::basic))); 1500 assert(m.size() == 0); 1501 } 1502 { 1503 std::wcmatch m; 1504 const wchar_t s[] = L"01a45cef9"; 1505 assert(std::regex_search(s, m, std::wregex(L"[ace1-9]*", 1506 std::regex_constants::basic))); 1507 assert(m.size() == 1); 1508 assert(!m.prefix().matched); 1509 assert(m.prefix().first == s); 1510 assert(m.prefix().second == m[0].first); 1511 assert(m.suffix().matched); 1512 assert(m.suffix().first == m[0].second); 1513 assert(m.suffix().second == s + std::char_traits<wchar_t>::length(s)); 1514 assert(m.length(0) == 0); 1515 assert(m.position(0) == 0); 1516 assert(m.str(0) == L""); 1517 } 1518 { 1519 std::wcmatch m; 1520 const wchar_t s[] = L"01a45cef9"; 1521 assert(std::regex_search(s, m, std::wregex(L"[ace1-9]\\{1,\\}", 1522 std::regex_constants::basic))); 1523 assert(m.size() == 1); 1524 assert(m.prefix().matched); 1525 assert(m.prefix().first == s); 1526 assert(m.prefix().second == m[0].first); 1527 assert(m.suffix().matched); 1528 assert(m.suffix().first == m[0].second); 1529 assert(m.suffix().second == s + std::char_traits<wchar_t>::length(s)); 1530 assert(m.length(0) == 6); 1531 assert(m.position(0) == 1); 1532 assert(m.str(0) == L"1a45ce"); 1533 } 1534 { 1535 const wchar_t r[] = L"^[-+]\\{0,1\\}[0-9]\\{1,\\}[CF]$"; 1536 std::ptrdiff_t sr = std::char_traits<wchar_t>::length(r); 1537 typedef forward_iterator<const wchar_t*> FI; 1538 typedef bidirectional_iterator<const wchar_t*> BI; 1539 std::wregex regex(FI(r), FI(r+sr), std::regex_constants::basic); 1540 std::match_results<BI> m; 1541 const wchar_t s[] = L"-40C"; 1542 std::ptrdiff_t ss = std::char_traits<wchar_t>::length(s); 1543 assert(std::regex_search(BI(s), BI(s+ss), m, regex)); 1544 assert(m.size() == 1); 1545 assert(!m.prefix().matched); 1546 assert(m.prefix().first == BI(s)); 1547 assert(m.prefix().second == m[0].first); 1548 assert(!m.suffix().matched); 1549 assert(m.suffix().first == m[0].second); 1550 assert(m.suffix().second == m[0].second); 1551 assert(m.length(0) == 4); 1552 assert(m.position(0) == 0); 1553 assert(m.str(0) == s); 1554 } 1555 } 1556