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