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_macros.h"
     27 #include "test_iterators.h"
     28 
     29 #include "platform_support.h" // locale name macros
     30 
     31 int main()
     32 {
     33     {
     34         std::cmatch m;
     35         assert(!std::regex_search("a", m, std::regex()));
     36         assert(m.size() == 0);
     37         assert(m.empty());
     38     }
     39     {
     40         std::cmatch m;
     41         const char s[] = "a";
     42         assert(std::regex_search(s, m, std::regex("a", std::regex_constants::basic)));
     43         assert(m.size() == 1);
     44         assert(!m.empty());
     45         assert(!m.prefix().matched);
     46         assert(m.prefix().first == s);
     47         assert(m.prefix().second == m[0].first);
     48         assert(!m.suffix().matched);
     49         assert(m.suffix().first == m[0].second);
     50         assert(m.suffix().second == s+1);
     51         assert(m.length(0) == 1);
     52         assert(m.position(0) == 0);
     53         assert(m.str(0) == "a");
     54     }
     55     {
     56         std::cmatch m;
     57         const char s[] = "ab";
     58         assert(std::regex_search(s, m, std::regex("ab", std::regex_constants::basic)));
     59         assert(m.size() == 1);
     60         assert(!m.prefix().matched);
     61         assert(m.prefix().first == s);
     62         assert(m.prefix().second == m[0].first);
     63         assert(!m.suffix().matched);
     64         assert(m.suffix().first == m[0].second);
     65         assert(m.suffix().second == s+2);
     66         assert(m.length(0) == 2);
     67         assert(m.position(0) == 0);
     68         assert(m.str(0) == "ab");
     69     }
     70     {
     71         std::cmatch m;
     72         const char s[] = "ab";
     73         assert(!std::regex_search(s, m, std::regex("ba", std::regex_constants::basic)));
     74         assert(m.size() == 0);
     75         assert(m.empty());
     76     }
     77     {
     78         std::cmatch m;
     79         const char s[] = "aab";
     80         assert(std::regex_search(s, m, std::regex("ab", std::regex_constants::basic)));
     81         assert(m.size() == 1);
     82         assert(m.prefix().matched);
     83         assert(m.prefix().first == s);
     84         assert(m.prefix().second == m[0].first);
     85         assert(!m.suffix().matched);
     86         assert(m.suffix().first == m[0].second);
     87         assert(m.suffix().second == s+3);
     88         assert(m.length(0) == 2);
     89         assert(m.position(0) == 1);
     90         assert(m.str(0) == "ab");
     91     }
     92     {
     93         std::cmatch m;
     94         const char s[] = "aab";
     95         assert(!std::regex_search(s, m, std::regex("ab", std::regex_constants::basic),
     96                                             std::regex_constants::match_continuous));
     97         assert(m.size() == 0);
     98     }
     99     {
    100         std::cmatch m;
    101         const char s[] = "abcd";
    102         assert(std::regex_search(s, m, std::regex("bc", std::regex_constants::basic)));
    103         assert(m.size() == 1);
    104         assert(m.prefix().matched);
    105         assert(m.prefix().first == s);
    106         assert(m.prefix().second == m[0].first);
    107         assert(m.suffix().matched);
    108         assert(m.suffix().first == m[0].second);
    109         assert(m.suffix().second == s+4);
    110         assert(m.length(0) == 2);
    111         assert(m.position(0) == 1);
    112         assert(m.str(0) == "bc");
    113     }
    114     {
    115         std::cmatch m;
    116         const char s[] = "abbc";
    117         assert(std::regex_search(s, m, std::regex("ab*c", std::regex_constants::basic)));
    118         assert(m.size() == 1);
    119         assert(!m.prefix().matched);
    120         assert(m.prefix().first == s);
    121         assert(m.prefix().second == m[0].first);
    122         assert(!m.suffix().matched);
    123         assert(m.suffix().first == m[0].second);
    124         assert(m.suffix().second == s+4);
    125         assert(m.length(0) == 4);
    126         assert(m.position(0) == 0);
    127         assert(m.str(0) == s);
    128     }
    129     {
    130         std::cmatch m;
    131         const char s[] = "ababc";
    132         assert(std::regex_search(s, m, std::regex("\\(ab\\)*c", std::regex_constants::basic)));
    133         assert(m.size() == 2);
    134         assert(!m.prefix().matched);
    135         assert(m.prefix().first == s);
    136         assert(m.prefix().second == m[0].first);
    137         assert(!m.suffix().matched);
    138         assert(m.suffix().first == m[0].second);
    139         assert(m.suffix().second == s+5);
    140         assert(m.length(0) == 5);
    141         assert(m.position(0) == 0);
    142         assert(m.str(0) == s);
    143         assert(m.length(1) == 2);
    144         assert(m.position(1) == 2);
    145         assert(m.str(1) == "ab");
    146     }
    147     {
    148         std::cmatch m;
    149         const char s[] = "abcdefghijk";
    150         assert(std::regex_search(s, m, std::regex("cd\\(\\(e\\)fg\\)hi",
    151                                  std::regex_constants::basic)));
    152         assert(m.size() == 3);
    153         assert(m.prefix().matched);
    154         assert(m.prefix().first == s);
    155         assert(m.prefix().second == m[0].first);
    156         assert(m.suffix().matched);
    157         assert(m.suffix().first == m[0].second);
    158         assert(m.suffix().second == s+std::regex_traits<char>::length(s));
    159         assert(m.length(0) == 7);
    160         assert(m.position(0) == 2);
    161         assert(m.str(0) == "cdefghi");
    162         assert(m.length(1) == 3);
    163         assert(m.position(1) == 4);
    164         assert(m.str(1) == "efg");
    165         assert(m.length(2) == 1);
    166         assert(m.position(2) == 4);
    167         assert(m.str(2) == "e");
    168     }
    169     {
    170         std::cmatch m;
    171         const char s[] = "abc";
    172         assert(std::regex_search(s, m, std::regex("^abc", std::regex_constants::basic)));
    173         assert(m.size() == 1);
    174         assert(!m.prefix().matched);
    175         assert(m.prefix().first == s);
    176         assert(m.prefix().second == m[0].first);
    177         assert(!m.suffix().matched);
    178         assert(m.suffix().first == m[0].second);
    179         assert(m.suffix().second == s+3);
    180         assert(m.length(0) == 3);
    181         assert(m.position(0) == 0);
    182         assert(m.str(0) == s);
    183     }
    184     {
    185         std::cmatch m;
    186         const char s[] = "abcd";
    187         assert(std::regex_search(s, m, std::regex("^abc", std::regex_constants::basic)));
    188         assert(m.size() == 1);
    189         assert(!m.prefix().matched);
    190         assert(m.prefix().first == s);
    191         assert(m.prefix().second == m[0].first);
    192         assert(m.suffix().matched);
    193         assert(m.suffix().first == m[0].second);
    194         assert(m.suffix().second == s+4);
    195         assert(m.length(0) == 3);
    196         assert(m.position(0) == 0);
    197         assert(m.str(0) == "abc");
    198     }
    199     {
    200         std::cmatch m;
    201         const char s[] = "aabc";
    202         assert(!std::regex_search(s, m, std::regex("^abc", std::regex_constants::basic)));
    203         assert(m.size() == 0);
    204     }
    205     {
    206         std::cmatch m;
    207         const char s[] = "abc";
    208         assert(std::regex_search(s, m, std::regex("abc$", std::regex_constants::basic)));
    209         assert(m.size() == 1);
    210         assert(!m.prefix().matched);
    211         assert(m.prefix().first == s);
    212         assert(m.prefix().second == m[0].first);
    213         assert(!m.suffix().matched);
    214         assert(m.suffix().first == m[0].second);
    215         assert(m.suffix().second == s+3);
    216         assert(m.length(0) == 3);
    217         assert(m.position(0) == 0);
    218         assert(m.str(0) == s);
    219     }
    220     {
    221         std::cmatch m;
    222         const char s[] = "efabc";
    223         assert(std::regex_search(s, m, std::regex("abc$", std::regex_constants::basic)));
    224         assert(m.size() == 1);
    225         assert(m.prefix().matched);
    226         assert(m.prefix().first == s);
    227         assert(m.prefix().second == m[0].first);
    228         assert(!m.suffix().matched);
    229         assert(m.suffix().first == m[0].second);
    230         assert(m.suffix().second == s+5);
    231         assert(m.length(0) == 3);
    232         assert(m.position(0) == 2);
    233         assert(m.str(0) == s+2);
    234     }
    235     {
    236         std::cmatch m;
    237         const char s[] = "efabcg";
    238         assert(!std::regex_search(s, m, std::regex("abc$", std::regex_constants::basic)));
    239         assert(m.size() == 0);
    240     }
    241     {
    242         std::cmatch m;
    243         const char s[] = "abc";
    244         assert(std::regex_search(s, m, std::regex("a.c", std::regex_constants::basic)));
    245         assert(m.size() == 1);
    246         assert(!m.prefix().matched);
    247         assert(m.prefix().first == s);
    248         assert(m.prefix().second == m[0].first);
    249         assert(!m.suffix().matched);
    250         assert(m.suffix().first == m[0].second);
    251         assert(m.suffix().second == s+3);
    252         assert(m.length(0) == 3);
    253         assert(m.position(0) == 0);
    254         assert(m.str(0) == s);
    255     }
    256     {
    257         std::cmatch m;
    258         const char s[] = "acc";
    259         assert(std::regex_search(s, m, std::regex("a.c", std::regex_constants::basic)));
    260         assert(m.size() == 1);
    261         assert(!m.prefix().matched);
    262         assert(m.prefix().first == s);
    263         assert(m.prefix().second == m[0].first);
    264         assert(!m.suffix().matched);
    265         assert(m.suffix().first == m[0].second);
    266         assert(m.suffix().second == s+3);
    267         assert(m.length(0) == 3);
    268         assert(m.position(0) == 0);
    269         assert(m.str(0) == s);
    270     }
    271     {
    272         std::cmatch m;
    273         const char s[] = "acc";
    274         assert(std::regex_search(s, m, std::regex("a.c", std::regex_constants::basic)));
    275         assert(m.size() == 1);
    276         assert(!m.prefix().matched);
    277         assert(m.prefix().first == s);
    278         assert(m.prefix().second == m[0].first);
    279         assert(!m.suffix().matched);
    280         assert(m.suffix().first == m[0].second);
    281         assert(m.suffix().second == s+3);
    282         assert(m.length(0) == 3);
    283         assert(m.position(0) == 0);
    284         assert(m.str(0) == s);
    285     }
    286     {
    287         std::cmatch m;
    288         const char s[] = "abcdef";
    289         assert(std::regex_search(s, m, std::regex("\\(.*\\).*", std::regex_constants::basic)));
    290         assert(m.size() == 2);
    291         assert(!m.prefix().matched);
    292         assert(m.prefix().first == s);
    293         assert(m.prefix().second == m[0].first);
    294         assert(!m.suffix().matched);
    295         assert(m.suffix().first == m[0].second);
    296         assert(m.suffix().second == s+6);
    297         assert(m.length(0) == 6);
    298         assert(m.position(0) == 0);
    299         assert(m.str(0) == s);
    300         assert(m.length(1) == 6);
    301         assert(m.position(1) == 0);
    302         assert(m.str(1) == s);
    303     }
    304     {
    305         std::cmatch m;
    306         const char s[] = "bc";
    307         assert(std::regex_search(s, m, std::regex("\\(a*\\)*", std::regex_constants::basic)));
    308         assert(m.size() == 2);
    309         assert(!m.prefix().matched);
    310         assert(m.prefix().first == s);
    311         assert(m.prefix().second == m[0].first);
    312         assert(m.suffix().matched);
    313         assert(m.suffix().first == m[0].second);
    314         assert(m.suffix().second == s+2);
    315         assert(m.length(0) == 0);
    316         assert(m.position(0) == 0);
    317         assert(m.str(0) == "");
    318         assert(m.length(1) == 0);
    319         assert(m.position(1) == 0);
    320         assert(m.str(1) == "");
    321     }
    322     {
    323         std::cmatch m;
    324         const char s[] = "abbc";
    325         assert(!std::regex_search(s, m, std::regex("ab\\{3,5\\}c", std::regex_constants::basic)));
    326         assert(m.size() == 0);
    327     }
    328     {
    329         std::cmatch m;
    330         const char s[] = "abbbc";
    331         assert(std::regex_search(s, m, std::regex("ab\\{3,5\\}c", std::regex_constants::basic)));
    332         assert(m.size() == 1);
    333         assert(!m.prefix().matched);
    334         assert(m.prefix().first == s);
    335         assert(m.prefix().second == m[0].first);
    336         assert(!m.suffix().matched);
    337         assert(m.suffix().first == m[0].second);
    338         assert(m.suffix().second == m[0].second);
    339         assert(m.length(0) == sizeof(s)-1);
    340         assert(m.position(0) == 0);
    341         assert(m.str(0) == s);
    342     }
    343     {
    344         std::cmatch m;
    345         const char s[] = "abbbbc";
    346         assert(std::regex_search(s, m, std::regex("ab\\{3,5\\}c", std::regex_constants::basic)));
    347         assert(m.size() == 1);
    348         assert(!m.prefix().matched);
    349         assert(m.prefix().first == s);
    350         assert(m.prefix().second == m[0].first);
    351         assert(!m.suffix().matched);
    352         assert(m.suffix().first == m[0].second);
    353         assert(m.suffix().second == m[0].second);
    354         assert(m.length(0) == sizeof(s)-1);
    355         assert(m.position(0) == 0);
    356         assert(m.str(0) == s);
    357     }
    358     {
    359         std::cmatch m;
    360         const char s[] = "abbbbbc";
    361         assert(std::regex_search(s, m, std::regex("ab\\{3,5\\}c", std::regex_constants::basic)));
    362         assert(m.size() == 1);
    363         assert(!m.prefix().matched);
    364         assert(m.prefix().first == s);
    365         assert(m.prefix().second == m[0].first);
    366         assert(!m.suffix().matched);
    367         assert(m.suffix().first == m[0].second);
    368         assert(m.suffix().second == m[0].second);
    369         assert(m.length(0) == sizeof(s)-1);
    370         assert(m.position(0) == 0);
    371         assert(m.str(0) == s);
    372     }
    373     {
    374         std::cmatch m;
    375         const char s[] = "adefc";
    376         assert(!std::regex_search(s, m, std::regex("ab\\{3,5\\}c", std::regex_constants::basic)));
    377         assert(m.size() == 0);
    378     }
    379     {
    380         std::cmatch m;
    381         const char s[] = "abbbbbbc";
    382         assert(!std::regex_search(s, m, std::regex("ab\\{3,5\\}c", std::regex_constants::basic)));
    383         assert(m.size() == 0);
    384     }
    385     {
    386         std::cmatch m;
    387         const char s[] = "adec";
    388         assert(!std::regex_search(s, m, std::regex("a.\\{3,5\\}c", std::regex_constants::basic)));
    389         assert(m.size() == 0);
    390     }
    391     {
    392         std::cmatch m;
    393         const char s[] = "adefc";
    394         assert(std::regex_search(s, m, std::regex("a.\\{3,5\\}c", std::regex_constants::basic)));
    395         assert(m.size() == 1);
    396         assert(!m.prefix().matched);
    397         assert(m.prefix().first == s);
    398         assert(m.prefix().second == m[0].first);
    399         assert(!m.suffix().matched);
    400         assert(m.suffix().first == m[0].second);
    401         assert(m.suffix().second == m[0].second);
    402         assert(m.length(0) == sizeof(s)-1);
    403         assert(m.position(0) == 0);
    404         assert(m.str(0) == s);
    405     }
    406     {
    407         std::cmatch m;
    408         const char s[] = "adefgc";
    409         assert(std::regex_search(s, m, std::regex("a.\\{3,5\\}c", std::regex_constants::basic)));
    410         assert(m.size() == 1);
    411         assert(!m.prefix().matched);
    412         assert(m.prefix().first == s);
    413         assert(m.prefix().second == m[0].first);
    414         assert(!m.suffix().matched);
    415         assert(m.suffix().first == m[0].second);
    416         assert(m.suffix().second == m[0].second);
    417         assert(m.length(0) == sizeof(s)-1);
    418         assert(m.position(0) == 0);
    419         assert(m.str(0) == s);
    420     }
    421     {
    422         std::cmatch m;
    423         const char s[] = "adefghc";
    424         assert(std::regex_search(s, m, std::regex("a.\\{3,5\\}c", std::regex_constants::basic)));
    425         assert(m.size() == 1);
    426         assert(!m.prefix().matched);
    427         assert(m.prefix().first == s);
    428         assert(m.prefix().second == m[0].first);
    429         assert(!m.suffix().matched);
    430         assert(m.suffix().first == m[0].second);
    431         assert(m.suffix().second == m[0].second);
    432         assert(m.length(0) == sizeof(s)-1);
    433         assert(m.position(0) == 0);
    434         assert(m.str(0) == s);
    435     }
    436     {
    437         std::cmatch m;
    438         const char s[] = "adefghic";
    439         assert(!std::regex_search(s, m, std::regex("a.\\{3,5\\}c", std::regex_constants::basic)));
    440         assert(m.size() == 0);
    441     }
    442     {
    443         std::cmatch m;
    444         const char s[] = "-ab,ab-";
    445         assert(std::regex_search(s, m, std::regex("-\\(.*\\),\\1-", std::regex_constants::basic)));
    446         assert(m.size() == 2);
    447         assert(!m.prefix().matched);
    448         assert(m.prefix().first == s);
    449         assert(m.prefix().second == m[0].first);
    450         assert(!m.suffix().matched);
    451         assert(m.suffix().first == m[0].second);
    452         assert(m.suffix().second == m[0].second);
    453         assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<char>::length(s));
    454         assert(m.position(0) == 0);
    455         assert(m.str(0) == s);
    456         assert(m.length(1) == 2);
    457         assert(m.position(1) == 1);
    458         assert(m.str(1) == "ab");
    459     }
    460     {
    461         std::cmatch m;
    462         const char s[] = "ababbabb";
    463         assert(std::regex_search(s, m, std::regex("^\\(ab*\\)*\\1$", std::regex_constants::basic)));
    464         assert(m.size() == 2);
    465         assert(!m.prefix().matched);
    466         assert(m.prefix().first == s);
    467         assert(m.prefix().second == m[0].first);
    468         assert(!m.suffix().matched);
    469         assert(m.suffix().first == m[0].second);
    470         assert(m.suffix().second == m[0].second);
    471         assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<char>::length(s));
    472         assert(m.position(0) == 0);
    473         assert(m.str(0) == s);
    474         assert(m.length(1) == 3);
    475         assert(m.position(1) == 2);
    476         assert(m.str(1) == "abb");
    477     }
    478     {
    479         std::cmatch m;
    480         const char s[] = "ababbab";
    481         assert(!std::regex_search(s, m, std::regex("^\\(ab*\\)*\\1$", std::regex_constants::basic)));
    482         assert(m.size() == 0);
    483     }
    484     {
    485         std::cmatch m;
    486         const char s[] = "aBAbbAbB";
    487         assert(std::regex_search(s, m, std::regex("^\\(Ab*\\)*\\1$",
    488                    std::regex_constants::basic | std::regex_constants::icase)));
    489         assert(m.size() == 2);
    490         assert(!m.prefix().matched);
    491         assert(m.prefix().first == s);
    492         assert(m.prefix().second == m[0].first);
    493         assert(!m.suffix().matched);
    494         assert(m.suffix().first == m[0].second);
    495         assert(m.suffix().second == m[0].second);
    496         assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<char>::length(s));
    497         assert(m.position(0) == 0);
    498         assert(m.str(0) == s);
    499         assert(m.length(1) == 3);
    500         assert(m.position(1) == 2);
    501         assert(m.str(1) == "Abb");
    502     }
    503     {
    504         std::cmatch m;
    505         const char s[] = "aBAbbAbB";
    506         assert(!std::regex_search(s, m, std::regex("^\\(Ab*\\)*\\1$",
    507                                                  std::regex_constants::basic)));
    508         assert(m.size() == 0);
    509     }
    510     {
    511         std::cmatch m;
    512         const char s[] = "a";
    513         assert(std::regex_search(s, m, std::regex("^[a]$",
    514                                                  std::regex_constants::basic)));
    515         assert(m.size() == 1);
    516         assert(!m.prefix().matched);
    517         assert(m.prefix().first == s);
    518         assert(m.prefix().second == m[0].first);
    519         assert(!m.suffix().matched);
    520         assert(m.suffix().first == m[0].second);
    521         assert(m.suffix().second == m[0].second);
    522         assert(m.length(0) == 1);
    523         assert(m.position(0) == 0);
    524         assert(m.str(0) == "a");
    525     }
    526     {
    527         std::cmatch m;
    528         const char s[] = "a";
    529         assert(std::regex_search(s, m, std::regex("^[ab]$",
    530                                                  std::regex_constants::basic)));
    531         assert(m.size() == 1);
    532         assert(!m.prefix().matched);
    533         assert(m.prefix().first == s);
    534         assert(m.prefix().second == m[0].first);
    535         assert(!m.suffix().matched);
    536         assert(m.suffix().first == m[0].second);
    537         assert(m.suffix().second == m[0].second);
    538         assert(m.length(0) == 1);
    539         assert(m.position(0) == 0);
    540         assert(m.str(0) == "a");
    541     }
    542     {
    543         std::cmatch m;
    544         const char s[] = "c";
    545         assert(std::regex_search(s, m, std::regex("^[a-f]$",
    546                                                  std::regex_constants::basic)));
    547         assert(m.size() == 1);
    548         assert(!m.prefix().matched);
    549         assert(m.prefix().first == s);
    550         assert(m.prefix().second == m[0].first);
    551         assert(!m.suffix().matched);
    552         assert(m.suffix().first == m[0].second);
    553         assert(m.suffix().second == m[0].second);
    554         assert(m.length(0) == 1);
    555         assert(m.position(0) == 0);
    556         assert(m.str(0) == s);
    557     }
    558     {
    559         std::cmatch m;
    560         const char s[] = "g";
    561         assert(!std::regex_search(s, m, std::regex("^[a-f]$",
    562                                                  std::regex_constants::basic)));
    563         assert(m.size() == 0);
    564     }
    565     {
    566         std::cmatch m;
    567         const char s[] = "Iraqi";
    568         assert(std::regex_search(s, m, std::regex("q[^u]",
    569                                                  std::regex_constants::basic)));
    570         assert(m.size() == 1);
    571         assert(m.prefix().matched);
    572         assert(m.prefix().first == s);
    573         assert(m.prefix().second == m[0].first);
    574         assert(!m.suffix().matched);
    575         assert(m.suffix().first == m[0].second);
    576         assert(m.suffix().second == m[0].second);
    577         assert(m.length(0) == 2);
    578         assert(m.position(0) == 3);
    579         assert(m.str(0) == "qi");
    580     }
    581     {
    582         std::cmatch m;
    583         const char s[] = "Iraq";
    584         assert(!std::regex_search(s, m, std::regex("q[^u]",
    585                                                  std::regex_constants::basic)));
    586         assert(m.size() == 0);
    587     }
    588     {
    589         std::cmatch m;
    590         const char s[] = "AmB";
    591         assert(std::regex_search(s, m, std::regex("A[[:lower:]]B",
    592                                                  std::regex_constants::basic)));
    593         assert(m.size() == 1);
    594         assert(!m.prefix().matched);
    595         assert(m.prefix().first == s);
    596         assert(m.prefix().second == m[0].first);
    597         assert(!m.suffix().matched);
    598         assert(m.suffix().first == m[0].second);
    599         assert(m.suffix().second == m[0].second);
    600         assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<char>::length(s));
    601         assert(m.position(0) == 0);
    602         assert(m.str(0) == s);
    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() == 0);
    610     }
    611     {
    612         std::cmatch m;
    613         const char s[] = "AMB";
    614         assert(std::regex_search(s, m, std::regex("A[^[:lower:]]B",
    615                                                  std::regex_constants::basic)));
    616         assert(m.size() == 1);
    617         assert(!m.prefix().matched);
    618         assert(m.prefix().first == s);
    619         assert(m.prefix().second == m[0].first);
    620         assert(!m.suffix().matched);
    621         assert(m.suffix().first == m[0].second);
    622         assert(m.suffix().second == m[0].second);
    623         assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<char>::length(s));
    624         assert(m.position(0) == 0);
    625         assert(m.str(0) == s);
    626     }
    627     {
    628         std::cmatch m;
    629         const char s[] = "AmB";
    630         assert(!std::regex_search(s, m, std::regex("A[^[:lower:]]B",
    631                                                  std::regex_constants::basic)));
    632         assert(m.size() == 0);
    633     }
    634     {
    635         std::cmatch m;
    636         const char s[] = "A5B";
    637         assert(!std::regex_search(s, m, std::regex("A[^[:lower:]0-9]B",
    638                                                  std::regex_constants::basic)));
    639         assert(m.size() == 0);
    640     }
    641     {
    642         std::cmatch m;
    643         const char s[] = "A?B";
    644         assert(std::regex_search(s, m, std::regex("A[^[:lower:]0-9]B",
    645                                                  std::regex_constants::basic)));
    646         assert(m.size() == 1);
    647         assert(!m.prefix().matched);
    648         assert(m.prefix().first == s);
    649         assert(m.prefix().second == m[0].first);
    650         assert(!m.suffix().matched);
    651         assert(m.suffix().first == m[0].second);
    652         assert(m.suffix().second == m[0].second);
    653         assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<char>::length(s));
    654         assert(m.position(0) == 0);
    655         assert(m.str(0) == s);
    656     }
    657     {
    658         std::cmatch m;
    659         const char s[] = "-";
    660         assert(std::regex_search(s, m, std::regex("[a[.hyphen.]z]",
    661                                                  std::regex_constants::basic)));
    662         assert(m.size() == 1);
    663         assert(!m.prefix().matched);
    664         assert(m.prefix().first == s);
    665         assert(m.prefix().second == m[0].first);
    666         assert(!m.suffix().matched);
    667         assert(m.suffix().first == m[0].second);
    668         assert(m.suffix().second == m[0].second);
    669         assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<char>::length(s));
    670         assert(m.position(0) == 0);
    671         assert(m.str(0) == s);
    672     }
    673     {
    674         std::cmatch m;
    675         const char s[] = "z";
    676         assert(std::regex_search(s, m, std::regex("[a[.hyphen.]z]",
    677                                                  std::regex_constants::basic)));
    678         assert(m.size() == 1);
    679         assert(!m.prefix().matched);
    680         assert(m.prefix().first == s);
    681         assert(m.prefix().second == m[0].first);
    682         assert(!m.suffix().matched);
    683         assert(m.suffix().first == m[0].second);
    684         assert(m.suffix().second == m[0].second);
    685         assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<char>::length(s));
    686         assert(m.position(0) == 0);
    687         assert(m.str(0) == s);
    688     }
    689     {
    690         std::cmatch m;
    691         const char s[] = "m";
    692         assert(!std::regex_search(s, m, std::regex("[a[.hyphen.]z]",
    693                                                  std::regex_constants::basic)));
    694         assert(m.size() == 0);
    695     }
    696     std::locale::global(std::locale(LOCALE_cs_CZ_ISO8859_2));
    697     {
    698         std::cmatch m;
    699         const char s[] = "m";
    700         assert(std::regex_search(s, m, std::regex("[a[=M=]z]",
    701                                                  std::regex_constants::basic)));
    702         assert(m.size() == 1);
    703         assert(!m.prefix().matched);
    704         assert(m.prefix().first == s);
    705         assert(m.prefix().second == m[0].first);
    706         assert(!m.suffix().matched);
    707         assert(m.suffix().first == m[0].second);
    708         assert(m.suffix().second == m[0].second);
    709         assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<char>::length(s));
    710         assert(m.position(0) == 0);
    711         assert(m.str(0) == s);
    712     }
    713     {
    714         std::cmatch m;
    715         const char s[] = "Ch";
    716         assert(std::regex_search(s, m, std::regex("[a[.ch.]z]",
    717                    std::regex_constants::basic | std::regex_constants::icase)));
    718         assert(m.size() == 1);
    719         assert(!m.prefix().matched);
    720         assert(m.prefix().first == s);
    721         assert(m.prefix().second == m[0].first);
    722         assert(!m.suffix().matched);
    723         assert(m.suffix().first == m[0].second);
    724         assert(m.suffix().second == m[0].second);
    725         assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<char>::length(s));
    726         assert(m.position(0) == 0);
    727         assert(m.str(0) == s);
    728     }
    729     std::locale::global(std::locale("C"));
    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) >= 0 && static_cast<size_t>(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) >= 0 && static_cast<size_t>(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) >= 0 && static_cast<size_t>(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) >= 0 && static_cast<size_t>(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) >= 0 && static_cast<size_t>(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) >= 0 && static_cast<size_t>(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) >= 0 && static_cast<size_t>(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) >= 0 && static_cast<size_t>(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) >= 0 && static_cast<size_t>(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) >= 0 && static_cast<size_t>(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) >= 0 && static_cast<size_t>(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) >= 0 && static_cast<size_t>(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) >= 0 && static_cast<size_t>(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) >= 0 && static_cast<size_t>(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     std::locale::global(std::locale(LOCALE_cs_CZ_ISO8859_2));
   1455     {
   1456         std::wcmatch m;
   1457         const wchar_t s[] = L"m";
   1458         assert(std::regex_search(s, m, std::wregex(L"[a[=M=]z]",
   1459                                                  std::regex_constants::basic)));
   1460         assert(m.size() == 1);
   1461         assert(!m.prefix().matched);
   1462         assert(m.prefix().first == s);
   1463         assert(m.prefix().second == m[0].first);
   1464         assert(!m.suffix().matched);
   1465         assert(m.suffix().first == m[0].second);
   1466         assert(m.suffix().second == m[0].second);
   1467         assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<wchar_t>::length(s));
   1468         assert(m.position(0) == 0);
   1469         assert(m.str(0) == s);
   1470     }
   1471     {
   1472         std::wcmatch m;
   1473         const wchar_t s[] = L"Ch";
   1474         assert(std::regex_search(s, m, std::wregex(L"[a[.ch.]z]",
   1475                    std::regex_constants::basic | std::regex_constants::icase)));
   1476         assert(m.size() == 1);
   1477         assert(!m.prefix().matched);
   1478         assert(m.prefix().first == s);
   1479         assert(m.prefix().second == m[0].first);
   1480         assert(!m.suffix().matched);
   1481         assert(m.suffix().first == m[0].second);
   1482         assert(m.suffix().second == m[0].second);
   1483         assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<wchar_t>::length(s));
   1484         assert(m.position(0) == 0);
   1485         assert(m.str(0) == s);
   1486     }
   1487     std::locale::global(std::locale("C"));
   1488     {
   1489         std::wcmatch m;
   1490         const wchar_t s[] = L"m";
   1491         assert(!std::regex_search(s, m, std::wregex(L"[a[=M=]z]",
   1492                                                  std::regex_constants::basic)));
   1493         assert(m.size() == 0);
   1494     }
   1495     {
   1496         std::wcmatch m;
   1497         const wchar_t s[] = L"01a45cef9";
   1498         assert(std::regex_search(s, m, std::wregex(L"[ace1-9]*",
   1499                                                  std::regex_constants::basic)));
   1500         assert(m.size() == 1);
   1501         assert(!m.prefix().matched);
   1502         assert(m.prefix().first == s);
   1503         assert(m.prefix().second == m[0].first);
   1504         assert(m.suffix().matched);
   1505         assert(m.suffix().first == m[0].second);
   1506         assert(m.suffix().second == s + std::char_traits<wchar_t>::length(s));
   1507         assert(m.length(0) == 0);
   1508         assert(m.position(0) == 0);
   1509         assert(m.str(0) == L"");
   1510     }
   1511     {
   1512         std::wcmatch m;
   1513         const wchar_t s[] = L"01a45cef9";
   1514         assert(std::regex_search(s, m, std::wregex(L"[ace1-9]\\{1,\\}",
   1515                                                  std::regex_constants::basic)));
   1516         assert(m.size() == 1);
   1517         assert(m.prefix().matched);
   1518         assert(m.prefix().first == s);
   1519         assert(m.prefix().second == m[0].first);
   1520         assert(m.suffix().matched);
   1521         assert(m.suffix().first == m[0].second);
   1522         assert(m.suffix().second == s + std::char_traits<wchar_t>::length(s));
   1523         assert(m.length(0) == 6);
   1524         assert(m.position(0) == 1);
   1525         assert(m.str(0) == L"1a45ce");
   1526     }
   1527     {
   1528         const wchar_t r[] = L"^[-+]\\{0,1\\}[0-9]\\{1,\\}[CF]$";
   1529         std::ptrdiff_t sr = std::char_traits<wchar_t>::length(r);
   1530         typedef forward_iterator<const wchar_t*> FI;
   1531         typedef bidirectional_iterator<const wchar_t*> BI;
   1532         std::wregex regex(FI(r), FI(r+sr), std::regex_constants::basic);
   1533         std::match_results<BI> m;
   1534         const wchar_t s[] = L"-40C";
   1535         std::ptrdiff_t ss = std::char_traits<wchar_t>::length(s);
   1536         assert(std::regex_search(BI(s), BI(s+ss), m, regex));
   1537         assert(m.size() == 1);
   1538         assert(!m.prefix().matched);
   1539         assert(m.prefix().first == BI(s));
   1540         assert(m.prefix().second == m[0].first);
   1541         assert(!m.suffix().matched);
   1542         assert(m.suffix().first == m[0].second);
   1543         assert(m.suffix().second == m[0].second);
   1544         assert(m.length(0) == 4);
   1545         assert(m.position(0) == 0);
   1546         assert(m.str(0) == s);
   1547     }
   1548 }
   1549