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