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