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