Home | History | Annotate | Download | only in re.alg.search 
      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::extended)));
     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::extended)));
     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::extended)));
     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::extended)));
     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::extended),
     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::extended)));
    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::extended)));
    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::extended)));
    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::extended)));
    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::extended)));
    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::extended)));
    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::extended)));
    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::extended)));
    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::extended)));
    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::extended)));
    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::extended)));
    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::extended)));
    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::extended)));
    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::extended)));
    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::extended)));
    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::extended)));
    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::extended)));
    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::extended)));
    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::extended)));
    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::extended)));
    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::extended)));
    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::extended)));
    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::extended)));
    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::extended)));
    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::extended)));
    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::extended)));
    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::extended)));
    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::extended | 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::extended)));
    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::extended)));
    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::extended)));
    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::extended)));
    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::extended)));
    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::extended)));
    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::extended)));
    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::extended)));
    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::extended)));
    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::extended)));
    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::extended)));
    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::extended)));
    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::extended)));
    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::extended)));
    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::extended)));
    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::extended)));
    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::extended)));
    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::extended)));
    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::extended)));
    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::extended | 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::extended)));
    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::extended)));
    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::extended)));
    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::extended);
    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     {
    793         std::wcmatch m;
    794         const wchar_t s[] = L"a";
    795         assert(std::regex_search(s, m, std::wregex(L"a", std::regex_constants::extended)));
    796         assert(m.size() == 1);
    797         assert(!m.empty());
    798         assert(!m.prefix().matched);
    799         assert(m.prefix().first == s);
    800         assert(m.prefix().second == m[0].first);
    801         assert(!m.suffix().matched);
    802         assert(m.suffix().first == m[0].second);
    803         assert(m.suffix().second == s+1);
    804         assert(m.length(0) == 1);
    805         assert(m.position(0) == 0);
    806         assert(m.str(0) == L"a");
    807     }
    808     {
    809         std::wcmatch m;
    810         const wchar_t s[] = L"ab";
    811         assert(std::regex_search(s, m, std::wregex(L"ab", std::regex_constants::extended)));
    812         assert(m.size() == 1);
    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+2);
    819         assert(m.length(0) == 2);
    820         assert(m.position(0) == 0);
    821         assert(m.str(0) == L"ab");
    822     }
    823     {
    824         std::wcmatch m;
    825         const wchar_t s[] = L"ab";
    826         assert(!std::regex_search(s, m, std::wregex(L"ba", std::regex_constants::extended)));
    827         assert(m.size() == 0);
    828         assert(m.empty());
    829     }
    830     {
    831         std::wcmatch m;
    832         const wchar_t s[] = L"aab";
    833         assert(std::regex_search(s, m, std::wregex(L"ab", std::regex_constants::extended)));
    834         assert(m.size() == 1);
    835         assert(m.prefix().matched);
    836         assert(m.prefix().first == s);
    837         assert(m.prefix().second == m[0].first);
    838         assert(!m.suffix().matched);
    839         assert(m.suffix().first == m[0].second);
    840         assert(m.suffix().second == s+3);
    841         assert(m.length(0) == 2);
    842         assert(m.position(0) == 1);
    843         assert(m.str(0) == L"ab");
    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::extended),
    849                                             std::regex_constants::match_continuous));
    850         assert(m.size() == 0);
    851     }
    852     {
    853         std::wcmatch m;
    854         const wchar_t s[] = L"abcd";
    855         assert(std::regex_search(s, m, std::wregex(L"bc", std::regex_constants::extended)));
    856         assert(m.size() == 1);
    857         assert(m.prefix().matched);
    858         assert(m.prefix().first == s);
    859         assert(m.prefix().second == m[0].first);
    860         assert(m.suffix().matched);
    861         assert(m.suffix().first == m[0].second);
    862         assert(m.suffix().second == s+4);
    863         assert(m.length(0) == 2);
    864         assert(m.position(0) == 1);
    865         assert(m.str(0) == L"bc");
    866     }
    867     {
    868         std::wcmatch m;
    869         const wchar_t s[] = L"abbc";
    870         assert(std::regex_search(s, m, std::wregex(L"ab*c", std::regex_constants::extended)));
    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) == 4);
    879         assert(m.position(0) == 0);
    880         assert(m.str(0) == s);
    881     }
    882     {
    883         std::wcmatch m;
    884         const wchar_t s[] = L"ababc";
    885         assert(std::regex_search(s, m, std::wregex(L"(ab)*c", std::regex_constants::extended)));
    886         assert(m.size() == 2);
    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+5);
    893         assert(m.length(0) == 5);
    894         assert(m.position(0) == 0);
    895         assert(m.str(0) == s);
    896         assert(m.length(1) == 2);
    897         assert(m.position(1) == 2);
    898         assert(m.str(1) == L"ab");
    899     }
    900     {
    901         std::wcmatch m;
    902         const wchar_t s[] = L"abcdefghijk";
    903         assert(std::regex_search(s, m, std::wregex(L"cd((e)fg)hi",
    904                                  std::regex_constants::extended)));
    905         assert(m.size() == 3);
    906         assert(m.prefix().matched);
    907         assert(m.prefix().first == s);
    908         assert(m.prefix().second == m[0].first);
    909         assert(m.suffix().matched);
    910         assert(m.suffix().first == m[0].second);
    911         assert(m.suffix().second == s+std::regex_traits<wchar_t>::length(s));
    912         assert(m.length(0) == 7);
    913         assert(m.position(0) == 2);
    914         assert(m.str(0) == L"cdefghi");
    915         assert(m.length(1) == 3);
    916         assert(m.position(1) == 4);
    917         assert(m.str(1) == L"efg");
    918         assert(m.length(2) == 1);
    919         assert(m.position(2) == 4);
    920         assert(m.str(2) == L"e");
    921     }
    922     {
    923         std::wcmatch m;
    924         const wchar_t s[] = L"abc";
    925         assert(std::regex_search(s, m, std::wregex(L"^abc", std::regex_constants::extended)));
    926         assert(m.size() == 1);
    927         assert(!m.prefix().matched);
    928         assert(m.prefix().first == s);
    929         assert(m.prefix().second == m[0].first);
    930         assert(!m.suffix().matched);
    931         assert(m.suffix().first == m[0].second);
    932         assert(m.suffix().second == s+3);
    933         assert(m.length(0) == 3);
    934         assert(m.position(0) == 0);
    935         assert(m.str(0) == s);
    936     }
    937     {
    938         std::wcmatch m;
    939         const wchar_t s[] = L"abcd";
    940         assert(std::regex_search(s, m, std::wregex(L"^abc", std::regex_constants::extended)));
    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+4);
    948         assert(m.length(0) == 3);
    949         assert(m.position(0) == 0);
    950         assert(m.str(0) == L"abc");
    951     }
    952     {
    953         std::wcmatch m;
    954         const wchar_t s[] = L"aabc";
    955         assert(!std::regex_search(s, m, std::wregex(L"^abc", std::regex_constants::extended)));
    956         assert(m.size() == 0);
    957     }
    958     {
    959         std::wcmatch m;
    960         const wchar_t s[] = L"abc";
    961         assert(std::regex_search(s, m, std::wregex(L"abc$", std::regex_constants::extended)));
    962         assert(m.size() == 1);
    963         assert(!m.prefix().matched);
    964         assert(m.prefix().first == s);
    965         assert(m.prefix().second == m[0].first);
    966         assert(!m.suffix().matched);
    967         assert(m.suffix().first == m[0].second);
    968         assert(m.suffix().second == s+3);
    969         assert(m.length(0) == 3);
    970         assert(m.position(0) == 0);
    971         assert(m.str(0) == s);
    972     }
    973     {
    974         std::wcmatch m;
    975         const wchar_t s[] = L"efabc";
    976         assert(std::regex_search(s, m, std::wregex(L"abc$", std::regex_constants::extended)));
    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+5);
    984         assert(m.length(0) == 3);
    985         assert(m.position(0) == 2);
    986         assert(m.str(0) == s+2);
    987     }
    988     {
    989         std::wcmatch m;
    990         const wchar_t s[] = L"efabcg";
    991         assert(!std::regex_search(s, m, std::wregex(L"abc$", std::regex_constants::extended)));
    992         assert(m.size() == 0);
    993     }
    994     {
    995         std::wcmatch m;
    996         const wchar_t s[] = L"abc";
    997         assert(std::regex_search(s, m, std::wregex(L"a.c", std::regex_constants::extended)));
    998         assert(m.size() == 1);
    999         assert(!m.prefix().matched);
   1000         assert(m.prefix().first == s);
   1001         assert(m.prefix().second == m[0].first);
   1002         assert(!m.suffix().matched);
   1003         assert(m.suffix().first == m[0].second);
   1004         assert(m.suffix().second == s+3);
   1005         assert(m.length(0) == 3);
   1006         assert(m.position(0) == 0);
   1007         assert(m.str(0) == s);
   1008     }
   1009     {
   1010         std::wcmatch m;
   1011         const wchar_t s[] = L"acc";
   1012         assert(std::regex_search(s, m, std::wregex(L"a.c", std::regex_constants::extended)));
   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::extended)));
   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"abcdef";
   1042         assert(std::regex_search(s, m, std::wregex(L"(.*).*", std::regex_constants::extended)));
   1043         assert(m.size() == 2);
   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+6);
   1050         assert(m.length(0) == 6);
   1051         assert(m.position(0) == 0);
   1052         assert(m.str(0) == s);
   1053         assert(m.length(1) == 6);
   1054         assert(m.position(1) == 0);
   1055         assert(m.str(1) == s);
   1056     }
   1057     {
   1058         std::wcmatch m;
   1059         const wchar_t s[] = L"bc";
   1060         assert(std::regex_search(s, m, std::wregex(L"(a*)*", std::regex_constants::extended)));
   1061         assert(m.size() == 2);
   1062         assert(!m.prefix().matched);
   1063         assert(m.prefix().first == s);
   1064         assert(m.prefix().second == m[0].first);
   1065         assert(m.suffix().matched);
   1066         assert(m.suffix().first == m[0].second);
   1067         assert(m.suffix().second == s+2);
   1068         assert(m.length(0) == 0);
   1069         assert(m.position(0) == 0);
   1070         assert(m.str(0) == L"");
   1071         assert(m.length(1) == 0);
   1072         assert(m.position(1) == 0);
   1073         assert(m.str(1) == L"");
   1074     }
   1075     {
   1076         std::wcmatch m;
   1077         const wchar_t s[] = L"abbc";
   1078         assert(!std::regex_search(s, m, std::wregex(L"ab{3,5}c", std::regex_constants::extended)));
   1079         assert(m.size() == 0);
   1080     }
   1081     {
   1082         std::wcmatch m;
   1083         const wchar_t s[] = L"abbbc";
   1084         assert(std::regex_search(s, m, std::wregex(L"ab{3,5}c", std::regex_constants::extended)));
   1085         assert(m.size() == 1);
   1086         assert(!m.prefix().matched);
   1087         assert(m.prefix().first == s);
   1088         assert(m.prefix().second == m[0].first);
   1089         assert(!m.suffix().matched);
   1090         assert(m.suffix().first == m[0].second);
   1091         assert(m.suffix().second == m[0].second);
   1092         assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<wchar_t>::length(s));
   1093         assert(m.position(0) == 0);
   1094         assert(m.str(0) == s);
   1095     }
   1096     {
   1097         std::wcmatch m;
   1098         const wchar_t s[] = L"abbbbc";
   1099         assert(std::regex_search(s, m, std::wregex(L"ab{3,5}c", std::regex_constants::extended)));
   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"abbbbbc";
   1114         assert(std::regex_search(s, m, std::wregex(L"ab{3,5}c", std::regex_constants::extended)));
   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"adefc";
   1129         assert(!std::regex_search(s, m, std::wregex(L"ab{3,5}c", std::regex_constants::extended)));
   1130         assert(m.size() == 0);
   1131     }
   1132     {
   1133         std::wcmatch m;
   1134         const wchar_t s[] = L"abbbbbbc";
   1135         assert(!std::regex_search(s, m, std::wregex(L"ab{3,5}c", std::regex_constants::extended)));
   1136         assert(m.size() == 0);
   1137     }
   1138     {
   1139         std::wcmatch m;
   1140         const wchar_t s[] = L"adec";
   1141         assert(!std::regex_search(s, m, std::wregex(L"a.{3,5}c", std::regex_constants::extended)));
   1142         assert(m.size() == 0);
   1143     }
   1144     {
   1145         std::wcmatch m;
   1146         const wchar_t s[] = L"adefc";
   1147         assert(std::regex_search(s, m, std::wregex(L"a.{3,5}c", std::regex_constants::extended)));
   1148         assert(m.size() == 1);
   1149         assert(!m.prefix().matched);
   1150         assert(m.prefix().first == s);
   1151         assert(m.prefix().second == m[0].first);
   1152         assert(!m.suffix().matched);
   1153         assert(m.suffix().first == m[0].second);
   1154         assert(m.suffix().second == m[0].second);
   1155         assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<wchar_t>::length(s));
   1156         assert(m.position(0) == 0);
   1157         assert(m.str(0) == s);
   1158     }
   1159     {
   1160         std::wcmatch m;
   1161         const wchar_t s[] = L"adefgc";
   1162         assert(std::regex_search(s, m, std::wregex(L"a.{3,5}c", std::regex_constants::extended)));
   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"adefghc";
   1177         assert(std::regex_search(s, m, std::wregex(L"a.{3,5}c", std::regex_constants::extended)));
   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"adefghic";
   1192         assert(!std::regex_search(s, m, std::wregex(L"a.{3,5}c", std::regex_constants::extended)));
   1193         assert(m.size() == 0);
   1194     }
   1195     {
   1196         std::wcmatch m;
   1197         const wchar_t s[] = L"tournament";
   1198         assert(std::regex_search(s, m, std::wregex(L"tour|to|tournament",
   1199                                               std::regex_constants::extended)));
   1200         assert(m.size() == 1);
   1201         assert(!m.prefix().matched);
   1202         assert(m.prefix().first == s);
   1203         assert(m.prefix().second == m[0].first);
   1204         assert(!m.suffix().matched);
   1205         assert(m.suffix().first == m[0].second);
   1206         assert(m.suffix().second == m[0].second);
   1207         assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<wchar_t>::length(s));
   1208         assert(m.position(0) == 0);
   1209         assert(m.str(0) == s);
   1210     }
   1211     {
   1212         std::wcmatch m;
   1213         const wchar_t s[] = L"tournamenttotour";
   1214         assert(std::regex_search(s, m, std::wregex(L"(tour|to|tournament)+",
   1215                std::regex_constants::extended | std::regex_constants::nosubs)));
   1216         assert(m.size() == 1);
   1217         assert(!m.prefix().matched);
   1218         assert(m.prefix().first == s);
   1219         assert(m.prefix().second == m[0].first);
   1220         assert(!m.suffix().matched);
   1221         assert(m.suffix().first == m[0].second);
   1222         assert(m.suffix().second == m[0].second);
   1223         assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<wchar_t>::length(s));
   1224         assert(m.position(0) == 0);
   1225         assert(m.str(0) == s);
   1226     }
   1227     {
   1228         std::wcmatch m;
   1229         const wchar_t s[] = L"ttotour";
   1230         assert(std::regex_search(s, m, std::wregex(L"(tour|to|t)+",
   1231                                               std::regex_constants::extended)));
   1232         assert(m.size() == 2);
   1233         assert(!m.prefix().matched);
   1234         assert(m.prefix().first == s);
   1235         assert(m.prefix().second == m[0].first);
   1236         assert(!m.suffix().matched);
   1237         assert(m.suffix().first == m[0].second);
   1238         assert(m.suffix().second == m[0].second);
   1239         assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<wchar_t>::length(s));
   1240         assert(m.position(0) == 0);
   1241         assert(m.str(0) == s);
   1242         assert(m.length(1) == 4);
   1243         assert(m.position(1) == 3);
   1244         assert(m.str(1) == L"tour");
   1245     }
   1246     {
   1247         std::wcmatch m;
   1248         const wchar_t s[] = L"-ab,ab-";
   1249         assert(!std::regex_search(s, m, std::wregex(L"-(.*),\1-", std::regex_constants::extended)));
   1250         assert(m.size() == 0);
   1251     }
   1252     {
   1253         std::wcmatch m;
   1254         const wchar_t s[] = L"-ab,ab-";
   1255         assert(std::regex_search(s, m, std::wregex(L"-.*,.*-", std::regex_constants::extended)));
   1256         assert(m.size() == 1);
   1257         assert(!m.prefix().matched);
   1258         assert(m.prefix().first == s);
   1259         assert(m.prefix().second == m[0].first);
   1260         assert(!m.suffix().matched);
   1261         assert(m.suffix().first == m[0].second);
   1262         assert(m.suffix().second == m[0].second);
   1263         assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<wchar_t>::length(s));
   1264         assert(m.position(0) == 0);
   1265         assert(m.str(0) == s);
   1266     }
   1267     {
   1268         std::wcmatch m;
   1269         const wchar_t s[] = L"a";
   1270         assert(std::regex_search(s, m, std::wregex(L"^[a]$",
   1271                                                  std::regex_constants::extended)));
   1272         assert(m.size() == 1);
   1273         assert(!m.prefix().matched);
   1274         assert(m.prefix().first == s);
   1275         assert(m.prefix().second == m[0].first);
   1276         assert(!m.suffix().matched);
   1277         assert(m.suffix().first == m[0].second);
   1278         assert(m.suffix().second == m[0].second);
   1279         assert(m.length(0) == 1);
   1280         assert(m.position(0) == 0);
   1281         assert(m.str(0) == L"a");
   1282     }
   1283     {
   1284         std::wcmatch m;
   1285         const wchar_t s[] = L"a";
   1286         assert(std::regex_search(s, m, std::wregex(L"^[ab]$",
   1287                                                  std::regex_constants::extended)));
   1288         assert(m.size() == 1);
   1289         assert(!m.prefix().matched);
   1290         assert(m.prefix().first == s);
   1291         assert(m.prefix().second == m[0].first);
   1292         assert(!m.suffix().matched);
   1293         assert(m.suffix().first == m[0].second);
   1294         assert(m.suffix().second == m[0].second);
   1295         assert(m.length(0) == 1);
   1296         assert(m.position(0) == 0);
   1297         assert(m.str(0) == L"a");
   1298     }
   1299     {
   1300         std::wcmatch m;
   1301         const wchar_t s[] = L"c";
   1302         assert(std::regex_search(s, m, std::wregex(L"^[a-f]$",
   1303                                                  std::regex_constants::extended)));
   1304         assert(m.size() == 1);
   1305         assert(!m.prefix().matched);
   1306         assert(m.prefix().first == s);
   1307         assert(m.prefix().second == m[0].first);
   1308         assert(!m.suffix().matched);
   1309         assert(m.suffix().first == m[0].second);
   1310         assert(m.suffix().second == m[0].second);
   1311         assert(m.length(0) == 1);
   1312         assert(m.position(0) == 0);
   1313         assert(m.str(0) == s);
   1314     }
   1315     {
   1316         std::wcmatch m;
   1317         const wchar_t s[] = L"g";
   1318         assert(!std::regex_search(s, m, std::wregex(L"^[a-f]$",
   1319                                                  std::regex_constants::extended)));
   1320         assert(m.size() == 0);
   1321     }
   1322     {
   1323         std::wcmatch m;
   1324         const wchar_t s[] = L"Iraqi";
   1325         assert(std::regex_search(s, m, std::wregex(L"q[^u]",
   1326                                                  std::regex_constants::extended)));
   1327         assert(m.size() == 1);
   1328         assert(m.prefix().matched);
   1329         assert(m.prefix().first == s);
   1330         assert(m.prefix().second == m[0].first);
   1331         assert(!m.suffix().matched);
   1332         assert(m.suffix().first == m[0].second);
   1333         assert(m.suffix().second == m[0].second);
   1334         assert(m.length(0) == 2);
   1335         assert(m.position(0) == 3);
   1336         assert(m.str(0) == L"qi");
   1337     }
   1338     {
   1339         std::wcmatch m;
   1340         const wchar_t s[] = L"Iraq";
   1341         assert(!std::regex_search(s, m, std::wregex(L"q[^u]",
   1342                                                  std::regex_constants::extended)));
   1343         assert(m.size() == 0);
   1344     }
   1345     {
   1346         std::wcmatch m;
   1347         const wchar_t s[] = L"AmB";
   1348         assert(std::regex_search(s, m, std::wregex(L"A[[:lower:]]B",
   1349                                                  std::regex_constants::extended)));
   1350         assert(m.size() == 1);
   1351         assert(!m.prefix().matched);
   1352         assert(m.prefix().first == s);
   1353         assert(m.prefix().second == m[0].first);
   1354         assert(!m.suffix().matched);
   1355         assert(m.suffix().first == m[0].second);
   1356         assert(m.suffix().second == m[0].second);
   1357         assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<wchar_t>::length(s));
   1358         assert(m.position(0) == 0);
   1359         assert(m.str(0) == s);
   1360     }
   1361     {
   1362         std::wcmatch m;
   1363         const wchar_t s[] = L"AMB";
   1364         assert(!std::regex_search(s, m, std::wregex(L"A[[:lower:]]B",
   1365                                                  std::regex_constants::extended)));
   1366         assert(m.size() == 0);
   1367     }
   1368     {
   1369         std::wcmatch m;
   1370         const wchar_t s[] = L"AMB";
   1371         assert(std::regex_search(s, m, std::wregex(L"A[^[:lower:]]B",
   1372                                                  std::regex_constants::extended)));
   1373         assert(m.size() == 1);
   1374         assert(!m.prefix().matched);
   1375         assert(m.prefix().first == s);
   1376         assert(m.prefix().second == m[0].first);
   1377         assert(!m.suffix().matched);
   1378         assert(m.suffix().first == m[0].second);
   1379         assert(m.suffix().second == m[0].second);
   1380         assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<wchar_t>::length(s));
   1381         assert(m.position(0) == 0);
   1382         assert(m.str(0) == s);
   1383     }
   1384     {
   1385         std::wcmatch m;
   1386         const wchar_t s[] = L"AmB";
   1387         assert(!std::regex_search(s, m, std::wregex(L"A[^[:lower:]]B",
   1388                                                  std::regex_constants::extended)));
   1389         assert(m.size() == 0);
   1390     }
   1391     {
   1392         std::wcmatch m;
   1393         const wchar_t s[] = L"A5B";
   1394         assert(!std::regex_search(s, m, std::wregex(L"A[^[:lower:]0-9]B",
   1395                                                  std::regex_constants::extended)));
   1396         assert(m.size() == 0);
   1397     }
   1398     {
   1399         std::wcmatch m;
   1400         const wchar_t s[] = L"A?B";
   1401         assert(std::regex_search(s, m, std::wregex(L"A[^[:lower:]0-9]B",
   1402                                                  std::regex_constants::extended)));
   1403         assert(m.size() == 1);
   1404         assert(!m.prefix().matched);
   1405         assert(m.prefix().first == s);
   1406         assert(m.prefix().second == m[0].first);
   1407         assert(!m.suffix().matched);
   1408         assert(m.suffix().first == m[0].second);
   1409         assert(m.suffix().second == m[0].second);
   1410         assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<wchar_t>::length(s));
   1411         assert(m.position(0) == 0);
   1412         assert(m.str(0) == s);
   1413     }
   1414     {
   1415         std::wcmatch m;
   1416         const wchar_t s[] = L"-";
   1417         assert(std::regex_search(s, m, std::wregex(L"[a[.hyphen.]z]",
   1418                                                  std::regex_constants::extended)));
   1419         assert(m.size() == 1);
   1420         assert(!m.prefix().matched);
   1421         assert(m.prefix().first == s);
   1422         assert(m.prefix().second == m[0].first);
   1423         assert(!m.suffix().matched);
   1424         assert(m.suffix().first == m[0].second);
   1425         assert(m.suffix().second == m[0].second);
   1426         assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<wchar_t>::length(s));
   1427         assert(m.position(0) == 0);
   1428         assert(m.str(0) == s);
   1429     }
   1430     {
   1431         std::wcmatch m;
   1432         const wchar_t s[] = L"z";
   1433         assert(std::regex_search(s, m, std::wregex(L"[a[.hyphen.]z]",
   1434                                                  std::regex_constants::extended)));
   1435         assert(m.size() == 1);
   1436         assert(!m.prefix().matched);
   1437         assert(m.prefix().first == s);
   1438         assert(m.prefix().second == m[0].first);
   1439         assert(!m.suffix().matched);
   1440         assert(m.suffix().first == m[0].second);
   1441         assert(m.suffix().second == m[0].second);
   1442         assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<wchar_t>::length(s));
   1443         assert(m.position(0) == 0);
   1444         assert(m.str(0) == s);
   1445     }
   1446     {
   1447         std::wcmatch m;
   1448         const wchar_t s[] = L"m";
   1449         assert(!std::regex_search(s, m, std::wregex(L"[a[.hyphen.]z]",
   1450                                                  std::regex_constants::extended)));
   1451         assert(m.size() == 0);
   1452     }
   1453     std::locale::global(std::locale(LOCALE_cs_CZ_ISO8859_2));
   1454     {
   1455         std::wcmatch m;
   1456         const wchar_t s[] = L"m";
   1457         assert(std::regex_search(s, m, std::wregex(L"[a[=M=]z]",
   1458                                                  std::regex_constants::extended)));
   1459         assert(m.size() == 1);
   1460         assert(!m.prefix().matched);
   1461         assert(m.prefix().first == s);
   1462         assert(m.prefix().second == m[0].first);
   1463         assert(!m.suffix().matched);
   1464         assert(m.suffix().first == m[0].second);
   1465         assert(m.suffix().second == m[0].second);
   1466         assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<wchar_t>::length(s));
   1467         assert(m.position(0) == 0);
   1468         assert(m.str(0) == s);
   1469     }
   1470     {
   1471         std::wcmatch m;
   1472         const wchar_t s[] = L"Ch";
   1473         assert(std::regex_search(s, m, std::wregex(L"[a[.ch.]z]",
   1474                    std::regex_constants::extended | std::regex_constants::icase)));
   1475         assert(m.size() == 1);
   1476         assert(!m.prefix().matched);
   1477         assert(m.prefix().first == s);
   1478         assert(m.prefix().second == m[0].first);
   1479         assert(!m.suffix().matched);
   1480         assert(m.suffix().first == m[0].second);
   1481         assert(m.suffix().second == m[0].second);
   1482         assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<wchar_t>::length(s));
   1483         assert(m.position(0) == 0);
   1484         assert(m.str(0) == s);
   1485     }
   1486     std::locale::global(std::locale("C"));
   1487     {
   1488         std::wcmatch m;
   1489         const wchar_t s[] = L"m";
   1490         assert(!std::regex_search(s, m, std::wregex(L"[a[=M=]z]",
   1491                                                  std::regex_constants::extended)));
   1492         assert(m.size() == 0);
   1493     }
   1494     {
   1495         std::wcmatch m;
   1496         const wchar_t s[] = L"01a45cef9";
   1497         assert(std::regex_search(s, m, std::wregex(L"[ace1-9]*",
   1498                                                  std::regex_constants::extended)));
   1499         assert(m.size() == 1);
   1500         assert(!m.prefix().matched);
   1501         assert(m.prefix().first == s);
   1502         assert(m.prefix().second == m[0].first);
   1503         assert(m.suffix().matched);
   1504         assert(m.suffix().first == m[0].second);
   1505         assert(m.suffix().second == s + std::char_traits<wchar_t>::length(s));
   1506         assert(m.length(0) == 0);
   1507         assert(m.position(0) == 0);
   1508         assert(m.str(0) == L"");
   1509     }
   1510     {
   1511         std::wcmatch m;
   1512         const wchar_t s[] = L"01a45cef9";
   1513         assert(std::regex_search(s, m, std::wregex(L"[ace1-9]+",
   1514                                                  std::regex_constants::extended)));
   1515         assert(m.size() == 1);
   1516         assert(m.prefix().matched);
   1517         assert(m.prefix().first == s);
   1518         assert(m.prefix().second == m[0].first);
   1519         assert(m.suffix().matched);
   1520         assert(m.suffix().first == m[0].second);
   1521         assert(m.suffix().second == s + std::char_traits<wchar_t>::length(s));
   1522         assert(m.length(0) == 6);
   1523         assert(m.position(0) == 1);
   1524         assert(m.str(0) == L"1a45ce");
   1525     }
   1526     {
   1527         const wchar_t r[] = L"^[-+]?[0-9]+[CF]$";
   1528         std::ptrdiff_t sr = std::char_traits<wchar_t>::length(r);
   1529         typedef forward_iterator<const wchar_t*> FI;
   1530         typedef bidirectional_iterator<const wchar_t*> BI;
   1531         std::wregex regex(FI(r), FI(r+sr), std::regex_constants::extended);
   1532         std::match_results<BI> m;
   1533         const wchar_t s[] = L"-40C";
   1534         std::ptrdiff_t ss = std::char_traits<wchar_t>::length(s);
   1535         assert(std::regex_search(BI(s), BI(s+ss), m, regex));
   1536         assert(m.size() == 1);
   1537         assert(!m.prefix().matched);
   1538         assert(m.prefix().first == BI(s));
   1539         assert(m.prefix().second == m[0].first);
   1540         assert(!m.suffix().matched);
   1541         assert(m.suffix().first == m[0].second);
   1542         assert(m.suffix().second == m[0].second);
   1543         assert(m.length(0) == 4);
   1544         assert(m.position(0) == 0);
   1545         assert(m.str(0) == s);
   1546     }
   1547 }
   1548