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