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