test/std/re/re.alg/re.alg.search/awk.pass.cpp

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