diff options
Diffstat (limited to 'libcxx/test/std/re/re.alg')
27 files changed, 12896 insertions, 0 deletions
diff --git a/libcxx/test/std/re/re.alg/nothing_to_do.pass.cpp b/libcxx/test/std/re/re.alg/nothing_to_do.pass.cpp new file mode 100644 index 00000000000..b58f5c55b64 --- /dev/null +++ b/libcxx/test/std/re/re.alg/nothing_to_do.pass.cpp @@ -0,0 +1,12 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +int main() +{ +} diff --git a/libcxx/test/std/re/re.alg/re.alg.match/awk.pass.cpp b/libcxx/test/std/re/re.alg/re.alg.match/awk.pass.cpp new file mode 100644 index 00000000000..d2065a033d3 --- /dev/null +++ b/libcxx/test/std/re/re.alg/re.alg.match/awk.pass.cpp @@ -0,0 +1,1389 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <regex> + +// template <class BidirectionalIterator, class Allocator, class charT, +// class traits> +// bool regex_match(BidirectionalIterator first, BidirectionalIterator last, +// match_results<BidirectionalIterator, Allocator>& m, +// const basic_regex<charT, traits>& e, +// regex_constants::match_flag_type flags +// = regex_constants::match_default); + +#include <regex> +#include <cassert> + +#include "test_iterators.h" + +int main() +{ +/* { + std::cmatch m; + const char s[] = "a"; + assert(std::regex_match(s, m, std::regex("a", std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.empty()); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+1); + assert(m.length(0) == 1); + assert(m.position(0) == 0); + assert(m.str(0) == "a"); + } + { + std::cmatch m; + const char s[] = "ab"; + assert(std::regex_match(s, m, std::regex("ab", std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+2); + assert(m.length(0) == 2); + assert(m.position(0) == 0); + assert(m.str(0) == "ab"); + } + { + std::cmatch m; + const char s[] = "ab"; + assert(!std::regex_match(s, m, std::regex("ba", std::regex_constants::awk))); + assert(m.size() == 0); + assert(m.empty()); + } + { + std::cmatch m; + const char s[] = "aab"; + assert(!std::regex_match(s, m, std::regex("ab", std::regex_constants::awk))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "aab"; + assert(!std::regex_match(s, m, std::regex("ab", std::regex_constants::awk), + std::regex_constants::match_continuous)); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "abcd"; + assert(!std::regex_match(s, m, std::regex("bc", std::regex_constants::awk))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "abbc"; + assert(std::regex_match(s, m, std::regex("ab*c", std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+4); + assert(m.length(0) == 4); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "ababc"; + assert(std::regex_match(s, m, std::regex("(ab)*c", std::regex_constants::awk))); + assert(m.size() == 2); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+5); + assert(m.length(0) == 5); + assert(m.position(0) == 0); + assert(m.str(0) == s); + assert(m.length(1) == 2); + assert(m.position(1) == 2); + assert(m.str(1) == "ab"); + } + { + std::cmatch m; + const char s[] = "abcdefghijk"; + assert(!std::regex_match(s, m, std::regex("cd((e)fg)hi", + std::regex_constants::awk))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "abc"; + assert(std::regex_match(s, m, std::regex("^abc", std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+3); + assert(m.length(0) == 3); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "abcd"; + assert(!std::regex_match(s, m, std::regex("^abc", std::regex_constants::awk))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "aabc"; + assert(!std::regex_match(s, m, std::regex("^abc", std::regex_constants::awk))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "abc"; + assert(std::regex_match(s, m, std::regex("abc$", std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+3); + assert(m.length(0) == 3); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "efabc"; + assert(!std::regex_match(s, m, std::regex("abc$", std::regex_constants::awk))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "efabcg"; + assert(!std::regex_match(s, m, std::regex("abc$", std::regex_constants::awk))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "abc"; + assert(std::regex_match(s, m, std::regex("a.c", std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+3); + assert(m.length(0) == 3); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "acc"; + assert(std::regex_match(s, m, std::regex("a.c", std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+3); + assert(m.length(0) == 3); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "acc"; + assert(std::regex_match(s, m, std::regex("a.c", std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+3); + assert(m.length(0) == 3); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "abcdef"; + assert(std::regex_match(s, m, std::regex("(.*).*", std::regex_constants::awk))); + assert(m.size() == 2); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+6); + assert(m.length(0) == 6); + assert(m.position(0) == 0); + assert(m.str(0) == s); + assert(m.length(1) == 6); + assert(m.position(1) == 0); + assert(m.str(1) == s); + } + { + std::cmatch m; + const char s[] = "bc"; + assert(!std::regex_match(s, m, std::regex("(a*)*", std::regex_constants::awk))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "abbc"; + assert(!std::regex_match(s, m, std::regex("ab{3,5}c", std::regex_constants::awk))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "abbbc"; + assert(std::regex_match(s, m, std::regex("ab{3,5}c", std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "abbbbc"; + assert(std::regex_match(s, m, std::regex("ab{3,5}c", std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "abbbbbc"; + assert(std::regex_match(s, m, std::regex("ab{3,5}c", std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "adefc"; + assert(!std::regex_match(s, m, std::regex("ab{3,5}c", std::regex_constants::awk))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "abbbbbbc"; + assert(!std::regex_match(s, m, std::regex("ab{3,5}c", std::regex_constants::awk))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "adec"; + assert(!std::regex_match(s, m, std::regex("a.{3,5}c", std::regex_constants::awk))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "adefc"; + assert(std::regex_match(s, m, std::regex("a.{3,5}c", std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "adefgc"; + assert(std::regex_match(s, m, std::regex("a.{3,5}c", std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "adefghc"; + assert(std::regex_match(s, m, std::regex("a.{3,5}c", std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "adefghic"; + assert(!std::regex_match(s, m, std::regex("a.{3,5}c", std::regex_constants::awk))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "tournament"; + assert(std::regex_match(s, m, std::regex("tour|to|tournament", + std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "tournamenttotour"; + assert(std::regex_match(s, m, std::regex("(tour|to|tournament)+", + std::regex_constants::awk | std::regex_constants::nosubs))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "ttotour"; + assert(std::regex_match(s, m, std::regex("(tour|to|t)+", + std::regex_constants::awk))); + assert(m.size() == 2); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + assert(m.length(1) == 4); + assert(m.position(1) == 3); + assert(m.str(1) == "tour"); + } + { + std::cmatch m; + const char s[] = "-ab,ab-"; + assert(!std::regex_match(s, m, std::regex("-(.*),\1-", std::regex_constants::awk))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "-ab,ab-"; + assert(std::regex_match(s, m, std::regex("-.*,.*-", std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "a"; + assert(std::regex_match(s, m, std::regex("^[a]$", + std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == 1); + assert(m.position(0) == 0); + assert(m.str(0) == "a"); + } + { + std::cmatch m; + const char s[] = "a"; + assert(std::regex_match(s, m, std::regex("^[ab]$", + std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == 1); + assert(m.position(0) == 0); + assert(m.str(0) == "a"); + } + { + std::cmatch m; + const char s[] = "c"; + assert(std::regex_match(s, m, std::regex("^[a-f]$", + std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == 1); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "g"; + assert(!std::regex_match(s, m, std::regex("^[a-f]$", + std::regex_constants::awk))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "Iraqi"; + assert(!std::regex_match(s, m, std::regex("q[^u]", + std::regex_constants::awk))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "Iraq"; + assert(!std::regex_match(s, m, std::regex("q[^u]", + std::regex_constants::awk))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "AmB"; + assert(std::regex_match(s, m, std::regex("A[[:lower:]]B", + std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "AMB"; + assert(!std::regex_match(s, m, std::regex("A[[:lower:]]B", + std::regex_constants::awk))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "AMB"; + assert(std::regex_match(s, m, std::regex("A[^[:lower:]]B", + std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "AmB"; + assert(!std::regex_match(s, m, std::regex("A[^[:lower:]]B", + std::regex_constants::awk))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "A5B"; + assert(!std::regex_match(s, m, std::regex("A[^[:lower:]0-9]B", + std::regex_constants::awk))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "A?B"; + assert(std::regex_match(s, m, std::regex("A[^[:lower:]0-9]B", + std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "-"; + assert(std::regex_match(s, m, std::regex("[a[.hyphen.]z]", + std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "z"; + assert(std::regex_match(s, m, std::regex("[a[.hyphen.]z]", + std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "m"; + assert(!std::regex_match(s, m, std::regex("[a[.hyphen.]z]", + std::regex_constants::awk))); + assert(m.size() == 0); + } + std::locale::global(std::locale("cs_CZ.ISO8859-2")); +*/ { + std::cmatch m; + const char s[] = "m"; + /* assert(std::regex_match(s, m,*/ std::regex("[a[=M=]z]"/*, + std::regex_constants::awk*/);//)); +/* assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); +*/ } +/* { + std::cmatch m; + const char s[] = "Ch"; + assert(std::regex_match(s, m, std::regex("[a[.ch.]z]", + std::regex_constants::awk | std::regex_constants::icase))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + std::locale::global(std::locale("C")); + { + std::cmatch m; + const char s[] = "m"; + assert(!std::regex_match(s, m, std::regex("[a[=M=]z]", + std::regex_constants::awk))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "01a45cef9"; + assert(!std::regex_match(s, m, std::regex("[ace1-9]*", + std::regex_constants::awk))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "01a45cef9"; + assert(!std::regex_match(s, m, std::regex("[ace1-9]+", + std::regex_constants::awk))); + assert(m.size() == 0); + } + { + const char r[] = "^[-+]?[0-9]+[CF]$"; + std::ptrdiff_t sr = std::char_traits<char>::length(r); + typedef forward_iterator<const char*> FI; + typedef bidirectional_iterator<const char*> BI; + std::regex regex(FI(r), FI(r+sr), std::regex_constants::awk); + std::match_results<BI> m; + const char s[] = "-40C"; + std::ptrdiff_t ss = std::char_traits<char>::length(s); + assert(std::regex_match(BI(s), BI(s+ss), m, regex)); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == BI(s)); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == 4); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "\n\n\n"; + assert(std::regex_match(s, m, std::regex("[\\n]+", + std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s + std::char_traits<char>::length(s)); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"a"; + assert(std::regex_match(s, m, std::wregex(L"a", std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.empty()); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+1); + assert(m.length(0) == 1); + assert(m.position(0) == 0); + assert(m.str(0) == L"a"); + } + { + std::wcmatch m; + const wchar_t s[] = L"ab"; + assert(std::regex_match(s, m, std::wregex(L"ab", std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+2); + assert(m.length(0) == 2); + assert(m.position(0) == 0); + assert(m.str(0) == L"ab"); + } + { + std::wcmatch m; + const wchar_t s[] = L"ab"; + assert(!std::regex_match(s, m, std::wregex(L"ba", std::regex_constants::awk))); + assert(m.size() == 0); + assert(m.empty()); + } + { + std::wcmatch m; + const wchar_t s[] = L"aab"; + assert(!std::regex_match(s, m, std::wregex(L"ab", std::regex_constants::awk))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"aab"; + assert(!std::regex_match(s, m, std::wregex(L"ab", std::regex_constants::awk), + std::regex_constants::match_continuous)); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"abcd"; + assert(!std::regex_match(s, m, std::wregex(L"bc", std::regex_constants::awk))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"abbc"; + assert(std::regex_match(s, m, std::wregex(L"ab*c", std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+4); + assert(m.length(0) == 4); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"ababc"; + assert(std::regex_match(s, m, std::wregex(L"(ab)*c", std::regex_constants::awk))); + assert(m.size() == 2); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+5); + assert(m.length(0) == 5); + assert(m.position(0) == 0); + assert(m.str(0) == s); + assert(m.length(1) == 2); + assert(m.position(1) == 2); + assert(m.str(1) == L"ab"); + } + { + std::wcmatch m; + const wchar_t s[] = L"abcdefghijk"; + assert(!std::regex_match(s, m, std::wregex(L"cd((e)fg)hi", + std::regex_constants::awk))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"abc"; + assert(std::regex_match(s, m, std::wregex(L"^abc", std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+3); + assert(m.length(0) == 3); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"abcd"; + assert(!std::regex_match(s, m, std::wregex(L"^abc", std::regex_constants::awk))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"aabc"; + assert(!std::regex_match(s, m, std::wregex(L"^abc", std::regex_constants::awk))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"abc"; + assert(std::regex_match(s, m, std::wregex(L"abc$", std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+3); + assert(m.length(0) == 3); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"efabc"; + assert(!std::regex_match(s, m, std::wregex(L"abc$", std::regex_constants::awk))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"efabcg"; + assert(!std::regex_match(s, m, std::wregex(L"abc$", std::regex_constants::awk))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"abc"; + assert(std::regex_match(s, m, std::wregex(L"a.c", std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+3); + assert(m.length(0) == 3); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"acc"; + assert(std::regex_match(s, m, std::wregex(L"a.c", std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+3); + assert(m.length(0) == 3); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"acc"; + assert(std::regex_match(s, m, std::wregex(L"a.c", std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+3); + assert(m.length(0) == 3); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"abcdef"; + assert(std::regex_match(s, m, std::wregex(L"(.*).*", std::regex_constants::awk))); + assert(m.size() == 2); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+6); + assert(m.length(0) == 6); + assert(m.position(0) == 0); + assert(m.str(0) == s); + assert(m.length(1) == 6); + assert(m.position(1) == 0); + assert(m.str(1) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"bc"; + assert(!std::regex_match(s, m, std::wregex(L"(a*)*", std::regex_constants::awk))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"abbc"; + assert(!std::regex_match(s, m, std::wregex(L"ab{3,5}c", std::regex_constants::awk))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"abbbc"; + assert(std::regex_match(s, m, std::wregex(L"ab{3,5}c", std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"abbbbc"; + assert(std::regex_match(s, m, std::wregex(L"ab{3,5}c", std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"abbbbbc"; + assert(std::regex_match(s, m, std::wregex(L"ab{3,5}c", std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"adefc"; + assert(!std::regex_match(s, m, std::wregex(L"ab{3,5}c", std::regex_constants::awk))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"abbbbbbc"; + assert(!std::regex_match(s, m, std::wregex(L"ab{3,5}c", std::regex_constants::awk))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"adec"; + assert(!std::regex_match(s, m, std::wregex(L"a.{3,5}c", std::regex_constants::awk))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"adefc"; + assert(std::regex_match(s, m, std::wregex(L"a.{3,5}c", std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"adefgc"; + assert(std::regex_match(s, m, std::wregex(L"a.{3,5}c", std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"adefghc"; + assert(std::regex_match(s, m, std::wregex(L"a.{3,5}c", std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"adefghic"; + assert(!std::regex_match(s, m, std::wregex(L"a.{3,5}c", std::regex_constants::awk))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"tournament"; + assert(std::regex_match(s, m, std::wregex(L"tour|to|tournament", + std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"tournamenttotour"; + assert(std::regex_match(s, m, std::wregex(L"(tour|to|tournament)+", + std::regex_constants::awk | std::regex_constants::nosubs))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"ttotour"; + assert(std::regex_match(s, m, std::wregex(L"(tour|to|t)+", + std::regex_constants::awk))); + assert(m.size() == 2); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + assert(m.length(1) == 4); + assert(m.position(1) == 3); + assert(m.str(1) == L"tour"); + } + { + std::wcmatch m; + const wchar_t s[] = L"-ab,ab-"; + assert(!std::regex_match(s, m, std::wregex(L"-(.*),\1-", std::regex_constants::awk))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"-ab,ab-"; + assert(std::regex_match(s, m, std::wregex(L"-.*,.*-", std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"a"; + assert(std::regex_match(s, m, std::wregex(L"^[a]$", + std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == 1); + assert(m.position(0) == 0); + assert(m.str(0) == L"a"); + } + { + std::wcmatch m; + const wchar_t s[] = L"a"; + assert(std::regex_match(s, m, std::wregex(L"^[ab]$", + std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == 1); + assert(m.position(0) == 0); + assert(m.str(0) == L"a"); + } + { + std::wcmatch m; + const wchar_t s[] = L"c"; + assert(std::regex_match(s, m, std::wregex(L"^[a-f]$", + std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == 1); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"g"; + assert(!std::regex_match(s, m, std::wregex(L"^[a-f]$", + std::regex_constants::awk))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"Iraqi"; + assert(!std::regex_match(s, m, std::wregex(L"q[^u]", + std::regex_constants::awk))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"Iraq"; + assert(!std::regex_match(s, m, std::wregex(L"q[^u]", + std::regex_constants::awk))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"AmB"; + assert(std::regex_match(s, m, std::wregex(L"A[[:lower:]]B", + std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"AMB"; + assert(!std::regex_match(s, m, std::wregex(L"A[[:lower:]]B", + std::regex_constants::awk))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"AMB"; + assert(std::regex_match(s, m, std::wregex(L"A[^[:lower:]]B", + std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"AmB"; + assert(!std::regex_match(s, m, std::wregex(L"A[^[:lower:]]B", + std::regex_constants::awk))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"A5B"; + assert(!std::regex_match(s, m, std::wregex(L"A[^[:lower:]0-9]B", + std::regex_constants::awk))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"A?B"; + assert(std::regex_match(s, m, std::wregex(L"A[^[:lower:]0-9]B", + std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"-"; + assert(std::regex_match(s, m, std::wregex(L"[a[.hyphen.]z]", + std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"z"; + assert(std::regex_match(s, m, std::wregex(L"[a[.hyphen.]z]", + std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"m"; + assert(!std::regex_match(s, m, std::wregex(L"[a[.hyphen.]z]", + std::regex_constants::awk))); + assert(m.size() == 0); + } + std::locale::global(std::locale("cs_CZ.ISO8859-2")); + { + std::wcmatch m; + const wchar_t s[] = L"m"; + assert(std::regex_match(s, m, std::wregex(L"[a[=M=]z]", + std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"Ch"; + assert(std::regex_match(s, m, std::wregex(L"[a[.ch.]z]", + std::regex_constants::awk | std::regex_constants::icase))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + std::locale::global(std::locale("C")); + { + std::wcmatch m; + const wchar_t s[] = L"m"; + assert(!std::regex_match(s, m, std::wregex(L"[a[=M=]z]", + std::regex_constants::awk))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"01a45cef9"; + assert(!std::regex_match(s, m, std::wregex(L"[ace1-9]*", + std::regex_constants::awk))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"01a45cef9"; + assert(!std::regex_match(s, m, std::wregex(L"[ace1-9]+", + std::regex_constants::awk))); + assert(m.size() == 0); + } + { + const wchar_t r[] = L"^[-+]?[0-9]+[CF]$"; + std::ptrdiff_t sr = std::char_traits<wchar_t>::length(r); + typedef forward_iterator<const wchar_t*> FI; + typedef bidirectional_iterator<const wchar_t*> BI; + std::wregex regex(FI(r), FI(r+sr), std::regex_constants::awk); + std::match_results<BI> m; + const wchar_t s[] = L"-40C"; + std::ptrdiff_t ss = std::char_traits<wchar_t>::length(s); + assert(std::regex_match(BI(s), BI(s+ss), m, regex)); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == BI(s)); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == 4); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"\n\n\n"; + assert(std::regex_match(s, m, std::wregex(L"[\\n]+", + std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s + std::char_traits<wchar_t>::length(s)); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } +*/} diff --git a/libcxx/test/std/re/re.alg/re.alg.match/basic.fail.cpp b/libcxx/test/std/re/re.alg/re.alg.match/basic.fail.cpp new file mode 100644 index 00000000000..d3b922c0782 --- /dev/null +++ b/libcxx/test/std/re/re.alg/re.alg.match/basic.fail.cpp @@ -0,0 +1,38 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <regex> + +// template <class ST, class SA, class Allocator, class charT, class traits> +// bool regex_match(const basic_string<charT, ST, SA>&&, +// match_results< +// typename basic_string<charT, ST, SA>::const_iterator, +// Allocator>&, +// const basic_regex<charT, traits>&, +// regex_constants::match_flag_type = +// regex_constants::match_default) = delete; + +#include <__config> + +#if _LIBCPP_STD_VER <= 11 +#error +#else + +#include <regex> +#include <cassert> + +int main() +{ + { + std::smatch m; + std::regex re{"*"}; + std::regex_match(std::string("abcde"), m, re); + } +} +#endif diff --git a/libcxx/test/std/re/re.alg/re.alg.match/basic.pass.cpp b/libcxx/test/std/re/re.alg/re.alg.match/basic.pass.cpp new file mode 100644 index 00000000000..4139cea35f8 --- /dev/null +++ b/libcxx/test/std/re/re.alg/re.alg.match/basic.pass.cpp @@ -0,0 +1,1366 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// REQUIRES: locale.cs_CZ.ISO8859-2 + +// <regex> + +// template <class BidirectionalIterator, class Allocator, class charT, class traits> +// bool +// regex_match(BidirectionalIterator first, BidirectionalIterator last, +// match_results<BidirectionalIterator, Allocator>& m, +// const basic_regex<charT, traits>& e, +// regex_constants::match_flag_type flags = regex_constants::match_default); + +// TODO: investigation needed +// XFAIL: linux-gnu + +#include <regex> +#include <cassert> + +#include "test_iterators.h" + +int main() +{ + { + std::cmatch m; + assert(!std::regex_match("a", m, std::regex())); + assert(m.size() == 0); + assert(m.empty()); + } + { + std::cmatch m; + const char s[] = "a"; + assert(std::regex_match(s, m, std::regex("a", std::regex_constants::basic))); + assert(m.size() == 1); + assert(!m.empty()); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+1); + assert(m.length(0) == 1); + assert(m.position(0) == 0); + assert(m.str(0) == "a"); + } + { + std::cmatch m; + const char s[] = "ab"; + assert(std::regex_match(s, m, std::regex("ab", std::regex_constants::basic))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+2); + assert(m.length(0) == 2); + assert(m.position(0) == 0); + assert(m.str(0) == "ab"); + } + { + std::cmatch m; + const char s[] = "ab"; + assert(!std::regex_match(s, m, std::regex("ba", std::regex_constants::basic))); + assert(m.size() == 0); + assert(m.empty()); + } + { + std::cmatch m; + const char s[] = "aab"; + assert(!std::regex_match(s, m, std::regex("ab", std::regex_constants::basic))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "aab"; + assert(!std::regex_match(s, m, std::regex("ab", std::regex_constants::basic), + std::regex_constants::match_continuous)); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "abcd"; + assert(!std::regex_match(s, m, std::regex("bc", std::regex_constants::basic))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "abbc"; + assert(std::regex_match(s, m, std::regex("ab*c", std::regex_constants::basic))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+4); + assert(m.length(0) == 4); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "ababc"; + assert(std::regex_match(s, m, std::regex("\\(ab\\)*c", std::regex_constants::basic))); + assert(m.size() == 2); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+5); + assert(m.length(0) == 5); + assert(m.position(0) == 0); + assert(m.str(0) == s); + assert(m.length(1) == 2); + assert(m.position(1) == 2); + assert(m.str(1) == "ab"); + } + { + std::cmatch m; + const char s[] = "abcdefghijk"; + assert(!std::regex_match(s, m, std::regex("cd\\(\\(e\\)fg\\)hi", + std::regex_constants::basic))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "abc"; + assert(std::regex_match(s, m, std::regex("^abc", std::regex_constants::basic))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+3); + assert(m.length(0) == 3); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "abcd"; + assert(!std::regex_match(s, m, std::regex("^abc", std::regex_constants::basic))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "aabc"; + assert(!std::regex_match(s, m, std::regex("^abc", std::regex_constants::basic))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "abc"; + assert(std::regex_match(s, m, std::regex("abc$", std::regex_constants::basic))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+3); + assert(m.length(0) == 3); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "efabc"; + assert(!std::regex_match(s, m, std::regex("abc$", std::regex_constants::basic))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "efabcg"; + assert(!std::regex_match(s, m, std::regex("abc$", std::regex_constants::basic))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "abc"; + assert(std::regex_match(s, m, std::regex("a.c", std::regex_constants::basic))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+3); + assert(m.length(0) == 3); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "acc"; + assert(std::regex_match(s, m, std::regex("a.c", std::regex_constants::basic))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+3); + assert(m.length(0) == 3); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "acc"; + assert(std::regex_match(s, m, std::regex("a.c", std::regex_constants::basic))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+3); + assert(m.length(0) == 3); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "abcdef"; + assert(std::regex_match(s, m, std::regex("\\(.*\\).*", std::regex_constants::basic))); + assert(m.size() == 2); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+6); + assert(m.length(0) == 6); + assert(m.position(0) == 0); + assert(m.str(0) == s); + assert(m.length(1) == 6); + assert(m.position(1) == 0); + assert(m.str(1) == s); + } + { + std::cmatch m; + const char s[] = "bc"; + assert(!std::regex_match(s, m, std::regex("\\(a*\\)*", std::regex_constants::basic))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "abbc"; + assert(!std::regex_match(s, m, std::regex("ab\\{3,5\\}c", std::regex_constants::basic))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "abbbc"; + assert(std::regex_match(s, m, std::regex("ab\\{3,5\\}c", std::regex_constants::basic))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == sizeof(s)-1); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "abbbbc"; + assert(std::regex_match(s, m, std::regex("ab\\{3,5\\}c", std::regex_constants::basic))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == sizeof(s)-1); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "abbbbbc"; + assert(std::regex_match(s, m, std::regex("ab\\{3,5\\}c", std::regex_constants::basic))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == sizeof(s)-1); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "adefc"; + assert(!std::regex_match(s, m, std::regex("ab\\{3,5\\}c", std::regex_constants::basic))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "abbbbbbc"; + assert(!std::regex_match(s, m, std::regex("ab\\{3,5\\}c", std::regex_constants::basic))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "adec"; + assert(!std::regex_match(s, m, std::regex("a.\\{3,5\\}c", std::regex_constants::basic))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "adefc"; + assert(std::regex_match(s, m, std::regex("a.\\{3,5\\}c", std::regex_constants::basic))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == sizeof(s)-1); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "adefgc"; + assert(std::regex_match(s, m, std::regex("a.\\{3,5\\}c", std::regex_constants::basic))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == sizeof(s)-1); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "adefghc"; + assert(std::regex_match(s, m, std::regex("a.\\{3,5\\}c", std::regex_constants::basic))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == sizeof(s)-1); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "adefghic"; + assert(!std::regex_match(s, m, std::regex("a.\\{3,5\\}c", std::regex_constants::basic))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "-ab,ab-"; + assert(std::regex_match(s, m, std::regex("-\\(.*\\),\\1-", std::regex_constants::basic))); + assert(m.size() == 2); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + assert(m.length(1) == 2); + assert(m.position(1) == 1); + assert(m.str(1) == "ab"); + } + { + std::cmatch m; + const char s[] = "ababbabb"; + assert(std::regex_match(s, m, std::regex("^\\(ab*\\)*\\1$", std::regex_constants::basic))); + assert(m.size() == 2); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + assert(m.length(1) == 3); + assert(m.position(1) == 2); + assert(m.str(1) == "abb"); + } + { + std::cmatch m; + const char s[] = "ababbab"; + assert(!std::regex_match(s, m, std::regex("^\\(ab*\\)*\\1$", std::regex_constants::basic))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "aBAbbAbB"; + assert(std::regex_match(s, m, std::regex("^\\(Ab*\\)*\\1$", + std::regex_constants::basic | std::regex_constants::icase))); + assert(m.size() == 2); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + assert(m.length(1) == 3); + assert(m.position(1) == 2); + assert(m.str(1) == "Abb"); + } + { + std::cmatch m; + const char s[] = "aBAbbAbB"; + assert(!std::regex_match(s, m, std::regex("^\\(Ab*\\)*\\1$", + std::regex_constants::basic))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "a"; + assert(std::regex_match(s, m, std::regex("^[a]$", + std::regex_constants::basic))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == 1); + assert(m.position(0) == 0); + assert(m.str(0) == "a"); + } + { + std::cmatch m; + const char s[] = "a"; + assert(std::regex_match(s, m, std::regex("^[ab]$", + std::regex_constants::basic))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == 1); + assert(m.position(0) == 0); + assert(m.str(0) == "a"); + } + { + std::cmatch m; + const char s[] = "c"; + assert(std::regex_match(s, m, std::regex("^[a-f]$", + std::regex_constants::basic))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == 1); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "g"; + assert(!std::regex_match(s, m, std::regex("^[a-f]$", + std::regex_constants::basic))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "Iraqi"; + assert(!std::regex_match(s, m, std::regex("q[^u]", + std::regex_constants::basic))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "Iraq"; + assert(!std::regex_match(s, m, std::regex("q[^u]", + std::regex_constants::basic))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "AmB"; + assert(std::regex_match(s, m, std::regex("A[[:lower:]]B", + std::regex_constants::basic))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "AMB"; + assert(!std::regex_match(s, m, std::regex("A[[:lower:]]B", + std::regex_constants::basic))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "AMB"; + assert(std::regex_match(s, m, std::regex("A[^[:lower:]]B", + std::regex_constants::basic))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "AmB"; + assert(!std::regex_match(s, m, std::regex("A[^[:lower:]]B", + std::regex_constants::basic))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "A5B"; + assert(!std::regex_match(s, m, std::regex("A[^[:lower:]0-9]B", + std::regex_constants::basic))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "A?B"; + assert(std::regex_match(s, m, std::regex("A[^[:lower:]0-9]B", + std::regex_constants::basic))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "-"; + assert(std::regex_match(s, m, std::regex("[a[.hyphen.]z]", + std::regex_constants::basic))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "z"; + assert(std::regex_match(s, m, std::regex("[a[.hyphen.]z]", + std::regex_constants::basic))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "m"; + assert(!std::regex_match(s, m, std::regex("[a[.hyphen.]z]", + std::regex_constants::basic))); + assert(m.size() == 0); + } + std::locale::global(std::locale("cs_CZ.ISO8859-2")); + { + std::cmatch m; + const char s[] = "m"; + assert(std::regex_match(s, m, std::regex("[a[=M=]z]", + std::regex_constants::basic))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "Ch"; + assert(std::regex_match(s, m, std::regex("[a[.ch.]z]", + std::regex_constants::basic | std::regex_constants::icase))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + std::locale::global(std::locale("C")); + { + std::cmatch m; + const char s[] = "m"; + assert(!std::regex_match(s, m, std::regex("[a[=M=]z]", + std::regex_constants::basic))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "01a45cef9"; + assert(!std::regex_match(s, m, std::regex("[ace1-9]*", + std::regex_constants::basic))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "01a45cef9"; + assert(!std::regex_match(s, m, std::regex("[ace1-9]\\{1,\\}", + std::regex_constants::basic))); + assert(m.size() == 0); + } + { + const char r[] = "^[-+]\\{0,1\\}[0-9]\\{1,\\}[CF]$"; + std::ptrdiff_t sr = std::char_traits<char>::length(r); + typedef forward_iterator<const char*> FI; + typedef bidirectional_iterator<const char*> BI; + std::regex regex(FI(r), FI(r+sr), std::regex_constants::basic); + std::match_results<BI> m; + const char s[] = "-40C"; + std::ptrdiff_t ss = std::char_traits<char>::length(s); + assert(std::regex_match(BI(s), BI(s+ss), m, regex)); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == BI(s)); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == 4); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + + { + std::wcmatch m; + assert(!std::regex_match(L"a", m, std::wregex())); + assert(m.size() == 0); + assert(m.empty()); + } + { + std::wcmatch m; + const wchar_t s[] = L"a"; + assert(std::regex_match(s, m, std::wregex(L"a", std::regex_constants::basic))); + assert(m.size() == 1); + assert(!m.empty()); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+1); + assert(m.length(0) == 1); + assert(m.position(0) == 0); + assert(m.str(0) == L"a"); + } + { + std::wcmatch m; + const wchar_t s[] = L"ab"; + assert(std::regex_match(s, m, std::wregex(L"ab", std::regex_constants::basic))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+2); + assert(m.length(0) == 2); + assert(m.position(0) == 0); + assert(m.str(0) == L"ab"); + } + { + std::wcmatch m; + const wchar_t s[] = L"ab"; + assert(!std::regex_match(s, m, std::wregex(L"ba", std::regex_constants::basic))); + assert(m.size() == 0); + assert(m.empty()); + } + { + std::wcmatch m; + const wchar_t s[] = L"aab"; + assert(!std::regex_match(s, m, std::wregex(L"ab", std::regex_constants::basic))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"aab"; + assert(!std::regex_match(s, m, std::wregex(L"ab", std::regex_constants::basic), + std::regex_constants::match_continuous)); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"abcd"; + assert(!std::regex_match(s, m, std::wregex(L"bc", std::regex_constants::basic))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"abbc"; + assert(std::regex_match(s, m, std::wregex(L"ab*c", std::regex_constants::basic))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+4); + assert(m.length(0) == 4); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"ababc"; + assert(std::regex_match(s, m, std::wregex(L"\\(ab\\)*c", std::regex_constants::basic))); + assert(m.size() == 2); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+5); + assert(m.length(0) == 5); + assert(m.position(0) == 0); + assert(m.str(0) == s); + assert(m.length(1) == 2); + assert(m.position(1) == 2); + assert(m.str(1) == L"ab"); + } + { + std::wcmatch m; + const wchar_t s[] = L"abcdefghijk"; + assert(!std::regex_match(s, m, std::wregex(L"cd\\(\\(e\\)fg\\)hi", + std::regex_constants::basic))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"abc"; + assert(std::regex_match(s, m, std::wregex(L"^abc", std::regex_constants::basic))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+3); + assert(m.length(0) == 3); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"abcd"; + assert(!std::regex_match(s, m, std::wregex(L"^abc", std::regex_constants::basic))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"aabc"; + assert(!std::regex_match(s, m, std::wregex(L"^abc", std::regex_constants::basic))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"abc"; + assert(std::regex_match(s, m, std::wregex(L"abc$", std::regex_constants::basic))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+3); + assert(m.length(0) == 3); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"efabc"; + assert(!std::regex_match(s, m, std::wregex(L"abc$", std::regex_constants::basic))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"efabcg"; + assert(!std::regex_match(s, m, std::wregex(L"abc$", std::regex_constants::basic))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"abc"; + assert(std::regex_match(s, m, std::wregex(L"a.c", std::regex_constants::basic))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+3); + assert(m.length(0) == 3); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"acc"; + assert(std::regex_match(s, m, std::wregex(L"a.c", std::regex_constants::basic))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+3); + assert(m.length(0) == 3); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"acc"; + assert(std::regex_match(s, m, std::wregex(L"a.c", std::regex_constants::basic))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+3); + assert(m.length(0) == 3); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"abcdef"; + assert(std::regex_match(s, m, std::wregex(L"\\(.*\\).*", std::regex_constants::basic))); + assert(m.size() == 2); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+6); + assert(m.length(0) == 6); + assert(m.position(0) == 0); + assert(m.str(0) == s); + assert(m.length(1) == 6); + assert(m.position(1) == 0); + assert(m.str(1) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"bc"; + assert(!std::regex_match(s, m, std::wregex(L"\\(a*\\)*", std::regex_constants::basic))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"abbc"; + assert(!std::regex_match(s, m, std::wregex(L"ab\\{3,5\\}c", std::regex_constants::basic))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"abbbc"; + assert(std::regex_match(s, m, std::wregex(L"ab\\{3,5\\}c", std::regex_constants::basic))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"abbbbc"; + assert(std::regex_match(s, m, std::wregex(L"ab\\{3,5\\}c", std::regex_constants::basic))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"abbbbbc"; + assert(std::regex_match(s, m, std::wregex(L"ab\\{3,5\\}c", std::regex_constants::basic))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"adefc"; + assert(!std::regex_match(s, m, std::wregex(L"ab\\{3,5\\}c", std::regex_constants::basic))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"abbbbbbc"; + assert(!std::regex_match(s, m, std::wregex(L"ab\\{3,5\\}c", std::regex_constants::basic))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"adec"; + assert(!std::regex_match(s, m, std::wregex(L"a.\\{3,5\\}c", std::regex_constants::basic))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"adefc"; + assert(std::regex_match(s, m, std::wregex(L"a.\\{3,5\\}c", std::regex_constants::basic))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"adefgc"; + assert(std::regex_match(s, m, std::wregex(L"a.\\{3,5\\}c", std::regex_constants::basic))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"adefghc"; + assert(std::regex_match(s, m, std::wregex(L"a.\\{3,5\\}c", std::regex_constants::basic))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"adefghic"; + assert(!std::regex_match(s, m, std::wregex(L"a.\\{3,5\\}c", std::regex_constants::basic))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"-ab,ab-"; + assert(std::regex_match(s, m, std::wregex(L"-\\(.*\\),\\1-", std::regex_constants::basic))); + assert(m.size() == 2); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + assert(m.length(1) == 2); + assert(m.position(1) == 1); + assert(m.str(1) == L"ab"); + } + { + std::wcmatch m; + const wchar_t s[] = L"ababbabb"; + assert(std::regex_match(s, m, std::wregex(L"^\\(ab*\\)*\\1$", std::regex_constants::basic))); + assert(m.size() == 2); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + assert(m.length(1) == 3); + assert(m.position(1) == 2); + assert(m.str(1) == L"abb"); + } + { + std::wcmatch m; + const wchar_t s[] = L"ababbab"; + assert(!std::regex_match(s, m, std::wregex(L"^\\(ab*\\)*\\1$", std::regex_constants::basic))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"aBAbbAbB"; + assert(std::regex_match(s, m, std::wregex(L"^\\(Ab*\\)*\\1$", + std::regex_constants::basic | std::regex_constants::icase))); + assert(m.size() == 2); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + assert(m.length(1) == 3); + assert(m.position(1) == 2); + assert(m.str(1) == L"Abb"); + } + { + std::wcmatch m; + const wchar_t s[] = L"aBAbbAbB"; + assert(!std::regex_match(s, m, std::wregex(L"^\\(Ab*\\)*\\1$", + std::regex_constants::basic))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"a"; + assert(std::regex_match(s, m, std::wregex(L"^[a]$", + std::regex_constants::basic))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == 1); + assert(m.position(0) == 0); + assert(m.str(0) == L"a"); + } + { + std::wcmatch m; + const wchar_t s[] = L"a"; + assert(std::regex_match(s, m, std::wregex(L"^[ab]$", + std::regex_constants::basic))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == 1); + assert(m.position(0) == 0); + assert(m.str(0) == L"a"); + } + { + std::wcmatch m; + const wchar_t s[] = L"c"; + assert(std::regex_match(s, m, std::wregex(L"^[a-f]$", + std::regex_constants::basic))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == 1); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"g"; + assert(!std::regex_match(s, m, std::wregex(L"^[a-f]$", + std::regex_constants::basic))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"Iraqi"; + assert(!std::regex_match(s, m, std::wregex(L"q[^u]", + std::regex_constants::basic))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"Iraq"; + assert(!std::regex_match(s, m, std::wregex(L"q[^u]", + std::regex_constants::basic))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"AmB"; + assert(std::regex_match(s, m, std::wregex(L"A[[:lower:]]B", + std::regex_constants::basic))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"AMB"; + assert(!std::regex_match(s, m, std::wregex(L"A[[:lower:]]B", + std::regex_constants::basic))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"AMB"; + assert(std::regex_match(s, m, std::wregex(L"A[^[:lower:]]B", + std::regex_constants::basic))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"AmB"; + assert(!std::regex_match(s, m, std::wregex(L"A[^[:lower:]]B", + std::regex_constants::basic))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"A5B"; + assert(!std::regex_match(s, m, std::wregex(L"A[^[:lower:]0-9]B", + std::regex_constants::basic))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"A?B"; + assert(std::regex_match(s, m, std::wregex(L"A[^[:lower:]0-9]B", + std::regex_constants::basic))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"-"; + assert(std::regex_match(s, m, std::wregex(L"[a[.hyphen.]z]", + std::regex_constants::basic))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"z"; + assert(std::regex_match(s, m, std::wregex(L"[a[.hyphen.]z]", + std::regex_constants::basic))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"m"; + assert(!std::regex_match(s, m, std::wregex(L"[a[.hyphen.]z]", + std::regex_constants::basic))); + assert(m.size() == 0); + } + std::locale::global(std::locale("cs_CZ.ISO8859-2")); + { + std::wcmatch m; + const wchar_t s[] = L"m"; + assert(std::regex_match(s, m, std::wregex(L"[a[=M=]z]", + std::regex_constants::basic))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"Ch"; + assert(std::regex_match(s, m, std::wregex(L"[a[.ch.]z]", + std::regex_constants::basic | std::regex_constants::icase))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + std::locale::global(std::locale("C")); + { + std::wcmatch m; + const wchar_t s[] = L"m"; + assert(!std::regex_match(s, m, std::wregex(L"[a[=M=]z]", + std::regex_constants::basic))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"01a45cef9"; + assert(!std::regex_match(s, m, std::wregex(L"[ace1-9]*", + std::regex_constants::basic))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"01a45cef9"; + assert(!std::regex_match(s, m, std::wregex(L"[ace1-9]\\{1,\\}", + std::regex_constants::basic))); + assert(m.size() == 0); + } + { + const wchar_t r[] = L"^[-+]\\{0,1\\}[0-9]\\{1,\\}[CF]$"; + std::ptrdiff_t sr = std::char_traits<wchar_t>::length(r); + typedef forward_iterator<const wchar_t*> FI; + typedef bidirectional_iterator<const wchar_t*> BI; + std::wregex regex(FI(r), FI(r+sr), std::regex_constants::basic); + std::match_results<BI> m; + const wchar_t s[] = L"-40C"; + std::ptrdiff_t ss = std::char_traits<wchar_t>::length(s); + assert(std::regex_match(BI(s), BI(s+ss), m, regex)); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == BI(s)); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == 4); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } +} diff --git a/libcxx/test/std/re/re.alg/re.alg.match/ecma.pass.cpp b/libcxx/test/std/re/re.alg/re.alg.match/ecma.pass.cpp new file mode 100644 index 00000000000..38540560452 --- /dev/null +++ b/libcxx/test/std/re/re.alg/re.alg.match/ecma.pass.cpp @@ -0,0 +1,1348 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// REQUIRES: locale.cs_CZ.ISO8859-2 + +// <regex> + +// template <class BidirectionalIterator, class Allocator, class charT, class traits> +// bool +// regex_match(BidirectionalIterator first, BidirectionalIterator last, +// match_results<BidirectionalIterator, Allocator>& m, +// const basic_regex<charT, traits>& e, +// regex_constants::match_flag_type flags = regex_constants::match_default); + +// TODO: investigation needed +// XFAIL: linux-gnu + +#include <regex> +#include <cassert> + +#include "test_iterators.h" + +int main() +{ + { + std::cmatch m; + const char s[] = "a"; + assert(std::regex_match(s, m, std::regex("a"))); + assert(m.size() == 1); + assert(!m.empty()); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+1); + assert(m.length(0) == 1); + assert(m.position(0) == 0); + assert(m.str(0) == "a"); + } + { + std::cmatch m; + const char s[] = "ab"; + assert(std::regex_match(s, m, std::regex("ab"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+2); + assert(m.length(0) == 2); + assert(m.position(0) == 0); + assert(m.str(0) == "ab"); + } + { + std::cmatch m; + const char s[] = "ab"; + assert(!std::regex_match(s, m, std::regex("ba"))); + assert(m.size() == 0); + assert(m.empty()); + } + { + std::cmatch m; + const char s[] = "aab"; + assert(!std::regex_match(s, m, std::regex("ab"))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "aab"; + assert(!std::regex_match(s, m, std::regex("ab"), + std::regex_constants::match_continuous)); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "abcd"; + assert(!std::regex_match(s, m, std::regex("bc"))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "abbc"; + assert(std::regex_match(s, m, std::regex("ab*c"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+4); + assert(m.length(0) == 4); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "ababc"; + assert(std::regex_match(s, m, std::regex("(ab)*c"))); + assert(m.size() == 2); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+5); + assert(m.length(0) == 5); + assert(m.position(0) == 0); + assert(m.str(0) == s); + assert(m.length(1) == 2); + assert(m.position(1) == 2); + assert(m.str(1) == "ab"); + } + { + std::cmatch m; + const char s[] = "abcdefghijk"; + assert(!std::regex_match(s, m, std::regex("cd((e)fg)hi"))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "abc"; + assert(std::regex_match(s, m, std::regex("^abc"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+3); + assert(m.length(0) == 3); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "abcd"; + assert(!std::regex_match(s, m, std::regex("^abc"))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "aabc"; + assert(!std::regex_match(s, m, std::regex("^abc"))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "abc"; + assert(std::regex_match(s, m, std::regex("abc$"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+3); + assert(m.length(0) == 3); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "efabc"; + assert(!std::regex_match(s, m, std::regex("abc$"))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "efabcg"; + assert(!std::regex_match(s, m, std::regex("abc$"))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "abc"; + assert(std::regex_match(s, m, std::regex("a.c"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+3); + assert(m.length(0) == 3); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "acc"; + assert(std::regex_match(s, m, std::regex("a.c"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+3); + assert(m.length(0) == 3); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "acc"; + assert(std::regex_match(s, m, std::regex("a.c"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+3); + assert(m.length(0) == 3); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "abcdef"; + assert(std::regex_match(s, m, std::regex("(.*).*"))); + assert(m.size() == 2); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+6); + assert(m.length(0) == 6); + assert(m.position(0) == 0); + assert(m.str(0) == s); + assert(m.length(1) == 6); + assert(m.position(1) == 0); + assert(m.str(1) == s); + } + { + std::cmatch m; + const char s[] = "bc"; + assert(!std::regex_match(s, m, std::regex("(a*)*"))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "abbc"; + assert(!std::regex_match(s, m, std::regex("ab{3,5}c"))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "abbbc"; + assert(std::regex_match(s, m, std::regex("ab{3,5}c"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "abbbbc"; + assert(std::regex_match(s, m, std::regex("ab{3,5}c"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "abbbbbc"; + assert(std::regex_match(s, m, std::regex("ab{3,5}c"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "adefc"; + assert(!std::regex_match(s, m, std::regex("ab{3,5}c"))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "abbbbbbc"; + assert(!std::regex_match(s, m, std::regex("ab{3,5}c"))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "adec"; + assert(!std::regex_match(s, m, std::regex("a.{3,5}c"))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "adefc"; + assert(std::regex_match(s, m, std::regex("a.{3,5}c"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "adefgc"; + assert(std::regex_match(s, m, std::regex("a.{3,5}c"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "adefghc"; + assert(std::regex_match(s, m, std::regex("a.{3,5}c"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "adefghic"; + assert(!std::regex_match(s, m, std::regex("a.{3,5}c"))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "tournament"; + assert(!std::regex_match(s, m, std::regex("tour|to|tournament"))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "tournamenttotour"; + assert(!std::regex_match(s, m, std::regex("(tour|to|tournament)+", + std::regex_constants::nosubs))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "ttotour"; + assert(std::regex_match(s, m, std::regex("(tour|to|t)+"))); + assert(m.size() == 2); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + assert(m.length(1) == 4); + assert(m.position(1) == 3); + assert(m.str(1) == "tour"); + } + { + std::cmatch m; + const char s[] = "-ab,ab-"; + assert(!std::regex_match(s, m, std::regex("-(.*),\1-"))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "-ab,ab-"; + assert(std::regex_match(s, m, std::regex("-.*,.*-"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "a"; + assert(std::regex_match(s, m, std::regex("^[a]$"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == 1); + assert(m.position(0) == 0); + assert(m.str(0) == "a"); + } + { + std::cmatch m; + const char s[] = "a"; + assert(std::regex_match(s, m, std::regex("^[ab]$"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == 1); + assert(m.position(0) == 0); + assert(m.str(0) == "a"); + } + { + std::cmatch m; + const char s[] = "c"; + assert(std::regex_match(s, m, std::regex("^[a-f]$"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == 1); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "g"; + assert(!std::regex_match(s, m, std::regex("^[a-f]$"))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "Iraqi"; + assert(!std::regex_match(s, m, std::regex("q[^u]"))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "Iraq"; + assert(!std::regex_match(s, m, std::regex("q[^u]"))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "AmB"; + assert(std::regex_match(s, m, std::regex("A[[:lower:]]B"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "AMB"; + assert(!std::regex_match(s, m, std::regex("A[[:lower:]]B"))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "AMB"; + assert(std::regex_match(s, m, std::regex("A[^[:lower:]]B"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "AmB"; + assert(!std::regex_match(s, m, std::regex("A[^[:lower:]]B"))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "A5B"; + assert(!std::regex_match(s, m, std::regex("A[^[:lower:]0-9]B"))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "A?B"; + assert(std::regex_match(s, m, std::regex("A[^[:lower:]0-9]B"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "-"; + assert(std::regex_match(s, m, std::regex("[a[.hyphen.]z]"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "z"; + assert(std::regex_match(s, m, std::regex("[a[.hyphen.]z]"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "m"; + assert(!std::regex_match(s, m, std::regex("[a[.hyphen.]z]"))); + assert(m.size() == 0); + } + std::locale::global(std::locale("cs_CZ.ISO8859-2")); + { + std::cmatch m; + const char s[] = "m"; + assert(std::regex_match(s, m, std::regex("[a[=M=]z]"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "Ch"; + assert(std::regex_match(s, m, std::regex("[a[.ch.]z]", + std::regex_constants::icase))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "foobar"; + assert(std::regex_match(s, m, std::regex("[^\\0]*"))); + assert(m.size() == 1); + } + { + std::cmatch m; + const char s[] = "foo\0bar"; + assert(std::regex_match(s, s+7, m, std::regex("[abfor\\0]*"))); + assert(m.size() == 1); + } + std::locale::global(std::locale("C")); + { + std::cmatch m; + const char s[] = "m"; + assert(!std::regex_match(s, m, std::regex("[a[=M=]z]"))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "01a45cef9"; + assert(!std::regex_match(s, m, std::regex("[ace1-9]*"))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "01a45cef9"; + assert(!std::regex_match(s, m, std::regex("[ace1-9]+"))); + assert(m.size() == 0); + } + { + const char r[] = "^[-+]?[0-9]+[CF]$"; + std::ptrdiff_t sr = std::char_traits<char>::length(r); + typedef forward_iterator<const char*> FI; + typedef bidirectional_iterator<const char*> BI; + std::regex regex(FI(r), FI(r+sr)); + std::match_results<BI> m; + const char s[] = "-40C"; + std::ptrdiff_t ss = std::char_traits<char>::length(s); + assert(std::regex_match(BI(s), BI(s+ss), m, regex)); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == BI(s)); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == 4); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "Jeff Jeffs "; + assert(!std::regex_match(s, m, std::regex("Jeff(?=s\\b)"))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "Jeffs Jeff"; + assert(!std::regex_match(s, m, std::regex("Jeff(?!s\\b)"))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "5%k"; + assert(std::regex_match(s, m, std::regex("\\d[\\W]k"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s + std::char_traits<char>::length(s)); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + + { + std::wcmatch m; + const wchar_t s[] = L"a"; + assert(std::regex_match(s, m, std::wregex(L"a"))); + assert(m.size() == 1); + assert(!m.empty()); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+1); + assert(m.length(0) == 1); + assert(m.position(0) == 0); + assert(m.str(0) == L"a"); + } + { + std::wcmatch m; + const wchar_t s[] = L"ab"; + assert(std::regex_match(s, m, std::wregex(L"ab"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+2); + assert(m.length(0) == 2); + assert(m.position(0) == 0); + assert(m.str(0) == L"ab"); + } + { + std::wcmatch m; + const wchar_t s[] = L"ab"; + assert(!std::regex_match(s, m, std::wregex(L"ba"))); + assert(m.size() == 0); + assert(m.empty()); + } + { + std::wcmatch m; + const wchar_t s[] = L"aab"; + assert(!std::regex_match(s, m, std::wregex(L"ab"))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"aab"; + assert(!std::regex_match(s, m, std::wregex(L"ab"), + std::regex_constants::match_continuous)); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"abcd"; + assert(!std::regex_match(s, m, std::wregex(L"bc"))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"abbc"; + assert(std::regex_match(s, m, std::wregex(L"ab*c"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+4); + assert(m.length(0) == 4); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"ababc"; + assert(std::regex_match(s, m, std::wregex(L"(ab)*c"))); + assert(m.size() == 2); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+5); + assert(m.length(0) == 5); + assert(m.position(0) == 0); + assert(m.str(0) == s); + assert(m.length(1) == 2); + assert(m.position(1) == 2); + assert(m.str(1) == L"ab"); + } + { + std::wcmatch m; + const wchar_t s[] = L"abcdefghijk"; + assert(!std::regex_match(s, m, std::wregex(L"cd((e)fg)hi"))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"abc"; + assert(std::regex_match(s, m, std::wregex(L"^abc"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+3); + assert(m.length(0) == 3); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"abcd"; + assert(!std::regex_match(s, m, std::wregex(L"^abc"))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"aabc"; + assert(!std::regex_match(s, m, std::wregex(L"^abc"))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"abc"; + assert(std::regex_match(s, m, std::wregex(L"abc$"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+3); + assert(m.length(0) == 3); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"efabc"; + assert(!std::regex_match(s, m, std::wregex(L"abc$"))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"efabcg"; + assert(!std::regex_match(s, m, std::wregex(L"abc$"))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"abc"; + assert(std::regex_match(s, m, std::wregex(L"a.c"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+3); + assert(m.length(0) == 3); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"acc"; + assert(std::regex_match(s, m, std::wregex(L"a.c"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+3); + assert(m.length(0) == 3); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"acc"; + assert(std::regex_match(s, m, std::wregex(L"a.c"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+3); + assert(m.length(0) == 3); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"abcdef"; + assert(std::regex_match(s, m, std::wregex(L"(.*).*"))); + assert(m.size() == 2); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+6); + assert(m.length(0) == 6); + assert(m.position(0) == 0); + assert(m.str(0) == s); + assert(m.length(1) == 6); + assert(m.position(1) == 0); + assert(m.str(1) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"bc"; + assert(!std::regex_match(s, m, std::wregex(L"(a*)*"))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"abbc"; + assert(!std::regex_match(s, m, std::wregex(L"ab{3,5}c"))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"abbbc"; + assert(std::regex_match(s, m, std::wregex(L"ab{3,5}c"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"abbbbc"; + assert(std::regex_match(s, m, std::wregex(L"ab{3,5}c"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"abbbbbc"; + assert(std::regex_match(s, m, std::wregex(L"ab{3,5}c"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"adefc"; + assert(!std::regex_match(s, m, std::wregex(L"ab{3,5}c"))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"abbbbbbc"; + assert(!std::regex_match(s, m, std::wregex(L"ab{3,5}c"))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"adec"; + assert(!std::regex_match(s, m, std::wregex(L"a.{3,5}c"))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"adefc"; + assert(std::regex_match(s, m, std::wregex(L"a.{3,5}c"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"adefgc"; + assert(std::regex_match(s, m, std::wregex(L"a.{3,5}c"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"adefghc"; + assert(std::regex_match(s, m, std::wregex(L"a.{3,5}c"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"adefghic"; + assert(!std::regex_match(s, m, std::wregex(L"a.{3,5}c"))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"tournament"; + assert(!std::regex_match(s, m, std::wregex(L"tour|to|tournament"))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"tournamenttotour"; + assert(!std::regex_match(s, m, std::wregex(L"(tour|to|tournament)+", + std::regex_constants::nosubs))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"ttotour"; + assert(std::regex_match(s, m, std::wregex(L"(tour|to|t)+"))); + assert(m.size() == 2); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + assert(m.length(1) == 4); + assert(m.position(1) == 3); + assert(m.str(1) == L"tour"); + } + { + std::wcmatch m; + const wchar_t s[] = L"-ab,ab-"; + assert(!std::regex_match(s, m, std::wregex(L"-(.*),\1-"))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"-ab,ab-"; + assert(std::regex_match(s, m, std::wregex(L"-.*,.*-"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"a"; + assert(std::regex_match(s, m, std::wregex(L"^[a]$"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == 1); + assert(m.position(0) == 0); + assert(m.str(0) == L"a"); + } + { + std::wcmatch m; + const wchar_t s[] = L"a"; + assert(std::regex_match(s, m, std::wregex(L"^[ab]$"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == 1); + assert(m.position(0) == 0); + assert(m.str(0) == L"a"); + } + { + std::wcmatch m; + const wchar_t s[] = L"c"; + assert(std::regex_match(s, m, std::wregex(L"^[a-f]$"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == 1); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"g"; + assert(!std::regex_match(s, m, std::wregex(L"^[a-f]$"))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"Iraqi"; + assert(!std::regex_match(s, m, std::wregex(L"q[^u]"))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"Iraq"; + assert(!std::regex_match(s, m, std::wregex(L"q[^u]"))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"AmB"; + assert(std::regex_match(s, m, std::wregex(L"A[[:lower:]]B"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"AMB"; + assert(!std::regex_match(s, m, std::wregex(L"A[[:lower:]]B"))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"AMB"; + assert(std::regex_match(s, m, std::wregex(L"A[^[:lower:]]B"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"AmB"; + assert(!std::regex_match(s, m, std::wregex(L"A[^[:lower:]]B"))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"A5B"; + assert(!std::regex_match(s, m, std::wregex(L"A[^[:lower:]0-9]B"))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"A?B"; + assert(std::regex_match(s, m, std::wregex(L"A[^[:lower:]0-9]B"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"-"; + assert(std::regex_match(s, m, std::wregex(L"[a[.hyphen.]z]"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"z"; + assert(std::regex_match(s, m, std::wregex(L"[a[.hyphen.]z]"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"m"; + assert(!std::regex_match(s, m, std::wregex(L"[a[.hyphen.]z]"))); + assert(m.size() == 0); + } + std::locale::global(std::locale("cs_CZ.ISO8859-2")); + { + std::wcmatch m; + const wchar_t s[] = L"m"; + assert(std::regex_match(s, m, std::wregex(L"[a[=M=]z]"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"Ch"; + assert(std::regex_match(s, m, std::wregex(L"[a[.ch.]z]", + std::regex_constants::icase))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + std::locale::global(std::locale("C")); + { + std::wcmatch m; + const wchar_t s[] = L"m"; + assert(!std::regex_match(s, m, std::wregex(L"[a[=M=]z]"))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"01a45cef9"; + assert(!std::regex_match(s, m, std::wregex(L"[ace1-9]*"))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"01a45cef9"; + assert(!std::regex_match(s, m, std::wregex(L"[ace1-9]+"))); + assert(m.size() == 0); + } + { + const wchar_t r[] = L"^[-+]?[0-9]+[CF]$"; + std::ptrdiff_t sr = std::char_traits<wchar_t>::length(r); + typedef forward_iterator<const wchar_t*> FI; + typedef bidirectional_iterator<const wchar_t*> BI; + std::wregex regex(FI(r), FI(r+sr)); + std::match_results<BI> m; + const wchar_t s[] = L"-40C"; + std::ptrdiff_t ss = std::char_traits<wchar_t>::length(s); + assert(std::regex_match(BI(s), BI(s+ss), m, regex)); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == BI(s)); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == 4); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"Jeff Jeffs "; + assert(!std::regex_match(s, m, std::wregex(L"Jeff(?=s\\b)"))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"Jeffs Jeff"; + assert(!std::regex_match(s, m, std::wregex(L"Jeff(?!s\\b)"))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"5%k"; + assert(std::regex_match(s, m, std::wregex(L"\\d[\\W]k"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s + std::char_traits<wchar_t>::length(s)); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } +} diff --git a/libcxx/test/std/re/re.alg/re.alg.match/egrep.pass.cpp b/libcxx/test/std/re/re.alg/re.alg.match/egrep.pass.cpp new file mode 100644 index 00000000000..dd2e6038dc3 --- /dev/null +++ b/libcxx/test/std/re/re.alg/re.alg.match/egrep.pass.cpp @@ -0,0 +1,81 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <regex> + +// template <class BidirectionalIterator, class Allocator, class charT, class traits> +// bool +// regex_match(BidirectionalIterator first, BidirectionalIterator last, +// match_results<BidirectionalIterator, Allocator>& m, +// const basic_regex<charT, traits>& e, +// regex_constants::match_flag_type flags = regex_constants::match_default); + +#include <regex> +#include <cassert> + +#include "test_iterators.h" + +int main() +{ + { + std::cmatch m; + const char s[] = "tournament"; + assert(std::regex_match(s, m, std::regex("tour\nto\ntournament", + std::regex_constants::egrep))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s + std::char_traits<char>::length(s)); + assert(m.length(0) == 10); + assert(m.position(0) == 0); + assert(m.str(0) == "tournament"); + } + { + std::cmatch m; + const char s[] = "ment"; + assert(!std::regex_match(s, m, std::regex("tour\n\ntournament", + std::regex_constants::egrep))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "tournament"; + assert(std::regex_match(s, m, std::regex("(tour|to|tournament)+\ntourna", + std::regex_constants::egrep))); + assert(m.size() == 2); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s + std::char_traits<char>::length(s)); + assert(m.length(0) == 10); + assert(m.position(0) == 0); + assert(m.str(0) == "tournament"); + } + { + std::cmatch m; + const char s[] = "tourna"; + assert(std::regex_match(s, m, std::regex("(tour|to|tournament)+\ntourna", + std::regex_constants::egrep))); + assert(m.size() == 2); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s + std::char_traits<char>::length(s)); + assert(m.length(0) == 6); + assert(m.position(0) == 0); + assert(m.str(0) == "tourna"); + } +} diff --git a/libcxx/test/std/re/re.alg/re.alg.match/extended.pass.cpp b/libcxx/test/std/re/re.alg/re.alg.match/extended.pass.cpp new file mode 100644 index 00000000000..c54825de584 --- /dev/null +++ b/libcxx/test/std/re/re.alg/re.alg.match/extended.pass.cpp @@ -0,0 +1,1362 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// REQUIRES: locale.cs_CZ.ISO8859-2 + +// <regex> + +// template <class BidirectionalIterator, class Allocator, class charT, class traits> +// bool +// regex_match(BidirectionalIterator first, BidirectionalIterator last, +// match_results<BidirectionalIterator, Allocator>& m, +// const basic_regex<charT, traits>& e, +// regex_constants::match_flag_type flags = regex_constants::match_default); + +// TODO: investigation needed +// XFAIL: linux-gnu + +#include <regex> +#include <cassert> + +#include "test_iterators.h" + +int main() +{ + { + std::cmatch m; + const char s[] = "a"; + assert(std::regex_match(s, m, std::regex("a", std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.empty()); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+1); + assert(m.length(0) == 1); + assert(m.position(0) == 0); + assert(m.str(0) == "a"); + } + { + std::cmatch m; + const char s[] = "ab"; + assert(std::regex_match(s, m, std::regex("ab", std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+2); + assert(m.length(0) == 2); + assert(m.position(0) == 0); + assert(m.str(0) == "ab"); + } + { + std::cmatch m; + const char s[] = "ab"; + assert(!std::regex_match(s, m, std::regex("ba", std::regex_constants::extended))); + assert(m.size() == 0); + assert(m.empty()); + } + { + std::cmatch m; + const char s[] = "aab"; + assert(!std::regex_match(s, m, std::regex("ab", std::regex_constants::extended))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "aab"; + assert(!std::regex_match(s, m, std::regex("ab", std::regex_constants::extended), + std::regex_constants::match_continuous)); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "abcd"; + assert(!std::regex_match(s, m, std::regex("bc", std::regex_constants::extended))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "abbc"; + assert(std::regex_match(s, m, std::regex("ab*c", std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+4); + assert(m.length(0) == 4); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "ababc"; + assert(std::regex_match(s, m, std::regex("(ab)*c", std::regex_constants::extended))); + assert(m.size() == 2); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+5); + assert(m.length(0) == 5); + assert(m.position(0) == 0); + assert(m.str(0) == s); + assert(m.length(1) == 2); + assert(m.position(1) == 2); + assert(m.str(1) == "ab"); + } + { + std::cmatch m; + const char s[] = "abcdefghijk"; + assert(!std::regex_match(s, m, std::regex("cd((e)fg)hi", + std::regex_constants::extended))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "abc"; + assert(std::regex_match(s, m, std::regex("^abc", std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+3); + assert(m.length(0) == 3); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "abcd"; + assert(!std::regex_match(s, m, std::regex("^abc", std::regex_constants::extended))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "aabc"; + assert(!std::regex_match(s, m, std::regex("^abc", std::regex_constants::extended))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "abc"; + assert(std::regex_match(s, m, std::regex("abc$", std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+3); + assert(m.length(0) == 3); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "efabc"; + assert(!std::regex_match(s, m, std::regex("abc$", std::regex_constants::extended))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "efabcg"; + assert(!std::regex_match(s, m, std::regex("abc$", std::regex_constants::extended))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "abc"; + assert(std::regex_match(s, m, std::regex("a.c", std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+3); + assert(m.length(0) == 3); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "acc"; + assert(std::regex_match(s, m, std::regex("a.c", std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+3); + assert(m.length(0) == 3); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "acc"; + assert(std::regex_match(s, m, std::regex("a.c", std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+3); + assert(m.length(0) == 3); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "abcdef"; + assert(std::regex_match(s, m, std::regex("(.*).*", std::regex_constants::extended))); + assert(m.size() == 2); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+6); + assert(m.length(0) == 6); + assert(m.position(0) == 0); + assert(m.str(0) == s); + assert(m.length(1) == 6); + assert(m.position(1) == 0); + assert(m.str(1) == s); + } + { + std::cmatch m; + const char s[] = "bc"; + assert(!std::regex_match(s, m, std::regex("(a*)*", std::regex_constants::extended))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "abbc"; + assert(!std::regex_match(s, m, std::regex("ab{3,5}c", std::regex_constants::extended))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "abbbc"; + assert(std::regex_match(s, m, std::regex("ab{3,5}c", std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "abbbbc"; + assert(std::regex_match(s, m, std::regex("ab{3,5}c", std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "abbbbbc"; + assert(std::regex_match(s, m, std::regex("ab{3,5}c", std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "adefc"; + assert(!std::regex_match(s, m, std::regex("ab{3,5}c", std::regex_constants::extended))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "abbbbbbc"; + assert(!std::regex_match(s, m, std::regex("ab{3,5}c", std::regex_constants::extended))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "adec"; + assert(!std::regex_match(s, m, std::regex("a.{3,5}c", std::regex_constants::extended))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "adefc"; + assert(std::regex_match(s, m, std::regex("a.{3,5}c", std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "adefgc"; + assert(std::regex_match(s, m, std::regex("a.{3,5}c", std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "adefghc"; + assert(std::regex_match(s, m, std::regex("a.{3,5}c", std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "adefghic"; + assert(!std::regex_match(s, m, std::regex("a.{3,5}c", std::regex_constants::extended))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "tournament"; + assert(std::regex_match(s, m, std::regex("tour|to|tournament", + std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "tournamenttotour"; + assert(std::regex_match(s, m, std::regex("(tour|to|tournament)+", + std::regex_constants::extended | std::regex_constants::nosubs))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "ttotour"; + assert(std::regex_match(s, m, std::regex("(tour|to|t)+", + std::regex_constants::extended))); + assert(m.size() == 2); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + assert(m.length(1) == 4); + assert(m.position(1) == 3); + assert(m.str(1) == "tour"); + } + { + std::cmatch m; + const char s[] = "-ab,ab-"; + assert(!std::regex_match(s, m, std::regex("-(.*),\1-", std::regex_constants::extended))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "-ab,ab-"; + assert(std::regex_match(s, m, std::regex("-.*,.*-", std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "a"; + assert(std::regex_match(s, m, std::regex("^[a]$", + std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == 1); + assert(m.position(0) == 0); + assert(m.str(0) == "a"); + } + { + std::cmatch m; + const char s[] = "a"; + assert(std::regex_match(s, m, std::regex("^[ab]$", + std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == 1); + assert(m.position(0) == 0); + assert(m.str(0) == "a"); + } + { + std::cmatch m; + const char s[] = "c"; + assert(std::regex_match(s, m, std::regex("^[a-f]$", + std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == 1); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "g"; + assert(!std::regex_match(s, m, std::regex("^[a-f]$", + std::regex_constants::extended))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "Iraqi"; + assert(!std::regex_match(s, m, std::regex("q[^u]", + std::regex_constants::extended))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "Iraq"; + assert(!std::regex_match(s, m, std::regex("q[^u]", + std::regex_constants::extended))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "AmB"; + assert(std::regex_match(s, m, std::regex("A[[:lower:]]B", + std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "AMB"; + assert(!std::regex_match(s, m, std::regex("A[[:lower:]]B", + std::regex_constants::extended))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "AMB"; + assert(std::regex_match(s, m, std::regex("A[^[:lower:]]B", + std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "AmB"; + assert(!std::regex_match(s, m, std::regex("A[^[:lower:]]B", + std::regex_constants::extended))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "A5B"; + assert(!std::regex_match(s, m, std::regex("A[^[:lower:]0-9]B", + std::regex_constants::extended))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "A?B"; + assert(std::regex_match(s, m, std::regex("A[^[:lower:]0-9]B", + std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "-"; + assert(std::regex_match(s, m, std::regex("[a[.hyphen.]z]", + std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "z"; + assert(std::regex_match(s, m, std::regex("[a[.hyphen.]z]", + std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "m"; + assert(!std::regex_match(s, m, std::regex("[a[.hyphen.]z]", + std::regex_constants::extended))); + assert(m.size() == 0); + } + std::locale::global(std::locale("cs_CZ.ISO8859-2")); + { + std::cmatch m; + const char s[] = "m"; + assert(std::regex_match(s, m, std::regex("[a[=M=]z]", + std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "Ch"; + assert(std::regex_match(s, m, std::regex("[a[.ch.]z]", + std::regex_constants::extended | std::regex_constants::icase))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + std::locale::global(std::locale("C")); + { + std::cmatch m; + const char s[] = "m"; + assert(!std::regex_match(s, m, std::regex("[a[=M=]z]", + std::regex_constants::extended))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "01a45cef9"; + assert(!std::regex_match(s, m, std::regex("[ace1-9]*", + std::regex_constants::extended))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "01a45cef9"; + assert(!std::regex_match(s, m, std::regex("[ace1-9]+", + std::regex_constants::extended))); + assert(m.size() == 0); + } + { + const char r[] = "^[-+]?[0-9]+[CF]$"; + std::ptrdiff_t sr = std::char_traits<char>::length(r); + typedef forward_iterator<const char*> FI; + typedef bidirectional_iterator<const char*> BI; + std::regex regex(FI(r), FI(r+sr), std::regex_constants::extended); + std::match_results<BI> m; + const char s[] = "-40C"; + std::ptrdiff_t ss = std::char_traits<char>::length(s); + assert(std::regex_match(BI(s), BI(s+ss), m, regex)); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == BI(s)); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == 4); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + + { + std::wcmatch m; + const wchar_t s[] = L"a"; + assert(std::regex_match(s, m, std::wregex(L"a", std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.empty()); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+1); + assert(m.length(0) == 1); + assert(m.position(0) == 0); + assert(m.str(0) == L"a"); + } + { + std::wcmatch m; + const wchar_t s[] = L"ab"; + assert(std::regex_match(s, m, std::wregex(L"ab", std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+2); + assert(m.length(0) == 2); + assert(m.position(0) == 0); + assert(m.str(0) == L"ab"); + } + { + std::wcmatch m; + const wchar_t s[] = L"ab"; + assert(!std::regex_match(s, m, std::wregex(L"ba", std::regex_constants::extended))); + assert(m.size() == 0); + assert(m.empty()); + } + { + std::wcmatch m; + const wchar_t s[] = L"aab"; + assert(!std::regex_match(s, m, std::wregex(L"ab", std::regex_constants::extended))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"aab"; + assert(!std::regex_match(s, m, std::wregex(L"ab", std::regex_constants::extended), + std::regex_constants::match_continuous)); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"abcd"; + assert(!std::regex_match(s, m, std::wregex(L"bc", std::regex_constants::extended))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"abbc"; + assert(std::regex_match(s, m, std::wregex(L"ab*c", std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+4); + assert(m.length(0) == 4); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"ababc"; + assert(std::regex_match(s, m, std::wregex(L"(ab)*c", std::regex_constants::extended))); + assert(m.size() == 2); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+5); + assert(m.length(0) == 5); + assert(m.position(0) == 0); + assert(m.str(0) == s); + assert(m.length(1) == 2); + assert(m.position(1) == 2); + assert(m.str(1) == L"ab"); + } + { + std::wcmatch m; + const wchar_t s[] = L"abcdefghijk"; + assert(!std::regex_match(s, m, std::wregex(L"cd((e)fg)hi", + std::regex_constants::extended))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"abc"; + assert(std::regex_match(s, m, std::wregex(L"^abc", std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+3); + assert(m.length(0) == 3); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"abcd"; + assert(!std::regex_match(s, m, std::wregex(L"^abc", std::regex_constants::extended))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"aabc"; + assert(!std::regex_match(s, m, std::wregex(L"^abc", std::regex_constants::extended))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"abc"; + assert(std::regex_match(s, m, std::wregex(L"abc$", std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+3); + assert(m.length(0) == 3); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"efabc"; + assert(!std::regex_match(s, m, std::wregex(L"abc$", std::regex_constants::extended))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"efabcg"; + assert(!std::regex_match(s, m, std::wregex(L"abc$", std::regex_constants::extended))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"abc"; + assert(std::regex_match(s, m, std::wregex(L"a.c", std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+3); + assert(m.length(0) == 3); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"acc"; + assert(std::regex_match(s, m, std::wregex(L"a.c", std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+3); + assert(m.length(0) == 3); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"acc"; + assert(std::regex_match(s, m, std::wregex(L"a.c", std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+3); + assert(m.length(0) == 3); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"abcdef"; + assert(std::regex_match(s, m, std::wregex(L"(.*).*", std::regex_constants::extended))); + assert(m.size() == 2); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+6); + assert(m.length(0) == 6); + assert(m.position(0) == 0); + assert(m.str(0) == s); + assert(m.length(1) == 6); + assert(m.position(1) == 0); + assert(m.str(1) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"bc"; + assert(!std::regex_match(s, m, std::wregex(L"(a*)*", std::regex_constants::extended))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"abbc"; + assert(!std::regex_match(s, m, std::wregex(L"ab{3,5}c", std::regex_constants::extended))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"abbbc"; + assert(std::regex_match(s, m, std::wregex(L"ab{3,5}c", std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"abbbbc"; + assert(std::regex_match(s, m, std::wregex(L"ab{3,5}c", std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"abbbbbc"; + assert(std::regex_match(s, m, std::wregex(L"ab{3,5}c", std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"adefc"; + assert(!std::regex_match(s, m, std::wregex(L"ab{3,5}c", std::regex_constants::extended))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"abbbbbbc"; + assert(!std::regex_match(s, m, std::wregex(L"ab{3,5}c", std::regex_constants::extended))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"adec"; + assert(!std::regex_match(s, m, std::wregex(L"a.{3,5}c", std::regex_constants::extended))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"adefc"; + assert(std::regex_match(s, m, std::wregex(L"a.{3,5}c", std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"adefgc"; + assert(std::regex_match(s, m, std::wregex(L"a.{3,5}c", std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"adefghc"; + assert(std::regex_match(s, m, std::wregex(L"a.{3,5}c", std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"adefghic"; + assert(!std::regex_match(s, m, std::wregex(L"a.{3,5}c", std::regex_constants::extended))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"tournament"; + assert(std::regex_match(s, m, std::wregex(L"tour|to|tournament", + std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"tournamenttotour"; + assert(std::regex_match(s, m, std::wregex(L"(tour|to|tournament)+", + std::regex_constants::extended | std::regex_constants::nosubs))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"ttotour"; + assert(std::regex_match(s, m, std::wregex(L"(tour|to|t)+", + std::regex_constants::extended))); + assert(m.size() == 2); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + assert(m.length(1) == 4); + assert(m.position(1) == 3); + assert(m.str(1) == L"tour"); + } + { + std::wcmatch m; + const wchar_t s[] = L"-ab,ab-"; + assert(!std::regex_match(s, m, std::wregex(L"-(.*),\1-", std::regex_constants::extended))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"-ab,ab-"; + assert(std::regex_match(s, m, std::wregex(L"-.*,.*-", std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"a"; + assert(std::regex_match(s, m, std::wregex(L"^[a]$", + std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == 1); + assert(m.position(0) == 0); + assert(m.str(0) == L"a"); + } + { + std::wcmatch m; + const wchar_t s[] = L"a"; + assert(std::regex_match(s, m, std::wregex(L"^[ab]$", + std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == 1); + assert(m.position(0) == 0); + assert(m.str(0) == L"a"); + } + { + std::wcmatch m; + const wchar_t s[] = L"c"; + assert(std::regex_match(s, m, std::wregex(L"^[a-f]$", + std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == 1); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"g"; + assert(!std::regex_match(s, m, std::wregex(L"^[a-f]$", + std::regex_constants::extended))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"Iraqi"; + assert(!std::regex_match(s, m, std::wregex(L"q[^u]", + std::regex_constants::extended))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"Iraq"; + assert(!std::regex_match(s, m, std::wregex(L"q[^u]", + std::regex_constants::extended))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"AmB"; + assert(std::regex_match(s, m, std::wregex(L"A[[:lower:]]B", + std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"AMB"; + assert(!std::regex_match(s, m, std::wregex(L"A[[:lower:]]B", + std::regex_constants::extended))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"AMB"; + assert(std::regex_match(s, m, std::wregex(L"A[^[:lower:]]B", + std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"AmB"; + assert(!std::regex_match(s, m, std::wregex(L"A[^[:lower:]]B", + std::regex_constants::extended))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"A5B"; + assert(!std::regex_match(s, m, std::wregex(L"A[^[:lower:]0-9]B", + std::regex_constants::extended))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"A?B"; + assert(std::regex_match(s, m, std::wregex(L"A[^[:lower:]0-9]B", + std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"-"; + assert(std::regex_match(s, m, std::wregex(L"[a[.hyphen.]z]", + std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"z"; + assert(std::regex_match(s, m, std::wregex(L"[a[.hyphen.]z]", + std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"m"; + assert(!std::regex_match(s, m, std::wregex(L"[a[.hyphen.]z]", + std::regex_constants::extended))); + assert(m.size() == 0); + } + std::locale::global(std::locale("cs_CZ.ISO8859-2")); + { + std::wcmatch m; + const wchar_t s[] = L"m"; + assert(std::regex_match(s, m, std::wregex(L"[a[=M=]z]", + std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"Ch"; + assert(std::regex_match(s, m, std::wregex(L"[a[.ch.]z]", + std::regex_constants::extended | std::regex_constants::icase))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + std::locale::global(std::locale("C")); + { + std::wcmatch m; + const wchar_t s[] = L"m"; + assert(!std::regex_match(s, m, std::wregex(L"[a[=M=]z]", + std::regex_constants::extended))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"01a45cef9"; + assert(!std::regex_match(s, m, std::wregex(L"[ace1-9]*", + std::regex_constants::extended))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"01a45cef9"; + assert(!std::regex_match(s, m, std::wregex(L"[ace1-9]+", + std::regex_constants::extended))); + assert(m.size() == 0); + } + { + const wchar_t r[] = L"^[-+]?[0-9]+[CF]$"; + std::ptrdiff_t sr = std::char_traits<wchar_t>::length(r); + typedef forward_iterator<const wchar_t*> FI; + typedef bidirectional_iterator<const wchar_t*> BI; + std::wregex regex(FI(r), FI(r+sr), std::regex_constants::extended); + std::match_results<BI> m; + const wchar_t s[] = L"-40C"; + std::ptrdiff_t ss = std::char_traits<wchar_t>::length(s); + assert(std::regex_match(BI(s), BI(s+ss), m, regex)); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == BI(s)); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == 4); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } +} diff --git a/libcxx/test/std/re/re.alg/re.alg.match/grep.pass.cpp b/libcxx/test/std/re/re.alg/re.alg.match/grep.pass.cpp new file mode 100644 index 00000000000..2dc0966d6b8 --- /dev/null +++ b/libcxx/test/std/re/re.alg/re.alg.match/grep.pass.cpp @@ -0,0 +1,49 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <regex> + +// template <class BidirectionalIterator, class Allocator, class charT, class traits> +// bool +// regex_match(BidirectionalIterator first, BidirectionalIterator last, +// match_results<BidirectionalIterator, Allocator>& m, +// const basic_regex<charT, traits>& e, +// regex_constants::match_flag_type flags = regex_constants::match_default); + +#include <regex> +#include <cassert> + +#include "test_iterators.h" + +int main() +{ + { + std::cmatch m; + const char s[] = "tournament"; + assert(std::regex_match(s, m, std::regex("tour\nto\ntournament", + std::regex_constants::grep))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s + std::char_traits<char>::length(s)); + assert(m.length(0) == 10); + assert(m.position(0) == 0); + assert(m.str(0) == "tournament"); + } + { + std::cmatch m; + const char s[] = "ment"; + assert(!std::regex_match(s, m, std::regex("tour\n\ntournament", + std::regex_constants::grep))); + assert(m.size() == 0); + } +} diff --git a/libcxx/test/std/re/re.alg/re.alg.match/lookahead_capture.pass.cpp b/libcxx/test/std/re/re.alg/re.alg.match/lookahead_capture.pass.cpp new file mode 100644 index 00000000000..949739b992c --- /dev/null +++ b/libcxx/test/std/re/re.alg/re.alg.match/lookahead_capture.pass.cpp @@ -0,0 +1,98 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <regex> + +// template <class BidirectionalIterator, class Allocator, class charT, class traits> +// bool +// regex_match(BidirectionalIterator first, BidirectionalIterator last, +// match_results<BidirectionalIterator, Allocator>& m, +// const basic_regex<charT, traits>& e, +// regex_constants::match_flag_type flags = regex_constants::match_default); + +// std::regex in ECMAScript mode should not ignore capture groups inside lookahead assertions. +// For example, matching /(?=(a))(a)/ to "a" should yield two captures: \1 = "a", \2 = "a" + +#include <regex> +#include <cassert> + +#include "test_iterators.h" + +int main() +{ + { + std::regex re("^(?=(.))a$"); + assert(re.mark_count() == 1); + + std::string s("a"); + std::smatch m; + assert(std::regex_match(s, m, re)); + assert(m.size() == 2); + assert(m[0] == "a"); + assert(m[1] == "a"); + } + + { + std::regex re("^(a)(?=(.))(b)$"); + assert(re.mark_count() == 3); + + std::string s("ab"); + std::smatch m; + assert(std::regex_match(s, m, re)); + assert(m.size() == 4); + assert(m[0] == "ab"); + assert(m[1] == "a"); + assert(m[2] == "b"); + assert(m[3] == "b"); + } + + { + std::regex re("^(.)(?=(.)(?=.(.)))(...)$"); + assert(re.mark_count() == 4); + + std::string s("abcd"); + std::smatch m; + assert(std::regex_match(s, m, re)); + assert(m.size() == 5); + assert(m[0] == "abcd"); + assert(m[1] == "a"); + assert(m[2] == "b"); + assert(m[3] == "d"); + assert(m[4] == "bcd"); + } + + { + std::regex re("^(a)(?!([^b]))(.c)$"); + assert(re.mark_count() == 3); + + std::string s("abc"); + std::smatch m; + assert(std::regex_match(s, m, re)); + assert(m.size() == 4); + assert(m[0] == "abc"); + assert(m[1] == "a"); + assert(m[2] == ""); + assert(m[3] == "bc"); + } + + { + std::regex re("^(?!((b)))(?=(.))(?!(abc)).b$"); + assert(re.mark_count() == 4); + + std::string s("ab"); + std::smatch m; + assert(std::regex_match(s, m, re)); + assert(m.size() == 5); + assert(m[0] == "ab"); + assert(m[1] == ""); + assert(m[2] == ""); + assert(m[3] == "a"); + assert(m[4] == ""); + } +} diff --git a/libcxx/test/std/re/re.alg/re.alg.match/parse_curly_brackets.pass.cpp b/libcxx/test/std/re/re.alg/re.alg.match/parse_curly_brackets.pass.cpp new file mode 100644 index 00000000000..0b4c6948140 --- /dev/null +++ b/libcxx/test/std/re/re.alg/re.alg.match/parse_curly_brackets.pass.cpp @@ -0,0 +1,72 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <regex> + +// template <class BidirectionalIterator, class Allocator, class charT, class traits> +// bool +// regex_match(BidirectionalIterator first, BidirectionalIterator last, +// match_results<BidirectionalIterator, Allocator>& m, +// const basic_regex<charT, traits>& e, +// regex_constants::match_flag_type flags = regex_constants::match_default); + +// http://llvm.org/bugs/show_bug.cgi?id=16135 + +#include <string> +#include <regex> +#include <cassert> + +void +test1() +{ + std::string re("\\{a\\}"); + std::string target("{a}"); + std::regex regex(re); + std::smatch smatch; + assert((std::regex_match(target, smatch, regex))); +} + +void +test2() +{ + std::string re("\\{a\\}"); + std::string target("{a}"); + std::regex regex(re, std::regex::extended); + std::smatch smatch; + assert((std::regex_match(target, smatch, regex))); +} + +void +test3() +{ + std::string re("\\{a\\}"); + std::string target("{a}"); + std::regex regex(re, std::regex::awk); + std::smatch smatch; + assert((std::regex_match(target, smatch, regex))); +} + +void +test4() +{ + std::string re("\\{a\\}"); + std::string target("{a}"); + std::regex regex(re, std::regex::egrep); + std::smatch smatch; + assert((std::regex_match(target, smatch, regex))); +} + +int +main() +{ + test1(); + test2(); + test3(); + test4(); +} diff --git a/libcxx/test/std/re/re.alg/re.alg.replace/test1.pass.cpp b/libcxx/test/std/re/re.alg/re.alg.replace/test1.pass.cpp new file mode 100644 index 00000000000..9fd84fdc1f6 --- /dev/null +++ b/libcxx/test/std/re/re.alg/re.alg.replace/test1.pass.cpp @@ -0,0 +1,107 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <regex> + +// template <class OutputIterator, class BidirectionalIterator, +// class traits, class charT, class ST, class SA> +// OutputIterator +// regex_replace(OutputIterator out, +// BidirectionalIterator first, BidirectionalIterator last, +// const basic_regex<charT, traits>& e, +// const basic_string<charT, ST, SA>& fmt, +// regex_constants::match_flag_type flags = +// regex_constants::match_default); + +#include <regex> +#include <cassert> + +#include "test_iterators.h" + +int main() +{ + { + std::regex phone_numbers("\\d{3}-\\d{4}"); + const char phone_book[] = "555-1234, 555-2345, 555-3456"; + typedef output_iterator<char*> Out; + typedef bidirectional_iterator<const char*> Bi; + char buf[100] = {0}; + Out r = std::regex_replace(Out(buf), Bi(std::begin(phone_book)), + Bi(std::end(phone_book)-1), phone_numbers, + std::string("123-$&")); + assert(r.base() == buf+40); + assert(buf == std::string("123-555-1234, 123-555-2345, 123-555-3456")); + } + { + std::regex phone_numbers("\\d{3}-\\d{4}"); + const char phone_book[] = "555-1234, 555-2345, 555-3456"; + typedef output_iterator<char*> Out; + typedef bidirectional_iterator<const char*> Bi; + char buf[100] = {0}; + Out r = std::regex_replace(Out(buf), Bi(std::begin(phone_book)), + Bi(std::end(phone_book)-1), phone_numbers, + std::string("123-$&"), + std::regex_constants::format_sed); + assert(r.base() == buf+43); + assert(buf == std::string("123-$555-1234, 123-$555-2345, 123-$555-3456")); + } + { + std::regex phone_numbers("\\d{3}-\\d{4}"); + const char phone_book[] = "555-1234, 555-2345, 555-3456"; + typedef output_iterator<char*> Out; + typedef bidirectional_iterator<const char*> Bi; + char buf[100] = {0}; + Out r = std::regex_replace(Out(buf), Bi(std::begin(phone_book)), + Bi(std::end(phone_book)-1), phone_numbers, + std::string("123-&"), + std::regex_constants::format_sed); + assert(r.base() == buf+40); + assert(buf == std::string("123-555-1234, 123-555-2345, 123-555-3456")); + } + { + std::regex phone_numbers("\\d{3}-\\d{4}"); + const char phone_book[] = "555-1234, 555-2345, 555-3456"; + typedef output_iterator<char*> Out; + typedef bidirectional_iterator<const char*> Bi; + char buf[100] = {0}; + Out r = std::regex_replace(Out(buf), Bi(std::begin(phone_book)), + Bi(std::end(phone_book)-1), phone_numbers, + std::string("123-$&"), + std::regex_constants::format_no_copy); + assert(r.base() == buf+36); + assert(buf == std::string("123-555-1234123-555-2345123-555-3456")); + } + { + std::regex phone_numbers("\\d{3}-\\d{4}"); + const char phone_book[] = "555-1234, 555-2345, 555-3456"; + typedef output_iterator<char*> Out; + typedef bidirectional_iterator<const char*> Bi; + char buf[100] = {0}; + Out r = std::regex_replace(Out(buf), Bi(std::begin(phone_book)), + Bi(std::end(phone_book)-1), phone_numbers, + std::string("123-$&"), + std::regex_constants::format_first_only); + assert(r.base() == buf+32); + assert(buf == std::string("123-555-1234, 555-2345, 555-3456")); + } + { + std::regex phone_numbers("\\d{3}-\\d{4}"); + const char phone_book[] = "555-1234, 555-2345, 555-3456"; + typedef output_iterator<char*> Out; + typedef bidirectional_iterator<const char*> Bi; + char buf[100] = {0}; + Out r = std::regex_replace(Out(buf), Bi(std::begin(phone_book)), + Bi(std::end(phone_book)-1), phone_numbers, + std::string("123-$&"), + std::regex_constants::format_first_only | + std::regex_constants::format_no_copy); + assert(r.base() == buf+12); + assert(buf == std::string("123-555-1234")); + } +} diff --git a/libcxx/test/std/re/re.alg/re.alg.replace/test2.pass.cpp b/libcxx/test/std/re/re.alg/re.alg.replace/test2.pass.cpp new file mode 100644 index 00000000000..63a4ed56933 --- /dev/null +++ b/libcxx/test/std/re/re.alg/re.alg.replace/test2.pass.cpp @@ -0,0 +1,107 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <regex> + +// template <class OutputIterator, class BidirectionalIterator, +// class traits, class charT, class ST, class SA> +// OutputIterator +// regex_replace(OutputIterator out, +// BidirectionalIterator first, BidirectionalIterator last, +// const basic_regex<charT, traits>& e, +// const charT* fmt, +// regex_constants::match_flag_type flags = +// regex_constants::match_default); + +#include <regex> +#include <cassert> + +#include "test_iterators.h" + +int main() +{ + { + std::regex phone_numbers("\\d{3}-\\d{4}"); + const char phone_book[] = "555-1234, 555-2345, 555-3456"; + typedef output_iterator<char*> Out; + typedef bidirectional_iterator<const char*> Bi; + char buf[100] = {0}; + Out r = std::regex_replace(Out(buf), Bi(std::begin(phone_book)), + Bi(std::end(phone_book)-1), phone_numbers, + "123-$&"); + assert(r.base() == buf+40); + assert(buf == std::string("123-555-1234, 123-555-2345, 123-555-3456")); + } + { + std::regex phone_numbers("\\d{3}-\\d{4}"); + const char phone_book[] = "555-1234, 555-2345, 555-3456"; + typedef output_iterator<char*> Out; + typedef bidirectional_iterator<const char*> Bi; + char buf[100] = {0}; + Out r = std::regex_replace(Out(buf), Bi(std::begin(phone_book)), + Bi(std::end(phone_book)-1), phone_numbers, + "123-$&", + std::regex_constants::format_sed); + assert(r.base() == buf+43); + assert(buf == std::string("123-$555-1234, 123-$555-2345, 123-$555-3456")); + } + { + std::regex phone_numbers("\\d{3}-\\d{4}"); + const char phone_book[] = "555-1234, 555-2345, 555-3456"; + typedef output_iterator<char*> Out; + typedef bidirectional_iterator<const char*> Bi; + char buf[100] = {0}; + Out r = std::regex_replace(Out(buf), Bi(std::begin(phone_book)), + Bi(std::end(phone_book)-1), phone_numbers, + "123-&", + std::regex_constants::format_sed); + assert(r.base() == buf+40); + assert(buf == std::string("123-555-1234, 123-555-2345, 123-555-3456")); + } + { + std::regex phone_numbers("\\d{3}-\\d{4}"); + const char phone_book[] = "555-1234, 555-2345, 555-3456"; + typedef output_iterator<char*> Out; + typedef bidirectional_iterator<const char*> Bi; + char buf[100] = {0}; + Out r = std::regex_replace(Out(buf), Bi(std::begin(phone_book)), + Bi(std::end(phone_book)-1), phone_numbers, + "123-$&", + std::regex_constants::format_no_copy); + assert(r.base() == buf+36); + assert(buf == std::string("123-555-1234123-555-2345123-555-3456")); + } + { + std::regex phone_numbers("\\d{3}-\\d{4}"); + const char phone_book[] = "555-1234, 555-2345, 555-3456"; + typedef output_iterator<char*> Out; + typedef bidirectional_iterator<const char*> Bi; + char buf[100] = {0}; + Out r = std::regex_replace(Out(buf), Bi(std::begin(phone_book)), + Bi(std::end(phone_book)-1), phone_numbers, + "123-$&", + std::regex_constants::format_first_only); + assert(r.base() == buf+32); + assert(buf == std::string("123-555-1234, 555-2345, 555-3456")); + } + { + std::regex phone_numbers("\\d{3}-\\d{4}"); + const char phone_book[] = "555-1234, 555-2345, 555-3456"; + typedef output_iterator<char*> Out; + typedef bidirectional_iterator<const char*> Bi; + char buf[100] = {0}; + Out r = std::regex_replace(Out(buf), Bi(std::begin(phone_book)), + Bi(std::end(phone_book)-1), phone_numbers, + "123-$&", + std::regex_constants::format_first_only | + std::regex_constants::format_no_copy); + assert(r.base() == buf+12); + assert(buf == std::string("123-555-1234")); + } +} diff --git a/libcxx/test/std/re/re.alg/re.alg.replace/test3.pass.cpp b/libcxx/test/std/re/re.alg/re.alg.replace/test3.pass.cpp new file mode 100644 index 00000000000..d1167860646 --- /dev/null +++ b/libcxx/test/std/re/re.alg/re.alg.replace/test3.pass.cpp @@ -0,0 +1,73 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <regex> + +// template <class traits, class charT, class ST, class SA, class FST, class FSA>> +// basic_string<charT, ST, SA> +// regex_replace(const basic_string<charT, ST, SA>& s, +// const basic_regex<charT, traits>& e, +// const basic_string<charT, FST, FSA>& fmt, +// regex_constants::match_flag_type flags = +// regex_constants::match_default); + +#include <regex> +#include <cassert> + +int main() +{ + { + std::regex phone_numbers("\\d{3}-\\d{4}"); + std::string phone_book("555-1234, 555-2345, 555-3456"); + std::string r = std::regex_replace(phone_book, phone_numbers, + std::string("123-$&")); + assert(r == "123-555-1234, 123-555-2345, 123-555-3456"); + } + { + std::regex phone_numbers("\\d{3}-\\d{4}"); + std::string phone_book("555-1234, 555-2345, 555-3456"); + std::string r = std::regex_replace(phone_book, phone_numbers, + std::string("123-$&"), + std::regex_constants::format_sed); + assert(r == "123-$555-1234, 123-$555-2345, 123-$555-3456"); + } + { + std::regex phone_numbers("\\d{3}-\\d{4}"); + std::string phone_book("555-1234, 555-2345, 555-3456"); + std::string r = std::regex_replace(phone_book, phone_numbers, + std::string("123-&"), + std::regex_constants::format_sed); + assert(r == "123-555-1234, 123-555-2345, 123-555-3456"); + } + { + std::regex phone_numbers("\\d{3}-\\d{4}"); + std::string phone_book("555-1234, 555-2345, 555-3456"); + std::string r = std::regex_replace(phone_book, phone_numbers, + std::string("123-$&"), + std::regex_constants::format_no_copy); + assert(r == "123-555-1234123-555-2345123-555-3456"); + } + { + std::regex phone_numbers("\\d{3}-\\d{4}"); + std::string phone_book("555-1234, 555-2345, 555-3456"); + std::string r = std::regex_replace(phone_book, phone_numbers, + std::string("123-$&"), + std::regex_constants::format_first_only); + assert(r == "123-555-1234, 555-2345, 555-3456"); + } + { + std::regex phone_numbers("\\d{3}-\\d{4}"); + std::string phone_book("555-1234, 555-2345, 555-3456"); + std::string r = std::regex_replace(phone_book, phone_numbers, + std::string("123-$&"), + std::regex_constants::format_first_only | + std::regex_constants::format_no_copy); + assert(r == "123-555-1234"); + } +} diff --git a/libcxx/test/std/re/re.alg/re.alg.replace/test4.pass.cpp b/libcxx/test/std/re/re.alg/re.alg.replace/test4.pass.cpp new file mode 100644 index 00000000000..fba1bc19546 --- /dev/null +++ b/libcxx/test/std/re/re.alg/re.alg.replace/test4.pass.cpp @@ -0,0 +1,72 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <regex> + +// template <class traits, class charT, class ST, class SA> +// basic_string<charT, ST, SA> +// regex_replace(const basic_string<charT, ST, SA>& s, +// const basic_regex<charT, traits>& e, const charT* fmt, +// regex_constants::match_flag_type flags = +// regex_constants::match_default); + +#include <regex> +#include <cassert> + +int main() +{ + { + std::regex phone_numbers("\\d{3}-\\d{4}"); + std::string phone_book("555-1234, 555-2345, 555-3456"); + std::string r = std::regex_replace(phone_book, phone_numbers, + "123-$&"); + assert(r == "123-555-1234, 123-555-2345, 123-555-3456"); + } + { + std::regex phone_numbers("\\d{3}-\\d{4}"); + std::string phone_book("555-1234, 555-2345, 555-3456"); + std::string r = std::regex_replace(phone_book, phone_numbers, + "123-$&", + std::regex_constants::format_sed); + assert(r == "123-$555-1234, 123-$555-2345, 123-$555-3456"); + } + { + std::regex phone_numbers("\\d{3}-\\d{4}"); + std::string phone_book("555-1234, 555-2345, 555-3456"); + std::string r = std::regex_replace(phone_book, phone_numbers, + "123-&", + std::regex_constants::format_sed); + assert(r == "123-555-1234, 123-555-2345, 123-555-3456"); + } + { + std::regex phone_numbers("\\d{3}-\\d{4}"); + std::string phone_book("555-1234, 555-2345, 555-3456"); + std::string r = std::regex_replace(phone_book, phone_numbers, + "123-$&", + std::regex_constants::format_no_copy); + assert(r == "123-555-1234123-555-2345123-555-3456"); + } + { + std::regex phone_numbers("\\d{3}-\\d{4}"); + std::string phone_book("555-1234, 555-2345, 555-3456"); + std::string r = std::regex_replace(phone_book, phone_numbers, + "123-$&", + std::regex_constants::format_first_only); + assert(r == "123-555-1234, 555-2345, 555-3456"); + } + { + std::regex phone_numbers("\\d{3}-\\d{4}"); + std::string phone_book("555-1234, 555-2345, 555-3456"); + std::string r = std::regex_replace(phone_book, phone_numbers, + "123-$&", + std::regex_constants::format_first_only | + std::regex_constants::format_no_copy); + assert(r == "123-555-1234"); + } +} diff --git a/libcxx/test/std/re/re.alg/re.alg.replace/test5.pass.cpp b/libcxx/test/std/re/re.alg/re.alg.replace/test5.pass.cpp new file mode 100644 index 00000000000..7190e41d522 --- /dev/null +++ b/libcxx/test/std/re/re.alg/re.alg.replace/test5.pass.cpp @@ -0,0 +1,73 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <regex> + +// template <class traits, class charT, class ST, class SA> +// basic_string<charT> +// regex_replace(const charT* s, +// const basic_regex<charT, traits>& e, +// const basic_string<charT, ST, SA>& fmt, +// regex_constants::match_flag_type flags = +// regex_constants::match_default); + +#include <regex> +#include <cassert> + +int main() +{ + { + std::regex phone_numbers("\\d{3}-\\d{4}"); + const char phone_book[] = "555-1234, 555-2345, 555-3456"; + std::string r = std::regex_replace(phone_book, phone_numbers, + std::string("123-$&")); + assert(r == "123-555-1234, 123-555-2345, 123-555-3456"); + } + { + std::regex phone_numbers("\\d{3}-\\d{4}"); + const char phone_book[] = "555-1234, 555-2345, 555-3456"; + std::string r = std::regex_replace(phone_book, phone_numbers, + std::string("123-$&"), + std::regex_constants::format_sed); + assert(r == "123-$555-1234, 123-$555-2345, 123-$555-3456"); + } + { + std::regex phone_numbers("\\d{3}-\\d{4}"); + const char phone_book[] = "555-1234, 555-2345, 555-3456"; + std::string r = std::regex_replace(phone_book, phone_numbers, + std::string("123-&"), + std::regex_constants::format_sed); + assert(r == "123-555-1234, 123-555-2345, 123-555-3456"); + } + { + std::regex phone_numbers("\\d{3}-\\d{4}"); + const char phone_book[] = "555-1234, 555-2345, 555-3456"; + std::string r = std::regex_replace(phone_book, phone_numbers, + std::string("123-$&"), + std::regex_constants::format_no_copy); + assert(r == "123-555-1234123-555-2345123-555-3456"); + } + { + std::regex phone_numbers("\\d{3}-\\d{4}"); + const char phone_book[] = "555-1234, 555-2345, 555-3456"; + std::string r = std::regex_replace(phone_book, phone_numbers, + std::string("123-$&"), + std::regex_constants::format_first_only); + assert(r == "123-555-1234, 555-2345, 555-3456"); + } + { + std::regex phone_numbers("\\d{3}-\\d{4}"); + const char phone_book[] = "555-1234, 555-2345, 555-3456"; + std::string r = std::regex_replace(phone_book, phone_numbers, + std::string("123-$&"), + std::regex_constants::format_first_only | + std::regex_constants::format_no_copy); + assert(r == "123-555-1234"); + } +} diff --git a/libcxx/test/std/re/re.alg/re.alg.replace/test6.pass.cpp b/libcxx/test/std/re/re.alg/re.alg.replace/test6.pass.cpp new file mode 100644 index 00000000000..b0178007730 --- /dev/null +++ b/libcxx/test/std/re/re.alg/re.alg.replace/test6.pass.cpp @@ -0,0 +1,73 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <regex> + +// template <class traits, class charT> +// basic_string<charT> +// regex_replace(const charT* s, +// const basic_regex<charT, traits>& e, +// const charT* fmt, +// regex_constants::match_flag_type flags = +// regex_constants::match_default); + +#include <regex> +#include <cassert> + +int main() +{ + { + std::regex phone_numbers("\\d{3}-\\d{4}"); + const char phone_book[] = "555-1234, 555-2345, 555-3456"; + std::string r = std::regex_replace(phone_book, phone_numbers, + "123-$&"); + assert(r == "123-555-1234, 123-555-2345, 123-555-3456"); + } + { + std::regex phone_numbers("\\d{3}-\\d{4}"); + const char phone_book[] = "555-1234, 555-2345, 555-3456"; + std::string r = std::regex_replace(phone_book, phone_numbers, + "123-$&", + std::regex_constants::format_sed); + assert(r == "123-$555-1234, 123-$555-2345, 123-$555-3456"); + } + { + std::regex phone_numbers("\\d{3}-\\d{4}"); + const char phone_book[] = "555-1234, 555-2345, 555-3456"; + std::string r = std::regex_replace(phone_book, phone_numbers, + "123-&", + std::regex_constants::format_sed); + assert(r == "123-555-1234, 123-555-2345, 123-555-3456"); + } + { + std::regex phone_numbers("\\d{3}-\\d{4}"); + const char phone_book[] = "555-1234, 555-2345, 555-3456"; + std::string r = std::regex_replace(phone_book, phone_numbers, + "123-$&", + std::regex_constants::format_no_copy); + assert(r == "123-555-1234123-555-2345123-555-3456"); + } + { + std::regex phone_numbers("\\d{3}-\\d{4}"); + const char phone_book[] = "555-1234, 555-2345, 555-3456"; + std::string r = std::regex_replace(phone_book, phone_numbers, + "123-$&", + std::regex_constants::format_first_only); + assert(r == "123-555-1234, 555-2345, 555-3456"); + } + { + std::regex phone_numbers("\\d{3}-\\d{4}"); + const char phone_book[] = "555-1234, 555-2345, 555-3456"; + std::string r = std::regex_replace(phone_book, phone_numbers, + "123-$&", + std::regex_constants::format_first_only | + std::regex_constants::format_no_copy); + assert(r == "123-555-1234"); + } +} diff --git a/libcxx/test/std/re/re.alg/re.alg.search/awk.pass.cpp b/libcxx/test/std/re/re.alg/re.alg.search/awk.pass.cpp new file mode 100644 index 00000000000..521e98b3a88 --- /dev/null +++ b/libcxx/test/std/re/re.alg/re.alg.search/awk.pass.cpp @@ -0,0 +1,1573 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// REQUIRES: locale.cs_CZ.ISO8859-2 + +// <regex> + +// template <class BidirectionalIterator, class Allocator, class charT, class traits> +// bool +// regex_search(BidirectionalIterator first, BidirectionalIterator last, +// match_results<BidirectionalIterator, Allocator>& m, +// const basic_regex<charT, traits>& e, +// regex_constants::match_flag_type flags = regex_constants::match_default); + +// TODO: investigation needed +// XFAIL: linux-gnu + +#include <regex> +#include <cassert> + +#include "test_iterators.h" + +int main() +{ + { + std::cmatch m; + const char s[] = "a"; + assert(std::regex_search(s, m, std::regex("a", std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.empty()); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+1); + assert(m.length(0) == 1); + assert(m.position(0) == 0); + assert(m.str(0) == "a"); + } + { + std::cmatch m; + const char s[] = "ab"; + assert(std::regex_search(s, m, std::regex("ab", std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+2); + assert(m.length(0) == 2); + assert(m.position(0) == 0); + assert(m.str(0) == "ab"); + } + { + std::cmatch m; + const char s[] = "ab"; + assert(!std::regex_search(s, m, std::regex("ba", std::regex_constants::awk))); + assert(m.size() == 0); + assert(m.empty()); + } + { + std::cmatch m; + const char s[] = "aab"; + assert(std::regex_search(s, m, std::regex("ab", std::regex_constants::awk))); + assert(m.size() == 1); + assert(m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+3); + assert(m.length(0) == 2); + assert(m.position(0) == 1); + assert(m.str(0) == "ab"); + } + { + std::cmatch m; + const char s[] = "aab"; + assert(!std::regex_search(s, m, std::regex("ab", std::regex_constants::awk), + std::regex_constants::match_continuous)); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "abcd"; + assert(std::regex_search(s, m, std::regex("bc", std::regex_constants::awk))); + assert(m.size() == 1); + assert(m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+4); + assert(m.length(0) == 2); + assert(m.position(0) == 1); + assert(m.str(0) == "bc"); + } + { + std::cmatch m; + const char s[] = "abbc"; + assert(std::regex_search(s, m, std::regex("ab*c", std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+4); + assert(m.length(0) == 4); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "ababc"; + assert(std::regex_search(s, m, std::regex("(ab)*c", std::regex_constants::awk))); + assert(m.size() == 2); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+5); + assert(m.length(0) == 5); + assert(m.position(0) == 0); + assert(m.str(0) == s); + assert(m.length(1) == 2); + assert(m.position(1) == 2); + assert(m.str(1) == "ab"); + } + { + std::cmatch m; + const char s[] = "abcdefghijk"; + assert(std::regex_search(s, m, std::regex("cd((e)fg)hi", + std::regex_constants::awk))); + assert(m.size() == 3); + assert(m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+std::regex_traits<char>::length(s)); + assert(m.length(0) == 7); + assert(m.position(0) == 2); + assert(m.str(0) == "cdefghi"); + assert(m.length(1) == 3); + assert(m.position(1) == 4); + assert(m.str(1) == "efg"); + assert(m.length(2) == 1); + assert(m.position(2) == 4); + assert(m.str(2) == "e"); + } + { + std::cmatch m; + const char s[] = "abc"; + assert(std::regex_search(s, m, std::regex("^abc", std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+3); + assert(m.length(0) == 3); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "abcd"; + assert(std::regex_search(s, m, std::regex("^abc", std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+4); + assert(m.length(0) == 3); + assert(m.position(0) == 0); + assert(m.str(0) == "abc"); + } + { + std::cmatch m; + const char s[] = "aabc"; + assert(!std::regex_search(s, m, std::regex("^abc", std::regex_constants::awk))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "abc"; + assert(std::regex_search(s, m, std::regex("abc$", std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+3); + assert(m.length(0) == 3); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "efabc"; + assert(std::regex_search(s, m, std::regex("abc$", std::regex_constants::awk))); + assert(m.size() == 1); + assert(m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+5); + assert(m.length(0) == 3); + assert(m.position(0) == 2); + assert(m.str(0) == s+2); + } + { + std::cmatch m; + const char s[] = "efabcg"; + assert(!std::regex_search(s, m, std::regex("abc$", std::regex_constants::awk))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "abc"; + assert(std::regex_search(s, m, std::regex("a.c", std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+3); + assert(m.length(0) == 3); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "acc"; + assert(std::regex_search(s, m, std::regex("a.c", std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+3); + assert(m.length(0) == 3); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "acc"; + assert(std::regex_search(s, m, std::regex("a.c", std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+3); + assert(m.length(0) == 3); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "abcdef"; + assert(std::regex_search(s, m, std::regex("(.*).*", std::regex_constants::awk))); + assert(m.size() == 2); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+6); + assert(m.length(0) == 6); + assert(m.position(0) == 0); + assert(m.str(0) == s); + assert(m.length(1) == 6); + assert(m.position(1) == 0); + assert(m.str(1) == s); + } + { + std::cmatch m; + const char s[] = "bc"; + assert(std::regex_search(s, m, std::regex("(a*)*", std::regex_constants::awk))); + assert(m.size() == 2); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+2); + assert(m.length(0) == 0); + assert(m.position(0) == 0); + assert(m.str(0) == ""); + assert(m.length(1) == 0); + assert(m.position(1) == 0); + assert(m.str(1) == ""); + } + { + std::cmatch m; + const char s[] = "abbc"; + assert(!std::regex_search(s, m, std::regex("ab{3,5}c", std::regex_constants::awk))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "abbbc"; + assert(std::regex_search(s, m, std::regex("ab{3,5}c", std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "abbbbc"; + assert(std::regex_search(s, m, std::regex("ab{3,5}c", std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "abbbbbc"; + assert(std::regex_search(s, m, std::regex("ab{3,5}c", std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "adefc"; + assert(!std::regex_search(s, m, std::regex("ab{3,5}c", std::regex_constants::awk))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "abbbbbbc"; + assert(!std::regex_search(s, m, std::regex("ab{3,5}c", std::regex_constants::awk))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "adec"; + assert(!std::regex_search(s, m, std::regex("a.{3,5}c", std::regex_constants::awk))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "adefc"; + assert(std::regex_search(s, m, std::regex("a.{3,5}c", std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "adefgc"; + assert(std::regex_search(s, m, std::regex("a.{3,5}c", std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "adefghc"; + assert(std::regex_search(s, m, std::regex("a.{3,5}c", std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "adefghic"; + assert(!std::regex_search(s, m, std::regex("a.{3,5}c", std::regex_constants::awk))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "tournament"; + assert(std::regex_search(s, m, std::regex("tour|to|tournament", + std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "tournamenttotour"; + assert(std::regex_search(s, m, std::regex("(tour|to|tournament)+", + std::regex_constants::awk | std::regex_constants::nosubs))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "ttotour"; + assert(std::regex_search(s, m, std::regex("(tour|to|t)+", + std::regex_constants::awk))); + assert(m.size() == 2); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + assert(m.length(1) == 4); + assert(m.position(1) == 3); + assert(m.str(1) == "tour"); + } + { + std::cmatch m; + const char s[] = "-ab,ab-"; + assert(!std::regex_search(s, m, std::regex("-(.*),\1-", std::regex_constants::awk))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "-ab,ab-"; + assert(std::regex_search(s, m, std::regex("-.*,.*-", std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "a"; + assert(std::regex_search(s, m, std::regex("^[a]$", + std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == 1); + assert(m.position(0) == 0); + assert(m.str(0) == "a"); + } + { + std::cmatch m; + const char s[] = "a"; + assert(std::regex_search(s, m, std::regex("^[ab]$", + std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == 1); + assert(m.position(0) == 0); + assert(m.str(0) == "a"); + } + { + std::cmatch m; + const char s[] = "c"; + assert(std::regex_search(s, m, std::regex("^[a-f]$", + std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == 1); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "g"; + assert(!std::regex_search(s, m, std::regex("^[a-f]$", + std::regex_constants::awk))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "Iraqi"; + assert(std::regex_search(s, m, std::regex("q[^u]", + std::regex_constants::awk))); + assert(m.size() == 1); + assert(m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == 2); + assert(m.position(0) == 3); + assert(m.str(0) == "qi"); + } + { + std::cmatch m; + const char s[] = "Iraq"; + assert(!std::regex_search(s, m, std::regex("q[^u]", + std::regex_constants::awk))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "AmB"; + assert(std::regex_search(s, m, std::regex("A[[:lower:]]B", + std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "AMB"; + assert(!std::regex_search(s, m, std::regex("A[[:lower:]]B", + std::regex_constants::awk))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "AMB"; + assert(std::regex_search(s, m, std::regex("A[^[:lower:]]B", + std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "AmB"; + assert(!std::regex_search(s, m, std::regex("A[^[:lower:]]B", + std::regex_constants::awk))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "A5B"; + assert(!std::regex_search(s, m, std::regex("A[^[:lower:]0-9]B", + std::regex_constants::awk))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "A?B"; + assert(std::regex_search(s, m, std::regex("A[^[:lower:]0-9]B", + std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "-"; + assert(std::regex_search(s, m, std::regex("[a[.hyphen.]z]", + std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "z"; + assert(std::regex_search(s, m, std::regex("[a[.hyphen.]z]", + std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "m"; + assert(!std::regex_search(s, m, std::regex("[a[.hyphen.]z]", + std::regex_constants::awk))); + assert(m.size() == 0); + } + std::locale::global(std::locale("cs_CZ.ISO8859-2")); + { + std::cmatch m; + const char s[] = "m"; + assert(std::regex_search(s, m, std::regex("[a[=M=]z]", + std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "Ch"; + assert(std::regex_search(s, m, std::regex("[a[.ch.]z]", + std::regex_constants::awk | std::regex_constants::icase))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + std::locale::global(std::locale("C")); + { + std::cmatch m; + const char s[] = "m"; + assert(!std::regex_search(s, m, std::regex("[a[=M=]z]", + std::regex_constants::awk))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "01a45cef9"; + assert(std::regex_search(s, m, std::regex("[ace1-9]*", + std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s + std::char_traits<char>::length(s)); + assert(m.length(0) == 0); + assert(m.position(0) == 0); + assert(m.str(0) == ""); + } + { + std::cmatch m; + const char s[] = "01a45cef9"; + assert(std::regex_search(s, m, std::regex("[ace1-9]+", + std::regex_constants::awk))); + assert(m.size() == 1); + assert(m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s + std::char_traits<char>::length(s)); + assert(m.length(0) == 6); + assert(m.position(0) == 1); + assert(m.str(0) == "1a45ce"); + } + { + const char r[] = "^[-+]?[0-9]+[CF]$"; + std::ptrdiff_t sr = std::char_traits<char>::length(r); + typedef forward_iterator<const char*> FI; + typedef bidirectional_iterator<const char*> BI; + std::regex regex(FI(r), FI(r+sr), std::regex_constants::awk); + std::match_results<BI> m; + const char s[] = "-40C"; + std::ptrdiff_t ss = std::char_traits<char>::length(s); + assert(std::regex_search(BI(s), BI(s+ss), m, regex)); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == BI(s)); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == 4); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "\n\n\n"; + assert(std::regex_search(s, m, std::regex("[\\n]+", + std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s + std::char_traits<char>::length(s)); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"a"; + assert(std::regex_search(s, m, std::wregex(L"a", std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.empty()); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+1); + assert(m.length(0) == 1); + assert(m.position(0) == 0); + assert(m.str(0) == L"a"); + } + { + std::wcmatch m; + const wchar_t s[] = L"ab"; + assert(std::regex_search(s, m, std::wregex(L"ab", std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+2); + assert(m.length(0) == 2); + assert(m.position(0) == 0); + assert(m.str(0) == L"ab"); + } + { + std::wcmatch m; + const wchar_t s[] = L"ab"; + assert(!std::regex_search(s, m, std::wregex(L"ba", std::regex_constants::awk))); + assert(m.size() == 0); + assert(m.empty()); + } + { + std::wcmatch m; + const wchar_t s[] = L"aab"; + assert(std::regex_search(s, m, std::wregex(L"ab", std::regex_constants::awk))); + assert(m.size() == 1); + assert(m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+3); + assert(m.length(0) == 2); + assert(m.position(0) == 1); + assert(m.str(0) == L"ab"); + } + { + std::wcmatch m; + const wchar_t s[] = L"aab"; + assert(!std::regex_search(s, m, std::wregex(L"ab", std::regex_constants::awk), + std::regex_constants::match_continuous)); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"abcd"; + assert(std::regex_search(s, m, std::wregex(L"bc", std::regex_constants::awk))); + assert(m.size() == 1); + assert(m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+4); + assert(m.length(0) == 2); + assert(m.position(0) == 1); + assert(m.str(0) == L"bc"); + } + { + std::wcmatch m; + const wchar_t s[] = L"abbc"; + assert(std::regex_search(s, m, std::wregex(L"ab*c", std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+4); + assert(m.length(0) == 4); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"ababc"; + assert(std::regex_search(s, m, std::wregex(L"(ab)*c", std::regex_constants::awk))); + assert(m.size() == 2); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+5); + assert(m.length(0) == 5); + assert(m.position(0) == 0); + assert(m.str(0) == s); + assert(m.length(1) == 2); + assert(m.position(1) == 2); + assert(m.str(1) == L"ab"); + } + { + std::wcmatch m; + const wchar_t s[] = L"abcdefghijk"; + assert(std::regex_search(s, m, std::wregex(L"cd((e)fg)hi", + std::regex_constants::awk))); + assert(m.size() == 3); + assert(m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+std::regex_traits<wchar_t>::length(s)); + assert(m.length(0) == 7); + assert(m.position(0) == 2); + assert(m.str(0) == L"cdefghi"); + assert(m.length(1) == 3); + assert(m.position(1) == 4); + assert(m.str(1) == L"efg"); + assert(m.length(2) == 1); + assert(m.position(2) == 4); + assert(m.str(2) == L"e"); + } + { + std::wcmatch m; + const wchar_t s[] = L"abc"; + assert(std::regex_search(s, m, std::wregex(L"^abc", std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+3); + assert(m.length(0) == 3); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"abcd"; + assert(std::regex_search(s, m, std::wregex(L"^abc", std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+4); + assert(m.length(0) == 3); + assert(m.position(0) == 0); + assert(m.str(0) == L"abc"); + } + { + std::wcmatch m; + const wchar_t s[] = L"aabc"; + assert(!std::regex_search(s, m, std::wregex(L"^abc", std::regex_constants::awk))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"abc"; + assert(std::regex_search(s, m, std::wregex(L"abc$", std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+3); + assert(m.length(0) == 3); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"efabc"; + assert(std::regex_search(s, m, std::wregex(L"abc$", std::regex_constants::awk))); + assert(m.size() == 1); + assert(m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+5); + assert(m.length(0) == 3); + assert(m.position(0) == 2); + assert(m.str(0) == s+2); + } + { + std::wcmatch m; + const wchar_t s[] = L"efabcg"; + assert(!std::regex_search(s, m, std::wregex(L"abc$", std::regex_constants::awk))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"abc"; + assert(std::regex_search(s, m, std::wregex(L"a.c", std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+3); + assert(m.length(0) == 3); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"acc"; + assert(std::regex_search(s, m, std::wregex(L"a.c", std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+3); + assert(m.length(0) == 3); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"acc"; + assert(std::regex_search(s, m, std::wregex(L"a.c", std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+3); + assert(m.length(0) == 3); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"abcdef"; + assert(std::regex_search(s, m, std::wregex(L"(.*).*", std::regex_constants::awk))); + assert(m.size() == 2); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+6); + assert(m.length(0) == 6); + assert(m.position(0) == 0); + assert(m.str(0) == s); + assert(m.length(1) == 6); + assert(m.position(1) == 0); + assert(m.str(1) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"bc"; + assert(std::regex_search(s, m, std::wregex(L"(a*)*", std::regex_constants::awk))); + assert(m.size() == 2); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+2); + assert(m.length(0) == 0); + assert(m.position(0) == 0); + assert(m.str(0) == L""); + assert(m.length(1) == 0); + assert(m.position(1) == 0); + assert(m.str(1) == L""); + } + { + std::wcmatch m; + const wchar_t s[] = L"abbc"; + assert(!std::regex_search(s, m, std::wregex(L"ab{3,5}c", std::regex_constants::awk))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"abbbc"; + assert(std::regex_search(s, m, std::wregex(L"ab{3,5}c", std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"abbbbc"; + assert(std::regex_search(s, m, std::wregex(L"ab{3,5}c", std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"abbbbbc"; + assert(std::regex_search(s, m, std::wregex(L"ab{3,5}c", std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"adefc"; + assert(!std::regex_search(s, m, std::wregex(L"ab{3,5}c", std::regex_constants::awk))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"abbbbbbc"; + assert(!std::regex_search(s, m, std::wregex(L"ab{3,5}c", std::regex_constants::awk))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"adec"; + assert(!std::regex_search(s, m, std::wregex(L"a.{3,5}c", std::regex_constants::awk))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"adefc"; + assert(std::regex_search(s, m, std::wregex(L"a.{3,5}c", std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"adefgc"; + assert(std::regex_search(s, m, std::wregex(L"a.{3,5}c", std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"adefghc"; + assert(std::regex_search(s, m, std::wregex(L"a.{3,5}c", std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"adefghic"; + assert(!std::regex_search(s, m, std::wregex(L"a.{3,5}c", std::regex_constants::awk))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"tournament"; + assert(std::regex_search(s, m, std::wregex(L"tour|to|tournament", + std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"tournamenttotour"; + assert(std::regex_search(s, m, std::wregex(L"(tour|to|tournament)+", + std::regex_constants::awk | std::regex_constants::nosubs))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"ttotour"; + assert(std::regex_search(s, m, std::wregex(L"(tour|to|t)+", + std::regex_constants::awk))); + assert(m.size() == 2); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + assert(m.length(1) == 4); + assert(m.position(1) == 3); + assert(m.str(1) == L"tour"); + } + { + std::wcmatch m; + const wchar_t s[] = L"-ab,ab-"; + assert(!std::regex_search(s, m, std::wregex(L"-(.*),\1-", std::regex_constants::awk))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"-ab,ab-"; + assert(std::regex_search(s, m, std::wregex(L"-.*,.*-", std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"a"; + assert(std::regex_search(s, m, std::wregex(L"^[a]$", + std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == 1); + assert(m.position(0) == 0); + assert(m.str(0) == L"a"); + } + { + std::wcmatch m; + const wchar_t s[] = L"a"; + assert(std::regex_search(s, m, std::wregex(L"^[ab]$", + std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == 1); + assert(m.position(0) == 0); + assert(m.str(0) == L"a"); + } + { + std::wcmatch m; + const wchar_t s[] = L"c"; + assert(std::regex_search(s, m, std::wregex(L"^[a-f]$", + std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == 1); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"g"; + assert(!std::regex_search(s, m, std::wregex(L"^[a-f]$", + std::regex_constants::awk))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"Iraqi"; + assert(std::regex_search(s, m, std::wregex(L"q[^u]", + std::regex_constants::awk))); + assert(m.size() == 1); + assert(m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == 2); + assert(m.position(0) == 3); + assert(m.str(0) == L"qi"); + } + { + std::wcmatch m; + const wchar_t s[] = L"Iraq"; + assert(!std::regex_search(s, m, std::wregex(L"q[^u]", + std::regex_constants::awk))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"AmB"; + assert(std::regex_search(s, m, std::wregex(L"A[[:lower:]]B", + std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"AMB"; + assert(!std::regex_search(s, m, std::wregex(L"A[[:lower:]]B", + std::regex_constants::awk))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"AMB"; + assert(std::regex_search(s, m, std::wregex(L"A[^[:lower:]]B", + std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"AmB"; + assert(!std::regex_search(s, m, std::wregex(L"A[^[:lower:]]B", + std::regex_constants::awk))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"A5B"; + assert(!std::regex_search(s, m, std::wregex(L"A[^[:lower:]0-9]B", + std::regex_constants::awk))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"A?B"; + assert(std::regex_search(s, m, std::wregex(L"A[^[:lower:]0-9]B", + std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"-"; + assert(std::regex_search(s, m, std::wregex(L"[a[.hyphen.]z]", + std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"z"; + assert(std::regex_search(s, m, std::wregex(L"[a[.hyphen.]z]", + std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"m"; + assert(!std::regex_search(s, m, std::wregex(L"[a[.hyphen.]z]", + std::regex_constants::awk))); + assert(m.size() == 0); + } + std::locale::global(std::locale("cs_CZ.ISO8859-2")); + { + std::wcmatch m; + const wchar_t s[] = L"m"; + assert(std::regex_search(s, m, std::wregex(L"[a[=M=]z]", + std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"Ch"; + assert(std::regex_search(s, m, std::wregex(L"[a[.ch.]z]", + std::regex_constants::awk | std::regex_constants::icase))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + std::locale::global(std::locale("C")); + { + std::wcmatch m; + const wchar_t s[] = L"m"; + assert(!std::regex_search(s, m, std::wregex(L"[a[=M=]z]", + std::regex_constants::awk))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"01a45cef9"; + assert(std::regex_search(s, m, std::wregex(L"[ace1-9]*", + std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s + std::char_traits<wchar_t>::length(s)); + assert(m.length(0) == 0); + assert(m.position(0) == 0); + assert(m.str(0) == L""); + } + { + std::wcmatch m; + const wchar_t s[] = L"01a45cef9"; + assert(std::regex_search(s, m, std::wregex(L"[ace1-9]+", + std::regex_constants::awk))); + assert(m.size() == 1); + assert(m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s + std::char_traits<wchar_t>::length(s)); + assert(m.length(0) == 6); + assert(m.position(0) == 1); + assert(m.str(0) == L"1a45ce"); + } + { + const wchar_t r[] = L"^[-+]?[0-9]+[CF]$"; + std::ptrdiff_t sr = std::char_traits<wchar_t>::length(r); + typedef forward_iterator<const wchar_t*> FI; + typedef bidirectional_iterator<const wchar_t*> BI; + std::wregex regex(FI(r), FI(r+sr), std::regex_constants::awk); + std::match_results<BI> m; + const wchar_t s[] = L"-40C"; + std::ptrdiff_t ss = std::char_traits<wchar_t>::length(s); + assert(std::regex_search(BI(s), BI(s+ss), m, regex)); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == BI(s)); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == 4); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"\n\n\n"; + assert(std::regex_search(s, m, std::wregex(L"[\\n]+", + std::regex_constants::awk))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s + std::char_traits<wchar_t>::length(s)); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } +} diff --git a/libcxx/test/std/re/re.alg/re.alg.search/backup.pass.cpp b/libcxx/test/std/re/re.alg/re.alg.search/backup.pass.cpp new file mode 100644 index 00000000000..7da58608705 --- /dev/null +++ b/libcxx/test/std/re/re.alg/re.alg.search/backup.pass.cpp @@ -0,0 +1,63 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <regex> + +// template <class BidirectionalIterator, class Allocator, class charT, class traits> +// bool +// regex_search(BidirectionalIterator first, BidirectionalIterator last, +// match_results<BidirectionalIterator, Allocator>& m, +// const basic_regex<charT, traits>& e, +// regex_constants::match_flag_type flags = regex_constants::match_default); + +#include <regex> +#include <string> +#include <list> +#include <cassert> + +int main() +{ + // This regex_iterator uses regex_search(__wrap_iter<_Iter> __first, ...) + // Test for http://llvm.org/bugs/show_bug.cgi?id=16240 fixed in r185273. + { + std::string s("aaaa a"); + std::regex re("\\ba"); + std::sregex_iterator it(s.begin(), s.end(), re); + std::sregex_iterator end = std::sregex_iterator(); + + assert(it->position(0) == 0); + assert(it->length(0) == 1); + + ++it; + assert(it->position(0) == 5); + assert(it->length(0) == 1); + + ++it; + assert(it == end); + } + + // This regex_iterator uses regex_search(_BidirectionalIterator __first, ...) + { + std::string s("aaaa a"); + std::list<char> l(s.begin(), s.end()); + std::regex re("\\ba"); + std::regex_iterator<std::list<char>::iterator> it(l.begin(), l.end(), re); + std::regex_iterator<std::list<char>::iterator> end = std::regex_iterator<std::list<char>::iterator>(); + + assert(it->position(0) == 0); + assert(it->length(0) == 1); + + ++it; + assert(it->position(0) == 5); + assert(it->length(0) == 1); + + ++it; + assert(it == end); + } +} diff --git a/libcxx/test/std/re/re.alg/re.alg.search/basic.fail.cpp b/libcxx/test/std/re/re.alg/re.alg.search/basic.fail.cpp new file mode 100644 index 00000000000..692ee94d944 --- /dev/null +++ b/libcxx/test/std/re/re.alg/re.alg.search/basic.fail.cpp @@ -0,0 +1,38 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <regex> + +// template <class ST, class SA, class Allocator, class charT, class traits> +// bool regex_search(const basic_string<charT, ST, SA>&&, +// match_results< +// typename basic_string<charT, ST, SA>::const_iterator, +// Allocator>&, +// const basic_regex<charT, traits>&, +// regex_constants::match_flag_type = +// regex_constants::match_default) = delete; + +#include <__config> + +#if _LIBCPP_STD_VER <= 11 +#error +#else + +#include <regex> +#include <cassert> + +int main() +{ + { + std::smatch m; + std::regex re{"*"}; + std::regex_search(std::string("abcde"), m, re); + } +} +#endif diff --git a/libcxx/test/std/re/re.alg/re.alg.search/basic.pass.cpp b/libcxx/test/std/re/re.alg/re.alg.search/basic.pass.cpp new file mode 100644 index 00000000000..838294e984c --- /dev/null +++ b/libcxx/test/std/re/re.alg/re.alg.search/basic.pass.cpp @@ -0,0 +1,1546 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// REQUIRES: locale.cs_CZ.ISO8859-2 + +// <regex> + +// template <class BidirectionalIterator, class Allocator, class charT, class traits> +// bool +// regex_search(BidirectionalIterator first, BidirectionalIterator last, +// match_results<BidirectionalIterator, Allocator>& m, +// const basic_regex<charT, traits>& e, +// regex_constants::match_flag_type flags = regex_constants::match_default); + +// TODO: investigation needed +// XFAIL: linux-gnu + +#include <regex> +#include <cassert> + +#include "test_iterators.h" + +int main() +{ + { + std::cmatch m; + assert(!std::regex_search("a", m, std::regex())); + assert(m.size() == 0); + assert(m.empty()); + } + { + std::cmatch m; + const char s[] = "a"; + assert(std::regex_search(s, m, std::regex("a", std::regex_constants::basic))); + assert(m.size() == 1); + assert(!m.empty()); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+1); + assert(m.length(0) == 1); + assert(m.position(0) == 0); + assert(m.str(0) == "a"); + } + { + std::cmatch m; + const char s[] = "ab"; + assert(std::regex_search(s, m, std::regex("ab", std::regex_constants::basic))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+2); + assert(m.length(0) == 2); + assert(m.position(0) == 0); + assert(m.str(0) == "ab"); + } + { + std::cmatch m; + const char s[] = "ab"; + assert(!std::regex_search(s, m, std::regex("ba", std::regex_constants::basic))); + assert(m.size() == 0); + assert(m.empty()); + } + { + std::cmatch m; + const char s[] = "aab"; + assert(std::regex_search(s, m, std::regex("ab", std::regex_constants::basic))); + assert(m.size() == 1); + assert(m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+3); + assert(m.length(0) == 2); + assert(m.position(0) == 1); + assert(m.str(0) == "ab"); + } + { + std::cmatch m; + const char s[] = "aab"; + assert(!std::regex_search(s, m, std::regex("ab", std::regex_constants::basic), + std::regex_constants::match_continuous)); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "abcd"; + assert(std::regex_search(s, m, std::regex("bc", std::regex_constants::basic))); + assert(m.size() == 1); + assert(m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+4); + assert(m.length(0) == 2); + assert(m.position(0) == 1); + assert(m.str(0) == "bc"); + } + { + std::cmatch m; + const char s[] = "abbc"; + assert(std::regex_search(s, m, std::regex("ab*c", std::regex_constants::basic))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+4); + assert(m.length(0) == 4); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "ababc"; + assert(std::regex_search(s, m, std::regex("\\(ab\\)*c", std::regex_constants::basic))); + assert(m.size() == 2); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+5); + assert(m.length(0) == 5); + assert(m.position(0) == 0); + assert(m.str(0) == s); + assert(m.length(1) == 2); + assert(m.position(1) == 2); + assert(m.str(1) == "ab"); + } + { + std::cmatch m; + const char s[] = "abcdefghijk"; + assert(std::regex_search(s, m, std::regex("cd\\(\\(e\\)fg\\)hi", + std::regex_constants::basic))); + assert(m.size() == 3); + assert(m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+std::regex_traits<char>::length(s)); + assert(m.length(0) == 7); + assert(m.position(0) == 2); + assert(m.str(0) == "cdefghi"); + assert(m.length(1) == 3); + assert(m.position(1) == 4); + assert(m.str(1) == "efg"); + assert(m.length(2) == 1); + assert(m.position(2) == 4); + assert(m.str(2) == "e"); + } + { + std::cmatch m; + const char s[] = "abc"; + assert(std::regex_search(s, m, std::regex("^abc", std::regex_constants::basic))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+3); + assert(m.length(0) == 3); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "abcd"; + assert(std::regex_search(s, m, std::regex("^abc", std::regex_constants::basic))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+4); + assert(m.length(0) == 3); + assert(m.position(0) == 0); + assert(m.str(0) == "abc"); + } + { + std::cmatch m; + const char s[] = "aabc"; + assert(!std::regex_search(s, m, std::regex("^abc", std::regex_constants::basic))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "abc"; + assert(std::regex_search(s, m, std::regex("abc$", std::regex_constants::basic))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+3); + assert(m.length(0) == 3); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "efabc"; + assert(std::regex_search(s, m, std::regex("abc$", std::regex_constants::basic))); + assert(m.size() == 1); + assert(m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+5); + assert(m.length(0) == 3); + assert(m.position(0) == 2); + assert(m.str(0) == s+2); + } + { + std::cmatch m; + const char s[] = "efabcg"; + assert(!std::regex_search(s, m, std::regex("abc$", std::regex_constants::basic))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "abc"; + assert(std::regex_search(s, m, std::regex("a.c", std::regex_constants::basic))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+3); + assert(m.length(0) == 3); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "acc"; + assert(std::regex_search(s, m, std::regex("a.c", std::regex_constants::basic))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+3); + assert(m.length(0) == 3); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "acc"; + assert(std::regex_search(s, m, std::regex("a.c", std::regex_constants::basic))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+3); + assert(m.length(0) == 3); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "abcdef"; + assert(std::regex_search(s, m, std::regex("\\(.*\\).*", std::regex_constants::basic))); + assert(m.size() == 2); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+6); + assert(m.length(0) == 6); + assert(m.position(0) == 0); + assert(m.str(0) == s); + assert(m.length(1) == 6); + assert(m.position(1) == 0); + assert(m.str(1) == s); + } + { + std::cmatch m; + const char s[] = "bc"; + assert(std::regex_search(s, m, std::regex("\\(a*\\)*", std::regex_constants::basic))); + assert(m.size() == 2); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+2); + assert(m.length(0) == 0); + assert(m.position(0) == 0); + assert(m.str(0) == ""); + assert(m.length(1) == 0); + assert(m.position(1) == 0); + assert(m.str(1) == ""); + } + { + std::cmatch m; + const char s[] = "abbc"; + assert(!std::regex_search(s, m, std::regex("ab\\{3,5\\}c", std::regex_constants::basic))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "abbbc"; + assert(std::regex_search(s, m, std::regex("ab\\{3,5\\}c", std::regex_constants::basic))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == sizeof(s)-1); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "abbbbc"; + assert(std::regex_search(s, m, std::regex("ab\\{3,5\\}c", std::regex_constants::basic))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == sizeof(s)-1); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "abbbbbc"; + assert(std::regex_search(s, m, std::regex("ab\\{3,5\\}c", std::regex_constants::basic))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == sizeof(s)-1); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "adefc"; + assert(!std::regex_search(s, m, std::regex("ab\\{3,5\\}c", std::regex_constants::basic))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "abbbbbbc"; + assert(!std::regex_search(s, m, std::regex("ab\\{3,5\\}c", std::regex_constants::basic))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "adec"; + assert(!std::regex_search(s, m, std::regex("a.\\{3,5\\}c", std::regex_constants::basic))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "adefc"; + assert(std::regex_search(s, m, std::regex("a.\\{3,5\\}c", std::regex_constants::basic))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == sizeof(s)-1); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "adefgc"; + assert(std::regex_search(s, m, std::regex("a.\\{3,5\\}c", std::regex_constants::basic))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == sizeof(s)-1); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "adefghc"; + assert(std::regex_search(s, m, std::regex("a.\\{3,5\\}c", std::regex_constants::basic))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == sizeof(s)-1); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "adefghic"; + assert(!std::regex_search(s, m, std::regex("a.\\{3,5\\}c", std::regex_constants::basic))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "-ab,ab-"; + assert(std::regex_search(s, m, std::regex("-\\(.*\\),\\1-", std::regex_constants::basic))); + assert(m.size() == 2); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + assert(m.length(1) == 2); + assert(m.position(1) == 1); + assert(m.str(1) == "ab"); + } + { + std::cmatch m; + const char s[] = "ababbabb"; + assert(std::regex_search(s, m, std::regex("^\\(ab*\\)*\\1$", std::regex_constants::basic))); + assert(m.size() == 2); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + assert(m.length(1) == 3); + assert(m.position(1) == 2); + assert(m.str(1) == "abb"); + } + { + std::cmatch m; + const char s[] = "ababbab"; + assert(!std::regex_search(s, m, std::regex("^\\(ab*\\)*\\1$", std::regex_constants::basic))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "aBAbbAbB"; + assert(std::regex_search(s, m, std::regex("^\\(Ab*\\)*\\1$", + std::regex_constants::basic | std::regex_constants::icase))); + assert(m.size() == 2); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + assert(m.length(1) == 3); + assert(m.position(1) == 2); + assert(m.str(1) == "Abb"); + } + { + std::cmatch m; + const char s[] = "aBAbbAbB"; + assert(!std::regex_search(s, m, std::regex("^\\(Ab*\\)*\\1$", + std::regex_constants::basic))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "a"; + assert(std::regex_search(s, m, std::regex("^[a]$", + std::regex_constants::basic))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == 1); + assert(m.position(0) == 0); + assert(m.str(0) == "a"); + } + { + std::cmatch m; + const char s[] = "a"; + assert(std::regex_search(s, m, std::regex("^[ab]$", + std::regex_constants::basic))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == 1); + assert(m.position(0) == 0); + assert(m.str(0) == "a"); + } + { + std::cmatch m; + const char s[] = "c"; + assert(std::regex_search(s, m, std::regex("^[a-f]$", + std::regex_constants::basic))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == 1); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "g"; + assert(!std::regex_search(s, m, std::regex("^[a-f]$", + std::regex_constants::basic))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "Iraqi"; + assert(std::regex_search(s, m, std::regex("q[^u]", + std::regex_constants::basic))); + assert(m.size() == 1); + assert(m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == 2); + assert(m.position(0) == 3); + assert(m.str(0) == "qi"); + } + { + std::cmatch m; + const char s[] = "Iraq"; + assert(!std::regex_search(s, m, std::regex("q[^u]", + std::regex_constants::basic))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "AmB"; + assert(std::regex_search(s, m, std::regex("A[[:lower:]]B", + std::regex_constants::basic))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "AMB"; + assert(!std::regex_search(s, m, std::regex("A[[:lower:]]B", + std::regex_constants::basic))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "AMB"; + assert(std::regex_search(s, m, std::regex("A[^[:lower:]]B", + std::regex_constants::basic))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "AmB"; + assert(!std::regex_search(s, m, std::regex("A[^[:lower:]]B", + std::regex_constants::basic))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "A5B"; + assert(!std::regex_search(s, m, std::regex("A[^[:lower:]0-9]B", + std::regex_constants::basic))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "A?B"; + assert(std::regex_search(s, m, std::regex("A[^[:lower:]0-9]B", + std::regex_constants::basic))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "-"; + assert(std::regex_search(s, m, std::regex("[a[.hyphen.]z]", + std::regex_constants::basic))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "z"; + assert(std::regex_search(s, m, std::regex("[a[.hyphen.]z]", + std::regex_constants::basic))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "m"; + assert(!std::regex_search(s, m, std::regex("[a[.hyphen.]z]", + std::regex_constants::basic))); + assert(m.size() == 0); + } + std::locale::global(std::locale("cs_CZ.ISO8859-2")); + { + std::cmatch m; + const char s[] = "m"; + assert(std::regex_search(s, m, std::regex("[a[=M=]z]", + std::regex_constants::basic))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "Ch"; + assert(std::regex_search(s, m, std::regex("[a[.ch.]z]", + std::regex_constants::basic | std::regex_constants::icase))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + std::locale::global(std::locale("C")); + { + std::cmatch m; + const char s[] = "m"; + assert(!std::regex_search(s, m, std::regex("[a[=M=]z]", + std::regex_constants::basic))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "01a45cef9"; + assert(std::regex_search(s, m, std::regex("[ace1-9]*", + std::regex_constants::basic))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s + std::char_traits<char>::length(s)); + assert(m.length(0) == 0); + assert(m.position(0) == 0); + assert(m.str(0) == ""); + } + { + std::cmatch m; + const char s[] = "01a45cef9"; + assert(std::regex_search(s, m, std::regex("[ace1-9]\\{1,\\}", + std::regex_constants::basic))); + assert(m.size() == 1); + assert(m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s + std::char_traits<char>::length(s)); + assert(m.length(0) == 6); + assert(m.position(0) == 1); + assert(m.str(0) == "1a45ce"); + } + { + const char r[] = "^[-+]\\{0,1\\}[0-9]\\{1,\\}[CF]$"; + std::ptrdiff_t sr = std::char_traits<char>::length(r); + typedef forward_iterator<const char*> FI; + typedef bidirectional_iterator<const char*> BI; + std::regex regex(FI(r), FI(r+sr), std::regex_constants::basic); + std::match_results<BI> m; + const char s[] = "-40C"; + std::ptrdiff_t ss = std::char_traits<char>::length(s); + assert(std::regex_search(BI(s), BI(s+ss), m, regex)); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == BI(s)); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == 4); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + + { + std::wcmatch m; + assert(!std::regex_search(L"a", m, std::wregex())); + assert(m.size() == 0); + assert(m.empty()); + } + { + std::wcmatch m; + const wchar_t s[] = L"a"; + assert(std::regex_search(s, m, std::wregex(L"a", std::regex_constants::basic))); + assert(m.size() == 1); + assert(!m.empty()); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+1); + assert(m.length(0) == 1); + assert(m.position(0) == 0); + assert(m.str(0) == L"a"); + } + { + std::wcmatch m; + const wchar_t s[] = L"ab"; + assert(std::regex_search(s, m, std::wregex(L"ab", std::regex_constants::basic))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+2); + assert(m.length(0) == 2); + assert(m.position(0) == 0); + assert(m.str(0) == L"ab"); + } + { + std::wcmatch m; + const wchar_t s[] = L"ab"; + assert(!std::regex_search(s, m, std::wregex(L"ba", std::regex_constants::basic))); + assert(m.size() == 0); + assert(m.empty()); + } + { + std::wcmatch m; + const wchar_t s[] = L"aab"; + assert(std::regex_search(s, m, std::wregex(L"ab", std::regex_constants::basic))); + assert(m.size() == 1); + assert(m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+3); + assert(m.length(0) == 2); + assert(m.position(0) == 1); + assert(m.str(0) == L"ab"); + } + { + std::wcmatch m; + const wchar_t s[] = L"aab"; + assert(!std::regex_search(s, m, std::wregex(L"ab", std::regex_constants::basic), + std::regex_constants::match_continuous)); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"abcd"; + assert(std::regex_search(s, m, std::wregex(L"bc", std::regex_constants::basic))); + assert(m.size() == 1); + assert(m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+4); + assert(m.length(0) == 2); + assert(m.position(0) == 1); + assert(m.str(0) == L"bc"); + } + { + std::wcmatch m; + const wchar_t s[] = L"abbc"; + assert(std::regex_search(s, m, std::wregex(L"ab*c", std::regex_constants::basic))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+4); + assert(m.length(0) == 4); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"ababc"; + assert(std::regex_search(s, m, std::wregex(L"\\(ab\\)*c", std::regex_constants::basic))); + assert(m.size() == 2); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+5); + assert(m.length(0) == 5); + assert(m.position(0) == 0); + assert(m.str(0) == s); + assert(m.length(1) == 2); + assert(m.position(1) == 2); + assert(m.str(1) == L"ab"); + } + { + std::wcmatch m; + const wchar_t s[] = L"abcdefghijk"; + assert(std::regex_search(s, m, std::wregex(L"cd\\(\\(e\\)fg\\)hi", + std::regex_constants::basic))); + assert(m.size() == 3); + assert(m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+std::regex_traits<wchar_t>::length(s)); + assert(m.length(0) == 7); + assert(m.position(0) == 2); + assert(m.str(0) == L"cdefghi"); + assert(m.length(1) == 3); + assert(m.position(1) == 4); + assert(m.str(1) == L"efg"); + assert(m.length(2) == 1); + assert(m.position(2) == 4); + assert(m.str(2) == L"e"); + } + { + std::wcmatch m; + const wchar_t s[] = L"abc"; + assert(std::regex_search(s, m, std::wregex(L"^abc", std::regex_constants::basic))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+3); + assert(m.length(0) == 3); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"abcd"; + assert(std::regex_search(s, m, std::wregex(L"^abc", std::regex_constants::basic))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+4); + assert(m.length(0) == 3); + assert(m.position(0) == 0); + assert(m.str(0) == L"abc"); + } + { + std::wcmatch m; + const wchar_t s[] = L"aabc"; + assert(!std::regex_search(s, m, std::wregex(L"^abc", std::regex_constants::basic))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"abc"; + assert(std::regex_search(s, m, std::wregex(L"abc$", std::regex_constants::basic))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+3); + assert(m.length(0) == 3); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"efabc"; + assert(std::regex_search(s, m, std::wregex(L"abc$", std::regex_constants::basic))); + assert(m.size() == 1); + assert(m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+5); + assert(m.length(0) == 3); + assert(m.position(0) == 2); + assert(m.str(0) == s+2); + } + { + std::wcmatch m; + const wchar_t s[] = L"efabcg"; + assert(!std::regex_search(s, m, std::wregex(L"abc$", std::regex_constants::basic))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"abc"; + assert(std::regex_search(s, m, std::wregex(L"a.c", std::regex_constants::basic))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+3); + assert(m.length(0) == 3); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"acc"; + assert(std::regex_search(s, m, std::wregex(L"a.c", std::regex_constants::basic))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+3); + assert(m.length(0) == 3); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"acc"; + assert(std::regex_search(s, m, std::wregex(L"a.c", std::regex_constants::basic))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+3); + assert(m.length(0) == 3); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"abcdef"; + assert(std::regex_search(s, m, std::wregex(L"\\(.*\\).*", std::regex_constants::basic))); + assert(m.size() == 2); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+6); + assert(m.length(0) == 6); + assert(m.position(0) == 0); + assert(m.str(0) == s); + assert(m.length(1) == 6); + assert(m.position(1) == 0); + assert(m.str(1) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"bc"; + assert(std::regex_search(s, m, std::wregex(L"\\(a*\\)*", std::regex_constants::basic))); + assert(m.size() == 2); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+2); + assert(m.length(0) == 0); + assert(m.position(0) == 0); + assert(m.str(0) == L""); + assert(m.length(1) == 0); + assert(m.position(1) == 0); + assert(m.str(1) == L""); + } + { + std::wcmatch m; + const wchar_t s[] = L"abbc"; + assert(!std::regex_search(s, m, std::wregex(L"ab\\{3,5\\}c", std::regex_constants::basic))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"abbbc"; + assert(std::regex_search(s, m, std::wregex(L"ab\\{3,5\\}c", std::regex_constants::basic))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"abbbbc"; + assert(std::regex_search(s, m, std::wregex(L"ab\\{3,5\\}c", std::regex_constants::basic))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"abbbbbc"; + assert(std::regex_search(s, m, std::wregex(L"ab\\{3,5\\}c", std::regex_constants::basic))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"adefc"; + assert(!std::regex_search(s, m, std::wregex(L"ab\\{3,5\\}c", std::regex_constants::basic))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"abbbbbbc"; + assert(!std::regex_search(s, m, std::wregex(L"ab\\{3,5\\}c", std::regex_constants::basic))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"adec"; + assert(!std::regex_search(s, m, std::wregex(L"a.\\{3,5\\}c", std::regex_constants::basic))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"adefc"; + assert(std::regex_search(s, m, std::wregex(L"a.\\{3,5\\}c", std::regex_constants::basic))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"adefgc"; + assert(std::regex_search(s, m, std::wregex(L"a.\\{3,5\\}c", std::regex_constants::basic))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"adefghc"; + assert(std::regex_search(s, m, std::wregex(L"a.\\{3,5\\}c", std::regex_constants::basic))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"adefghic"; + assert(!std::regex_search(s, m, std::wregex(L"a.\\{3,5\\}c", std::regex_constants::basic))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"-ab,ab-"; + assert(std::regex_search(s, m, std::wregex(L"-\\(.*\\),\\1-", std::regex_constants::basic))); + assert(m.size() == 2); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + assert(m.length(1) == 2); + assert(m.position(1) == 1); + assert(m.str(1) == L"ab"); + } + { + std::wcmatch m; + const wchar_t s[] = L"ababbabb"; + assert(std::regex_search(s, m, std::wregex(L"^\\(ab*\\)*\\1$", std::regex_constants::basic))); + assert(m.size() == 2); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + assert(m.length(1) == 3); + assert(m.position(1) == 2); + assert(m.str(1) == L"abb"); + } + { + std::wcmatch m; + const wchar_t s[] = L"ababbab"; + assert(!std::regex_search(s, m, std::wregex(L"^\\(ab*\\)*\\1$", std::regex_constants::basic))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"aBAbbAbB"; + assert(std::regex_search(s, m, std::wregex(L"^\\(Ab*\\)*\\1$", + std::regex_constants::basic | std::regex_constants::icase))); + assert(m.size() == 2); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + assert(m.length(1) == 3); + assert(m.position(1) == 2); + assert(m.str(1) == L"Abb"); + } + { + std::wcmatch m; + const wchar_t s[] = L"aBAbbAbB"; + assert(!std::regex_search(s, m, std::wregex(L"^\\(Ab*\\)*\\1$", + std::regex_constants::basic))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"a"; + assert(std::regex_search(s, m, std::wregex(L"^[a]$", + std::regex_constants::basic))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == 1); + assert(m.position(0) == 0); + assert(m.str(0) == L"a"); + } + { + std::wcmatch m; + const wchar_t s[] = L"a"; + assert(std::regex_search(s, m, std::wregex(L"^[ab]$", + std::regex_constants::basic))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == 1); + assert(m.position(0) == 0); + assert(m.str(0) == L"a"); + } + { + std::wcmatch m; + const wchar_t s[] = L"c"; + assert(std::regex_search(s, m, std::wregex(L"^[a-f]$", + std::regex_constants::basic))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == 1); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"g"; + assert(!std::regex_search(s, m, std::wregex(L"^[a-f]$", + std::regex_constants::basic))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"Iraqi"; + assert(std::regex_search(s, m, std::wregex(L"q[^u]", + std::regex_constants::basic))); + assert(m.size() == 1); + assert(m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == 2); + assert(m.position(0) == 3); + assert(m.str(0) == L"qi"); + } + { + std::wcmatch m; + const wchar_t s[] = L"Iraq"; + assert(!std::regex_search(s, m, std::wregex(L"q[^u]", + std::regex_constants::basic))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"AmB"; + assert(std::regex_search(s, m, std::wregex(L"A[[:lower:]]B", + std::regex_constants::basic))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"AMB"; + assert(!std::regex_search(s, m, std::wregex(L"A[[:lower:]]B", + std::regex_constants::basic))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"AMB"; + assert(std::regex_search(s, m, std::wregex(L"A[^[:lower:]]B", + std::regex_constants::basic))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"AmB"; + assert(!std::regex_search(s, m, std::wregex(L"A[^[:lower:]]B", + std::regex_constants::basic))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"A5B"; + assert(!std::regex_search(s, m, std::wregex(L"A[^[:lower:]0-9]B", + std::regex_constants::basic))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"A?B"; + assert(std::regex_search(s, m, std::wregex(L"A[^[:lower:]0-9]B", + std::regex_constants::basic))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"-"; + assert(std::regex_search(s, m, std::wregex(L"[a[.hyphen.]z]", + std::regex_constants::basic))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"z"; + assert(std::regex_search(s, m, std::wregex(L"[a[.hyphen.]z]", + std::regex_constants::basic))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"m"; + assert(!std::regex_search(s, m, std::wregex(L"[a[.hyphen.]z]", + std::regex_constants::basic))); + assert(m.size() == 0); + } + std::locale::global(std::locale("cs_CZ.ISO8859-2")); + { + std::wcmatch m; + const wchar_t s[] = L"m"; + assert(std::regex_search(s, m, std::wregex(L"[a[=M=]z]", + std::regex_constants::basic))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"Ch"; + assert(std::regex_search(s, m, std::wregex(L"[a[.ch.]z]", + std::regex_constants::basic | std::regex_constants::icase))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + std::locale::global(std::locale("C")); + { + std::wcmatch m; + const wchar_t s[] = L"m"; + assert(!std::regex_search(s, m, std::wregex(L"[a[=M=]z]", + std::regex_constants::basic))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"01a45cef9"; + assert(std::regex_search(s, m, std::wregex(L"[ace1-9]*", + std::regex_constants::basic))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s + std::char_traits<wchar_t>::length(s)); + assert(m.length(0) == 0); + assert(m.position(0) == 0); + assert(m.str(0) == L""); + } + { + std::wcmatch m; + const wchar_t s[] = L"01a45cef9"; + assert(std::regex_search(s, m, std::wregex(L"[ace1-9]\\{1,\\}", + std::regex_constants::basic))); + assert(m.size() == 1); + assert(m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s + std::char_traits<wchar_t>::length(s)); + assert(m.length(0) == 6); + assert(m.position(0) == 1); + assert(m.str(0) == L"1a45ce"); + } + { + const wchar_t r[] = L"^[-+]\\{0,1\\}[0-9]\\{1,\\}[CF]$"; + std::ptrdiff_t sr = std::char_traits<wchar_t>::length(r); + typedef forward_iterator<const wchar_t*> FI; + typedef bidirectional_iterator<const wchar_t*> BI; + std::wregex regex(FI(r), FI(r+sr), std::regex_constants::basic); + std::match_results<BI> m; + const wchar_t s[] = L"-40C"; + std::ptrdiff_t ss = std::char_traits<wchar_t>::length(s); + assert(std::regex_search(BI(s), BI(s+ss), m, regex)); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == BI(s)); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == 4); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } +} diff --git a/libcxx/test/std/re/re.alg/re.alg.search/ecma.pass.cpp b/libcxx/test/std/re/re.alg/re.alg.search/ecma.pass.cpp new file mode 100644 index 00000000000..2796850fbd5 --- /dev/null +++ b/libcxx/test/std/re/re.alg/re.alg.search/ecma.pass.cpp @@ -0,0 +1,1588 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// REQUIRES: locale.cs_CZ.ISO8859-2 + +// <regex> + +// template <class BidirectionalIterator, class Allocator, class charT, class traits> +// bool +// regex_search(BidirectionalIterator first, BidirectionalIterator last, +// match_results<BidirectionalIterator, Allocator>& m, +// const basic_regex<charT, traits>& e, +// regex_constants::match_flag_type flags = regex_constants::match_default); + +// TODO: investigation needed +// XFAIL: linux-gnu + +#include <regex> +#include <cassert> + +#include "test_iterators.h" + +int main() +{ + { + std::cmatch m; + const char s[] = "a"; + assert(std::regex_search(s, m, std::regex("a"))); + assert(m.size() == 1); + assert(!m.empty()); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+1); + assert(m.length(0) == 1); + assert(m.position(0) == 0); + assert(m.str(0) == "a"); + } + { + std::cmatch m; + const char s[] = "ab"; + assert(std::regex_search(s, m, std::regex("ab"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+2); + assert(m.length(0) == 2); + assert(m.position(0) == 0); + assert(m.str(0) == "ab"); + } + { + std::cmatch m; + const char s[] = "ab"; + assert(!std::regex_search(s, m, std::regex("ba"))); + assert(m.size() == 0); + assert(m.empty()); + } + { + std::cmatch m; + const char s[] = "aab"; + assert(std::regex_search(s, m, std::regex("ab"))); + assert(m.size() == 1); + assert(m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+3); + assert(m.length(0) == 2); + assert(m.position(0) == 1); + assert(m.str(0) == "ab"); + } + { + std::cmatch m; + const char s[] = "aab"; + assert(!std::regex_search(s, m, std::regex("ab"), + std::regex_constants::match_continuous)); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "abcd"; + assert(std::regex_search(s, m, std::regex("bc"))); + assert(m.size() == 1); + assert(m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+4); + assert(m.length(0) == 2); + assert(m.position(0) == 1); + assert(m.str(0) == "bc"); + } + { + std::cmatch m; + const char s[] = "abbc"; + assert(std::regex_search(s, m, std::regex("ab*c"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+4); + assert(m.length(0) == 4); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "ababc"; + assert(std::regex_search(s, m, std::regex("(ab)*c"))); + assert(m.size() == 2); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+5); + assert(m.length(0) == 5); + assert(m.position(0) == 0); + assert(m.str(0) == s); + assert(m.length(1) == 2); + assert(m.position(1) == 2); + assert(m.str(1) == "ab"); + } + { + std::cmatch m; + const char s[] = "abcdefghijk"; + assert(std::regex_search(s, m, std::regex("cd((e)fg)hi"))); + assert(m.size() == 3); + assert(m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+std::regex_traits<char>::length(s)); + assert(m.length(0) == 7); + assert(m.position(0) == 2); + assert(m.str(0) == "cdefghi"); + assert(m.length(1) == 3); + assert(m.position(1) == 4); + assert(m.str(1) == "efg"); + assert(m.length(2) == 1); + assert(m.position(2) == 4); + assert(m.str(2) == "e"); + } + { + std::cmatch m; + const char s[] = "abc"; + assert(std::regex_search(s, m, std::regex("^abc"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+3); + assert(m.length(0) == 3); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "abcd"; + assert(std::regex_search(s, m, std::regex("^abc"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+4); + assert(m.length(0) == 3); + assert(m.position(0) == 0); + assert(m.str(0) == "abc"); + } + { + std::cmatch m; + const char s[] = "aabc"; + assert(!std::regex_search(s, m, std::regex("^abc"))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "abc"; + assert(std::regex_search(s, m, std::regex("abc$"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+3); + assert(m.length(0) == 3); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "efabc"; + assert(std::regex_search(s, m, std::regex("abc$"))); + assert(m.size() == 1); + assert(m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+5); + assert(m.length(0) == 3); + assert(m.position(0) == 2); + assert(m.str(0) == s+2); + } + { + std::cmatch m; + const char s[] = "efabcg"; + assert(!std::regex_search(s, m, std::regex("abc$"))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "abc"; + assert(std::regex_search(s, m, std::regex("a.c"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+3); + assert(m.length(0) == 3); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "acc"; + assert(std::regex_search(s, m, std::regex("a.c"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+3); + assert(m.length(0) == 3); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "acc"; + assert(std::regex_search(s, m, std::regex("a.c"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+3); + assert(m.length(0) == 3); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "abcdef"; + assert(std::regex_search(s, m, std::regex("(.*).*"))); + assert(m.size() == 2); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+6); + assert(m.length(0) == 6); + assert(m.position(0) == 0); + assert(m.str(0) == s); + assert(m.length(1) == 6); + assert(m.position(1) == 0); + assert(m.str(1) == s); + } + { + std::cmatch m; + const char s[] = "bc"; + assert(std::regex_search(s, m, std::regex("(a*)*"))); + assert(m.size() == 2); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+2); + assert(m.length(0) == 0); + assert(m.position(0) == 0); + assert(m.str(0) == ""); + assert(m.length(1) == 0); + assert(m.position(1) == 0); + assert(m.str(1) == ""); + } + { + std::cmatch m; + const char s[] = "abbc"; + assert(!std::regex_search(s, m, std::regex("ab{3,5}c"))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "abbbc"; + assert(std::regex_search(s, m, std::regex("ab{3,5}c"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "abbbbc"; + assert(std::regex_search(s, m, std::regex("ab{3,5}c"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "abbbbbc"; + assert(std::regex_search(s, m, std::regex("ab{3,5}c"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "adefc"; + assert(!std::regex_search(s, m, std::regex("ab{3,5}c"))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "abbbbbbc"; + assert(!std::regex_search(s, m, std::regex("ab{3,5}c"))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "adec"; + assert(!std::regex_search(s, m, std::regex("a.{3,5}c"))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "adefc"; + assert(std::regex_search(s, m, std::regex("a.{3,5}c"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "adefgc"; + assert(std::regex_search(s, m, std::regex("a.{3,5}c"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "adefghc"; + assert(std::regex_search(s, m, std::regex("a.{3,5}c"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "adefghic"; + assert(!std::regex_search(s, m, std::regex("a.{3,5}c"))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "tournament"; + assert(std::regex_search(s, m, std::regex("tour|to|tournament"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s + std::char_traits<char>::length(s)); + assert(m.length(0) == 4); + assert(m.position(0) == 0); + assert(m.str(0) == "tour"); + } + { + std::cmatch m; + const char s[] = "tournamenttotour"; + assert(std::regex_search(s, m, std::regex("(tour|to|tournament)+", + std::regex_constants::nosubs))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s + std::char_traits<char>::length(s)); + assert(m.length(0) == 4); + assert(m.position(0) == 0); + assert(m.str(0) == "tour"); + } + { + std::cmatch m; + const char s[] = "ttotour"; + assert(std::regex_search(s, m, std::regex("(tour|to|t)+"))); + assert(m.size() == 2); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + assert(m.length(1) == 4); + assert(m.position(1) == 3); + assert(m.str(1) == "tour"); + } + { + std::cmatch m; + const char s[] = "-ab,ab-"; + assert(!std::regex_search(s, m, std::regex("-(.*),\1-"))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "-ab,ab-"; + assert(std::regex_search(s, m, std::regex("-.*,.*-"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "a"; + assert(std::regex_search(s, m, std::regex("^[a]$"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == 1); + assert(m.position(0) == 0); + assert(m.str(0) == "a"); + } + { + std::cmatch m; + const char s[] = "a"; + assert(std::regex_search(s, m, std::regex("^[ab]$"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == 1); + assert(m.position(0) == 0); + assert(m.str(0) == "a"); + } + { + std::cmatch m; + const char s[] = "c"; + assert(std::regex_search(s, m, std::regex("^[a-f]$"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == 1); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "g"; + assert(!std::regex_search(s, m, std::regex("^[a-f]$"))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "Iraqi"; + assert(std::regex_search(s, m, std::regex("q[^u]"))); + assert(m.size() == 1); + assert(m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == 2); + assert(m.position(0) == 3); + assert(m.str(0) == "qi"); + } + { + std::cmatch m; + const char s[] = "Iraq"; + assert(!std::regex_search(s, m, std::regex("q[^u]"))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "AmB"; + assert(std::regex_search(s, m, std::regex("A[[:lower:]]B"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "AMB"; + assert(!std::regex_search(s, m, std::regex("A[[:lower:]]B"))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "AMB"; + assert(std::regex_search(s, m, std::regex("A[^[:lower:]]B"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "AmB"; + assert(!std::regex_search(s, m, std::regex("A[^[:lower:]]B"))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "A5B"; + assert(!std::regex_search(s, m, std::regex("A[^[:lower:]0-9]B"))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "A?B"; + assert(std::regex_search(s, m, std::regex("A[^[:lower:]0-9]B"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "-"; + assert(std::regex_search(s, m, std::regex("[a[.hyphen.]z]"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "z"; + assert(std::regex_search(s, m, std::regex("[a[.hyphen.]z]"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "m"; + assert(!std::regex_search(s, m, std::regex("[a[.hyphen.]z]"))); + assert(m.size() == 0); + } + std::locale::global(std::locale("cs_CZ.ISO8859-2")); + { + std::cmatch m; + const char s[] = "m"; + assert(std::regex_search(s, m, std::regex("[a[=M=]z]"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "Ch"; + assert(std::regex_search(s, m, std::regex("[a[.ch.]z]", + std::regex_constants::icase))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + std::locale::global(std::locale("C")); + { + std::cmatch m; + const char s[] = "m"; + assert(!std::regex_search(s, m, std::regex("[a[=M=]z]"))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "01a45cef9"; + assert(std::regex_search(s, m, std::regex("[ace1-9]*"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s + std::char_traits<char>::length(s)); + assert(m.length(0) == 0); + assert(m.position(0) == 0); + assert(m.str(0) == ""); + } + { + std::cmatch m; + const char s[] = "01a45cef9"; + assert(std::regex_search(s, m, std::regex("[ace1-9]+"))); + assert(m.size() == 1); + assert(m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s + std::char_traits<char>::length(s)); + assert(m.length(0) == 6); + assert(m.position(0) == 1); + assert(m.str(0) == "1a45ce"); + } + { + const char r[] = "^[-+]?[0-9]+[CF]$"; + std::ptrdiff_t sr = std::char_traits<char>::length(r); + typedef forward_iterator<const char*> FI; + typedef bidirectional_iterator<const char*> BI; + std::regex regex(FI(r), FI(r+sr)); + std::match_results<BI> m; + const char s[] = "-40C"; + std::ptrdiff_t ss = std::char_traits<char>::length(s); + assert(std::regex_search(BI(s), BI(s+ss), m, regex)); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == BI(s)); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == 4); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "Jeff Jeffs "; + assert(std::regex_search(s, m, std::regex("Jeff(?=s\\b)"))); + assert(m.size() == 1); + assert(m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s + std::char_traits<char>::length(s)); + assert(m.length(0) == 4); + assert(m.position(0) == 5); + assert(m.str(0) == "Jeff"); + } + { + std::cmatch m; + const char s[] = "Jeffs Jeff"; + assert(std::regex_search(s, m, std::regex("Jeff(?!s\\b)"))); + assert(m.size() == 1); + assert(m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s + std::char_traits<char>::length(s)); + assert(m.length(0) == 4); + assert(m.position(0) == 6); + assert(m.str(0) == "Jeff"); + } + { + std::cmatch m; + const char s[] = "5%k"; + assert(std::regex_search(s, m, std::regex("\\d[\\W]k"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s + std::char_traits<char>::length(s)); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + + { + std::wcmatch m; + const wchar_t s[] = L"a"; + assert(std::regex_search(s, m, std::wregex(L"a"))); + assert(m.size() == 1); + assert(!m.empty()); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+1); + assert(m.length(0) == 1); + assert(m.position(0) == 0); + assert(m.str(0) == L"a"); + } + { + std::wcmatch m; + const wchar_t s[] = L"ab"; + assert(std::regex_search(s, m, std::wregex(L"ab"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+2); + assert(m.length(0) == 2); + assert(m.position(0) == 0); + assert(m.str(0) == L"ab"); + } + { + std::wcmatch m; + const wchar_t s[] = L"ab"; + assert(!std::regex_search(s, m, std::wregex(L"ba"))); + assert(m.size() == 0); + assert(m.empty()); + } + { + std::wcmatch m; + const wchar_t s[] = L"aab"; + assert(std::regex_search(s, m, std::wregex(L"ab"))); + assert(m.size() == 1); + assert(m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+3); + assert(m.length(0) == 2); + assert(m.position(0) == 1); + assert(m.str(0) == L"ab"); + } + { + std::wcmatch m; + const wchar_t s[] = L"aab"; + assert(!std::regex_search(s, m, std::wregex(L"ab"), + std::regex_constants::match_continuous)); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"abcd"; + assert(std::regex_search(s, m, std::wregex(L"bc"))); + assert(m.size() == 1); + assert(m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+4); + assert(m.length(0) == 2); + assert(m.position(0) == 1); + assert(m.str(0) == L"bc"); + } + { + std::wcmatch m; + const wchar_t s[] = L"abbc"; + assert(std::regex_search(s, m, std::wregex(L"ab*c"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+4); + assert(m.length(0) == 4); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"ababc"; + assert(std::regex_search(s, m, std::wregex(L"(ab)*c"))); + assert(m.size() == 2); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+5); + assert(m.length(0) == 5); + assert(m.position(0) == 0); + assert(m.str(0) == s); + assert(m.length(1) == 2); + assert(m.position(1) == 2); + assert(m.str(1) == L"ab"); + } + { + std::wcmatch m; + const wchar_t s[] = L"abcdefghijk"; + assert(std::regex_search(s, m, std::wregex(L"cd((e)fg)hi"))); + assert(m.size() == 3); + assert(m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+std::regex_traits<wchar_t>::length(s)); + assert(m.length(0) == 7); + assert(m.position(0) == 2); + assert(m.str(0) == L"cdefghi"); + assert(m.length(1) == 3); + assert(m.position(1) == 4); + assert(m.str(1) == L"efg"); + assert(m.length(2) == 1); + assert(m.position(2) == 4); + assert(m.str(2) == L"e"); + } + { + std::wcmatch m; + const wchar_t s[] = L"abc"; + assert(std::regex_search(s, m, std::wregex(L"^abc"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+3); + assert(m.length(0) == 3); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"abcd"; + assert(std::regex_search(s, m, std::wregex(L"^abc"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+4); + assert(m.length(0) == 3); + assert(m.position(0) == 0); + assert(m.str(0) == L"abc"); + } + { + std::wcmatch m; + const wchar_t s[] = L"aabc"; + assert(!std::regex_search(s, m, std::wregex(L"^abc"))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"abc"; + assert(std::regex_search(s, m, std::wregex(L"abc$"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+3); + assert(m.length(0) == 3); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"efabc"; + assert(std::regex_search(s, m, std::wregex(L"abc$"))); + assert(m.size() == 1); + assert(m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+5); + assert(m.length(0) == 3); + assert(m.position(0) == 2); + assert(m.str(0) == s+2); + } + { + std::wcmatch m; + const wchar_t s[] = L"efabcg"; + assert(!std::regex_search(s, m, std::wregex(L"abc$"))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"abc"; + assert(std::regex_search(s, m, std::wregex(L"a.c"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+3); + assert(m.length(0) == 3); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"acc"; + assert(std::regex_search(s, m, std::wregex(L"a.c"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+3); + assert(m.length(0) == 3); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"acc"; + assert(std::regex_search(s, m, std::wregex(L"a.c"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+3); + assert(m.length(0) == 3); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"abcdef"; + assert(std::regex_search(s, m, std::wregex(L"(.*).*"))); + assert(m.size() == 2); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+6); + assert(m.length(0) == 6); + assert(m.position(0) == 0); + assert(m.str(0) == s); + assert(m.length(1) == 6); + assert(m.position(1) == 0); + assert(m.str(1) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"bc"; + assert(std::regex_search(s, m, std::wregex(L"(a*)*"))); + assert(m.size() == 2); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+2); + assert(m.length(0) == 0); + assert(m.position(0) == 0); + assert(m.str(0) == L""); + assert(m.length(1) == 0); + assert(m.position(1) == 0); + assert(m.str(1) == L""); + } + { + std::wcmatch m; + const wchar_t s[] = L"abbc"; + assert(!std::regex_search(s, m, std::wregex(L"ab{3,5}c"))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"abbbc"; + assert(std::regex_search(s, m, std::wregex(L"ab{3,5}c"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"abbbbc"; + assert(std::regex_search(s, m, std::wregex(L"ab{3,5}c"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"abbbbbc"; + assert(std::regex_search(s, m, std::wregex(L"ab{3,5}c"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"adefc"; + assert(!std::regex_search(s, m, std::wregex(L"ab{3,5}c"))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"abbbbbbc"; + assert(!std::regex_search(s, m, std::wregex(L"ab{3,5}c"))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"adec"; + assert(!std::regex_search(s, m, std::wregex(L"a.{3,5}c"))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"adefc"; + assert(std::regex_search(s, m, std::wregex(L"a.{3,5}c"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"adefgc"; + assert(std::regex_search(s, m, std::wregex(L"a.{3,5}c"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"adefghc"; + assert(std::regex_search(s, m, std::wregex(L"a.{3,5}c"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"adefghic"; + assert(!std::regex_search(s, m, std::wregex(L"a.{3,5}c"))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"tournament"; + assert(std::regex_search(s, m, std::wregex(L"tour|to|tournament"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s + std::char_traits<wchar_t>::length(s)); + assert(m.length(0) == 4); + assert(m.position(0) == 0); + assert(m.str(0) == L"tour"); + } + { + std::wcmatch m; + const wchar_t s[] = L"tournamenttotour"; + assert(std::regex_search(s, m, std::wregex(L"(tour|to|tournament)+", + std::regex_constants::nosubs))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s + std::char_traits<wchar_t>::length(s)); + assert(m.length(0) == 4); + assert(m.position(0) == 0); + assert(m.str(0) == L"tour"); + } + { + std::wcmatch m; + const wchar_t s[] = L"ttotour"; + assert(std::regex_search(s, m, std::wregex(L"(tour|to|t)+"))); + assert(m.size() == 2); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + assert(m.length(1) == 4); + assert(m.position(1) == 3); + assert(m.str(1) == L"tour"); + } + { + std::wcmatch m; + const wchar_t s[] = L"-ab,ab-"; + assert(!std::regex_search(s, m, std::wregex(L"-(.*),\1-"))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"-ab,ab-"; + assert(std::regex_search(s, m, std::wregex(L"-.*,.*-"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"a"; + assert(std::regex_search(s, m, std::wregex(L"^[a]$"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == 1); + assert(m.position(0) == 0); + assert(m.str(0) == L"a"); + } + { + std::wcmatch m; + const wchar_t s[] = L"a"; + assert(std::regex_search(s, m, std::wregex(L"^[ab]$"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == 1); + assert(m.position(0) == 0); + assert(m.str(0) == L"a"); + } + { + std::wcmatch m; + const wchar_t s[] = L"c"; + assert(std::regex_search(s, m, std::wregex(L"^[a-f]$"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == 1); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"g"; + assert(!std::regex_search(s, m, std::wregex(L"^[a-f]$"))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"Iraqi"; + assert(std::regex_search(s, m, std::wregex(L"q[^u]"))); + assert(m.size() == 1); + assert(m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == 2); + assert(m.position(0) == 3); + assert(m.str(0) == L"qi"); + } + { + std::wcmatch m; + const wchar_t s[] = L"Iraq"; + assert(!std::regex_search(s, m, std::wregex(L"q[^u]"))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"AmB"; + assert(std::regex_search(s, m, std::wregex(L"A[[:lower:]]B"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"AMB"; + assert(!std::regex_search(s, m, std::wregex(L"A[[:lower:]]B"))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"AMB"; + assert(std::regex_search(s, m, std::wregex(L"A[^[:lower:]]B"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"AmB"; + assert(!std::regex_search(s, m, std::wregex(L"A[^[:lower:]]B"))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"A5B"; + assert(!std::regex_search(s, m, std::wregex(L"A[^[:lower:]0-9]B"))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"A?B"; + assert(std::regex_search(s, m, std::wregex(L"A[^[:lower:]0-9]B"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"-"; + assert(std::regex_search(s, m, std::wregex(L"[a[.hyphen.]z]"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"z"; + assert(std::regex_search(s, m, std::wregex(L"[a[.hyphen.]z]"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"m"; + assert(!std::regex_search(s, m, std::wregex(L"[a[.hyphen.]z]"))); + assert(m.size() == 0); + } + std::locale::global(std::locale("cs_CZ.ISO8859-2")); + { + std::wcmatch m; + const wchar_t s[] = L"m"; + assert(std::regex_search(s, m, std::wregex(L"[a[=M=]z]"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"Ch"; + assert(std::regex_search(s, m, std::wregex(L"[a[.ch.]z]", + std::regex_constants::icase))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + std::locale::global(std::locale("C")); + { + std::wcmatch m; + const wchar_t s[] = L"m"; + assert(!std::regex_search(s, m, std::wregex(L"[a[=M=]z]"))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"01a45cef9"; + assert(std::regex_search(s, m, std::wregex(L"[ace1-9]*"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s + std::char_traits<wchar_t>::length(s)); + assert(m.length(0) == 0); + assert(m.position(0) == 0); + assert(m.str(0) == L""); + } + { + std::wcmatch m; + const wchar_t s[] = L"01a45cef9"; + assert(std::regex_search(s, m, std::wregex(L"[ace1-9]+"))); + assert(m.size() == 1); + assert(m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s + std::char_traits<wchar_t>::length(s)); + assert(m.length(0) == 6); + assert(m.position(0) == 1); + assert(m.str(0) == L"1a45ce"); + } + { + const wchar_t r[] = L"^[-+]?[0-9]+[CF]$"; + std::ptrdiff_t sr = std::char_traits<wchar_t>::length(r); + typedef forward_iterator<const wchar_t*> FI; + typedef bidirectional_iterator<const wchar_t*> BI; + std::wregex regex(FI(r), FI(r+sr)); + std::match_results<BI> m; + const wchar_t s[] = L"-40C"; + std::ptrdiff_t ss = std::char_traits<wchar_t>::length(s); + assert(std::regex_search(BI(s), BI(s+ss), m, regex)); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == BI(s)); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == 4); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"Jeff Jeffs "; + assert(std::regex_search(s, m, std::wregex(L"Jeff(?=s\\b)"))); + assert(m.size() == 1); + assert(m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s + std::char_traits<wchar_t>::length(s)); + assert(m.length(0) == 4); + assert(m.position(0) == 5); + assert(m.str(0) == L"Jeff"); + } + { + std::wcmatch m; + const wchar_t s[] = L"Jeffs Jeff"; + assert(std::regex_search(s, m, std::wregex(L"Jeff(?!s\\b)"))); + assert(m.size() == 1); + assert(m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s + std::char_traits<wchar_t>::length(s)); + assert(m.length(0) == 4); + assert(m.position(0) == 6); + assert(m.str(0) == L"Jeff"); + } + { + std::wcmatch m; + const wchar_t s[] = L"5%k"; + assert(std::regex_search(s, m, std::wregex(L"\\d[\\W]k"))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s + std::char_traits<wchar_t>::length(s)); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } +} diff --git a/libcxx/test/std/re/re.alg/re.alg.search/egrep.pass.cpp b/libcxx/test/std/re/re.alg/re.alg.search/egrep.pass.cpp new file mode 100644 index 00000000000..1dffed44f22 --- /dev/null +++ b/libcxx/test/std/re/re.alg/re.alg.search/egrep.pass.cpp @@ -0,0 +1,90 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <regex> + +// template <class BidirectionalIterator, class Allocator, class charT, class traits> +// bool +// regex_search(BidirectionalIterator first, BidirectionalIterator last, +// match_results<BidirectionalIterator, Allocator>& m, +// const basic_regex<charT, traits>& e, +// regex_constants::match_flag_type flags = regex_constants::match_default); + +#include <regex> +#include <cassert> + +#include "test_iterators.h" + +int main() +{ + { + std::cmatch m; + const char s[] = "tournament"; + assert(std::regex_search(s, m, std::regex("tour\nto\ntournament", + std::regex_constants::egrep))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s + std::char_traits<char>::length(s)); + assert(m.length(0) == 10); + assert(m.position(0) == 0); + assert(m.str(0) == "tournament"); + } + { + std::cmatch m; + const char s[] = "ment"; + assert(std::regex_search(s, m, std::regex("tour\n\ntournament", + std::regex_constants::egrep))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s + std::char_traits<char>::length(s)); + assert(m.length(0) == 0); + assert(m.position(0) == 0); + assert(m.str(0) == ""); + } + { + std::cmatch m; + const char s[] = "tournament"; + assert(std::regex_search(s, m, std::regex("(tour|to|tournament)+\ntourna", + std::regex_constants::egrep))); + assert(m.size() == 2); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s + std::char_traits<char>::length(s)); + assert(m.length(0) == 10); + assert(m.position(0) == 0); + assert(m.str(0) == "tournament"); + } + { + std::cmatch m; + const char s[] = "tourna"; + assert(std::regex_search(s, m, std::regex("(tour|to|tournament)+\ntourna", + std::regex_constants::egrep))); + assert(m.size() == 2); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s + std::char_traits<char>::length(s)); + assert(m.length(0) == 6); + assert(m.position(0) == 0); + assert(m.str(0) == "tourna"); + } +} diff --git a/libcxx/test/std/re/re.alg/re.alg.search/extended.pass.cpp b/libcxx/test/std/re/re.alg/re.alg.search/extended.pass.cpp new file mode 100644 index 00000000000..a8a121bdd45 --- /dev/null +++ b/libcxx/test/std/re/re.alg/re.alg.search/extended.pass.cpp @@ -0,0 +1,1542 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// REQUIRES: locale.cs_CZ.ISO8859-2 + +// <regex> + +// template <class BidirectionalIterator, class Allocator, class charT, class traits> +// bool +// regex_search(BidirectionalIterator first, BidirectionalIterator last, +// match_results<BidirectionalIterator, Allocator>& m, +// const basic_regex<charT, traits>& e, +// regex_constants::match_flag_type flags = regex_constants::match_default); + +// TODO: investigation needed +// XFAIL: linux-gnu + +#include <regex> +#include <cassert> + +#include "test_iterators.h" + +int main() +{ + { + std::cmatch m; + const char s[] = "a"; + assert(std::regex_search(s, m, std::regex("a", std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.empty()); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+1); + assert(m.length(0) == 1); + assert(m.position(0) == 0); + assert(m.str(0) == "a"); + } + { + std::cmatch m; + const char s[] = "ab"; + assert(std::regex_search(s, m, std::regex("ab", std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+2); + assert(m.length(0) == 2); + assert(m.position(0) == 0); + assert(m.str(0) == "ab"); + } + { + std::cmatch m; + const char s[] = "ab"; + assert(!std::regex_search(s, m, std::regex("ba", std::regex_constants::extended))); + assert(m.size() == 0); + assert(m.empty()); + } + { + std::cmatch m; + const char s[] = "aab"; + assert(std::regex_search(s, m, std::regex("ab", std::regex_constants::extended))); + assert(m.size() == 1); + assert(m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+3); + assert(m.length(0) == 2); + assert(m.position(0) == 1); + assert(m.str(0) == "ab"); + } + { + std::cmatch m; + const char s[] = "aab"; + assert(!std::regex_search(s, m, std::regex("ab", std::regex_constants::extended), + std::regex_constants::match_continuous)); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "abcd"; + assert(std::regex_search(s, m, std::regex("bc", std::regex_constants::extended))); + assert(m.size() == 1); + assert(m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+4); + assert(m.length(0) == 2); + assert(m.position(0) == 1); + assert(m.str(0) == "bc"); + } + { + std::cmatch m; + const char s[] = "abbc"; + assert(std::regex_search(s, m, std::regex("ab*c", std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+4); + assert(m.length(0) == 4); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "ababc"; + assert(std::regex_search(s, m, std::regex("(ab)*c", std::regex_constants::extended))); + assert(m.size() == 2); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+5); + assert(m.length(0) == 5); + assert(m.position(0) == 0); + assert(m.str(0) == s); + assert(m.length(1) == 2); + assert(m.position(1) == 2); + assert(m.str(1) == "ab"); + } + { + std::cmatch m; + const char s[] = "abcdefghijk"; + assert(std::regex_search(s, m, std::regex("cd((e)fg)hi", + std::regex_constants::extended))); + assert(m.size() == 3); + assert(m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+std::regex_traits<char>::length(s)); + assert(m.length(0) == 7); + assert(m.position(0) == 2); + assert(m.str(0) == "cdefghi"); + assert(m.length(1) == 3); + assert(m.position(1) == 4); + assert(m.str(1) == "efg"); + assert(m.length(2) == 1); + assert(m.position(2) == 4); + assert(m.str(2) == "e"); + } + { + std::cmatch m; + const char s[] = "abc"; + assert(std::regex_search(s, m, std::regex("^abc", std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+3); + assert(m.length(0) == 3); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "abcd"; + assert(std::regex_search(s, m, std::regex("^abc", std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+4); + assert(m.length(0) == 3); + assert(m.position(0) == 0); + assert(m.str(0) == "abc"); + } + { + std::cmatch m; + const char s[] = "aabc"; + assert(!std::regex_search(s, m, std::regex("^abc", std::regex_constants::extended))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "abc"; + assert(std::regex_search(s, m, std::regex("abc$", std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+3); + assert(m.length(0) == 3); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "efabc"; + assert(std::regex_search(s, m, std::regex("abc$", std::regex_constants::extended))); + assert(m.size() == 1); + assert(m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+5); + assert(m.length(0) == 3); + assert(m.position(0) == 2); + assert(m.str(0) == s+2); + } + { + std::cmatch m; + const char s[] = "efabcg"; + assert(!std::regex_search(s, m, std::regex("abc$", std::regex_constants::extended))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "abc"; + assert(std::regex_search(s, m, std::regex("a.c", std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+3); + assert(m.length(0) == 3); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "acc"; + assert(std::regex_search(s, m, std::regex("a.c", std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+3); + assert(m.length(0) == 3); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "acc"; + assert(std::regex_search(s, m, std::regex("a.c", std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+3); + assert(m.length(0) == 3); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "abcdef"; + assert(std::regex_search(s, m, std::regex("(.*).*", std::regex_constants::extended))); + assert(m.size() == 2); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+6); + assert(m.length(0) == 6); + assert(m.position(0) == 0); + assert(m.str(0) == s); + assert(m.length(1) == 6); + assert(m.position(1) == 0); + assert(m.str(1) == s); + } + { + std::cmatch m; + const char s[] = "bc"; + assert(std::regex_search(s, m, std::regex("(a*)*", std::regex_constants::extended))); + assert(m.size() == 2); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+2); + assert(m.length(0) == 0); + assert(m.position(0) == 0); + assert(m.str(0) == ""); + assert(m.length(1) == 0); + assert(m.position(1) == 0); + assert(m.str(1) == ""); + } + { + std::cmatch m; + const char s[] = "abbc"; + assert(!std::regex_search(s, m, std::regex("ab{3,5}c", std::regex_constants::extended))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "abbbc"; + assert(std::regex_search(s, m, std::regex("ab{3,5}c", std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "abbbbc"; + assert(std::regex_search(s, m, std::regex("ab{3,5}c", std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "abbbbbc"; + assert(std::regex_search(s, m, std::regex("ab{3,5}c", std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "adefc"; + assert(!std::regex_search(s, m, std::regex("ab{3,5}c", std::regex_constants::extended))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "abbbbbbc"; + assert(!std::regex_search(s, m, std::regex("ab{3,5}c", std::regex_constants::extended))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "adec"; + assert(!std::regex_search(s, m, std::regex("a.{3,5}c", std::regex_constants::extended))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "adefc"; + assert(std::regex_search(s, m, std::regex("a.{3,5}c", std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "adefgc"; + assert(std::regex_search(s, m, std::regex("a.{3,5}c", std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "adefghc"; + assert(std::regex_search(s, m, std::regex("a.{3,5}c", std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "adefghic"; + assert(!std::regex_search(s, m, std::regex("a.{3,5}c", std::regex_constants::extended))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "tournament"; + assert(std::regex_search(s, m, std::regex("tour|to|tournament", + std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "tournamenttotour"; + assert(std::regex_search(s, m, std::regex("(tour|to|tournament)+", + std::regex_constants::extended | std::regex_constants::nosubs))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "ttotour"; + assert(std::regex_search(s, m, std::regex("(tour|to|t)+", + std::regex_constants::extended))); + assert(m.size() == 2); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + assert(m.length(1) == 4); + assert(m.position(1) == 3); + assert(m.str(1) == "tour"); + } + { + std::cmatch m; + const char s[] = "-ab,ab-"; + assert(!std::regex_search(s, m, std::regex("-(.*),\1-", std::regex_constants::extended))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "-ab,ab-"; + assert(std::regex_search(s, m, std::regex("-.*,.*-", std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "a"; + assert(std::regex_search(s, m, std::regex("^[a]$", + std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == 1); + assert(m.position(0) == 0); + assert(m.str(0) == "a"); + } + { + std::cmatch m; + const char s[] = "a"; + assert(std::regex_search(s, m, std::regex("^[ab]$", + std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == 1); + assert(m.position(0) == 0); + assert(m.str(0) == "a"); + } + { + std::cmatch m; + const char s[] = "c"; + assert(std::regex_search(s, m, std::regex("^[a-f]$", + std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == 1); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "g"; + assert(!std::regex_search(s, m, std::regex("^[a-f]$", + std::regex_constants::extended))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "Iraqi"; + assert(std::regex_search(s, m, std::regex("q[^u]", + std::regex_constants::extended))); + assert(m.size() == 1); + assert(m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == 2); + assert(m.position(0) == 3); + assert(m.str(0) == "qi"); + } + { + std::cmatch m; + const char s[] = "Iraq"; + assert(!std::regex_search(s, m, std::regex("q[^u]", + std::regex_constants::extended))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "AmB"; + assert(std::regex_search(s, m, std::regex("A[[:lower:]]B", + std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "AMB"; + assert(!std::regex_search(s, m, std::regex("A[[:lower:]]B", + std::regex_constants::extended))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "AMB"; + assert(std::regex_search(s, m, std::regex("A[^[:lower:]]B", + std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "AmB"; + assert(!std::regex_search(s, m, std::regex("A[^[:lower:]]B", + std::regex_constants::extended))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "A5B"; + assert(!std::regex_search(s, m, std::regex("A[^[:lower:]0-9]B", + std::regex_constants::extended))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "A?B"; + assert(std::regex_search(s, m, std::regex("A[^[:lower:]0-9]B", + std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "-"; + assert(std::regex_search(s, m, std::regex("[a[.hyphen.]z]", + std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "z"; + assert(std::regex_search(s, m, std::regex("[a[.hyphen.]z]", + std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "m"; + assert(!std::regex_search(s, m, std::regex("[a[.hyphen.]z]", + std::regex_constants::extended))); + assert(m.size() == 0); + } + std::locale::global(std::locale("cs_CZ.ISO8859-2")); + { + std::cmatch m; + const char s[] = "m"; + assert(std::regex_search(s, m, std::regex("[a[=M=]z]", + std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::cmatch m; + const char s[] = "Ch"; + assert(std::regex_search(s, m, std::regex("[a[.ch.]z]", + std::regex_constants::extended | std::regex_constants::icase))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<char>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + std::locale::global(std::locale("C")); + { + std::cmatch m; + const char s[] = "m"; + assert(!std::regex_search(s, m, std::regex("[a[=M=]z]", + std::regex_constants::extended))); + assert(m.size() == 0); + } + { + std::cmatch m; + const char s[] = "01a45cef9"; + assert(std::regex_search(s, m, std::regex("[ace1-9]*", + std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s + std::char_traits<char>::length(s)); + assert(m.length(0) == 0); + assert(m.position(0) == 0); + assert(m.str(0) == ""); + } + { + std::cmatch m; + const char s[] = "01a45cef9"; + assert(std::regex_search(s, m, std::regex("[ace1-9]+", + std::regex_constants::extended))); + assert(m.size() == 1); + assert(m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s + std::char_traits<char>::length(s)); + assert(m.length(0) == 6); + assert(m.position(0) == 1); + assert(m.str(0) == "1a45ce"); + } + { + const char r[] = "^[-+]?[0-9]+[CF]$"; + std::ptrdiff_t sr = std::char_traits<char>::length(r); + typedef forward_iterator<const char*> FI; + typedef bidirectional_iterator<const char*> BI; + std::regex regex(FI(r), FI(r+sr), std::regex_constants::extended); + std::match_results<BI> m; + const char s[] = "-40C"; + std::ptrdiff_t ss = std::char_traits<char>::length(s); + assert(std::regex_search(BI(s), BI(s+ss), m, regex)); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == BI(s)); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == 4); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + + { + std::wcmatch m; + const wchar_t s[] = L"a"; + assert(std::regex_search(s, m, std::wregex(L"a", std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.empty()); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+1); + assert(m.length(0) == 1); + assert(m.position(0) == 0); + assert(m.str(0) == L"a"); + } + { + std::wcmatch m; + const wchar_t s[] = L"ab"; + assert(std::regex_search(s, m, std::wregex(L"ab", std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+2); + assert(m.length(0) == 2); + assert(m.position(0) == 0); + assert(m.str(0) == L"ab"); + } + { + std::wcmatch m; + const wchar_t s[] = L"ab"; + assert(!std::regex_search(s, m, std::wregex(L"ba", std::regex_constants::extended))); + assert(m.size() == 0); + assert(m.empty()); + } + { + std::wcmatch m; + const wchar_t s[] = L"aab"; + assert(std::regex_search(s, m, std::wregex(L"ab", std::regex_constants::extended))); + assert(m.size() == 1); + assert(m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+3); + assert(m.length(0) == 2); + assert(m.position(0) == 1); + assert(m.str(0) == L"ab"); + } + { + std::wcmatch m; + const wchar_t s[] = L"aab"; + assert(!std::regex_search(s, m, std::wregex(L"ab", std::regex_constants::extended), + std::regex_constants::match_continuous)); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"abcd"; + assert(std::regex_search(s, m, std::wregex(L"bc", std::regex_constants::extended))); + assert(m.size() == 1); + assert(m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+4); + assert(m.length(0) == 2); + assert(m.position(0) == 1); + assert(m.str(0) == L"bc"); + } + { + std::wcmatch m; + const wchar_t s[] = L"abbc"; + assert(std::regex_search(s, m, std::wregex(L"ab*c", std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+4); + assert(m.length(0) == 4); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"ababc"; + assert(std::regex_search(s, m, std::wregex(L"(ab)*c", std::regex_constants::extended))); + assert(m.size() == 2); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+5); + assert(m.length(0) == 5); + assert(m.position(0) == 0); + assert(m.str(0) == s); + assert(m.length(1) == 2); + assert(m.position(1) == 2); + assert(m.str(1) == L"ab"); + } + { + std::wcmatch m; + const wchar_t s[] = L"abcdefghijk"; + assert(std::regex_search(s, m, std::wregex(L"cd((e)fg)hi", + std::regex_constants::extended))); + assert(m.size() == 3); + assert(m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+std::regex_traits<wchar_t>::length(s)); + assert(m.length(0) == 7); + assert(m.position(0) == 2); + assert(m.str(0) == L"cdefghi"); + assert(m.length(1) == 3); + assert(m.position(1) == 4); + assert(m.str(1) == L"efg"); + assert(m.length(2) == 1); + assert(m.position(2) == 4); + assert(m.str(2) == L"e"); + } + { + std::wcmatch m; + const wchar_t s[] = L"abc"; + assert(std::regex_search(s, m, std::wregex(L"^abc", std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+3); + assert(m.length(0) == 3); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"abcd"; + assert(std::regex_search(s, m, std::wregex(L"^abc", std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+4); + assert(m.length(0) == 3); + assert(m.position(0) == 0); + assert(m.str(0) == L"abc"); + } + { + std::wcmatch m; + const wchar_t s[] = L"aabc"; + assert(!std::regex_search(s, m, std::wregex(L"^abc", std::regex_constants::extended))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"abc"; + assert(std::regex_search(s, m, std::wregex(L"abc$", std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+3); + assert(m.length(0) == 3); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"efabc"; + assert(std::regex_search(s, m, std::wregex(L"abc$", std::regex_constants::extended))); + assert(m.size() == 1); + assert(m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+5); + assert(m.length(0) == 3); + assert(m.position(0) == 2); + assert(m.str(0) == s+2); + } + { + std::wcmatch m; + const wchar_t s[] = L"efabcg"; + assert(!std::regex_search(s, m, std::wregex(L"abc$", std::regex_constants::extended))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"abc"; + assert(std::regex_search(s, m, std::wregex(L"a.c", std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+3); + assert(m.length(0) == 3); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"acc"; + assert(std::regex_search(s, m, std::wregex(L"a.c", std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+3); + assert(m.length(0) == 3); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"acc"; + assert(std::regex_search(s, m, std::wregex(L"a.c", std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+3); + assert(m.length(0) == 3); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"abcdef"; + assert(std::regex_search(s, m, std::wregex(L"(.*).*", std::regex_constants::extended))); + assert(m.size() == 2); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+6); + assert(m.length(0) == 6); + assert(m.position(0) == 0); + assert(m.str(0) == s); + assert(m.length(1) == 6); + assert(m.position(1) == 0); + assert(m.str(1) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"bc"; + assert(std::regex_search(s, m, std::wregex(L"(a*)*", std::regex_constants::extended))); + assert(m.size() == 2); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s+2); + assert(m.length(0) == 0); + assert(m.position(0) == 0); + assert(m.str(0) == L""); + assert(m.length(1) == 0); + assert(m.position(1) == 0); + assert(m.str(1) == L""); + } + { + std::wcmatch m; + const wchar_t s[] = L"abbc"; + assert(!std::regex_search(s, m, std::wregex(L"ab{3,5}c", std::regex_constants::extended))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"abbbc"; + assert(std::regex_search(s, m, std::wregex(L"ab{3,5}c", std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"abbbbc"; + assert(std::regex_search(s, m, std::wregex(L"ab{3,5}c", std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"abbbbbc"; + assert(std::regex_search(s, m, std::wregex(L"ab{3,5}c", std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"adefc"; + assert(!std::regex_search(s, m, std::wregex(L"ab{3,5}c", std::regex_constants::extended))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"abbbbbbc"; + assert(!std::regex_search(s, m, std::wregex(L"ab{3,5}c", std::regex_constants::extended))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"adec"; + assert(!std::regex_search(s, m, std::wregex(L"a.{3,5}c", std::regex_constants::extended))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"adefc"; + assert(std::regex_search(s, m, std::wregex(L"a.{3,5}c", std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"adefgc"; + assert(std::regex_search(s, m, std::wregex(L"a.{3,5}c", std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"adefghc"; + assert(std::regex_search(s, m, std::wregex(L"a.{3,5}c", std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"adefghic"; + assert(!std::regex_search(s, m, std::wregex(L"a.{3,5}c", std::regex_constants::extended))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"tournament"; + assert(std::regex_search(s, m, std::wregex(L"tour|to|tournament", + std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"tournamenttotour"; + assert(std::regex_search(s, m, std::wregex(L"(tour|to|tournament)+", + std::regex_constants::extended | std::regex_constants::nosubs))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"ttotour"; + assert(std::regex_search(s, m, std::wregex(L"(tour|to|t)+", + std::regex_constants::extended))); + assert(m.size() == 2); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + assert(m.length(1) == 4); + assert(m.position(1) == 3); + assert(m.str(1) == L"tour"); + } + { + std::wcmatch m; + const wchar_t s[] = L"-ab,ab-"; + assert(!std::regex_search(s, m, std::wregex(L"-(.*),\1-", std::regex_constants::extended))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"-ab,ab-"; + assert(std::regex_search(s, m, std::wregex(L"-.*,.*-", std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"a"; + assert(std::regex_search(s, m, std::wregex(L"^[a]$", + std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == 1); + assert(m.position(0) == 0); + assert(m.str(0) == L"a"); + } + { + std::wcmatch m; + const wchar_t s[] = L"a"; + assert(std::regex_search(s, m, std::wregex(L"^[ab]$", + std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == 1); + assert(m.position(0) == 0); + assert(m.str(0) == L"a"); + } + { + std::wcmatch m; + const wchar_t s[] = L"c"; + assert(std::regex_search(s, m, std::wregex(L"^[a-f]$", + std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == 1); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"g"; + assert(!std::regex_search(s, m, std::wregex(L"^[a-f]$", + std::regex_constants::extended))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"Iraqi"; + assert(std::regex_search(s, m, std::wregex(L"q[^u]", + std::regex_constants::extended))); + assert(m.size() == 1); + assert(m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == 2); + assert(m.position(0) == 3); + assert(m.str(0) == L"qi"); + } + { + std::wcmatch m; + const wchar_t s[] = L"Iraq"; + assert(!std::regex_search(s, m, std::wregex(L"q[^u]", + std::regex_constants::extended))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"AmB"; + assert(std::regex_search(s, m, std::wregex(L"A[[:lower:]]B", + std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"AMB"; + assert(!std::regex_search(s, m, std::wregex(L"A[[:lower:]]B", + std::regex_constants::extended))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"AMB"; + assert(std::regex_search(s, m, std::wregex(L"A[^[:lower:]]B", + std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"AmB"; + assert(!std::regex_search(s, m, std::wregex(L"A[^[:lower:]]B", + std::regex_constants::extended))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"A5B"; + assert(!std::regex_search(s, m, std::wregex(L"A[^[:lower:]0-9]B", + std::regex_constants::extended))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"A?B"; + assert(std::regex_search(s, m, std::wregex(L"A[^[:lower:]0-9]B", + std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"-"; + assert(std::regex_search(s, m, std::wregex(L"[a[.hyphen.]z]", + std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"z"; + assert(std::regex_search(s, m, std::wregex(L"[a[.hyphen.]z]", + std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"m"; + assert(!std::regex_search(s, m, std::wregex(L"[a[.hyphen.]z]", + std::regex_constants::extended))); + assert(m.size() == 0); + } + std::locale::global(std::locale("cs_CZ.ISO8859-2")); + { + std::wcmatch m; + const wchar_t s[] = L"m"; + assert(std::regex_search(s, m, std::wregex(L"[a[=M=]z]", + std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + { + std::wcmatch m; + const wchar_t s[] = L"Ch"; + assert(std::regex_search(s, m, std::wregex(L"[a[.ch.]z]", + std::regex_constants::extended | std::regex_constants::icase))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == std::char_traits<wchar_t>::length(s)); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } + std::locale::global(std::locale("C")); + { + std::wcmatch m; + const wchar_t s[] = L"m"; + assert(!std::regex_search(s, m, std::wregex(L"[a[=M=]z]", + std::regex_constants::extended))); + assert(m.size() == 0); + } + { + std::wcmatch m; + const wchar_t s[] = L"01a45cef9"; + assert(std::regex_search(s, m, std::wregex(L"[ace1-9]*", + std::regex_constants::extended))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s + std::char_traits<wchar_t>::length(s)); + assert(m.length(0) == 0); + assert(m.position(0) == 0); + assert(m.str(0) == L""); + } + { + std::wcmatch m; + const wchar_t s[] = L"01a45cef9"; + assert(std::regex_search(s, m, std::wregex(L"[ace1-9]+", + std::regex_constants::extended))); + assert(m.size() == 1); + assert(m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s + std::char_traits<wchar_t>::length(s)); + assert(m.length(0) == 6); + assert(m.position(0) == 1); + assert(m.str(0) == L"1a45ce"); + } + { + const wchar_t r[] = L"^[-+]?[0-9]+[CF]$"; + std::ptrdiff_t sr = std::char_traits<wchar_t>::length(r); + typedef forward_iterator<const wchar_t*> FI; + typedef bidirectional_iterator<const wchar_t*> BI; + std::wregex regex(FI(r), FI(r+sr), std::regex_constants::extended); + std::match_results<BI> m; + const wchar_t s[] = L"-40C"; + std::ptrdiff_t ss = std::char_traits<wchar_t>::length(s); + assert(std::regex_search(BI(s), BI(s+ss), m, regex)); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == BI(s)); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == m[0].second); + assert(m.length(0) == 4); + assert(m.position(0) == 0); + assert(m.str(0) == s); + } +} diff --git a/libcxx/test/std/re/re.alg/re.alg.search/grep.pass.cpp b/libcxx/test/std/re/re.alg/re.alg.search/grep.pass.cpp new file mode 100644 index 00000000000..113243ecd34 --- /dev/null +++ b/libcxx/test/std/re/re.alg/re.alg.search/grep.pass.cpp @@ -0,0 +1,58 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <regex> + +// template <class BidirectionalIterator, class Allocator, class charT, class traits> +// bool +// regex_search(BidirectionalIterator first, BidirectionalIterator last, +// match_results<BidirectionalIterator, Allocator>& m, +// const basic_regex<charT, traits>& e, +// regex_constants::match_flag_type flags = regex_constants::match_default); + +#include <regex> +#include <cassert> + +#include "test_iterators.h" + +int main() +{ + { + std::cmatch m; + const char s[] = "tournament"; + assert(std::regex_search(s, m, std::regex("tour\nto\ntournament", + std::regex_constants::grep))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(!m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s + std::char_traits<char>::length(s)); + assert(m.length(0) == 10); + assert(m.position(0) == 0); + assert(m.str(0) == "tournament"); + } + { + std::cmatch m; + const char s[] = "ment"; + assert(std::regex_search(s, m, std::regex("tour\n\ntournament", + std::regex_constants::grep))); + assert(m.size() == 1); + assert(!m.prefix().matched); + assert(m.prefix().first == s); + assert(m.prefix().second == m[0].first); + assert(m.suffix().matched); + assert(m.suffix().first == m[0].second); + assert(m.suffix().second == s + std::char_traits<char>::length(s)); + assert(m.length(0) == 0); + assert(m.position(0) == 0); + assert(m.str(0) == ""); + } +} diff --git a/libcxx/test/std/re/re.alg/re.alg.search/lookahead.pass.cpp b/libcxx/test/std/re/re.alg/re.alg.search/lookahead.pass.cpp new file mode 100644 index 00000000000..9f5f9540165 --- /dev/null +++ b/libcxx/test/std/re/re.alg/re.alg.search/lookahead.pass.cpp @@ -0,0 +1,28 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <regex> + +// template <class BidirectionalIterator, class Allocator, class charT, class traits> +// bool +// regex_search(BidirectionalIterator first, BidirectionalIterator last, +// match_results<BidirectionalIterator, Allocator>& m, +// const basic_regex<charT, traits>& e, +// regex_constants::match_flag_type flags = regex_constants::match_default); + +// http://llvm.org/bugs/show_bug.cgi?id=11118 + +#include <regex> +#include <cassert> + +int main() +{ + assert(!std::regex_search("ab", std::regex("(?=^)b"))); + assert(!std::regex_search("ab", std::regex("a(?=^)b"))); +} diff --git a/libcxx/test/std/re/re.alg/re.alg.search/no_update_pos.pass.cpp b/libcxx/test/std/re/re.alg/re.alg.search/no_update_pos.pass.cpp new file mode 100644 index 00000000000..ef9cec5f736 --- /dev/null +++ b/libcxx/test/std/re/re.alg/re.alg.search/no_update_pos.pass.cpp @@ -0,0 +1,38 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <regex> + +// template <class BidirectionalIterator, class Allocator, class charT, class traits> +// bool +// regex_search(BidirectionalIterator first, BidirectionalIterator last, +// match_results<BidirectionalIterator, Allocator>& m, +// const basic_regex<charT, traits>& e, +// regex_constants::match_flag_type flags = regex_constants::match_default); + +#include <regex> +#include <cassert> + +int main() +{ + // Iterating over /^a/ should yield one instance at the beginning + // of the text. + + const char *text = "aaa\naa"; + std::regex re("^a"); + std::cregex_iterator it(text, text+6, re); + std::cregex_iterator end = std::cregex_iterator(); + + assert(it->str() == "a"); + assert(it->position(0) == 0); + assert(it->length(0) == 1); + + ++it; + assert(it == end); +} diff --git a/libcxx/test/std/re/re.alg/re.except/nothing_to_do.pass.cpp b/libcxx/test/std/re/re.alg/re.except/nothing_to_do.pass.cpp new file mode 100644 index 00000000000..b58f5c55b64 --- /dev/null +++ b/libcxx/test/std/re/re.alg/re.except/nothing_to_do.pass.cpp @@ -0,0 +1,12 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +int main() +{ +} |
