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