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