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