1//===----------------------------------------------------------------------===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is dual licensed under the MIT and the University of Illinois Open 6// Source Licenses. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9 10// REQUIRES: locale.cs_CZ.ISO8859-2 11 12// <regex> 13 14// template <class BidirectionalIterator, class Allocator, class charT, class traits> 15// bool 16// regex_search(BidirectionalIterator first, BidirectionalIterator last, 17// match_results<BidirectionalIterator, Allocator>& m, 18// const basic_regex<charT, traits>& e, 19// regex_constants::match_flag_type flags = regex_constants::match_default); 20 21// TODO: investigation needed 22// XFAIL: linux-gnu 23 24#include <regex> 25#include <cassert> 26#include "test_iterators.h" 27 28#include "platform_support.h" // locale name macros 29 30int main() 31{ 32 { 33 std::cmatch m; 34 const char s[] = "a"; 35 assert(std::regex_search(s, m, std::regex("a", std::regex_constants::awk))); 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::awk))); 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::awk))); 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::awk))); 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::awk), 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::awk))); 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::awk))); 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::awk))); 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::awk))); 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::awk))); 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::awk))); 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::awk))); 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::awk))); 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::awk))); 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::awk))); 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::awk))); 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::awk))); 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::awk))); 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::awk))); 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::awk))); 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::awk))); 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::awk))); 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) == std::char_traits<char>::length(s)); 333 assert(m.position(0) == 0); 334 assert(m.str(0) == s); 335 } 336 { 337 std::cmatch m; 338 const char s[] = "abbbbc"; 339 assert(std::regex_search(s, m, std::regex("ab{3,5}c", std::regex_constants::awk))); 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) == std::char_traits<char>::length(s)); 348 assert(m.position(0) == 0); 349 assert(m.str(0) == s); 350 } 351 { 352 std::cmatch m; 353 const char s[] = "abbbbbc"; 354 assert(std::regex_search(s, m, std::regex("ab{3,5}c", std::regex_constants::awk))); 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) == std::char_traits<char>::length(s)); 363 assert(m.position(0) == 0); 364 assert(m.str(0) == s); 365 } 366 { 367 std::cmatch m; 368 const char s[] = "adefc"; 369 assert(!std::regex_search(s, m, std::regex("ab{3,5}c", std::regex_constants::awk))); 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::awk))); 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::awk))); 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::awk))); 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) == std::char_traits<char>::length(s)); 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::awk))); 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) == std::char_traits<char>::length(s)); 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::awk))); 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) == std::char_traits<char>::length(s)); 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::awk))); 433 assert(m.size() == 0); 434 } 435 { 436 std::cmatch m; 437 const char s[] = "tournament"; 438 assert(std::regex_search(s, m, std::regex("tour|to|tournament", 439 std::regex_constants::awk))); 440 assert(m.size() == 1); 441 assert(!m.prefix().matched); 442 assert(m.prefix().first == s); 443 assert(m.prefix().second == m[0].first); 444 assert(!m.suffix().matched); 445 assert(m.suffix().first == m[0].second); 446 assert(m.suffix().second == m[0].second); 447 assert(m.length(0) == std::char_traits<char>::length(s)); 448 assert(m.position(0) == 0); 449 assert(m.str(0) == s); 450 } 451 { 452 std::cmatch m; 453 const char s[] = "tournamenttotour"; 454 assert(std::regex_search(s, m, std::regex("(tour|to|tournament)+", 455 std::regex_constants::awk | std::regex_constants::nosubs))); 456 assert(m.size() == 1); 457 assert(!m.prefix().matched); 458 assert(m.prefix().first == s); 459 assert(m.prefix().second == m[0].first); 460 assert(!m.suffix().matched); 461 assert(m.suffix().first == m[0].second); 462 assert(m.suffix().second == m[0].second); 463 assert(m.length(0) == std::char_traits<char>::length(s)); 464 assert(m.position(0) == 0); 465 assert(m.str(0) == s); 466 } 467 { 468 std::cmatch m; 469 const char s[] = "ttotour"; 470 assert(std::regex_search(s, m, std::regex("(tour|to|t)+", 471 std::regex_constants::awk))); 472 assert(m.size() == 2); 473 assert(!m.prefix().matched); 474 assert(m.prefix().first == s); 475 assert(m.prefix().second == m[0].first); 476 assert(!m.suffix().matched); 477 assert(m.suffix().first == m[0].second); 478 assert(m.suffix().second == m[0].second); 479 assert(m.length(0) == std::char_traits<char>::length(s)); 480 assert(m.position(0) == 0); 481 assert(m.str(0) == s); 482 assert(m.length(1) == 4); 483 assert(m.position(1) == 3); 484 assert(m.str(1) == "tour"); 485 } 486 { 487 std::cmatch m; 488 const char s[] = "-ab,ab-"; 489 assert(!std::regex_search(s, m, std::regex("-(.*),\1-", std::regex_constants::awk))); 490 assert(m.size() == 0); 491 } 492 { 493 std::cmatch m; 494 const char s[] = "-ab,ab-"; 495 assert(std::regex_search(s, m, std::regex("-.*,.*-", std::regex_constants::awk))); 496 assert(m.size() == 1); 497 assert(!m.prefix().matched); 498 assert(m.prefix().first == s); 499 assert(m.prefix().second == m[0].first); 500 assert(!m.suffix().matched); 501 assert(m.suffix().first == m[0].second); 502 assert(m.suffix().second == m[0].second); 503 assert(m.length(0) == std::char_traits<char>::length(s)); 504 assert(m.position(0) == 0); 505 assert(m.str(0) == s); 506 } 507 { 508 std::cmatch m; 509 const char s[] = "a"; 510 assert(std::regex_search(s, m, std::regex("^[a]$", 511 std::regex_constants::awk))); 512 assert(m.size() == 1); 513 assert(!m.prefix().matched); 514 assert(m.prefix().first == s); 515 assert(m.prefix().second == m[0].first); 516 assert(!m.suffix().matched); 517 assert(m.suffix().first == m[0].second); 518 assert(m.suffix().second == m[0].second); 519 assert(m.length(0) == 1); 520 assert(m.position(0) == 0); 521 assert(m.str(0) == "a"); 522 } 523 { 524 std::cmatch m; 525 const char s[] = "a"; 526 assert(std::regex_search(s, m, std::regex("^[ab]$", 527 std::regex_constants::awk))); 528 assert(m.size() == 1); 529 assert(!m.prefix().matched); 530 assert(m.prefix().first == s); 531 assert(m.prefix().second == m[0].first); 532 assert(!m.suffix().matched); 533 assert(m.suffix().first == m[0].second); 534 assert(m.suffix().second == m[0].second); 535 assert(m.length(0) == 1); 536 assert(m.position(0) == 0); 537 assert(m.str(0) == "a"); 538 } 539 { 540 std::cmatch m; 541 const char s[] = "c"; 542 assert(std::regex_search(s, m, std::regex("^[a-f]$", 543 std::regex_constants::awk))); 544 assert(m.size() == 1); 545 assert(!m.prefix().matched); 546 assert(m.prefix().first == s); 547 assert(m.prefix().second == m[0].first); 548 assert(!m.suffix().matched); 549 assert(m.suffix().first == m[0].second); 550 assert(m.suffix().second == m[0].second); 551 assert(m.length(0) == 1); 552 assert(m.position(0) == 0); 553 assert(m.str(0) == s); 554 } 555 { 556 std::cmatch m; 557 const char s[] = "g"; 558 assert(!std::regex_search(s, m, std::regex("^[a-f]$", 559 std::regex_constants::awk))); 560 assert(m.size() == 0); 561 } 562 { 563 std::cmatch m; 564 const char s[] = "Iraqi"; 565 assert(std::regex_search(s, m, std::regex("q[^u]", 566 std::regex_constants::awk))); 567 assert(m.size() == 1); 568 assert(m.prefix().matched); 569 assert(m.prefix().first == s); 570 assert(m.prefix().second == m[0].first); 571 assert(!m.suffix().matched); 572 assert(m.suffix().first == m[0].second); 573 assert(m.suffix().second == m[0].second); 574 assert(m.length(0) == 2); 575 assert(m.position(0) == 3); 576 assert(m.str(0) == "qi"); 577 } 578 { 579 std::cmatch m; 580 const char s[] = "Iraq"; 581 assert(!std::regex_search(s, m, std::regex("q[^u]", 582 std::regex_constants::awk))); 583 assert(m.size() == 0); 584 } 585 { 586 std::cmatch m; 587 const char s[] = "AmB"; 588 assert(std::regex_search(s, m, std::regex("A[[:lower:]]B", 589 std::regex_constants::awk))); 590 assert(m.size() == 1); 591 assert(!m.prefix().matched); 592 assert(m.prefix().first == s); 593 assert(m.prefix().second == m[0].first); 594 assert(!m.suffix().matched); 595 assert(m.suffix().first == m[0].second); 596 assert(m.suffix().second == m[0].second); 597 assert(m.length(0) == std::char_traits<char>::length(s)); 598 assert(m.position(0) == 0); 599 assert(m.str(0) == s); 600 } 601 { 602 std::cmatch m; 603 const char s[] = "AMB"; 604 assert(!std::regex_search(s, m, std::regex("A[[:lower:]]B", 605 std::regex_constants::awk))); 606 assert(m.size() == 0); 607 } 608 { 609 std::cmatch m; 610 const char s[] = "AMB"; 611 assert(std::regex_search(s, m, std::regex("A[^[:lower:]]B", 612 std::regex_constants::awk))); 613 assert(m.size() == 1); 614 assert(!m.prefix().matched); 615 assert(m.prefix().first == s); 616 assert(m.prefix().second == m[0].first); 617 assert(!m.suffix().matched); 618 assert(m.suffix().first == m[0].second); 619 assert(m.suffix().second == m[0].second); 620 assert(m.length(0) == std::char_traits<char>::length(s)); 621 assert(m.position(0) == 0); 622 assert(m.str(0) == s); 623 } 624 { 625 std::cmatch m; 626 const char s[] = "AmB"; 627 assert(!std::regex_search(s, m, std::regex("A[^[:lower:]]B", 628 std::regex_constants::awk))); 629 assert(m.size() == 0); 630 } 631 { 632 std::cmatch m; 633 const char s[] = "A5B"; 634 assert(!std::regex_search(s, m, std::regex("A[^[:lower:]0-9]B", 635 std::regex_constants::awk))); 636 assert(m.size() == 0); 637 } 638 { 639 std::cmatch m; 640 const char s[] = "A?B"; 641 assert(std::regex_search(s, m, std::regex("A[^[:lower:]0-9]B", 642 std::regex_constants::awk))); 643 assert(m.size() == 1); 644 assert(!m.prefix().matched); 645 assert(m.prefix().first == s); 646 assert(m.prefix().second == m[0].first); 647 assert(!m.suffix().matched); 648 assert(m.suffix().first == m[0].second); 649 assert(m.suffix().second == m[0].second); 650 assert(m.length(0) == std::char_traits<char>::length(s)); 651 assert(m.position(0) == 0); 652 assert(m.str(0) == s); 653 } 654 { 655 std::cmatch m; 656 const char s[] = "-"; 657 assert(std::regex_search(s, m, std::regex("[a[.hyphen.]z]", 658 std::regex_constants::awk))); 659 assert(m.size() == 1); 660 assert(!m.prefix().matched); 661 assert(m.prefix().first == s); 662 assert(m.prefix().second == m[0].first); 663 assert(!m.suffix().matched); 664 assert(m.suffix().first == m[0].second); 665 assert(m.suffix().second == m[0].second); 666 assert(m.length(0) == std::char_traits<char>::length(s)); 667 assert(m.position(0) == 0); 668 assert(m.str(0) == s); 669 } 670 { 671 std::cmatch m; 672 const char s[] = "z"; 673 assert(std::regex_search(s, m, std::regex("[a[.hyphen.]z]", 674 std::regex_constants::awk))); 675 assert(m.size() == 1); 676 assert(!m.prefix().matched); 677 assert(m.prefix().first == s); 678 assert(m.prefix().second == m[0].first); 679 assert(!m.suffix().matched); 680 assert(m.suffix().first == m[0].second); 681 assert(m.suffix().second == m[0].second); 682 assert(m.length(0) == std::char_traits<char>::length(s)); 683 assert(m.position(0) == 0); 684 assert(m.str(0) == s); 685 } 686 { 687 std::cmatch m; 688 const char s[] = "m"; 689 assert(!std::regex_search(s, m, std::regex("[a[.hyphen.]z]", 690 std::regex_constants::awk))); 691 assert(m.size() == 0); 692 } 693 std::locale::global(std::locale(LOCALE_cs_CZ_ISO8859_2)); 694 { 695 std::cmatch m; 696 const char s[] = "m"; 697 assert(std::regex_search(s, m, std::regex("[a[=M=]z]", 698 std::regex_constants::awk))); 699 assert(m.size() == 1); 700 assert(!m.prefix().matched); 701 assert(m.prefix().first == s); 702 assert(m.prefix().second == m[0].first); 703 assert(!m.suffix().matched); 704 assert(m.suffix().first == m[0].second); 705 assert(m.suffix().second == m[0].second); 706 assert(m.length(0) == std::char_traits<char>::length(s)); 707 assert(m.position(0) == 0); 708 assert(m.str(0) == s); 709 } 710 { 711 std::cmatch m; 712 const char s[] = "Ch"; 713 assert(std::regex_search(s, m, std::regex("[a[.ch.]z]", 714 std::regex_constants::awk | std::regex_constants::icase))); 715 assert(m.size() == 1); 716 assert(!m.prefix().matched); 717 assert(m.prefix().first == s); 718 assert(m.prefix().second == m[0].first); 719 assert(!m.suffix().matched); 720 assert(m.suffix().first == m[0].second); 721 assert(m.suffix().second == m[0].second); 722 assert(m.length(0) == std::char_traits<char>::length(s)); 723 assert(m.position(0) == 0); 724 assert(m.str(0) == s); 725 } 726 std::locale::global(std::locale("C")); 727 { 728 std::cmatch m; 729 const char s[] = "m"; 730 assert(!std::regex_search(s, m, std::regex("[a[=M=]z]", 731 std::regex_constants::awk))); 732 assert(m.size() == 0); 733 } 734 { 735 std::cmatch m; 736 const char s[] = "01a45cef9"; 737 assert(std::regex_search(s, m, std::regex("[ace1-9]*", 738 std::regex_constants::awk))); 739 assert(m.size() == 1); 740 assert(!m.prefix().matched); 741 assert(m.prefix().first == s); 742 assert(m.prefix().second == m[0].first); 743 assert(m.suffix().matched); 744 assert(m.suffix().first == m[0].second); 745 assert(m.suffix().second == s + std::char_traits<char>::length(s)); 746 assert(m.length(0) == 0); 747 assert(m.position(0) == 0); 748 assert(m.str(0) == ""); 749 } 750 { 751 std::cmatch m; 752 const char s[] = "01a45cef9"; 753 assert(std::regex_search(s, m, std::regex("[ace1-9]+", 754 std::regex_constants::awk))); 755 assert(m.size() == 1); 756 assert(m.prefix().matched); 757 assert(m.prefix().first == s); 758 assert(m.prefix().second == m[0].first); 759 assert(m.suffix().matched); 760 assert(m.suffix().first == m[0].second); 761 assert(m.suffix().second == s + std::char_traits<char>::length(s)); 762 assert(m.length(0) == 6); 763 assert(m.position(0) == 1); 764 assert(m.str(0) == "1a45ce"); 765 } 766 { 767 const char r[] = "^[-+]?[0-9]+[CF]$"; 768 std::ptrdiff_t sr = std::char_traits<char>::length(r); 769 typedef forward_iterator<const char*> FI; 770 typedef bidirectional_iterator<const char*> BI; 771 std::regex regex(FI(r), FI(r+sr), std::regex_constants::awk); 772 std::match_results<BI> m; 773 const char s[] = "-40C"; 774 std::ptrdiff_t ss = std::char_traits<char>::length(s); 775 assert(std::regex_search(BI(s), BI(s+ss), m, regex)); 776 assert(m.size() == 1); 777 assert(!m.prefix().matched); 778 assert(m.prefix().first == BI(s)); 779 assert(m.prefix().second == m[0].first); 780 assert(!m.suffix().matched); 781 assert(m.suffix().first == m[0].second); 782 assert(m.suffix().second == m[0].second); 783 assert(m.length(0) == 4); 784 assert(m.position(0) == 0); 785 assert(m.str(0) == s); 786 } 787 { 788 std::cmatch m; 789 const char s[] = "\n\n\n"; 790 assert(std::regex_search(s, m, std::regex("[\\n]+", 791 std::regex_constants::awk))); 792 assert(m.size() == 1); 793 assert(!m.prefix().matched); 794 assert(m.prefix().first == s); 795 assert(m.prefix().second == m[0].first); 796 assert(!m.suffix().matched); 797 assert(m.suffix().first == m[0].second); 798 assert(m.suffix().second == s + std::char_traits<char>::length(s)); 799 assert(m.length(0) == std::char_traits<char>::length(s)); 800 assert(m.position(0) == 0); 801 assert(m.str(0) == s); 802 } 803 { 804 std::wcmatch m; 805 const wchar_t s[] = L"a"; 806 assert(std::regex_search(s, m, std::wregex(L"a", std::regex_constants::awk))); 807 assert(m.size() == 1); 808 assert(!m.empty()); 809 assert(!m.prefix().matched); 810 assert(m.prefix().first == s); 811 assert(m.prefix().second == m[0].first); 812 assert(!m.suffix().matched); 813 assert(m.suffix().first == m[0].second); 814 assert(m.suffix().second == s+1); 815 assert(m.length(0) == 1); 816 assert(m.position(0) == 0); 817 assert(m.str(0) == L"a"); 818 } 819 { 820 std::wcmatch m; 821 const wchar_t s[] = L"ab"; 822 assert(std::regex_search(s, m, std::wregex(L"ab", std::regex_constants::awk))); 823 assert(m.size() == 1); 824 assert(!m.prefix().matched); 825 assert(m.prefix().first == s); 826 assert(m.prefix().second == m[0].first); 827 assert(!m.suffix().matched); 828 assert(m.suffix().first == m[0].second); 829 assert(m.suffix().second == s+2); 830 assert(m.length(0) == 2); 831 assert(m.position(0) == 0); 832 assert(m.str(0) == L"ab"); 833 } 834 { 835 std::wcmatch m; 836 const wchar_t s[] = L"ab"; 837 assert(!std::regex_search(s, m, std::wregex(L"ba", std::regex_constants::awk))); 838 assert(m.size() == 0); 839 assert(m.empty()); 840 } 841 { 842 std::wcmatch m; 843 const wchar_t s[] = L"aab"; 844 assert(std::regex_search(s, m, std::wregex(L"ab", std::regex_constants::awk))); 845 assert(m.size() == 1); 846 assert(m.prefix().matched); 847 assert(m.prefix().first == s); 848 assert(m.prefix().second == m[0].first); 849 assert(!m.suffix().matched); 850 assert(m.suffix().first == m[0].second); 851 assert(m.suffix().second == s+3); 852 assert(m.length(0) == 2); 853 assert(m.position(0) == 1); 854 assert(m.str(0) == L"ab"); 855 } 856 { 857 std::wcmatch m; 858 const wchar_t s[] = L"aab"; 859 assert(!std::regex_search(s, m, std::wregex(L"ab", std::regex_constants::awk), 860 std::regex_constants::match_continuous)); 861 assert(m.size() == 0); 862 } 863 { 864 std::wcmatch m; 865 const wchar_t s[] = L"abcd"; 866 assert(std::regex_search(s, m, std::wregex(L"bc", std::regex_constants::awk))); 867 assert(m.size() == 1); 868 assert(m.prefix().matched); 869 assert(m.prefix().first == s); 870 assert(m.prefix().second == m[0].first); 871 assert(m.suffix().matched); 872 assert(m.suffix().first == m[0].second); 873 assert(m.suffix().second == s+4); 874 assert(m.length(0) == 2); 875 assert(m.position(0) == 1); 876 assert(m.str(0) == L"bc"); 877 } 878 { 879 std::wcmatch m; 880 const wchar_t s[] = L"abbc"; 881 assert(std::regex_search(s, m, std::wregex(L"ab*c", std::regex_constants::awk))); 882 assert(m.size() == 1); 883 assert(!m.prefix().matched); 884 assert(m.prefix().first == s); 885 assert(m.prefix().second == m[0].first); 886 assert(!m.suffix().matched); 887 assert(m.suffix().first == m[0].second); 888 assert(m.suffix().second == s+4); 889 assert(m.length(0) == 4); 890 assert(m.position(0) == 0); 891 assert(m.str(0) == s); 892 } 893 { 894 std::wcmatch m; 895 const wchar_t s[] = L"ababc"; 896 assert(std::regex_search(s, m, std::wregex(L"(ab)*c", std::regex_constants::awk))); 897 assert(m.size() == 2); 898 assert(!m.prefix().matched); 899 assert(m.prefix().first == s); 900 assert(m.prefix().second == m[0].first); 901 assert(!m.suffix().matched); 902 assert(m.suffix().first == m[0].second); 903 assert(m.suffix().second == s+5); 904 assert(m.length(0) == 5); 905 assert(m.position(0) == 0); 906 assert(m.str(0) == s); 907 assert(m.length(1) == 2); 908 assert(m.position(1) == 2); 909 assert(m.str(1) == L"ab"); 910 } 911 { 912 std::wcmatch m; 913 const wchar_t s[] = L"abcdefghijk"; 914 assert(std::regex_search(s, m, std::wregex(L"cd((e)fg)hi", 915 std::regex_constants::awk))); 916 assert(m.size() == 3); 917 assert(m.prefix().matched); 918 assert(m.prefix().first == s); 919 assert(m.prefix().second == m[0].first); 920 assert(m.suffix().matched); 921 assert(m.suffix().first == m[0].second); 922 assert(m.suffix().second == s+std::regex_traits<wchar_t>::length(s)); 923 assert(m.length(0) == 7); 924 assert(m.position(0) == 2); 925 assert(m.str(0) == L"cdefghi"); 926 assert(m.length(1) == 3); 927 assert(m.position(1) == 4); 928 assert(m.str(1) == L"efg"); 929 assert(m.length(2) == 1); 930 assert(m.position(2) == 4); 931 assert(m.str(2) == L"e"); 932 } 933 { 934 std::wcmatch m; 935 const wchar_t s[] = L"abc"; 936 assert(std::regex_search(s, m, std::wregex(L"^abc", std::regex_constants::awk))); 937 assert(m.size() == 1); 938 assert(!m.prefix().matched); 939 assert(m.prefix().first == s); 940 assert(m.prefix().second == m[0].first); 941 assert(!m.suffix().matched); 942 assert(m.suffix().first == m[0].second); 943 assert(m.suffix().second == s+3); 944 assert(m.length(0) == 3); 945 assert(m.position(0) == 0); 946 assert(m.str(0) == s); 947 } 948 { 949 std::wcmatch m; 950 const wchar_t s[] = L"abcd"; 951 assert(std::regex_search(s, m, std::wregex(L"^abc", std::regex_constants::awk))); 952 assert(m.size() == 1); 953 assert(!m.prefix().matched); 954 assert(m.prefix().first == s); 955 assert(m.prefix().second == m[0].first); 956 assert(m.suffix().matched); 957 assert(m.suffix().first == m[0].second); 958 assert(m.suffix().second == s+4); 959 assert(m.length(0) == 3); 960 assert(m.position(0) == 0); 961 assert(m.str(0) == L"abc"); 962 } 963 { 964 std::wcmatch m; 965 const wchar_t s[] = L"aabc"; 966 assert(!std::regex_search(s, m, std::wregex(L"^abc", std::regex_constants::awk))); 967 assert(m.size() == 0); 968 } 969 { 970 std::wcmatch m; 971 const wchar_t s[] = L"abc"; 972 assert(std::regex_search(s, m, std::wregex(L"abc$", std::regex_constants::awk))); 973 assert(m.size() == 1); 974 assert(!m.prefix().matched); 975 assert(m.prefix().first == s); 976 assert(m.prefix().second == m[0].first); 977 assert(!m.suffix().matched); 978 assert(m.suffix().first == m[0].second); 979 assert(m.suffix().second == s+3); 980 assert(m.length(0) == 3); 981 assert(m.position(0) == 0); 982 assert(m.str(0) == s); 983 } 984 { 985 std::wcmatch m; 986 const wchar_t s[] = L"efabc"; 987 assert(std::regex_search(s, m, std::wregex(L"abc$", std::regex_constants::awk))); 988 assert(m.size() == 1); 989 assert(m.prefix().matched); 990 assert(m.prefix().first == s); 991 assert(m.prefix().second == m[0].first); 992 assert(!m.suffix().matched); 993 assert(m.suffix().first == m[0].second); 994 assert(m.suffix().second == s+5); 995 assert(m.length(0) == 3); 996 assert(m.position(0) == 2); 997 assert(m.str(0) == s+2); 998 } 999 { 1000 std::wcmatch m; 1001 const wchar_t s[] = L"efabcg"; 1002 assert(!std::regex_search(s, m, std::wregex(L"abc$", std::regex_constants::awk))); 1003 assert(m.size() == 0); 1004 } 1005 { 1006 std::wcmatch m; 1007 const wchar_t s[] = L"abc"; 1008 assert(std::regex_search(s, m, std::wregex(L"a.c", std::regex_constants::awk))); 1009 assert(m.size() == 1); 1010 assert(!m.prefix().matched); 1011 assert(m.prefix().first == s); 1012 assert(m.prefix().second == m[0].first); 1013 assert(!m.suffix().matched); 1014 assert(m.suffix().first == m[0].second); 1015 assert(m.suffix().second == s+3); 1016 assert(m.length(0) == 3); 1017 assert(m.position(0) == 0); 1018 assert(m.str(0) == s); 1019 } 1020 { 1021 std::wcmatch m; 1022 const wchar_t s[] = L"acc"; 1023 assert(std::regex_search(s, m, std::wregex(L"a.c", std::regex_constants::awk))); 1024 assert(m.size() == 1); 1025 assert(!m.prefix().matched); 1026 assert(m.prefix().first == s); 1027 assert(m.prefix().second == m[0].first); 1028 assert(!m.suffix().matched); 1029 assert(m.suffix().first == m[0].second); 1030 assert(m.suffix().second == s+3); 1031 assert(m.length(0) == 3); 1032 assert(m.position(0) == 0); 1033 assert(m.str(0) == s); 1034 } 1035 { 1036 std::wcmatch m; 1037 const wchar_t s[] = L"acc"; 1038 assert(std::regex_search(s, m, std::wregex(L"a.c", std::regex_constants::awk))); 1039 assert(m.size() == 1); 1040 assert(!m.prefix().matched); 1041 assert(m.prefix().first == s); 1042 assert(m.prefix().second == m[0].first); 1043 assert(!m.suffix().matched); 1044 assert(m.suffix().first == m[0].second); 1045 assert(m.suffix().second == s+3); 1046 assert(m.length(0) == 3); 1047 assert(m.position(0) == 0); 1048 assert(m.str(0) == s); 1049 } 1050 { 1051 std::wcmatch m; 1052 const wchar_t s[] = L"abcdef"; 1053 assert(std::regex_search(s, m, std::wregex(L"(.*).*", std::regex_constants::awk))); 1054 assert(m.size() == 2); 1055 assert(!m.prefix().matched); 1056 assert(m.prefix().first == s); 1057 assert(m.prefix().second == m[0].first); 1058 assert(!m.suffix().matched); 1059 assert(m.suffix().first == m[0].second); 1060 assert(m.suffix().second == s+6); 1061 assert(m.length(0) == 6); 1062 assert(m.position(0) == 0); 1063 assert(m.str(0) == s); 1064 assert(m.length(1) == 6); 1065 assert(m.position(1) == 0); 1066 assert(m.str(1) == s); 1067 } 1068 { 1069 std::wcmatch m; 1070 const wchar_t s[] = L"bc"; 1071 assert(std::regex_search(s, m, std::wregex(L"(a*)*", std::regex_constants::awk))); 1072 assert(m.size() == 2); 1073 assert(!m.prefix().matched); 1074 assert(m.prefix().first == s); 1075 assert(m.prefix().second == m[0].first); 1076 assert(m.suffix().matched); 1077 assert(m.suffix().first == m[0].second); 1078 assert(m.suffix().second == s+2); 1079 assert(m.length(0) == 0); 1080 assert(m.position(0) == 0); 1081 assert(m.str(0) == L""); 1082 assert(m.length(1) == 0); 1083 assert(m.position(1) == 0); 1084 assert(m.str(1) == L""); 1085 } 1086 { 1087 std::wcmatch m; 1088 const wchar_t s[] = L"abbc"; 1089 assert(!std::regex_search(s, m, std::wregex(L"ab{3,5}c", std::regex_constants::awk))); 1090 assert(m.size() == 0); 1091 } 1092 { 1093 std::wcmatch m; 1094 const wchar_t s[] = L"abbbc"; 1095 assert(std::regex_search(s, m, std::wregex(L"ab{3,5}c", std::regex_constants::awk))); 1096 assert(m.size() == 1); 1097 assert(!m.prefix().matched); 1098 assert(m.prefix().first == s); 1099 assert(m.prefix().second == m[0].first); 1100 assert(!m.suffix().matched); 1101 assert(m.suffix().first == m[0].second); 1102 assert(m.suffix().second == m[0].second); 1103 assert(m.length(0) == std::char_traits<wchar_t>::length(s)); 1104 assert(m.position(0) == 0); 1105 assert(m.str(0) == s); 1106 } 1107 { 1108 std::wcmatch m; 1109 const wchar_t s[] = L"abbbbc"; 1110 assert(std::regex_search(s, m, std::wregex(L"ab{3,5}c", std::regex_constants::awk))); 1111 assert(m.size() == 1); 1112 assert(!m.prefix().matched); 1113 assert(m.prefix().first == s); 1114 assert(m.prefix().second == m[0].first); 1115 assert(!m.suffix().matched); 1116 assert(m.suffix().first == m[0].second); 1117 assert(m.suffix().second == m[0].second); 1118 assert(m.length(0) == std::char_traits<wchar_t>::length(s)); 1119 assert(m.position(0) == 0); 1120 assert(m.str(0) == s); 1121 } 1122 { 1123 std::wcmatch m; 1124 const wchar_t s[] = L"abbbbbc"; 1125 assert(std::regex_search(s, m, std::wregex(L"ab{3,5}c", std::regex_constants::awk))); 1126 assert(m.size() == 1); 1127 assert(!m.prefix().matched); 1128 assert(m.prefix().first == s); 1129 assert(m.prefix().second == m[0].first); 1130 assert(!m.suffix().matched); 1131 assert(m.suffix().first == m[0].second); 1132 assert(m.suffix().second == m[0].second); 1133 assert(m.length(0) == std::char_traits<wchar_t>::length(s)); 1134 assert(m.position(0) == 0); 1135 assert(m.str(0) == s); 1136 } 1137 { 1138 std::wcmatch m; 1139 const wchar_t s[] = L"adefc"; 1140 assert(!std::regex_search(s, m, std::wregex(L"ab{3,5}c", std::regex_constants::awk))); 1141 assert(m.size() == 0); 1142 } 1143 { 1144 std::wcmatch m; 1145 const wchar_t s[] = L"abbbbbbc"; 1146 assert(!std::regex_search(s, m, std::wregex(L"ab{3,5}c", std::regex_constants::awk))); 1147 assert(m.size() == 0); 1148 } 1149 { 1150 std::wcmatch m; 1151 const wchar_t s[] = L"adec"; 1152 assert(!std::regex_search(s, m, std::wregex(L"a.{3,5}c", std::regex_constants::awk))); 1153 assert(m.size() == 0); 1154 } 1155 { 1156 std::wcmatch m; 1157 const wchar_t s[] = L"adefc"; 1158 assert(std::regex_search(s, m, std::wregex(L"a.{3,5}c", std::regex_constants::awk))); 1159 assert(m.size() == 1); 1160 assert(!m.prefix().matched); 1161 assert(m.prefix().first == s); 1162 assert(m.prefix().second == m[0].first); 1163 assert(!m.suffix().matched); 1164 assert(m.suffix().first == m[0].second); 1165 assert(m.suffix().second == m[0].second); 1166 assert(m.length(0) == std::char_traits<wchar_t>::length(s)); 1167 assert(m.position(0) == 0); 1168 assert(m.str(0) == s); 1169 } 1170 { 1171 std::wcmatch m; 1172 const wchar_t s[] = L"adefgc"; 1173 assert(std::regex_search(s, m, std::wregex(L"a.{3,5}c", std::regex_constants::awk))); 1174 assert(m.size() == 1); 1175 assert(!m.prefix().matched); 1176 assert(m.prefix().first == s); 1177 assert(m.prefix().second == m[0].first); 1178 assert(!m.suffix().matched); 1179 assert(m.suffix().first == m[0].second); 1180 assert(m.suffix().second == m[0].second); 1181 assert(m.length(0) == std::char_traits<wchar_t>::length(s)); 1182 assert(m.position(0) == 0); 1183 assert(m.str(0) == s); 1184 } 1185 { 1186 std::wcmatch m; 1187 const wchar_t s[] = L"adefghc"; 1188 assert(std::regex_search(s, m, std::wregex(L"a.{3,5}c", std::regex_constants::awk))); 1189 assert(m.size() == 1); 1190 assert(!m.prefix().matched); 1191 assert(m.prefix().first == s); 1192 assert(m.prefix().second == m[0].first); 1193 assert(!m.suffix().matched); 1194 assert(m.suffix().first == m[0].second); 1195 assert(m.suffix().second == m[0].second); 1196 assert(m.length(0) == std::char_traits<wchar_t>::length(s)); 1197 assert(m.position(0) == 0); 1198 assert(m.str(0) == s); 1199 } 1200 { 1201 std::wcmatch m; 1202 const wchar_t s[] = L"adefghic"; 1203 assert(!std::regex_search(s, m, std::wregex(L"a.{3,5}c", std::regex_constants::awk))); 1204 assert(m.size() == 0); 1205 } 1206 { 1207 std::wcmatch m; 1208 const wchar_t s[] = L"tournament"; 1209 assert(std::regex_search(s, m, std::wregex(L"tour|to|tournament", 1210 std::regex_constants::awk))); 1211 assert(m.size() == 1); 1212 assert(!m.prefix().matched); 1213 assert(m.prefix().first == s); 1214 assert(m.prefix().second == m[0].first); 1215 assert(!m.suffix().matched); 1216 assert(m.suffix().first == m[0].second); 1217 assert(m.suffix().second == m[0].second); 1218 assert(m.length(0) == std::char_traits<wchar_t>::length(s)); 1219 assert(m.position(0) == 0); 1220 assert(m.str(0) == s); 1221 } 1222 { 1223 std::wcmatch m; 1224 const wchar_t s[] = L"tournamenttotour"; 1225 assert(std::regex_search(s, m, std::wregex(L"(tour|to|tournament)+", 1226 std::regex_constants::awk | std::regex_constants::nosubs))); 1227 assert(m.size() == 1); 1228 assert(!m.prefix().matched); 1229 assert(m.prefix().first == s); 1230 assert(m.prefix().second == m[0].first); 1231 assert(!m.suffix().matched); 1232 assert(m.suffix().first == m[0].second); 1233 assert(m.suffix().second == m[0].second); 1234 assert(m.length(0) == std::char_traits<wchar_t>::length(s)); 1235 assert(m.position(0) == 0); 1236 assert(m.str(0) == s); 1237 } 1238 { 1239 std::wcmatch m; 1240 const wchar_t s[] = L"ttotour"; 1241 assert(std::regex_search(s, m, std::wregex(L"(tour|to|t)+", 1242 std::regex_constants::awk))); 1243 assert(m.size() == 2); 1244 assert(!m.prefix().matched); 1245 assert(m.prefix().first == s); 1246 assert(m.prefix().second == m[0].first); 1247 assert(!m.suffix().matched); 1248 assert(m.suffix().first == m[0].second); 1249 assert(m.suffix().second == m[0].second); 1250 assert(m.length(0) == std::char_traits<wchar_t>::length(s)); 1251 assert(m.position(0) == 0); 1252 assert(m.str(0) == s); 1253 assert(m.length(1) == 4); 1254 assert(m.position(1) == 3); 1255 assert(m.str(1) == L"tour"); 1256 } 1257 { 1258 std::wcmatch m; 1259 const wchar_t s[] = L"-ab,ab-"; 1260 assert(!std::regex_search(s, m, std::wregex(L"-(.*),\1-", std::regex_constants::awk))); 1261 assert(m.size() == 0); 1262 } 1263 { 1264 std::wcmatch m; 1265 const wchar_t s[] = L"-ab,ab-"; 1266 assert(std::regex_search(s, m, std::wregex(L"-.*,.*-", std::regex_constants::awk))); 1267 assert(m.size() == 1); 1268 assert(!m.prefix().matched); 1269 assert(m.prefix().first == s); 1270 assert(m.prefix().second == m[0].first); 1271 assert(!m.suffix().matched); 1272 assert(m.suffix().first == m[0].second); 1273 assert(m.suffix().second == m[0].second); 1274 assert(m.length(0) == std::char_traits<wchar_t>::length(s)); 1275 assert(m.position(0) == 0); 1276 assert(m.str(0) == s); 1277 } 1278 { 1279 std::wcmatch m; 1280 const wchar_t s[] = L"a"; 1281 assert(std::regex_search(s, m, std::wregex(L"^[a]$", 1282 std::regex_constants::awk))); 1283 assert(m.size() == 1); 1284 assert(!m.prefix().matched); 1285 assert(m.prefix().first == s); 1286 assert(m.prefix().second == m[0].first); 1287 assert(!m.suffix().matched); 1288 assert(m.suffix().first == m[0].second); 1289 assert(m.suffix().second == m[0].second); 1290 assert(m.length(0) == 1); 1291 assert(m.position(0) == 0); 1292 assert(m.str(0) == L"a"); 1293 } 1294 { 1295 std::wcmatch m; 1296 const wchar_t s[] = L"a"; 1297 assert(std::regex_search(s, m, std::wregex(L"^[ab]$", 1298 std::regex_constants::awk))); 1299 assert(m.size() == 1); 1300 assert(!m.prefix().matched); 1301 assert(m.prefix().first == s); 1302 assert(m.prefix().second == m[0].first); 1303 assert(!m.suffix().matched); 1304 assert(m.suffix().first == m[0].second); 1305 assert(m.suffix().second == m[0].second); 1306 assert(m.length(0) == 1); 1307 assert(m.position(0) == 0); 1308 assert(m.str(0) == L"a"); 1309 } 1310 { 1311 std::wcmatch m; 1312 const wchar_t s[] = L"c"; 1313 assert(std::regex_search(s, m, std::wregex(L"^[a-f]$", 1314 std::regex_constants::awk))); 1315 assert(m.size() == 1); 1316 assert(!m.prefix().matched); 1317 assert(m.prefix().first == s); 1318 assert(m.prefix().second == m[0].first); 1319 assert(!m.suffix().matched); 1320 assert(m.suffix().first == m[0].second); 1321 assert(m.suffix().second == m[0].second); 1322 assert(m.length(0) == 1); 1323 assert(m.position(0) == 0); 1324 assert(m.str(0) == s); 1325 } 1326 { 1327 std::wcmatch m; 1328 const wchar_t s[] = L"g"; 1329 assert(!std::regex_search(s, m, std::wregex(L"^[a-f]$", 1330 std::regex_constants::awk))); 1331 assert(m.size() == 0); 1332 } 1333 { 1334 std::wcmatch m; 1335 const wchar_t s[] = L"Iraqi"; 1336 assert(std::regex_search(s, m, std::wregex(L"q[^u]", 1337 std::regex_constants::awk))); 1338 assert(m.size() == 1); 1339 assert(m.prefix().matched); 1340 assert(m.prefix().first == s); 1341 assert(m.prefix().second == m[0].first); 1342 assert(!m.suffix().matched); 1343 assert(m.suffix().first == m[0].second); 1344 assert(m.suffix().second == m[0].second); 1345 assert(m.length(0) == 2); 1346 assert(m.position(0) == 3); 1347 assert(m.str(0) == L"qi"); 1348 } 1349 { 1350 std::wcmatch m; 1351 const wchar_t s[] = L"Iraq"; 1352 assert(!std::regex_search(s, m, std::wregex(L"q[^u]", 1353 std::regex_constants::awk))); 1354 assert(m.size() == 0); 1355 } 1356 { 1357 std::wcmatch m; 1358 const wchar_t s[] = L"AmB"; 1359 assert(std::regex_search(s, m, std::wregex(L"A[[:lower:]]B", 1360 std::regex_constants::awk))); 1361 assert(m.size() == 1); 1362 assert(!m.prefix().matched); 1363 assert(m.prefix().first == s); 1364 assert(m.prefix().second == m[0].first); 1365 assert(!m.suffix().matched); 1366 assert(m.suffix().first == m[0].second); 1367 assert(m.suffix().second == m[0].second); 1368 assert(m.length(0) == std::char_traits<wchar_t>::length(s)); 1369 assert(m.position(0) == 0); 1370 assert(m.str(0) == s); 1371 } 1372 { 1373 std::wcmatch m; 1374 const wchar_t s[] = L"AMB"; 1375 assert(!std::regex_search(s, m, std::wregex(L"A[[:lower:]]B", 1376 std::regex_constants::awk))); 1377 assert(m.size() == 0); 1378 } 1379 { 1380 std::wcmatch m; 1381 const wchar_t s[] = L"AMB"; 1382 assert(std::regex_search(s, m, std::wregex(L"A[^[:lower:]]B", 1383 std::regex_constants::awk))); 1384 assert(m.size() == 1); 1385 assert(!m.prefix().matched); 1386 assert(m.prefix().first == s); 1387 assert(m.prefix().second == m[0].first); 1388 assert(!m.suffix().matched); 1389 assert(m.suffix().first == m[0].second); 1390 assert(m.suffix().second == m[0].second); 1391 assert(m.length(0) == std::char_traits<wchar_t>::length(s)); 1392 assert(m.position(0) == 0); 1393 assert(m.str(0) == s); 1394 } 1395 { 1396 std::wcmatch m; 1397 const wchar_t s[] = L"AmB"; 1398 assert(!std::regex_search(s, m, std::wregex(L"A[^[:lower:]]B", 1399 std::regex_constants::awk))); 1400 assert(m.size() == 0); 1401 } 1402 { 1403 std::wcmatch m; 1404 const wchar_t s[] = L"A5B"; 1405 assert(!std::regex_search(s, m, std::wregex(L"A[^[:lower:]0-9]B", 1406 std::regex_constants::awk))); 1407 assert(m.size() == 0); 1408 } 1409 { 1410 std::wcmatch m; 1411 const wchar_t s[] = L"A?B"; 1412 assert(std::regex_search(s, m, std::wregex(L"A[^[:lower:]0-9]B", 1413 std::regex_constants::awk))); 1414 assert(m.size() == 1); 1415 assert(!m.prefix().matched); 1416 assert(m.prefix().first == s); 1417 assert(m.prefix().second == m[0].first); 1418 assert(!m.suffix().matched); 1419 assert(m.suffix().first == m[0].second); 1420 assert(m.suffix().second == m[0].second); 1421 assert(m.length(0) == std::char_traits<wchar_t>::length(s)); 1422 assert(m.position(0) == 0); 1423 assert(m.str(0) == s); 1424 } 1425 { 1426 std::wcmatch m; 1427 const wchar_t s[] = L"-"; 1428 assert(std::regex_search(s, m, std::wregex(L"[a[.hyphen.]z]", 1429 std::regex_constants::awk))); 1430 assert(m.size() == 1); 1431 assert(!m.prefix().matched); 1432 assert(m.prefix().first == s); 1433 assert(m.prefix().second == m[0].first); 1434 assert(!m.suffix().matched); 1435 assert(m.suffix().first == m[0].second); 1436 assert(m.suffix().second == m[0].second); 1437 assert(m.length(0) == std::char_traits<wchar_t>::length(s)); 1438 assert(m.position(0) == 0); 1439 assert(m.str(0) == s); 1440 } 1441 { 1442 std::wcmatch m; 1443 const wchar_t s[] = L"z"; 1444 assert(std::regex_search(s, m, std::wregex(L"[a[.hyphen.]z]", 1445 std::regex_constants::awk))); 1446 assert(m.size() == 1); 1447 assert(!m.prefix().matched); 1448 assert(m.prefix().first == s); 1449 assert(m.prefix().second == m[0].first); 1450 assert(!m.suffix().matched); 1451 assert(m.suffix().first == m[0].second); 1452 assert(m.suffix().second == m[0].second); 1453 assert(m.length(0) == std::char_traits<wchar_t>::length(s)); 1454 assert(m.position(0) == 0); 1455 assert(m.str(0) == s); 1456 } 1457 { 1458 std::wcmatch m; 1459 const wchar_t s[] = L"m"; 1460 assert(!std::regex_search(s, m, std::wregex(L"[a[.hyphen.]z]", 1461 std::regex_constants::awk))); 1462 assert(m.size() == 0); 1463 } 1464 std::locale::global(std::locale(LOCALE_cs_CZ_ISO8859_2)); 1465 { 1466 std::wcmatch m; 1467 const wchar_t s[] = L"m"; 1468 assert(std::regex_search(s, m, std::wregex(L"[a[=M=]z]", 1469 std::regex_constants::awk))); 1470 assert(m.size() == 1); 1471 assert(!m.prefix().matched); 1472 assert(m.prefix().first == s); 1473 assert(m.prefix().second == m[0].first); 1474 assert(!m.suffix().matched); 1475 assert(m.suffix().first == m[0].second); 1476 assert(m.suffix().second == m[0].second); 1477 assert(m.length(0) == std::char_traits<wchar_t>::length(s)); 1478 assert(m.position(0) == 0); 1479 assert(m.str(0) == s); 1480 } 1481 { 1482 std::wcmatch m; 1483 const wchar_t s[] = L"Ch"; 1484 assert(std::regex_search(s, m, std::wregex(L"[a[.ch.]z]", 1485 std::regex_constants::awk | std::regex_constants::icase))); 1486 assert(m.size() == 1); 1487 assert(!m.prefix().matched); 1488 assert(m.prefix().first == s); 1489 assert(m.prefix().second == m[0].first); 1490 assert(!m.suffix().matched); 1491 assert(m.suffix().first == m[0].second); 1492 assert(m.suffix().second == m[0].second); 1493 assert(m.length(0) == std::char_traits<wchar_t>::length(s)); 1494 assert(m.position(0) == 0); 1495 assert(m.str(0) == s); 1496 } 1497 std::locale::global(std::locale("C")); 1498 { 1499 std::wcmatch m; 1500 const wchar_t s[] = L"m"; 1501 assert(!std::regex_search(s, m, std::wregex(L"[a[=M=]z]", 1502 std::regex_constants::awk))); 1503 assert(m.size() == 0); 1504 } 1505 { 1506 std::wcmatch m; 1507 const wchar_t s[] = L"01a45cef9"; 1508 assert(std::regex_search(s, m, std::wregex(L"[ace1-9]*", 1509 std::regex_constants::awk))); 1510 assert(m.size() == 1); 1511 assert(!m.prefix().matched); 1512 assert(m.prefix().first == s); 1513 assert(m.prefix().second == m[0].first); 1514 assert(m.suffix().matched); 1515 assert(m.suffix().first == m[0].second); 1516 assert(m.suffix().second == s + std::char_traits<wchar_t>::length(s)); 1517 assert(m.length(0) == 0); 1518 assert(m.position(0) == 0); 1519 assert(m.str(0) == L""); 1520 } 1521 { 1522 std::wcmatch m; 1523 const wchar_t s[] = L"01a45cef9"; 1524 assert(std::regex_search(s, m, std::wregex(L"[ace1-9]+", 1525 std::regex_constants::awk))); 1526 assert(m.size() == 1); 1527 assert(m.prefix().matched); 1528 assert(m.prefix().first == s); 1529 assert(m.prefix().second == m[0].first); 1530 assert(m.suffix().matched); 1531 assert(m.suffix().first == m[0].second); 1532 assert(m.suffix().second == s + std::char_traits<wchar_t>::length(s)); 1533 assert(m.length(0) == 6); 1534 assert(m.position(0) == 1); 1535 assert(m.str(0) == L"1a45ce"); 1536 } 1537 { 1538 const wchar_t r[] = L"^[-+]?[0-9]+[CF]$"; 1539 std::ptrdiff_t sr = std::char_traits<wchar_t>::length(r); 1540 typedef forward_iterator<const wchar_t*> FI; 1541 typedef bidirectional_iterator<const wchar_t*> BI; 1542 std::wregex regex(FI(r), FI(r+sr), std::regex_constants::awk); 1543 std::match_results<BI> m; 1544 const wchar_t s[] = L"-40C"; 1545 std::ptrdiff_t ss = std::char_traits<wchar_t>::length(s); 1546 assert(std::regex_search(BI(s), BI(s+ss), m, regex)); 1547 assert(m.size() == 1); 1548 assert(!m.prefix().matched); 1549 assert(m.prefix().first == BI(s)); 1550 assert(m.prefix().second == m[0].first); 1551 assert(!m.suffix().matched); 1552 assert(m.suffix().first == m[0].second); 1553 assert(m.suffix().second == m[0].second); 1554 assert(m.length(0) == 4); 1555 assert(m.position(0) == 0); 1556 assert(m.str(0) == s); 1557 } 1558 { 1559 std::wcmatch m; 1560 const wchar_t s[] = L"\n\n\n"; 1561 assert(std::regex_search(s, m, std::wregex(L"[\\n]+", 1562 std::regex_constants::awk))); 1563 assert(m.size() == 1); 1564 assert(!m.prefix().matched); 1565 assert(m.prefix().first == s); 1566 assert(m.prefix().second == m[0].first); 1567 assert(!m.suffix().matched); 1568 assert(m.suffix().first == m[0].second); 1569 assert(m.suffix().second == s + std::char_traits<wchar_t>::length(s)); 1570 assert(m.length(0) == std::char_traits<wchar_t>::length(s)); 1571 assert(m.position(0) == 0); 1572 assert(m.str(0) == s); 1573 } 1574} 1575