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
index 024738258c050..ef906ff21d3f1 100644
--- 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
@@ -21,1336 +21,1289 @@
 #include "test_macros.h"
 #include "test_iterators.h"
 
-int main(int, char**)
-{
-    {
-        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((std::size_t)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((std::size_t)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((std::size_t)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((std::size_t)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((std::size_t)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((std::size_t)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((std::size_t)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((std::size_t)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((std::size_t)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((std::size_t)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((std::size_t)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((std::size_t)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((std::size_t)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[=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((std::size_t)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[=M=]z]", std::regex_constants::awk)));
-        assert(m.size() == 0);
-    }
-    {
-        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((std::size_t)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((std::size_t)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::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((std::size_t)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((std::size_t)m.length(0) == std::char_traits<char>::length(s));
-        assert(m.position(0) == 0);
-        assert(m.str(0) == s);
-    }
+int main(int, char**) {
+  {
+    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((std::size_t)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((std::size_t)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((std::size_t)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((std::size_t)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((std::size_t)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((std::size_t)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((std::size_t)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((std::size_t)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((std::size_t)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((std::size_t)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((std::size_t)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((std::size_t)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((std::size_t)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[=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((std::size_t)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[=M=]z]", std::regex_constants::awk)));
+    assert(m.size() == 0);
+  }
+  {
+    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((std::size_t)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((std::size_t)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::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((std::size_t)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((std::size_t)m.length(0) == std::char_traits<char>::length(s));
+    assert(m.position(0) == 0);
+    assert(m.str(0) == s);
+  }
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-    {
-        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((std::size_t)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((std::size_t)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((std::size_t)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((std::size_t)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((std::size_t)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((std::size_t)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((std::size_t)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((std::size_t)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((std::size_t)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((std::size_t)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((std::size_t)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((std::size_t)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((std::size_t)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((std::size_t)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((std::size_t)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[=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((std::size_t)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[=M=]z]",
-                                                 std::regex_constants::awk)));
-        assert(m.size() == 0);
-    }
-    {
-        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((std::size_t)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((std::size_t)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::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((std::size_t)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.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((std::size_t)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((std::size_t)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((std::size_t)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((std::size_t)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((std::size_t)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((std::size_t)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((std::size_t)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((std::size_t)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((std::size_t)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((std::size_t)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((std::size_t)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((std::size_t)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((std::size_t)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((std::size_t)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((std::size_t)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[=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((std::size_t)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[=M=]z]", std::regex_constants::awk)));
+    assert(m.size() == 0);
+  }
+  {
+    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((std::size_t)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((std::size_t)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::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((std::size_t)m.length(0) == std::char_traits<wchar_t>::length(s));
+    assert(m.position(0) == 0);
+    assert(m.str(0) == s);
+  }
 #endif // TEST_HAS_NO_WIDE_CHARACTERS
-    return 0;
+  return 0;
 }
diff --git a/libcxx/test/std/re/re.alg/re.alg.match/basic.compile.fail.cpp b/libcxx/test/std/re/re.alg/re.alg.match/basic.compile.fail.cpp
index d71fc280a29f2..61e03533770fb 100644
--- a/libcxx/test/std/re/re.alg/re.alg.match/basic.compile.fail.cpp
+++ b/libcxx/test/std/re/re.alg/re.alg.match/basic.compile.fail.cpp
@@ -22,16 +22,15 @@
 #include "test_macros.h"
 
 #if TEST_STD_VER < 14
-#error
+#  error
 #endif
 
-int main(int, char**)
-{
-    {
-        std::smatch m;
-        std::regex re{"*"};
-        std::regex_match(std::string("abcde"), m, re);
-    }
+int main(int, char**) {
+  {
+    std::smatch m;
+    std::regex re{"*"};
+    std::regex_match(std::string("abcde"), m, re);
+  }
 
   return 0;
 }
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
index fd91866b9209b..347cc5dd2ae92 100644
--- 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
@@ -21,1334 +21,1291 @@
 #include "test_macros.h"
 #include "test_iterators.h"
 
-int main(int, char**)
-{
-    {
-        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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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[=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) >= 0 && static_cast<std::size_t>(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[=M=]z]",
-                                                 std::regex_constants::basic)));
-        assert(m.size() == 0);
-    }
-    {
-        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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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::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);
-    }
+int main(int, char**) {
+  {
+    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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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[=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) >= 0 && static_cast<std::size_t>(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[=M=]z]", std::regex_constants::basic)));
+    assert(m.size() == 0);
+  }
+  {
+    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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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::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);
+  }
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  {
+    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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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[=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) >= 0 && static_cast<std::size_t>(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[=M=]z]", std::regex_constants::basic)));
+    assert(m.size() == 0);
+  }
+  {
+    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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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::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);
+  }
+#endif // TEST_HAS_NO_WIDE_CHARACTERS
+
+  { // LWG 2273
+    std::regex re("Foo|FooBar");
+    std::cmatch m;
     {
-        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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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[=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) >= 0 && static_cast<std::size_t>(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[=M=]z]",
-                                                 std::regex_constants::basic)));
-        assert(m.size() == 0);
-    }
-    {
-        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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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);
+      assert(std::regex_match("FooBar", m, re));
+      assert(m.size() == 1);
+      assert(m[0] == "FooBar");
     }
     {
-        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);
+      assert(std::regex_match("Foo", m, re));
+      assert(m.size() == 1);
+      assert(m[0] == "Foo");
     }
     {
-        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);
+      assert(!std::regex_match("FooBarBaz", m, re));
+      assert(m.size() == 0);
+      assert(m.empty());
     }
     {
-        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);
-    }
-#endif // TEST_HAS_NO_WIDE_CHARACTERS
-
-    { // LWG 2273
-        std::regex re("Foo|FooBar");
-        std::cmatch m;
-        {
-            assert(std::regex_match("FooBar", m, re));
-            assert(m.size() == 1);
-            assert(m[0] == "FooBar");
-        }
-        {
-            assert(std::regex_match("Foo", m, re));
-            assert(m.size() == 1);
-            assert(m[0] == "Foo");
-        }
-        {
-            assert(!std::regex_match("FooBarBaz", m, re));
-            assert(m.size() == 0);
-            assert(m.empty());
-        }
-        {
-            assert(!std::regex_match("FooBa", m, re));
-            assert(m.size() == 0);
-            assert(m.empty());
-        }
+      assert(!std::regex_match("FooBa", m, re));
+      assert(m.size() == 0);
+      assert(m.empty());
     }
+  }
 
   return 0;
 }
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
index 0184a3835fb0d..ddf97ba4df8d7 100644
--- 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
@@ -21,1362 +21,1355 @@
 #include "test_macros.h"
 #include "test_iterators.h"
 
-int main(int, char**)
-{
-    {
-        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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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;
-        // http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#2273
-        const char s[] = "tournament";
-        assert(std::regex_match(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 == m[0].second);
-        assert(m.length(0) >= 0 && static_cast<std::size_t>(m.length(0)) == std::char_traits<char>::length(s));
-        assert(m.position(0) == 0);
-        assert(m.str(0) == s);
-    }
-    {
-        std::cmatch m;
-        // http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#2273
-        const char s[] = "tournamenttotour";
-        assert(
-            std::regex_match(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 == m[0].second);
-        assert(m.length(0) >= 0 && static_cast<std::size_t>(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)+")));
-        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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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[=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) >= 0 && static_cast<std::size_t>(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[=M=]z]")));
-        assert(m.size() == 0);
-    }
-    {
-        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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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::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::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) >= 0 && static_cast<std::size_t>(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[] = "$_se";
-      assert(std::regex_match(s, m, std::regex("\\$\\_se")));
-      assert(m.size() == 1);
-      assert(!m.prefix().matched);
-      assert(m.prefix().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 && static_cast<size_t>(m.length(0)) == std::char_traits<char>::length(s));
-      assert(m.position(0) == 0);
-      assert(m.str(0) == s);
-    }
+int main(int, char**) {
+  {
+    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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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;
+    // http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#2273
+    const char s[] = "tournament";
+    assert(std::regex_match(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 == m[0].second);
+    assert(m.length(0) >= 0 && static_cast<std::size_t>(m.length(0)) == std::char_traits<char>::length(s));
+    assert(m.position(0) == 0);
+    assert(m.str(0) == s);
+  }
+  {
+    std::cmatch m;
+    // http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#2273
+    const char s[] = "tournamenttotour";
+    assert(std::regex_match(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 == m[0].second);
+    assert(m.length(0) >= 0 && static_cast<std::size_t>(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)+")));
+    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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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[=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) >= 0 && static_cast<std::size_t>(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[=M=]z]")));
+    assert(m.size() == 0);
+  }
+  {
+    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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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::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::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) >= 0 && static_cast<std::size_t>(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[] = "$_se";
+    assert(std::regex_match(s, m, std::regex("\\$\\_se")));
+    assert(m.size() == 1);
+    assert(!m.prefix().matched);
+    assert(m.prefix().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 && static_cast<size_t>(m.length(0)) == std::char_traits<char>::length(s));
+    assert(m.position(0) == 0);
+    assert(m.str(0) == s);
+  }
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-    {
-        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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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;
-        // http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#2273
-        const wchar_t s[] = L"tournament";
-        assert(std::regex_match(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 == m[0].second);
-        assert(m.length(0) >= 0 && static_cast<std::size_t>(m.length(0)) == std::char_traits<wchar_t>::length(s));
-        assert(m.position(0) == 0);
-        assert(m.str(0) == s);
-    }
-    {
-        std::wcmatch m;
-        // http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#2273
-        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() == 1);
-        assert(!m.prefix().matched);
-        assert(m.prefix().first == s);
-        assert(m.prefix().second == m[0].first);
-        assert(!m.suffix().matched);
-        assert(m.suffix().first == m[0].second);
-        assert(m.suffix().second == m[0].second);
-        assert(m.length(0) >= 0 && static_cast<std::size_t>(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)+")));
-        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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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[=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) >= 0 && static_cast<std::size_t>(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[=M=]z]")));
-        assert(m.size() == 0);
-    }
-    {
-        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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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::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) >= 0 && static_cast<std::size_t>(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"$_se";
-      assert(std::regex_match(s, m, std::wregex(L"\\$\\_se")));
-      assert(m.size() == 1);
-      assert(!m.prefix().matched);
-      assert(m.prefix().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 && static_cast<std::size_t>(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.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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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;
+    // http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#2273
+    const wchar_t s[] = L"tournament";
+    assert(std::regex_match(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 == m[0].second);
+    assert(m.length(0) >= 0 && static_cast<std::size_t>(m.length(0)) == std::char_traits<wchar_t>::length(s));
+    assert(m.position(0) == 0);
+    assert(m.str(0) == s);
+  }
+  {
+    std::wcmatch m;
+    // http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#2273
+    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() == 1);
+    assert(!m.prefix().matched);
+    assert(m.prefix().first == s);
+    assert(m.prefix().second == m[0].first);
+    assert(!m.suffix().matched);
+    assert(m.suffix().first == m[0].second);
+    assert(m.suffix().second == m[0].second);
+    assert(m.length(0) >= 0 && static_cast<std::size_t>(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)+")));
+    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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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[=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) >= 0 && static_cast<std::size_t>(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[=M=]z]")));
+    assert(m.size() == 0);
+  }
+  {
+    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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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::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) >= 0 && static_cast<std::size_t>(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"$_se";
+    assert(std::regex_match(s, m, std::wregex(L"\\$\\_se")));
+    assert(m.size() == 1);
+    assert(!m.prefix().matched);
+    assert(m.prefix().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 && static_cast<std::size_t>(m.length(0)) == std::char_traits<wchar_t>::length(s));
+    assert(m.position(0) == 0);
+    assert(m.str(0) == s);
+  }
 #endif // TEST_HAS_NO_WIDE_CHARACTERS
 
   return 0;
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
index 4e1b6940c09e1..6079281e56e5b 100644
--- 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
@@ -21,63 +21,58 @@
 #include "test_macros.h"
 #include "test_iterators.h"
 
-int main(int, char**)
-{
-    {
-        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");
-    }
+int main(int, char**) {
+  {
+    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");
+  }
 
   return 0;
 }
diff --git a/libcxx/test/std/re/re.alg/re.alg.match/exponential.pass.cpp b/libcxx/test/std/re/re.alg/re.alg.match/exponential.pass.cpp
index 2493f6a643a6d..ebadaaab73f60 100644
--- a/libcxx/test/std/re/re.alg/re.alg.match/exponential.pass.cpp
+++ b/libcxx/test/std/re/re.alg/re.alg.match/exponential.pass.cpp
@@ -25,24 +25,19 @@
 
 int main(int, char**) {
   for (std::regex_constants::syntax_option_type op :
-       {std::regex::ECMAScript, std::regex::extended, std::regex::egrep,
-        std::regex::awk}) {
+       {std::regex::ECMAScript, std::regex::extended, std::regex::egrep, std::regex::awk}) {
     try {
       bool b = std::regex_match(
-          "aaaaaaaaaaaaaaaaaaaa",
-          std::regex(
-              "a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?aaaaaaaaaaaaaaaaaaaa",
-              op));
+          "aaaaaaaaaaaaaaaaaaaa", std::regex("a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?aaaaaaaaaaaaaaaaaaaa", op));
       LIBCPP_ASSERT(false);
       assert(b);
-    } catch (const std::regex_error &e) {
+    } catch (const std::regex_error& e) {
       assert(e.code() == std::regex_constants::error_complexity);
     }
   }
   std::string s(100000, 'a');
   for (std::regex_constants::syntax_option_type op :
-       {std::regex::ECMAScript, std::regex::extended, std::regex::egrep,
-        std::regex::awk}) {
+       {std::regex::ECMAScript, std::regex::extended, std::regex::egrep, std::regex::awk}) {
     assert(std::regex_match(s, std::regex("a*", op)));
   }
   return 0;
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
index e800fa88d8300..9d40d475e3df6 100644
--- 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
@@ -20,1340 +20,1295 @@
 #include "test_macros.h"
 #include "test_iterators.h"
 
-int main(int, char**)
-{
-    {
-        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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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("-(.*),\\1-", 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) >= 0 && static_cast<std::size_t>(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[] = "-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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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[=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) >= 0 && static_cast<std::size_t>(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[=M=]z]",
-                                                 std::regex_constants::extended)));
-        assert(m.size() == 0);
-    }
-    {
-        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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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::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);
-    }
+int main(int, char**) {
+  {
+    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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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("-(.*),\\1-", 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) >= 0 && static_cast<std::size_t>(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[] = "-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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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[=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) >= 0 && static_cast<std::size_t>(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[=M=]z]", std::regex_constants::extended)));
+    assert(m.size() == 0);
+  }
+  {
+    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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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::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);
+  }
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-    {
-        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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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"-(.*),\\1-", 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) >= 0 && static_cast<std::size_t>(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"-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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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[=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) >= 0 && static_cast<std::size_t>(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[=M=]z]",
-                                                 std::regex_constants::extended)));
-        assert(m.size() == 0);
-    }
-    {
-        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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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::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);
-    }
+  {
+    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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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"-(.*),\\1-", 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) >= 0 && static_cast<std::size_t>(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"-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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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[=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) >= 0 && static_cast<std::size_t>(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[=M=]z]", std::regex_constants::extended)));
+    assert(m.size() == 0);
+  }
+  {
+    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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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::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);
+  }
 #endif // TEST_HAS_NO_WIDE_CHARACTERS
 
   return 0;
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
index 0f75d618c0c02..59871e9877015 100644
--- 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
@@ -21,31 +21,28 @@
 #include "test_macros.h"
 #include "test_iterators.h"
 
-int main(int, char**)
-{
-    {
-        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);
-    }
+int main(int, char**) {
+  {
+    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);
+  }
 
   return 0;
 }
diff --git a/libcxx/test/std/re/re.alg/re.alg.match/inverted_character_classes.pass.cpp b/libcxx/test/std/re/re.alg/re.alg.match/inverted_character_classes.pass.cpp
index 004127f1625db..eeff134bcf232 100644
--- a/libcxx/test/std/re/re.alg/re.alg.match/inverted_character_classes.pass.cpp
+++ b/libcxx/test/std/re/re.alg/re.alg.match/inverted_character_classes.pass.cpp
@@ -16,45 +16,44 @@
 
 #include "test_macros.h"
 
-
 int main(int, char**) {
-    assert(std::regex_match("X", std::regex("[X]")));
-    assert(std::regex_match("X", std::regex("[XY]")));
-    assert(!std::regex_match("X", std::regex("[^X]")));
-    assert(!std::regex_match("X", std::regex("[^XY]")));
-
-    assert(std::regex_match("X", std::regex("[\\S]")));
-    assert(!std::regex_match("X", std::regex("[^\\S]")));
-
-    assert(!std::regex_match("X", std::regex("[\\s]")));
-    assert(std::regex_match("X", std::regex("[^\\s]")));
-
-    assert(std::regex_match("X", std::regex("[\\s\\S]")));
-    assert(std::regex_match("X", std::regex("[^Y\\s]")));
-    assert(!std::regex_match("X", std::regex("[^X\\s]")));
-
-    assert(std::regex_match("X", std::regex("[\\w]")));
-    assert(std::regex_match("_", std::regex("[\\w]")));
-    assert(!std::regex_match("X", std::regex("[^\\w]")));
-    assert(!std::regex_match("_", std::regex("[^\\w]")));
-
-    assert(!std::regex_match("X", std::regex("[\\W]")));
-    assert(!std::regex_match("_", std::regex("[\\W]")));
-    assert(std::regex_match("X", std::regex("[^\\W]")));
-    assert(std::regex_match("_", std::regex("[^\\W]")));
-
-    // Those test cases are taken from PR40904
-    assert(std::regex_match("abZcd", std::regex("^ab[\\d\\D]cd")));
-    assert(std::regex_match("ab5cd", std::regex("^ab[\\d\\D]cd")));
-    assert(std::regex_match("abZcd", std::regex("^ab[\\D]cd")));
-    assert(std::regex_match("abZcd", std::regex("^ab\\Dcd")));
-    assert(std::regex_match("ab5cd", std::regex("^ab[\\d]cd")));
-    assert(std::regex_match("ab5cd", std::regex("^ab\\dcd")));
-    assert(!std::regex_match("abZcd", std::regex("^ab\\dcd")));
-    assert(!std::regex_match("ab5cd", std::regex("^ab\\Dcd")));
-
-    assert(std::regex_match("_xyz_", std::regex("_(\\s|\\S)+_")));
-    assert(std::regex_match("_xyz_", std::regex("_[\\s\\S]+_")));
-
-    return 0;
+  assert(std::regex_match("X", std::regex("[X]")));
+  assert(std::regex_match("X", std::regex("[XY]")));
+  assert(!std::regex_match("X", std::regex("[^X]")));
+  assert(!std::regex_match("X", std::regex("[^XY]")));
+
+  assert(std::regex_match("X", std::regex("[\\S]")));
+  assert(!std::regex_match("X", std::regex("[^\\S]")));
+
+  assert(!std::regex_match("X", std::regex("[\\s]")));
+  assert(std::regex_match("X", std::regex("[^\\s]")));
+
+  assert(std::regex_match("X", std::regex("[\\s\\S]")));
+  assert(std::regex_match("X", std::regex("[^Y\\s]")));
+  assert(!std::regex_match("X", std::regex("[^X\\s]")));
+
+  assert(std::regex_match("X", std::regex("[\\w]")));
+  assert(std::regex_match("_", std::regex("[\\w]")));
+  assert(!std::regex_match("X", std::regex("[^\\w]")));
+  assert(!std::regex_match("_", std::regex("[^\\w]")));
+
+  assert(!std::regex_match("X", std::regex("[\\W]")));
+  assert(!std::regex_match("_", std::regex("[\\W]")));
+  assert(std::regex_match("X", std::regex("[^\\W]")));
+  assert(std::regex_match("_", std::regex("[^\\W]")));
+
+  // Those test cases are taken from PR40904
+  assert(std::regex_match("abZcd", std::regex("^ab[\\d\\D]cd")));
+  assert(std::regex_match("ab5cd", std::regex("^ab[\\d\\D]cd")));
+  assert(std::regex_match("abZcd", std::regex("^ab[\\D]cd")));
+  assert(std::regex_match("abZcd", std::regex("^ab\\Dcd")));
+  assert(std::regex_match("ab5cd", std::regex("^ab[\\d]cd")));
+  assert(std::regex_match("ab5cd", std::regex("^ab\\dcd")));
+  assert(!std::regex_match("abZcd", std::regex("^ab\\dcd")));
+  assert(!std::regex_match("ab5cd", std::regex("^ab\\Dcd")));
+
+  assert(std::regex_match("_xyz_", std::regex("_(\\s|\\S)+_")));
+  assert(std::regex_match("_xyz_", std::regex("_[\\s\\S]+_")));
+
+  return 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
index 1550f3728563a..8e8d4e6929a66 100644
--- 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
@@ -24,77 +24,76 @@
 #include "test_macros.h"
 #include "test_iterators.h"
 
-int main(int, char**)
-{
-    {
-        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] == "");
-    }
+int main(int, char**) {
+  {
+    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] == "");
+  }
 
   return 0;
 }
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
index a680baf9dde8b..ac1f4b2f6bc03 100644
--- 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
@@ -22,52 +22,43 @@
 #include <cassert>
 #include "test_macros.h"
 
-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 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 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 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)));
+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(int, char**)
-{
-    test1();
-    test2();
-    test3();
-    test4();
+int main(int, char**) {
+  test1();
+  test2();
+  test3();
+  test4();
 
   return 0;
 }
diff --git a/libcxx/test/std/re/re.alg/re.alg.replace/exponential.pass.cpp b/libcxx/test/std/re/re.alg/re.alg.replace/exponential.pass.cpp
index 316759fd895dd..83acc201d75ba 100644
--- a/libcxx/test/std/re/re.alg/re.alg.replace/exponential.pass.cpp
+++ b/libcxx/test/std/re/re.alg/re.alg.replace/exponential.pass.cpp
@@ -24,16 +24,15 @@
 
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    try {
-        std::regex re("a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?aaaaaaaaaaaaaaaaaaaa");
-        const char s[] = "aaaaaaaaaaaaaaaaaaaa";
-        std::string r = std::regex_replace(s, re, "123-&", std::regex_constants::format_sed);
-        LIBCPP_ASSERT(false);
-        assert(r == "123-aaaaaaaaaaaaaaaaaaaa");
-    } catch (const std::regex_error &e) {
-      assert(e.code() == std::regex_constants::error_complexity);
-    }
-    return 0;
+int main(int, char**) {
+  try {
+    std::regex re("a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?aaaaaaaaaaaaaaaaaaaa");
+    const char s[] = "aaaaaaaaaaaaaaaaaaaa";
+    std::string r  = std::regex_replace(s, re, "123-&", std::regex_constants::format_sed);
+    LIBCPP_ASSERT(false);
+    assert(r == "123-aaaaaaaaaaaaaaaaaaaa");
+  } catch (const std::regex_error& e) {
+    assert(e.code() == std::regex_constants::error_complexity);
+  }
+  return 0;
 }
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
index 193dd614d6e79..49f288c822b5d 100644
--- 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
@@ -24,86 +24,98 @@
 #include "test_macros.h"
 #include "test_iterators.h"
 
-int main(int, char**)
-{
-    {
-        std::regex phone_numbers("\\d{3}-\\d{4}");
-        const char phone_book[] = "555-1234, 555-2345, 555-3456";
-        typedef cpp17_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(base(r) == 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 cpp17_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(base(r) == 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 cpp17_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(base(r) == 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 cpp17_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(base(r) == 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 cpp17_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(base(r) == 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 cpp17_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(base(r) == buf+12);
-        assert(buf == std::string("123-555-1234"));
-    }
+int main(int, char**) {
+  {
+    std::regex phone_numbers("\\d{3}-\\d{4}");
+    const char phone_book[] = "555-1234, 555-2345, 555-3456";
+    typedef cpp17_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(base(r) == 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 cpp17_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(base(r) == 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 cpp17_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(base(r) == 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 cpp17_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(base(r) == 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 cpp17_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(base(r) == 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 cpp17_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(base(r) == buf + 12);
+    assert(buf == std::string("123-555-1234"));
+  }
 
   return 0;
 }
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
index ed5230a9e78dc..a6c1136308d46 100644
--- 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
@@ -24,86 +24,98 @@
 #include "test_macros.h"
 #include "test_iterators.h"
 
-int main(int, char**)
-{
-    {
-        std::regex phone_numbers("\\d{3}-\\d{4}");
-        const char phone_book[] = "555-1234, 555-2345, 555-3456";
-        typedef cpp17_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(base(r) == 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 cpp17_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(base(r) == 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 cpp17_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(base(r) == 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 cpp17_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(base(r) == 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 cpp17_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(base(r) == 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 cpp17_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(base(r) == buf+12);
-        assert(buf == std::string("123-555-1234"));
-    }
+int main(int, char**) {
+  {
+    std::regex phone_numbers("\\d{3}-\\d{4}");
+    const char phone_book[] = "555-1234, 555-2345, 555-3456";
+    typedef cpp17_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(base(r) == 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 cpp17_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(base(r) == 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 cpp17_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(base(r) == 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 cpp17_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(base(r) == 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 cpp17_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(base(r) == 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 cpp17_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(base(r) == buf + 12);
+    assert(buf == std::string("123-555-1234"));
+  }
 
   return 0;
 }
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
index 09ecc53a9f998..0c9eea4c9e093 100644
--- 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
@@ -20,56 +20,51 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    {
-        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");
-    }
+int main(int, char**) {
+  {
+    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");
+  }
 
   return 0;
 }
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
index 4d567ed1f644f..42605bb44fb36 100644
--- 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
@@ -19,56 +19,47 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    {
-        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");
-    }
+int main(int, char**) {
+  {
+    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");
+  }
 
   return 0;
 }
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
index 585a60f8780e1..ef6aa44712c2b 100644
--- 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
@@ -20,56 +20,51 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    {
-        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");
-    }
+int main(int, char**) {
+  {
+    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");
+  }
 
   return 0;
 }
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
index 66a910172c497..5bdf345c32e4b 100644
--- 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
@@ -20,56 +20,47 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    {
-        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");
-    }
+int main(int, char**) {
+  {
+    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");
+  }
 
   return 0;
 }
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
index 904ba066125ec..f2769b624c2f2 100644
--- 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
@@ -21,1516 +21,1469 @@
 #include "test_macros.h"
 #include "test_iterators.h"
 
-int main(int, char**)
-{
-    {
-        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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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[=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) >= 0 && static_cast<std::size_t>(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[=M=]z]",
-                                                 std::regex_constants::awk)));
-        assert(m.size() == 0);
-    }
-    {
-        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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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::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) >= 0 && static_cast<std::size_t>(m.length(0)) == std::char_traits<char>::length(s));
-        assert(m.position(0) == 0);
-        assert(m.str(0) == s);
-    }
+int main(int, char**) {
+  {
+    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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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[=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) >= 0 && static_cast<std::size_t>(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[=M=]z]", std::regex_constants::awk)));
+    assert(m.size() == 0);
+  }
+  {
+    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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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::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) >= 0 && static_cast<std::size_t>(m.length(0)) == std::char_traits<char>::length(s));
+    assert(m.position(0) == 0);
+    assert(m.str(0) == s);
+  }
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-    {
-        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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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[=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) >= 0 && static_cast<std::size_t>(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[=M=]z]",
-                                                 std::regex_constants::awk)));
-        assert(m.size() == 0);
-    }
-    {
-        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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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::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) >= 0 && static_cast<std::size_t>(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.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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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[=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) >= 0 && static_cast<std::size_t>(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[=M=]z]", std::regex_constants::awk)));
+    assert(m.size() == 0);
+  }
+  {
+    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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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::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) >= 0 && static_cast<std::size_t>(m.length(0)) == std::char_traits<wchar_t>::length(s));
+    assert(m.position(0) == 0);
+    assert(m.str(0) == s);
+  }
 #endif // TEST_HAS_NO_WIDE_CHARACTERS
 
   return 0;
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
index 22d522163ce13..3aa9df68343f2 100644
--- 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
@@ -21,45 +21,44 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    // This regex_iterator uses regex_search(__wrap_iter<_Iter> __first, ...)
-    // Test for https://llvm.org/PR16240 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();
+int main(int, char**) {
+  // This regex_iterator uses regex_search(__wrap_iter<_Iter> __first, ...)
+  // Test for https://llvm.org/PR16240 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);
+    assert(it->position(0) == 0);
+    assert(it->length(0) == 1);
 
-        ++it;
-        assert(it->position(0) == 5);
-        assert(it->length(0) == 1);
+    ++it;
+    assert(it->position(0) == 5);
+    assert(it->length(0) == 1);
 
-        ++it;
-        assert(it == end);
-    }
+    ++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>();
+  // 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);
+    assert(it->position(0) == 0);
+    assert(it->length(0) == 1);
 
-        ++it;
-        assert(it->position(0) == 5);
-        assert(it->length(0) == 1);
+    ++it;
+    assert(it->position(0) == 5);
+    assert(it->length(0) == 1);
 
-        ++it;
-        assert(it == end);
-    }
+    ++it;
+    assert(it == end);
+  }
 
   return 0;
 }
diff --git a/libcxx/test/std/re/re.alg/re.alg.search/basic.compile.fail.cpp b/libcxx/test/std/re/re.alg/re.alg.search/basic.compile.fail.cpp
index fb9677f7e9392..40f1886163dba 100644
--- a/libcxx/test/std/re/re.alg/re.alg.search/basic.compile.fail.cpp
+++ b/libcxx/test/std/re/re.alg/re.alg.search/basic.compile.fail.cpp
@@ -22,16 +22,15 @@
 #include "test_macros.h"
 
 #if TEST_STD_VER < 14
-#error
+#  error
 #endif
 
-int main(int, char**)
-{
-    {
-        std::smatch m;
-        std::regex re{"*"};
-        std::regex_search(std::string("abcde"), m, re);
-    }
+int main(int, char**) {
+  {
+    std::smatch m;
+    std::regex re{"*"};
+    std::regex_search(std::string("abcde"), m, re);
+  }
 
   return 0;
 }
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
index 74b4d6341e9de..13d51bfd05e2e 100644
--- 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
@@ -21,1514 +21,1471 @@
 #include "test_macros.h"
 #include "test_iterators.h"
 
-int main(int, char**)
-{
-    {
-        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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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[=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) >= 0 && static_cast<std::size_t>(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[=M=]z]",
-                                                 std::regex_constants::basic)));
-        assert(m.size() == 0);
-    }
-    {
-        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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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::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);
-    }
+int main(int, char**) {
+  {
+    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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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[=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) >= 0 && static_cast<std::size_t>(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[=M=]z]", std::regex_constants::basic)));
+    assert(m.size() == 0);
+  }
+  {
+    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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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::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);
+  }
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  {
+    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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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[=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) >= 0 && static_cast<std::size_t>(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[=M=]z]", std::regex_constants::basic)));
+    assert(m.size() == 0);
+  }
+  {
+    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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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::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);
+  }
+#endif // TEST_HAS_NO_WIDE_CHARACTERS
+
+  { // LWG 2273
+    std::regex re("Foo|FooBar");
+    std::cmatch m;
     {
-        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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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[=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) >= 0 && static_cast<std::size_t>(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[=M=]z]",
-                                                 std::regex_constants::basic)));
-        assert(m.size() == 0);
-    }
-    {
-        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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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);
+      assert(std::regex_search("FooBar", m, re));
+      assert(m.size() == 1);
+      assert(m[0] == "Foo");
     }
     {
-        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"");
+      assert(std::regex_search("Foo", m, re));
+      assert(m.size() == 1);
+      assert(m[0] == "Foo");
     }
     {
-        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");
+      assert(std::regex_search("FooBarBaz", m, re));
+      assert(m.size() == 1);
+      assert(m[0] == "Foo");
     }
     {
-        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);
-    }
-#endif // TEST_HAS_NO_WIDE_CHARACTERS
-
-    { // LWG 2273
-        std::regex re("Foo|FooBar");
-        std::cmatch m;
-        {
-            assert(std::regex_search("FooBar", m, re));
-            assert(m.size() == 1);
-            assert(m[0] == "Foo");
-        }
-        {
-            assert(std::regex_search("Foo", m, re));
-            assert(m.size() == 1);
-            assert(m[0] == "Foo");
-        }
-        {
-            assert(std::regex_search("FooBarBaz", m, re));
-            assert(m.size() == 1);
-            assert(m[0] == "Foo");
-        }
-        {
-            assert(std::regex_search("FooBa", m, re));
-            assert(m.size() == 1);
-            assert(m[0] == "Foo");
-        }
+      assert(std::regex_search("FooBa", m, re));
+      assert(m.size() == 1);
+      assert(m[0] == "Foo");
     }
+  }
 
   return 0;
 }
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
index ee88d11385c8d..83321a05d08dc 100644
--- 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
@@ -21,1530 +21,1525 @@
 #include "test_macros.h"
 #include "test_iterators.h"
 
-int main(int, char**)
-{
-    {
-        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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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[=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) >= 0 && static_cast<std::size_t>(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[=M=]z]")));
-        assert(m.size() == 0);
-    }
-    {
-        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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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::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) >= 0 && static_cast<std::size_t>(m.length(0)) == std::char_traits<char>::length(s));
-        assert(m.position(0) == 0);
-        assert(m.str(0) == s);
-    }
+int main(int, char**) {
+  {
+    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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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[=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) >= 0 && static_cast<std::size_t>(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[=M=]z]")));
+    assert(m.size() == 0);
+  }
+  {
+    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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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::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) >= 0 && static_cast<std::size_t>(m.length(0)) == std::char_traits<char>::length(s));
+    assert(m.position(0) == 0);
+    assert(m.str(0) == s);
+  }
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-    {
-        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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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[=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) >= 0 && static_cast<std::size_t>(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[=M=]z]")));
-        assert(m.size() == 0);
-    }
-    {
-        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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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::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) >= 0 && static_cast<std::size_t>(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.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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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[=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) >= 0 && static_cast<std::size_t>(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[=M=]z]")));
+    assert(m.size() == 0);
+  }
+  {
+    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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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::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) >= 0 && static_cast<std::size_t>(m.length(0)) == std::char_traits<wchar_t>::length(s));
+    assert(m.position(0) == 0);
+    assert(m.str(0) == s);
+  }
 #endif // TEST_HAS_NO_WIDE_CHARACTERS
 
   return 0;
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
index df8560f5fa8c4..6b479b946953d 100644
--- 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
@@ -21,72 +21,67 @@
 #include "test_macros.h"
 #include "test_iterators.h"
 
-int main(int, char**)
-{
-    {
-        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");
-    }
+int main(int, char**) {
+  {
+    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");
+  }
 
   return 0;
 }
diff --git a/libcxx/test/std/re/re.alg/re.alg.search/exponential.pass.cpp b/libcxx/test/std/re/re.alg/re.alg.search/exponential.pass.cpp
index 64a6a135addab..7f326b30a0d10 100644
--- a/libcxx/test/std/re/re.alg/re.alg.search/exponential.pass.cpp
+++ b/libcxx/test/std/re/re.alg/re.alg.search/exponential.pass.cpp
@@ -25,24 +25,19 @@
 
 int main(int, char**) {
   for (std::regex_constants::syntax_option_type op :
-       {std::regex::ECMAScript, std::regex::extended, std::regex::egrep,
-        std::regex::awk}) {
+       {std::regex::ECMAScript, std::regex::extended, std::regex::egrep, std::regex::awk}) {
     try {
       bool b = std::regex_search(
-          "aaaaaaaaaaaaaaaaaaaa",
-          std::regex(
-              "a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?aaaaaaaaaaaaaaaaaaaa",
-              op));
+          "aaaaaaaaaaaaaaaaaaaa", std::regex("a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?aaaaaaaaaaaaaaaaaaaa", op));
       LIBCPP_ASSERT(false);
       assert(b);
-    } catch (const std::regex_error &e) {
+    } catch (const std::regex_error& e) {
       assert(e.code() == std::regex_constants::error_complexity);
     }
   }
   std::string s(100000, 'a');
   for (std::regex_constants::syntax_option_type op :
-       {std::regex::ECMAScript, std::regex::extended, std::regex::egrep,
-        std::regex::awk}) {
+       {std::regex::ECMAScript, std::regex::extended, std::regex::egrep, std::regex::awk}) {
     assert(std::regex_search(s, std::regex("a*", op)));
   }
   return 0;
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
index 73c37267efe86..597dd99ccfb7a 100644
--- 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
@@ -21,1520 +21,1475 @@
 #include "test_macros.h"
 #include "test_iterators.h"
 
-int main(int, char**)
-{
-    {
-        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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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("-(.*),\\1-", 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) >= 0 && static_cast<std::size_t>(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[] = "-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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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[=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) >= 0 && static_cast<std::size_t>(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[=M=]z]",
-                                                 std::regex_constants::extended)));
-        assert(m.size() == 0);
-    }
-    {
-        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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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::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);
-    }
+int main(int, char**) {
+  {
+    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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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("-(.*),\\1-", 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) >= 0 && static_cast<std::size_t>(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[] = "-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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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[=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) >= 0 && static_cast<std::size_t>(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[=M=]z]", std::regex_constants::extended)));
+    assert(m.size() == 0);
+  }
+  {
+    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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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::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);
+  }
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-    {
-        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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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"-(.*),\\1-", 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) >= 0 && static_cast<std::size_t>(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"-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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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[=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) >= 0 && static_cast<std::size_t>(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[=M=]z]",
-                                                 std::regex_constants::extended)));
-        assert(m.size() == 0);
-    }
-    {
-        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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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::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);
-    }
+  {
+    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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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"-(.*),\\1-", 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) >= 0 && static_cast<std::size_t>(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"-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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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[=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) >= 0 && static_cast<std::size_t>(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[=M=]z]", std::regex_constants::extended)));
+    assert(m.size() == 0);
+  }
+  {
+    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) >= 0 && static_cast<std::size_t>(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) >= 0 && static_cast<std::size_t>(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::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);
+  }
 #endif // TEST_HAS_NO_WIDE_CHARACTERS
 
   return 0;
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
index 3569ad53ee60b..d04056a1918b1 100644
--- 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
@@ -21,70 +21,64 @@
 #include "test_macros.h"
 #include "test_iterators.h"
 
-extern "C" void LLVMFuzzerTestOneInput(const char *data)
-{
+extern "C" void LLVMFuzzerTestOneInput(const char* data) {
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    std::size_t size = strlen(data);
-    if (size > 0)
-    {
-        try
-        {
-            std::regex::flag_type flag = std::regex_constants::grep;
-            std::string s((const char *)data, size);
-            std::regex re(s, flag);
-            TEST_IGNORE_NODISCARD std::regex_match(s, re);
-        }
-        catch (std::regex_error &) {}
+  std::size_t size = strlen(data);
+  if (size > 0) {
+    try {
+      std::regex::flag_type flag = std::regex_constants::grep;
+      std::string s((const char*)data, size);
+      std::regex re(s, flag);
+      TEST_IGNORE_NODISCARD std::regex_match(s, re);
+    } catch (std::regex_error&) {
     }
+  }
 #else
-    ((void)data);
+  ((void)data);
 #endif
 }
 
-
-void fuzz_tests()  // patterns that the fuzzer has found
+void fuzz_tests() // patterns that the fuzzer has found
 {
 // Raw string literals are a C++11 feature.
 #if TEST_STD_VER >= 11
-    LLVMFuzzerTestOneInput(R"XX(Õ)_%()()((\8'_%()_%()_%()_%(()_%()_%()_%(.t;)()¥f()_%()(.)_%;)()!¥f(((()()XX");
+  LLVMFuzzerTestOneInput(
+      R"XX(Õ)_%()()((\8'_%()_%()_%()_%(()_%()_%()_%(.t;)()¥f()_%()(.)_%;)()!¥f(((()()XX");
 #endif
 }
 
-int main(int, char**)
-{
-    {
-        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) == "");
-    }
-    fuzz_tests();
+int main(int, char**) {
+  {
+    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) == "");
+  }
+  fuzz_tests();
 
   return 0;
 }
diff --git a/libcxx/test/std/re/re.alg/re.alg.search/invert_neg_word_search.pass.cpp b/libcxx/test/std/re/re.alg/re.alg.search/invert_neg_word_search.pass.cpp
index 9334bcc5b2b09..5b4e1d1f364eb 100644
--- a/libcxx/test/std/re/re.alg/re.alg.search/invert_neg_word_search.pass.cpp
+++ b/libcxx/test/std/re/re.alg/re.alg.search/invert_neg_word_search.pass.cpp
@@ -20,10 +20,8 @@
 
 #include "test_macros.h"
 
-
 // PR34310
-int main(int, char**)
-{
+int main(int, char**) {
   assert(std::regex_search("HelloWorld", std::regex("[^\\W]")));
   assert(std::regex_search("_", std::regex("[^\\W]")));
   return 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
index 1a3ebfc6442c2..a455e8547e3dc 100644
--- 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
@@ -21,10 +21,9 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    assert(!std::regex_search("ab", std::regex("(?=^)b")));
-    assert(!std::regex_search("ab", std::regex("a(?=^)b")));
+int main(int, char**) {
+  assert(!std::regex_search("ab", std::regex("(?=^)b")));
+  assert(!std::regex_search("ab", std::regex("a(?=^)b")));
 
   return 0;
 }
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
index 73158dc53c912..88d0cdc750b58 100644
--- 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
@@ -19,22 +19,21 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    // 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);
+int main(int, char**) {
+  // 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);
 
   return 0;
 }
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
index 1f764da05d6b5..3e0d2a6570f42 100644
--- 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
@@ -6,8 +6,4 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main(int, char**)
-{
-
-  return 0;
-}
+int main(int, char**) { return 0; }
diff --git a/libcxx/test/std/re/re.badexp/regex_error.pass.cpp b/libcxx/test/std/re/re.badexp/regex_error.pass.cpp
index f1a1237a747a7..356207c764020 100644
--- a/libcxx/test/std/re/re.badexp/regex_error.pass.cpp
+++ b/libcxx/test/std/re/re.badexp/regex_error.pass.cpp
@@ -20,78 +20,77 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    {
-        std::regex_error e(std::regex_constants::error_collate);
-        assert(e.code() == std::regex_constants::error_collate);
-        LIBCPP_ASSERT(e.what() == std::string("The expression contained an invalid collating element name."));
-    }
-    {
-        std::regex_error e(std::regex_constants::error_ctype);
-        assert(e.code() == std::regex_constants::error_ctype);
-        LIBCPP_ASSERT(e.what() == std::string("The expression contained an invalid character class name."));
-    }
-    {
-        std::regex_error e(std::regex_constants::error_escape);
-        assert(e.code() == std::regex_constants::error_escape);
-        LIBCPP_ASSERT(e.what() == std::string("The expression contained an invalid escaped character, or a "
-               "trailing escape."));
-    }
-    {
-        std::regex_error e(std::regex_constants::error_backref);
-        assert(e.code() == std::regex_constants::error_backref);
-        LIBCPP_ASSERT(e.what() == std::string("The expression contained an invalid back reference."));
-    }
-    {
-        std::regex_error e(std::regex_constants::error_brack);
-        assert(e.code() == std::regex_constants::error_brack);
-        LIBCPP_ASSERT(e.what() == std::string("The expression contained mismatched [ and ]."));
-    }
-    {
-        std::regex_error e(std::regex_constants::error_paren);
-        assert(e.code() == std::regex_constants::error_paren);
-        LIBCPP_ASSERT(e.what() == std::string("The expression contained mismatched ( and )."));
-    }
-    {
-        std::regex_error e(std::regex_constants::error_brace);
-        assert(e.code() == std::regex_constants::error_brace);
-        LIBCPP_ASSERT(e.what() == std::string("The expression contained mismatched { and }."));
-    }
-    {
-        std::regex_error e(std::regex_constants::error_badbrace);
-        assert(e.code() == std::regex_constants::error_badbrace);
-        LIBCPP_ASSERT(e.what() == std::string("The expression contained an invalid range in a {} expression."));
-    }
-    {
-        std::regex_error e(std::regex_constants::error_range);
-        assert(e.code() == std::regex_constants::error_range);
-        LIBCPP_ASSERT(e.what() == std::string("The expression contained an invalid character range, "
-               "such as [b-a] in most encodings."));
-    }
-    {
-        std::regex_error e(std::regex_constants::error_space);
-        assert(e.code() == std::regex_constants::error_space);
-        LIBCPP_ASSERT(e.what() == std::string("There was insufficient memory to convert the expression into "
-               "a finite state machine."));
-    }
-    {
-        std::regex_error e(std::regex_constants::error_badrepeat);
-        assert(e.code() == std::regex_constants::error_badrepeat);
-        LIBCPP_ASSERT(e.what() == std::string("One of *?+{ was not preceded by a valid regular expression."));
-    }
-    {
-        std::regex_error e(std::regex_constants::error_complexity);
-        assert(e.code() == std::regex_constants::error_complexity);
-        LIBCPP_ASSERT(e.what() == std::string("The complexity of an attempted match against a regular "
-               "expression exceeded a pre-set level."));
-    }
-    {
-        std::regex_error e(std::regex_constants::error_stack);
-        assert(e.code() == std::regex_constants::error_stack);
-        LIBCPP_ASSERT(e.what() == std::string("There was insufficient memory to determine whether the regular "
-               "expression could match the specified character sequence."));
-    }
+int main(int, char**) {
+  {
+    std::regex_error e(std::regex_constants::error_collate);
+    assert(e.code() == std::regex_constants::error_collate);
+    LIBCPP_ASSERT(e.what() == std::string("The expression contained an invalid collating element name."));
+  }
+  {
+    std::regex_error e(std::regex_constants::error_ctype);
+    assert(e.code() == std::regex_constants::error_ctype);
+    LIBCPP_ASSERT(e.what() == std::string("The expression contained an invalid character class name."));
+  }
+  {
+    std::regex_error e(std::regex_constants::error_escape);
+    assert(e.code() == std::regex_constants::error_escape);
+    LIBCPP_ASSERT(e.what() == std::string("The expression contained an invalid escaped character, or a "
+                                          "trailing escape."));
+  }
+  {
+    std::regex_error e(std::regex_constants::error_backref);
+    assert(e.code() == std::regex_constants::error_backref);
+    LIBCPP_ASSERT(e.what() == std::string("The expression contained an invalid back reference."));
+  }
+  {
+    std::regex_error e(std::regex_constants::error_brack);
+    assert(e.code() == std::regex_constants::error_brack);
+    LIBCPP_ASSERT(e.what() == std::string("The expression contained mismatched [ and ]."));
+  }
+  {
+    std::regex_error e(std::regex_constants::error_paren);
+    assert(e.code() == std::regex_constants::error_paren);
+    LIBCPP_ASSERT(e.what() == std::string("The expression contained mismatched ( and )."));
+  }
+  {
+    std::regex_error e(std::regex_constants::error_brace);
+    assert(e.code() == std::regex_constants::error_brace);
+    LIBCPP_ASSERT(e.what() == std::string("The expression contained mismatched { and }."));
+  }
+  {
+    std::regex_error e(std::regex_constants::error_badbrace);
+    assert(e.code() == std::regex_constants::error_badbrace);
+    LIBCPP_ASSERT(e.what() == std::string("The expression contained an invalid range in a {} expression."));
+  }
+  {
+    std::regex_error e(std::regex_constants::error_range);
+    assert(e.code() == std::regex_constants::error_range);
+    LIBCPP_ASSERT(e.what() == std::string("The expression contained an invalid character range, "
+                                          "such as [b-a] in most encodings."));
+  }
+  {
+    std::regex_error e(std::regex_constants::error_space);
+    assert(e.code() == std::regex_constants::error_space);
+    LIBCPP_ASSERT(e.what() == std::string("There was insufficient memory to convert the expression into "
+                                          "a finite state machine."));
+  }
+  {
+    std::regex_error e(std::regex_constants::error_badrepeat);
+    assert(e.code() == std::regex_constants::error_badrepeat);
+    LIBCPP_ASSERT(e.what() == std::string("One of *?+{ was not preceded by a valid regular expression."));
+  }
+  {
+    std::regex_error e(std::regex_constants::error_complexity);
+    assert(e.code() == std::regex_constants::error_complexity);
+    LIBCPP_ASSERT(e.what() == std::string("The complexity of an attempted match against a regular "
+                                          "expression exceeded a pre-set level."));
+  }
+  {
+    std::regex_error e(std::regex_constants::error_stack);
+    assert(e.code() == std::regex_constants::error_stack);
+    LIBCPP_ASSERT(e.what() == std::string("There was insufficient memory to determine whether the regular "
+                                          "expression could match the specified character sequence."));
+  }
 
   return 0;
 }
diff --git a/libcxx/test/std/re/re.const/re.err/error_type.pass.cpp b/libcxx/test/std/re/re.const/re.err/error_type.pass.cpp
index 75a69517eb5ff..987b7dc73d505 100644
--- a/libcxx/test/std/re/re.const/re.err/error_type.pass.cpp
+++ b/libcxx/test/std/re/re.const/re.err/error_type.pass.cpp
@@ -34,111 +34,110 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    LIBCPP_ASSERT(std::regex_constants::error_collate != 0);
-    LIBCPP_ASSERT(std::regex_constants::error_ctype != 0);
-    LIBCPP_ASSERT(std::regex_constants::error_escape != 0);
-    LIBCPP_ASSERT(std::regex_constants::error_backref != 0);
-    LIBCPP_ASSERT(std::regex_constants::error_brack != 0);
-    LIBCPP_ASSERT(std::regex_constants::error_paren != 0);
-    LIBCPP_ASSERT(std::regex_constants::error_brace != 0);
-    LIBCPP_ASSERT(std::regex_constants::error_badbrace != 0);
-    LIBCPP_ASSERT(std::regex_constants::error_range != 0);
-    LIBCPP_ASSERT(std::regex_constants::error_space != 0);
-    LIBCPP_ASSERT(std::regex_constants::error_badrepeat != 0);
-    LIBCPP_ASSERT(std::regex_constants::error_complexity != 0);
-    LIBCPP_ASSERT(std::regex_constants::error_stack != 0);
-
-    assert(std::regex_constants::error_collate != std::regex_constants::error_ctype);
-    assert(std::regex_constants::error_collate != std::regex_constants::error_escape);
-    assert(std::regex_constants::error_collate != std::regex_constants::error_backref);
-    assert(std::regex_constants::error_collate != std::regex_constants::error_brack);
-    assert(std::regex_constants::error_collate != std::regex_constants::error_paren);
-    assert(std::regex_constants::error_collate != std::regex_constants::error_brace);
-    assert(std::regex_constants::error_collate != std::regex_constants::error_badbrace);
-    assert(std::regex_constants::error_collate != std::regex_constants::error_range);
-    assert(std::regex_constants::error_collate != std::regex_constants::error_space);
-    assert(std::regex_constants::error_collate != std::regex_constants::error_badrepeat);
-    assert(std::regex_constants::error_collate != std::regex_constants::error_complexity);
-    assert(std::regex_constants::error_collate != std::regex_constants::error_stack);
-
-    assert(std::regex_constants::error_ctype != std::regex_constants::error_escape);
-    assert(std::regex_constants::error_ctype != std::regex_constants::error_backref);
-    assert(std::regex_constants::error_ctype != std::regex_constants::error_brack);
-    assert(std::regex_constants::error_ctype != std::regex_constants::error_paren);
-    assert(std::regex_constants::error_ctype != std::regex_constants::error_brace);
-    assert(std::regex_constants::error_ctype != std::regex_constants::error_badbrace);
-    assert(std::regex_constants::error_ctype != std::regex_constants::error_range);
-    assert(std::regex_constants::error_ctype != std::regex_constants::error_space);
-    assert(std::regex_constants::error_ctype != std::regex_constants::error_badrepeat);
-    assert(std::regex_constants::error_ctype != std::regex_constants::error_complexity);
-    assert(std::regex_constants::error_ctype != std::regex_constants::error_stack);
-
-    assert(std::regex_constants::error_escape != std::regex_constants::error_backref);
-    assert(std::regex_constants::error_escape != std::regex_constants::error_brack);
-    assert(std::regex_constants::error_escape != std::regex_constants::error_paren);
-    assert(std::regex_constants::error_escape != std::regex_constants::error_brace);
-    assert(std::regex_constants::error_escape != std::regex_constants::error_badbrace);
-    assert(std::regex_constants::error_escape != std::regex_constants::error_range);
-    assert(std::regex_constants::error_escape != std::regex_constants::error_space);
-    assert(std::regex_constants::error_escape != std::regex_constants::error_badrepeat);
-    assert(std::regex_constants::error_escape != std::regex_constants::error_complexity);
-    assert(std::regex_constants::error_escape != std::regex_constants::error_stack);
-
-    assert(std::regex_constants::error_backref != std::regex_constants::error_brack);
-    assert(std::regex_constants::error_backref != std::regex_constants::error_paren);
-    assert(std::regex_constants::error_backref != std::regex_constants::error_brace);
-    assert(std::regex_constants::error_backref != std::regex_constants::error_badbrace);
-    assert(std::regex_constants::error_backref != std::regex_constants::error_range);
-    assert(std::regex_constants::error_backref != std::regex_constants::error_space);
-    assert(std::regex_constants::error_backref != std::regex_constants::error_badrepeat);
-    assert(std::regex_constants::error_backref != std::regex_constants::error_complexity);
-    assert(std::regex_constants::error_backref != std::regex_constants::error_stack);
-
-    assert(std::regex_constants::error_brack != std::regex_constants::error_paren);
-    assert(std::regex_constants::error_brack != std::regex_constants::error_brace);
-    assert(std::regex_constants::error_brack != std::regex_constants::error_badbrace);
-    assert(std::regex_constants::error_brack != std::regex_constants::error_range);
-    assert(std::regex_constants::error_brack != std::regex_constants::error_space);
-    assert(std::regex_constants::error_brack != std::regex_constants::error_badrepeat);
-    assert(std::regex_constants::error_brack != std::regex_constants::error_complexity);
-    assert(std::regex_constants::error_brack != std::regex_constants::error_stack);
-
-    assert(std::regex_constants::error_paren != std::regex_constants::error_brace);
-    assert(std::regex_constants::error_paren != std::regex_constants::error_badbrace);
-    assert(std::regex_constants::error_paren != std::regex_constants::error_range);
-    assert(std::regex_constants::error_paren != std::regex_constants::error_space);
-    assert(std::regex_constants::error_paren != std::regex_constants::error_badrepeat);
-    assert(std::regex_constants::error_paren != std::regex_constants::error_complexity);
-    assert(std::regex_constants::error_paren != std::regex_constants::error_stack);
-
-    assert(std::regex_constants::error_brace != std::regex_constants::error_badbrace);
-    assert(std::regex_constants::error_brace != std::regex_constants::error_range);
-    assert(std::regex_constants::error_brace != std::regex_constants::error_space);
-    assert(std::regex_constants::error_brace != std::regex_constants::error_badrepeat);
-    assert(std::regex_constants::error_brace != std::regex_constants::error_complexity);
-    assert(std::regex_constants::error_brace != std::regex_constants::error_stack);
-
-    assert(std::regex_constants::error_badbrace != std::regex_constants::error_range);
-    assert(std::regex_constants::error_badbrace != std::regex_constants::error_space);
-    assert(std::regex_constants::error_badbrace != std::regex_constants::error_badrepeat);
-    assert(std::regex_constants::error_badbrace != std::regex_constants::error_complexity);
-    assert(std::regex_constants::error_badbrace != std::regex_constants::error_stack);
-
-    assert(std::regex_constants::error_range != std::regex_constants::error_space);
-    assert(std::regex_constants::error_range != std::regex_constants::error_badrepeat);
-    assert(std::regex_constants::error_range != std::regex_constants::error_complexity);
-    assert(std::regex_constants::error_range != std::regex_constants::error_stack);
-
-    assert(std::regex_constants::error_space != std::regex_constants::error_badrepeat);
-    assert(std::regex_constants::error_space != std::regex_constants::error_complexity);
-    assert(std::regex_constants::error_space != std::regex_constants::error_stack);
-
-    assert(std::regex_constants::error_badrepeat != std::regex_constants::error_complexity);
-    assert(std::regex_constants::error_badrepeat != std::regex_constants::error_stack);
-
-    assert(std::regex_constants::error_complexity != std::regex_constants::error_stack);
+int main(int, char**) {
+  LIBCPP_ASSERT(std::regex_constants::error_collate != 0);
+  LIBCPP_ASSERT(std::regex_constants::error_ctype != 0);
+  LIBCPP_ASSERT(std::regex_constants::error_escape != 0);
+  LIBCPP_ASSERT(std::regex_constants::error_backref != 0);
+  LIBCPP_ASSERT(std::regex_constants::error_brack != 0);
+  LIBCPP_ASSERT(std::regex_constants::error_paren != 0);
+  LIBCPP_ASSERT(std::regex_constants::error_brace != 0);
+  LIBCPP_ASSERT(std::regex_constants::error_badbrace != 0);
+  LIBCPP_ASSERT(std::regex_constants::error_range != 0);
+  LIBCPP_ASSERT(std::regex_constants::error_space != 0);
+  LIBCPP_ASSERT(std::regex_constants::error_badrepeat != 0);
+  LIBCPP_ASSERT(std::regex_constants::error_complexity != 0);
+  LIBCPP_ASSERT(std::regex_constants::error_stack != 0);
+
+  assert(std::regex_constants::error_collate != std::regex_constants::error_ctype);
+  assert(std::regex_constants::error_collate != std::regex_constants::error_escape);
+  assert(std::regex_constants::error_collate != std::regex_constants::error_backref);
+  assert(std::regex_constants::error_collate != std::regex_constants::error_brack);
+  assert(std::regex_constants::error_collate != std::regex_constants::error_paren);
+  assert(std::regex_constants::error_collate != std::regex_constants::error_brace);
+  assert(std::regex_constants::error_collate != std::regex_constants::error_badbrace);
+  assert(std::regex_constants::error_collate != std::regex_constants::error_range);
+  assert(std::regex_constants::error_collate != std::regex_constants::error_space);
+  assert(std::regex_constants::error_collate != std::regex_constants::error_badrepeat);
+  assert(std::regex_constants::error_collate != std::regex_constants::error_complexity);
+  assert(std::regex_constants::error_collate != std::regex_constants::error_stack);
+
+  assert(std::regex_constants::error_ctype != std::regex_constants::error_escape);
+  assert(std::regex_constants::error_ctype != std::regex_constants::error_backref);
+  assert(std::regex_constants::error_ctype != std::regex_constants::error_brack);
+  assert(std::regex_constants::error_ctype != std::regex_constants::error_paren);
+  assert(std::regex_constants::error_ctype != std::regex_constants::error_brace);
+  assert(std::regex_constants::error_ctype != std::regex_constants::error_badbrace);
+  assert(std::regex_constants::error_ctype != std::regex_constants::error_range);
+  assert(std::regex_constants::error_ctype != std::regex_constants::error_space);
+  assert(std::regex_constants::error_ctype != std::regex_constants::error_badrepeat);
+  assert(std::regex_constants::error_ctype != std::regex_constants::error_complexity);
+  assert(std::regex_constants::error_ctype != std::regex_constants::error_stack);
+
+  assert(std::regex_constants::error_escape != std::regex_constants::error_backref);
+  assert(std::regex_constants::error_escape != std::regex_constants::error_brack);
+  assert(std::regex_constants::error_escape != std::regex_constants::error_paren);
+  assert(std::regex_constants::error_escape != std::regex_constants::error_brace);
+  assert(std::regex_constants::error_escape != std::regex_constants::error_badbrace);
+  assert(std::regex_constants::error_escape != std::regex_constants::error_range);
+  assert(std::regex_constants::error_escape != std::regex_constants::error_space);
+  assert(std::regex_constants::error_escape != std::regex_constants::error_badrepeat);
+  assert(std::regex_constants::error_escape != std::regex_constants::error_complexity);
+  assert(std::regex_constants::error_escape != std::regex_constants::error_stack);
+
+  assert(std::regex_constants::error_backref != std::regex_constants::error_brack);
+  assert(std::regex_constants::error_backref != std::regex_constants::error_paren);
+  assert(std::regex_constants::error_backref != std::regex_constants::error_brace);
+  assert(std::regex_constants::error_backref != std::regex_constants::error_badbrace);
+  assert(std::regex_constants::error_backref != std::regex_constants::error_range);
+  assert(std::regex_constants::error_backref != std::regex_constants::error_space);
+  assert(std::regex_constants::error_backref != std::regex_constants::error_badrepeat);
+  assert(std::regex_constants::error_backref != std::regex_constants::error_complexity);
+  assert(std::regex_constants::error_backref != std::regex_constants::error_stack);
+
+  assert(std::regex_constants::error_brack != std::regex_constants::error_paren);
+  assert(std::regex_constants::error_brack != std::regex_constants::error_brace);
+  assert(std::regex_constants::error_brack != std::regex_constants::error_badbrace);
+  assert(std::regex_constants::error_brack != std::regex_constants::error_range);
+  assert(std::regex_constants::error_brack != std::regex_constants::error_space);
+  assert(std::regex_constants::error_brack != std::regex_constants::error_badrepeat);
+  assert(std::regex_constants::error_brack != std::regex_constants::error_complexity);
+  assert(std::regex_constants::error_brack != std::regex_constants::error_stack);
+
+  assert(std::regex_constants::error_paren != std::regex_constants::error_brace);
+  assert(std::regex_constants::error_paren != std::regex_constants::error_badbrace);
+  assert(std::regex_constants::error_paren != std::regex_constants::error_range);
+  assert(std::regex_constants::error_paren != std::regex_constants::error_space);
+  assert(std::regex_constants::error_paren != std::regex_constants::error_badrepeat);
+  assert(std::regex_constants::error_paren != std::regex_constants::error_complexity);
+  assert(std::regex_constants::error_paren != std::regex_constants::error_stack);
+
+  assert(std::regex_constants::error_brace != std::regex_constants::error_badbrace);
+  assert(std::regex_constants::error_brace != std::regex_constants::error_range);
+  assert(std::regex_constants::error_brace != std::regex_constants::error_space);
+  assert(std::regex_constants::error_brace != std::regex_constants::error_badrepeat);
+  assert(std::regex_constants::error_brace != std::regex_constants::error_complexity);
+  assert(std::regex_constants::error_brace != std::regex_constants::error_stack);
+
+  assert(std::regex_constants::error_badbrace != std::regex_constants::error_range);
+  assert(std::regex_constants::error_badbrace != std::regex_constants::error_space);
+  assert(std::regex_constants::error_badbrace != std::regex_constants::error_badrepeat);
+  assert(std::regex_constants::error_badbrace != std::regex_constants::error_complexity);
+  assert(std::regex_constants::error_badbrace != std::regex_constants::error_stack);
+
+  assert(std::regex_constants::error_range != std::regex_constants::error_space);
+  assert(std::regex_constants::error_range != std::regex_constants::error_badrepeat);
+  assert(std::regex_constants::error_range != std::regex_constants::error_complexity);
+  assert(std::regex_constants::error_range != std::regex_constants::error_stack);
+
+  assert(std::regex_constants::error_space != std::regex_constants::error_badrepeat);
+  assert(std::regex_constants::error_space != std::regex_constants::error_complexity);
+  assert(std::regex_constants::error_space != std::regex_constants::error_stack);
+
+  assert(std::regex_constants::error_badrepeat != std::regex_constants::error_complexity);
+  assert(std::regex_constants::error_badrepeat != std::regex_constants::error_stack);
+
+  assert(std::regex_constants::error_complexity != std::regex_constants::error_stack);
 
   return 0;
 }
diff --git a/libcxx/test/std/re/re.const/re.matchflag/match_flag_type.pass.cpp b/libcxx/test/std/re/re.const/re.matchflag/match_flag_type.pass.cpp
index b631b49c9a8e1..8e182fc77391b 100644
--- a/libcxx/test/std/re/re.const/re.matchflag/match_flag_type.pass.cpp
+++ b/libcxx/test/std/re/re.const/re.matchflag/match_flag_type.pass.cpp
@@ -34,96 +34,96 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    assert(std::regex_constants::match_default == 0);
-    assert(std::regex_constants::match_not_bol != 0);
-    assert(std::regex_constants::match_not_eol != 0);
-    assert(std::regex_constants::match_not_bow != 0);
-    assert(std::regex_constants::match_not_eow != 0);
-    assert(std::regex_constants::match_any != 0);
-    assert(std::regex_constants::match_not_null != 0);
-    assert(std::regex_constants::match_continuous != 0);
-    assert(std::regex_constants::match_prev_avail != 0);
-    assert(std::regex_constants::format_default == 0);
-    assert(std::regex_constants::format_sed != 0);
-    assert(std::regex_constants::format_no_copy != 0);
-    assert(std::regex_constants::format_first_only != 0);
-
-    assert((std::regex_constants::match_not_bol & std::regex_constants::match_not_eol) == 0);
-    assert((std::regex_constants::match_not_bol & std::regex_constants::match_not_bow) == 0);
-    assert((std::regex_constants::match_not_bol & std::regex_constants::match_not_eow) == 0);
-    assert((std::regex_constants::match_not_bol & std::regex_constants::match_any) == 0);
-    assert((std::regex_constants::match_not_bol & std::regex_constants::match_not_null) == 0);
-    assert((std::regex_constants::match_not_bol & std::regex_constants::match_continuous) == 0);
-    assert((std::regex_constants::match_not_bol & std::regex_constants::match_prev_avail) == 0);
-    assert((std::regex_constants::match_not_bol & std::regex_constants::format_sed) == 0);
-    assert((std::regex_constants::match_not_bol & std::regex_constants::format_no_copy) == 0);
-    assert((std::regex_constants::match_not_bol & std::regex_constants::format_first_only) == 0);
-
-    assert((std::regex_constants::match_not_eol & std::regex_constants::match_not_bow) == 0);
-    assert((std::regex_constants::match_not_eol & std::regex_constants::match_not_eow) == 0);
-    assert((std::regex_constants::match_not_eol & std::regex_constants::match_any) == 0);
-    assert((std::regex_constants::match_not_eol & std::regex_constants::match_not_null) == 0);
-    assert((std::regex_constants::match_not_eol & std::regex_constants::match_continuous) == 0);
-    assert((std::regex_constants::match_not_eol & std::regex_constants::match_prev_avail) == 0);
-    assert((std::regex_constants::match_not_eol & std::regex_constants::format_sed) == 0);
-    assert((std::regex_constants::match_not_eol & std::regex_constants::format_no_copy) == 0);
-    assert((std::regex_constants::match_not_eol & std::regex_constants::format_first_only) == 0);
-
-    assert((std::regex_constants::match_not_bow & std::regex_constants::match_not_eow) == 0);
-    assert((std::regex_constants::match_not_bow & std::regex_constants::match_any) == 0);
-    assert((std::regex_constants::match_not_bow & std::regex_constants::match_not_null) == 0);
-    assert((std::regex_constants::match_not_bow & std::regex_constants::match_continuous) == 0);
-    assert((std::regex_constants::match_not_bow & std::regex_constants::match_prev_avail) == 0);
-    assert((std::regex_constants::match_not_bow & std::regex_constants::format_sed) == 0);
-    assert((std::regex_constants::match_not_bow & std::regex_constants::format_no_copy) == 0);
-    assert((std::regex_constants::match_not_bow & std::regex_constants::format_first_only) == 0);
-
-    assert((std::regex_constants::match_not_eow & std::regex_constants::match_any) == 0);
-    assert((std::regex_constants::match_not_eow & std::regex_constants::match_not_null) == 0);
-    assert((std::regex_constants::match_not_eow & std::regex_constants::match_continuous) == 0);
-    assert((std::regex_constants::match_not_eow & std::regex_constants::match_prev_avail) == 0);
-    assert((std::regex_constants::match_not_eow & std::regex_constants::format_sed) == 0);
-    assert((std::regex_constants::match_not_eow & std::regex_constants::format_no_copy) == 0);
-    assert((std::regex_constants::match_not_eow & std::regex_constants::format_first_only) == 0);
-
-    assert((std::regex_constants::match_any & std::regex_constants::match_not_null) == 0);
-    assert((std::regex_constants::match_any & std::regex_constants::match_continuous) == 0);
-    assert((std::regex_constants::match_any & std::regex_constants::match_prev_avail) == 0);
-    assert((std::regex_constants::match_any & std::regex_constants::format_sed) == 0);
-    assert((std::regex_constants::match_any & std::regex_constants::format_no_copy) == 0);
-    assert((std::regex_constants::match_any & std::regex_constants::format_first_only) == 0);
-
-    assert((std::regex_constants::match_not_null & std::regex_constants::match_continuous) == 0);
-    assert((std::regex_constants::match_not_null & std::regex_constants::match_prev_avail) == 0);
-    assert((std::regex_constants::match_not_null & std::regex_constants::format_sed) == 0);
-    assert((std::regex_constants::match_not_null & std::regex_constants::format_no_copy) == 0);
-    assert((std::regex_constants::match_not_null & std::regex_constants::format_first_only) == 0);
-
-    assert((std::regex_constants::match_continuous & std::regex_constants::match_prev_avail) == 0);
-    assert((std::regex_constants::match_continuous & std::regex_constants::format_sed) == 0);
-    assert((std::regex_constants::match_continuous & std::regex_constants::format_no_copy) == 0);
-    assert((std::regex_constants::match_continuous & std::regex_constants::format_first_only) == 0);
-
-    assert((std::regex_constants::match_prev_avail & std::regex_constants::format_sed) == 0);
-    assert((std::regex_constants::match_prev_avail & std::regex_constants::format_no_copy) == 0);
-    assert((std::regex_constants::match_prev_avail & std::regex_constants::format_first_only) == 0);
-
-    assert((std::regex_constants::format_sed & std::regex_constants::format_no_copy) == 0);
-    assert((std::regex_constants::format_sed & std::regex_constants::format_first_only) == 0);
-
-    assert((std::regex_constants::format_no_copy & std::regex_constants::format_first_only) == 0);
-
-    std::regex_constants::match_flag_type e1 = std::regex_constants::match_not_bol;
-    std::regex_constants::match_flag_type e2 = std::regex_constants::match_not_eol;
-    e1 = ~e1;
-    e1 = e1 & e2;
-    e1 = e1 | e2;
-    e1 = e1 ^ e2;
-    e1 &= e2;
-    e1 |= e2;
-    e1 ^= e2;
+int main(int, char**) {
+  assert(std::regex_constants::match_default == 0);
+  assert(std::regex_constants::match_not_bol != 0);
+  assert(std::regex_constants::match_not_eol != 0);
+  assert(std::regex_constants::match_not_bow != 0);
+  assert(std::regex_constants::match_not_eow != 0);
+  assert(std::regex_constants::match_any != 0);
+  assert(std::regex_constants::match_not_null != 0);
+  assert(std::regex_constants::match_continuous != 0);
+  assert(std::regex_constants::match_prev_avail != 0);
+  assert(std::regex_constants::format_default == 0);
+  assert(std::regex_constants::format_sed != 0);
+  assert(std::regex_constants::format_no_copy != 0);
+  assert(std::regex_constants::format_first_only != 0);
+
+  assert((std::regex_constants::match_not_bol & std::regex_constants::match_not_eol) == 0);
+  assert((std::regex_constants::match_not_bol & std::regex_constants::match_not_bow) == 0);
+  assert((std::regex_constants::match_not_bol & std::regex_constants::match_not_eow) == 0);
+  assert((std::regex_constants::match_not_bol & std::regex_constants::match_any) == 0);
+  assert((std::regex_constants::match_not_bol & std::regex_constants::match_not_null) == 0);
+  assert((std::regex_constants::match_not_bol & std::regex_constants::match_continuous) == 0);
+  assert((std::regex_constants::match_not_bol & std::regex_constants::match_prev_avail) == 0);
+  assert((std::regex_constants::match_not_bol & std::regex_constants::format_sed) == 0);
+  assert((std::regex_constants::match_not_bol & std::regex_constants::format_no_copy) == 0);
+  assert((std::regex_constants::match_not_bol & std::regex_constants::format_first_only) == 0);
+
+  assert((std::regex_constants::match_not_eol & std::regex_constants::match_not_bow) == 0);
+  assert((std::regex_constants::match_not_eol & std::regex_constants::match_not_eow) == 0);
+  assert((std::regex_constants::match_not_eol & std::regex_constants::match_any) == 0);
+  assert((std::regex_constants::match_not_eol & std::regex_constants::match_not_null) == 0);
+  assert((std::regex_constants::match_not_eol & std::regex_constants::match_continuous) == 0);
+  assert((std::regex_constants::match_not_eol & std::regex_constants::match_prev_avail) == 0);
+  assert((std::regex_constants::match_not_eol & std::regex_constants::format_sed) == 0);
+  assert((std::regex_constants::match_not_eol & std::regex_constants::format_no_copy) == 0);
+  assert((std::regex_constants::match_not_eol & std::regex_constants::format_first_only) == 0);
+
+  assert((std::regex_constants::match_not_bow & std::regex_constants::match_not_eow) == 0);
+  assert((std::regex_constants::match_not_bow & std::regex_constants::match_any) == 0);
+  assert((std::regex_constants::match_not_bow & std::regex_constants::match_not_null) == 0);
+  assert((std::regex_constants::match_not_bow & std::regex_constants::match_continuous) == 0);
+  assert((std::regex_constants::match_not_bow & std::regex_constants::match_prev_avail) == 0);
+  assert((std::regex_constants::match_not_bow & std::regex_constants::format_sed) == 0);
+  assert((std::regex_constants::match_not_bow & std::regex_constants::format_no_copy) == 0);
+  assert((std::regex_constants::match_not_bow & std::regex_constants::format_first_only) == 0);
+
+  assert((std::regex_constants::match_not_eow & std::regex_constants::match_any) == 0);
+  assert((std::regex_constants::match_not_eow & std::regex_constants::match_not_null) == 0);
+  assert((std::regex_constants::match_not_eow & std::regex_constants::match_continuous) == 0);
+  assert((std::regex_constants::match_not_eow & std::regex_constants::match_prev_avail) == 0);
+  assert((std::regex_constants::match_not_eow & std::regex_constants::format_sed) == 0);
+  assert((std::regex_constants::match_not_eow & std::regex_constants::format_no_copy) == 0);
+  assert((std::regex_constants::match_not_eow & std::regex_constants::format_first_only) == 0);
+
+  assert((std::regex_constants::match_any & std::regex_constants::match_not_null) == 0);
+  assert((std::regex_constants::match_any & std::regex_constants::match_continuous) == 0);
+  assert((std::regex_constants::match_any & std::regex_constants::match_prev_avail) == 0);
+  assert((std::regex_constants::match_any & std::regex_constants::format_sed) == 0);
+  assert((std::regex_constants::match_any & std::regex_constants::format_no_copy) == 0);
+  assert((std::regex_constants::match_any & std::regex_constants::format_first_only) == 0);
+
+  assert((std::regex_constants::match_not_null & std::regex_constants::match_continuous) == 0);
+  assert((std::regex_constants::match_not_null & std::regex_constants::match_prev_avail) == 0);
+  assert((std::regex_constants::match_not_null & std::regex_constants::format_sed) == 0);
+  assert((std::regex_constants::match_not_null & std::regex_constants::format_no_copy) == 0);
+  assert((std::regex_constants::match_not_null & std::regex_constants::format_first_only) == 0);
+
+  assert((std::regex_constants::match_continuous & std::regex_constants::match_prev_avail) == 0);
+  assert((std::regex_constants::match_continuous & std::regex_constants::format_sed) == 0);
+  assert((std::regex_constants::match_continuous & std::regex_constants::format_no_copy) == 0);
+  assert((std::regex_constants::match_continuous & std::regex_constants::format_first_only) == 0);
+
+  assert((std::regex_constants::match_prev_avail & std::regex_constants::format_sed) == 0);
+  assert((std::regex_constants::match_prev_avail & std::regex_constants::format_no_copy) == 0);
+  assert((std::regex_constants::match_prev_avail & std::regex_constants::format_first_only) == 0);
+
+  assert((std::regex_constants::format_sed & std::regex_constants::format_no_copy) == 0);
+  assert((std::regex_constants::format_sed & std::regex_constants::format_first_only) == 0);
+
+  assert((std::regex_constants::format_no_copy & std::regex_constants::format_first_only) == 0);
+
+  std::regex_constants::match_flag_type e1 = std::regex_constants::match_not_bol;
+  std::regex_constants::match_flag_type e2 = std::regex_constants::match_not_eol;
+
+  e1 = ~e1;
+  e1 = e1 & e2;
+  e1 = e1 | e2;
+  e1 = e1 ^ e2;
+  e1 &= e2;
+  e1 |= e2;
+  e1 ^= e2;
 
   return 0;
 }
diff --git a/libcxx/test/std/re/re.const/re.matchflag/match_multiline.pass.cpp b/libcxx/test/std/re/re.const/re.matchflag/match_multiline.pass.cpp
index 91cffaa99df9c..3b5bcd869ea63 100644
--- a/libcxx/test/std/re/re.const/re.matchflag/match_multiline.pass.cpp
+++ b/libcxx/test/std/re/re.const/re.matchflag/match_multiline.pass.cpp
@@ -18,254 +18,248 @@
 #include <cassert>
 #include "test_macros.h"
 
-static void search(const char* pat, std::regex_constants::syntax_option_type f,
-                   const char* target, bool expected)
-{
-    std::regex re(pat, f);
-    std::cmatch m;
-    assert(std::regex_search(target, m, re) == expected);
-
-    if(expected) {
-        assert(m.size() == 1);
-        assert(m.length(0) == 3);
-        assert(m.str(0) == "foo");
-    }
-    else
-    {
-        assert(m.size() == 0);
-    }
+static void search(const char* pat, std::regex_constants::syntax_option_type f, const char* target, bool expected) {
+  std::regex re(pat, f);
+  std::cmatch m;
+  assert(std::regex_search(target, m, re) == expected);
+
+  if (expected) {
+    assert(m.size() == 1);
+    assert(m.length(0) == 3);
+    assert(m.str(0) == "foo");
+  } else {
+    assert(m.size() == 0);
+  }
 }
 
-int main(int, char**)
-{
-    using std::regex_constants::ECMAScript;
-    using std::regex_constants::basic;
-    using std::regex_constants::extended;
-    using std::regex_constants::awk;
-    using std::regex_constants::grep;
-    using std::regex_constants::egrep;
-    using std::regex_constants::multiline;
-
-    {
-        const char* pat = "^foo";
-        const char* target = "foo";
-
-        search(pat, ECMAScript, target, true);
-        search(pat, basic, target, true);
-        search(pat, extended, target, true);
-        search(pat, awk, target, true);
-        search(pat, grep, target, true);
-        search(pat, egrep, target, true);
-
-        search(pat, ECMAScript | multiline, target, true);
-        search(pat, basic | multiline, target, true);
-        search(pat, extended | multiline, target, true);
-        search(pat, awk | multiline, target, true);
-        search(pat, grep | multiline, target, true);
-        search(pat, egrep | multiline, target, true);
-    }
-    {
-        const char* pat = "^foo";
-        const char* target = "\nfoo";
-
-        search(pat, ECMAScript, target, false);
-        search(pat, basic, target, false);
-        search(pat, extended, target, false);
-        search(pat, awk, target, false);
-        search(pat, grep, target, false);
-        search(pat, egrep, target, false);
-
-        search(pat, ECMAScript | multiline, target, true);
-        search(pat, basic | multiline, target, false);
-        search(pat, extended | multiline, target, false);
-        search(pat, awk | multiline, target, false);
-        search(pat, grep | multiline, target, false);
-        search(pat, egrep | multiline, target, false);
-    }
-    {
-        const char* pat = "^foo";
-        const char* target = "bar\nfoo";
-
-        search(pat, ECMAScript, target, false);
-        search(pat, basic, target, false);
-        search(pat, extended, target, false);
-        search(pat, awk, target, false);
-        search(pat, grep, target, false);
-        search(pat, egrep, target, false);
-
-        search(pat, ECMAScript | multiline, target, true);
-        search(pat, basic | multiline, target, false);
-        search(pat, extended | multiline, target, false);
-        search(pat, awk | multiline, target, false);
-        search(pat, grep | multiline, target, false);
-        search(pat, egrep | multiline, target, false);
-    }
-
-    {
-        const char* pat = "foo$";
-        const char* target = "foo";
-
-        search(pat, ECMAScript, target, true);
-        search(pat, basic, target, true);
-        search(pat, extended, target, true);
-        search(pat, awk, target, true);
-        search(pat, grep, target, true);
-        search(pat, egrep, target, true);
-
-        search(pat, ECMAScript | multiline, target, true);
-        search(pat, basic | multiline, target, true);
-        search(pat, extended | multiline, target, true);
-        search(pat, awk | multiline, target, true);
-        search(pat, grep | multiline, target, true);
-        search(pat, egrep | multiline, target, true);
-    }
-    {
-        const char* pat = "foo$";
-        const char* target = "foo\n";
-
-        search(pat, ECMAScript, target, false);
-        search(pat, basic, target, false);
-        search(pat, extended, target, false);
-        search(pat, awk, target, false);
-        search(pat, grep, target, false);
-        search(pat, egrep, target, false);
-
-        search(pat, ECMAScript | multiline, target, true);
-        search(pat, basic | multiline, target, false);
-        search(pat, extended | multiline, target, false);
-        search(pat, awk | multiline, target, false);
-        search(pat, grep | multiline, target, false);
-        search(pat, egrep | multiline, target, false);
-    }
-    {
-        const char* pat = "foo$";
-        const char* target = "foo\nbar";
-
-        search(pat, ECMAScript, target, false);
-        search(pat, basic, target, false);
-        search(pat, extended, target, false);
-        search(pat, awk, target, false);
-        search(pat, grep, target, false);
-        search(pat, egrep, target, false);
-
-        search(pat, ECMAScript | multiline, target, true);
-        search(pat, basic | multiline, target, false);
-        search(pat, extended | multiline, target, false);
-        search(pat, awk | multiline, target, false);
-        search(pat, grep | multiline, target, false);
-        search(pat, egrep | multiline, target, false);
-    }
-
-
-    {
-        const char* pat = "^foo";
-        const char* target = "foo";
-
-        search(pat, ECMAScript, target, true);
-        search(pat, basic, target, true);
-        search(pat, extended, target, true);
-        search(pat, awk, target, true);
-        search(pat, grep, target, true);
-        search(pat, egrep, target, true);
-
-        search(pat, ECMAScript | multiline, target, true);
-        search(pat, basic | multiline, target, true);
-        search(pat, extended | multiline, target, true);
-        search(pat, awk | multiline, target, true);
-        search(pat, grep | multiline, target, true);
-        search(pat, egrep | multiline, target, true);
-    }
-    {
-        const char* pat = "^foo";
-        const char* target = "\rfoo";
-
-        search(pat, ECMAScript, target, false);
-        search(pat, basic, target, false);
-        search(pat, extended, target, false);
-        search(pat, awk, target, false);
-        search(pat, grep, target, false);
-        search(pat, egrep, target, false);
-
-        search(pat, ECMAScript | multiline, target, true);
-        search(pat, basic | multiline, target, false);
-        search(pat, extended | multiline, target, false);
-        search(pat, awk | multiline, target, false);
-        search(pat, grep | multiline, target, false);
-        search(pat, egrep | multiline, target, false);
-    }
-    {
-        const char* pat = "^foo";
-        const char* target = "bar\rfoo";
-
-        search(pat, ECMAScript, target, false);
-        search(pat, basic, target, false);
-        search(pat, extended, target, false);
-        search(pat, awk, target, false);
-        search(pat, grep, target, false);
-        search(pat, egrep, target, false);
-
-        search(pat, ECMAScript | multiline, target, true);
-        search(pat, basic | multiline, target, false);
-        search(pat, extended | multiline, target, false);
-        search(pat, awk | multiline, target, false);
-        search(pat, grep | multiline, target, false);
-        search(pat, egrep | multiline, target, false);
-    }
-
-    {
-        const char* pat = "foo$";
-        const char* target = "foo";
-
-        search(pat, ECMAScript, target, true);
-        search(pat, basic, target, true);
-        search(pat, extended, target, true);
-        search(pat, awk, target, true);
-        search(pat, grep, target, true);
-        search(pat, egrep, target, true);
-
-        search(pat, ECMAScript | multiline, target, true);
-        search(pat, basic | multiline, target, true);
-        search(pat, extended | multiline, target, true);
-        search(pat, awk | multiline, target, true);
-        search(pat, grep | multiline, target, true);
-        search(pat, egrep | multiline, target, true);
-    }
-    {
-        const char* pat = "foo$";
-        const char* target = "foo\r";
-
-        search(pat, ECMAScript, target, false);
-        search(pat, basic, target, false);
-        search(pat, extended, target, false);
-        search(pat, awk, target, false);
-        search(pat, grep, target, false);
-        search(pat, egrep, target, false);
-
-        search(pat, ECMAScript | multiline, target, true);
-        search(pat, basic | multiline, target, false);
-        search(pat, extended | multiline, target, false);
-        search(pat, awk | multiline, target, false);
-        search(pat, grep | multiline, target, false);
-        search(pat, egrep | multiline, target, false);
-    }
-    {
-        const char* pat = "foo$";
-        const char* target = "foo\rbar";
-
-        search(pat, ECMAScript, target, false);
-        search(pat, basic, target, false);
-        search(pat, extended, target, false);
-        search(pat, awk, target, false);
-        search(pat, grep, target, false);
-        search(pat, egrep, target, false);
-
-        search(pat, ECMAScript | multiline, target, true);
-        search(pat, basic | multiline, target, false);
-        search(pat, extended | multiline, target, false);
-        search(pat, awk | multiline, target, false);
-        search(pat, grep | multiline, target, false);
-        search(pat, egrep | multiline, target, false);
-    }
-
-    return 0;
+int main(int, char**) {
+  using std::regex_constants::awk;
+  using std::regex_constants::basic;
+  using std::regex_constants::ECMAScript;
+  using std::regex_constants::egrep;
+  using std::regex_constants::extended;
+  using std::regex_constants::grep;
+  using std::regex_constants::multiline;
+
+  {
+    const char* pat    = "^foo";
+    const char* target = "foo";
+
+    search(pat, ECMAScript, target, true);
+    search(pat, basic, target, true);
+    search(pat, extended, target, true);
+    search(pat, awk, target, true);
+    search(pat, grep, target, true);
+    search(pat, egrep, target, true);
+
+    search(pat, ECMAScript | multiline, target, true);
+    search(pat, basic | multiline, target, true);
+    search(pat, extended | multiline, target, true);
+    search(pat, awk | multiline, target, true);
+    search(pat, grep | multiline, target, true);
+    search(pat, egrep | multiline, target, true);
+  }
+  {
+    const char* pat    = "^foo";
+    const char* target = "\nfoo";
+
+    search(pat, ECMAScript, target, false);
+    search(pat, basic, target, false);
+    search(pat, extended, target, false);
+    search(pat, awk, target, false);
+    search(pat, grep, target, false);
+    search(pat, egrep, target, false);
+
+    search(pat, ECMAScript | multiline, target, true);
+    search(pat, basic | multiline, target, false);
+    search(pat, extended | multiline, target, false);
+    search(pat, awk | multiline, target, false);
+    search(pat, grep | multiline, target, false);
+    search(pat, egrep | multiline, target, false);
+  }
+  {
+    const char* pat    = "^foo";
+    const char* target = "bar\nfoo";
+
+    search(pat, ECMAScript, target, false);
+    search(pat, basic, target, false);
+    search(pat, extended, target, false);
+    search(pat, awk, target, false);
+    search(pat, grep, target, false);
+    search(pat, egrep, target, false);
+
+    search(pat, ECMAScript | multiline, target, true);
+    search(pat, basic | multiline, target, false);
+    search(pat, extended | multiline, target, false);
+    search(pat, awk | multiline, target, false);
+    search(pat, grep | multiline, target, false);
+    search(pat, egrep | multiline, target, false);
+  }
+
+  {
+    const char* pat    = "foo$";
+    const char* target = "foo";
+
+    search(pat, ECMAScript, target, true);
+    search(pat, basic, target, true);
+    search(pat, extended, target, true);
+    search(pat, awk, target, true);
+    search(pat, grep, target, true);
+    search(pat, egrep, target, true);
+
+    search(pat, ECMAScript | multiline, target, true);
+    search(pat, basic | multiline, target, true);
+    search(pat, extended | multiline, target, true);
+    search(pat, awk | multiline, target, true);
+    search(pat, grep | multiline, target, true);
+    search(pat, egrep | multiline, target, true);
+  }
+  {
+    const char* pat    = "foo$";
+    const char* target = "foo\n";
+
+    search(pat, ECMAScript, target, false);
+    search(pat, basic, target, false);
+    search(pat, extended, target, false);
+    search(pat, awk, target, false);
+    search(pat, grep, target, false);
+    search(pat, egrep, target, false);
+
+    search(pat, ECMAScript | multiline, target, true);
+    search(pat, basic | multiline, target, false);
+    search(pat, extended | multiline, target, false);
+    search(pat, awk | multiline, target, false);
+    search(pat, grep | multiline, target, false);
+    search(pat, egrep | multiline, target, false);
+  }
+  {
+    const char* pat    = "foo$";
+    const char* target = "foo\nbar";
+
+    search(pat, ECMAScript, target, false);
+    search(pat, basic, target, false);
+    search(pat, extended, target, false);
+    search(pat, awk, target, false);
+    search(pat, grep, target, false);
+    search(pat, egrep, target, false);
+
+    search(pat, ECMAScript | multiline, target, true);
+    search(pat, basic | multiline, target, false);
+    search(pat, extended | multiline, target, false);
+    search(pat, awk | multiline, target, false);
+    search(pat, grep | multiline, target, false);
+    search(pat, egrep | multiline, target, false);
+  }
+
+  {
+    const char* pat    = "^foo";
+    const char* target = "foo";
+
+    search(pat, ECMAScript, target, true);
+    search(pat, basic, target, true);
+    search(pat, extended, target, true);
+    search(pat, awk, target, true);
+    search(pat, grep, target, true);
+    search(pat, egrep, target, true);
+
+    search(pat, ECMAScript | multiline, target, true);
+    search(pat, basic | multiline, target, true);
+    search(pat, extended | multiline, target, true);
+    search(pat, awk | multiline, target, true);
+    search(pat, grep | multiline, target, true);
+    search(pat, egrep | multiline, target, true);
+  }
+  {
+    const char* pat    = "^foo";
+    const char* target = "\rfoo";
+
+    search(pat, ECMAScript, target, false);
+    search(pat, basic, target, false);
+    search(pat, extended, target, false);
+    search(pat, awk, target, false);
+    search(pat, grep, target, false);
+    search(pat, egrep, target, false);
+
+    search(pat, ECMAScript | multiline, target, true);
+    search(pat, basic | multiline, target, false);
+    search(pat, extended | multiline, target, false);
+    search(pat, awk | multiline, target, false);
+    search(pat, grep | multiline, target, false);
+    search(pat, egrep | multiline, target, false);
+  }
+  {
+    const char* pat    = "^foo";
+    const char* target = "bar\rfoo";
+
+    search(pat, ECMAScript, target, false);
+    search(pat, basic, target, false);
+    search(pat, extended, target, false);
+    search(pat, awk, target, false);
+    search(pat, grep, target, false);
+    search(pat, egrep, target, false);
+
+    search(pat, ECMAScript | multiline, target, true);
+    search(pat, basic | multiline, target, false);
+    search(pat, extended | multiline, target, false);
+    search(pat, awk | multiline, target, false);
+    search(pat, grep | multiline, target, false);
+    search(pat, egrep | multiline, target, false);
+  }
+
+  {
+    const char* pat    = "foo$";
+    const char* target = "foo";
+
+    search(pat, ECMAScript, target, true);
+    search(pat, basic, target, true);
+    search(pat, extended, target, true);
+    search(pat, awk, target, true);
+    search(pat, grep, target, true);
+    search(pat, egrep, target, true);
+
+    search(pat, ECMAScript | multiline, target, true);
+    search(pat, basic | multiline, target, true);
+    search(pat, extended | multiline, target, true);
+    search(pat, awk | multiline, target, true);
+    search(pat, grep | multiline, target, true);
+    search(pat, egrep | multiline, target, true);
+  }
+  {
+    const char* pat    = "foo$";
+    const char* target = "foo\r";
+
+    search(pat, ECMAScript, target, false);
+    search(pat, basic, target, false);
+    search(pat, extended, target, false);
+    search(pat, awk, target, false);
+    search(pat, grep, target, false);
+    search(pat, egrep, target, false);
+
+    search(pat, ECMAScript | multiline, target, true);
+    search(pat, basic | multiline, target, false);
+    search(pat, extended | multiline, target, false);
+    search(pat, awk | multiline, target, false);
+    search(pat, grep | multiline, target, false);
+    search(pat, egrep | multiline, target, false);
+  }
+  {
+    const char* pat    = "foo$";
+    const char* target = "foo\rbar";
+
+    search(pat, ECMAScript, target, false);
+    search(pat, basic, target, false);
+    search(pat, extended, target, false);
+    search(pat, awk, target, false);
+    search(pat, grep, target, false);
+    search(pat, egrep, target, false);
+
+    search(pat, ECMAScript | multiline, target, true);
+    search(pat, basic | multiline, target, false);
+    search(pat, extended | multiline, target, false);
+    search(pat, awk | multiline, target, false);
+    search(pat, grep | multiline, target, false);
+    search(pat, egrep | multiline, target, false);
+  }
+
+  return 0;
 }
diff --git a/libcxx/test/std/re/re.const/re.matchflag/match_not_bol.pass.cpp b/libcxx/test/std/re/re.const/re.matchflag/match_not_bol.pass.cpp
index 6522d429ebccc..04bbd432c8341 100644
--- a/libcxx/test/std/re/re.const/re.matchflag/match_not_bol.pass.cpp
+++ b/libcxx/test/std/re/re.const/re.matchflag/match_not_bol.pass.cpp
@@ -17,35 +17,34 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    {
+int main(int, char**) {
+  {
     std::string target = "foo";
     std::regex re("^foo");
-    assert( std::regex_match(target, re));
+    assert(std::regex_match(target, re));
     assert(!std::regex_match(target, re, std::regex_constants::match_not_bol));
-    }
+  }
 
-    {
+  {
     std::string target = "foo";
     std::regex re("foo");
-    assert( std::regex_match(target, re));
-    assert( std::regex_match(target, re, std::regex_constants::match_not_bol));
-    }
+    assert(std::regex_match(target, re));
+    assert(std::regex_match(target, re, std::regex_constants::match_not_bol));
+  }
 
-    {
+  {
     std::string target = "fooby";
     std::regex re("^foo");
-    assert( std::regex_search(target, re));
+    assert(std::regex_search(target, re));
     assert(!std::regex_search(target, re, std::regex_constants::match_not_bol));
-    }
+  }
 
-    {
+  {
     std::string target = "fooby";
     std::regex re("foo");
-    assert( std::regex_search(target, re));
-    assert( std::regex_search(target, re, std::regex_constants::match_not_bol));
-    }
+    assert(std::regex_search(target, re));
+    assert(std::regex_search(target, re, std::regex_constants::match_not_bol));
+  }
 
   return 0;
 }
diff --git a/libcxx/test/std/re/re.const/re.matchflag/match_not_eol.pass.cpp b/libcxx/test/std/re/re.const/re.matchflag/match_not_eol.pass.cpp
index 89d939eaf809f..6cbaa3094be07 100644
--- a/libcxx/test/std/re/re.const/re.matchflag/match_not_eol.pass.cpp
+++ b/libcxx/test/std/re/re.const/re.matchflag/match_not_eol.pass.cpp
@@ -17,74 +17,73 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    {
+int main(int, char**) {
+  {
     std::string target = "foo";
     std::regex re("foo$");
-    assert( std::regex_match(target, re));
+    assert(std::regex_match(target, re));
     assert(!std::regex_match(target, re, std::regex_constants::match_not_eol));
-    }
+  }
 
-    {
+  {
     std::string target = "foo";
     std::regex re("foo");
-    assert( std::regex_match(target, re));
-    assert( std::regex_match(target, re, std::regex_constants::match_not_eol));
-    }
+    assert(std::regex_match(target, re));
+    assert(std::regex_match(target, re, std::regex_constants::match_not_eol));
+  }
 
-    {
+  {
     std::string target = "refoo";
     std::regex re("foo$");
-    assert( std::regex_search(target, re));
+    assert(std::regex_search(target, re));
     assert(!std::regex_search(target, re, std::regex_constants::match_not_eol));
-    }
+  }
 
-    {
+  {
     std::string target = "refoo";
     std::regex re("foo");
-    assert( std::regex_search(target, re));
-    assert( std::regex_search(target, re, std::regex_constants::match_not_eol));
-    }
+    assert(std::regex_search(target, re));
+    assert(std::regex_search(target, re, std::regex_constants::match_not_eol));
+  }
 
-    {
-      std::string target = "foo";
-      std::regex re("$");
-      assert(std::regex_search(target, re));
-      assert(!std::regex_search(target, re, std::regex_constants::match_not_eol));
+  {
+    std::string target = "foo";
+    std::regex re("$");
+    assert(std::regex_search(target, re));
+    assert(!std::regex_search(target, re, std::regex_constants::match_not_eol));
 
-      std::smatch match;
-      assert(std::regex_search(target, match, re));
-      assert(match.position(0) == 3);
-      assert(match.length(0) == 0);
-      assert(!std::regex_search(target, match, re, std::regex_constants::match_not_eol));
-      assert(match.length(0) == 0);
-    }
+    std::smatch match;
+    assert(std::regex_search(target, match, re));
+    assert(match.position(0) == 3);
+    assert(match.length(0) == 0);
+    assert(!std::regex_search(target, match, re, std::regex_constants::match_not_eol));
+    assert(match.length(0) == 0);
+  }
 
-    {
-      std::string target = "foo";
-      std::regex re("$", std::regex::multiline);
-      std::smatch match;
-      assert(std::regex_search(target, match, re));
-      assert(match.position(0) == 3);
-      assert(match.length(0) == 0);
-      assert(!std::regex_search(target, match, re, std::regex_constants::match_not_eol));
-      assert(match.length(0) == 0);
-    }
+  {
+    std::string target = "foo";
+    std::regex re("$", std::regex::multiline);
+    std::smatch match;
+    assert(std::regex_search(target, match, re));
+    assert(match.position(0) == 3);
+    assert(match.length(0) == 0);
+    assert(!std::regex_search(target, match, re, std::regex_constants::match_not_eol));
+    assert(match.length(0) == 0);
+  }
 
-    {
-      std::string target = "foo";
-      std::regex re("$");
-      assert(!std::regex_match(target, re));
-      assert(!std::regex_match(target, re, std::regex_constants::match_not_eol));
-    }
+  {
+    std::string target = "foo";
+    std::regex re("$");
+    assert(!std::regex_match(target, re));
+    assert(!std::regex_match(target, re, std::regex_constants::match_not_eol));
+  }
 
-    {
-      std::string target = "a";
-      std::regex re("^b*$");
-      assert(!std::regex_search(target, re));
-      assert(!std::regex_search(target, re, std::regex_constants::match_not_eol));
-    }
+  {
+    std::string target = "a";
+    std::regex re("^b*$");
+    assert(!std::regex_search(target, re));
+    assert(!std::regex_search(target, re, std::regex_constants::match_not_eol));
+  }
 
   return 0;
 }
diff --git a/libcxx/test/std/re/re.const/re.matchflag/match_not_null.pass.cpp b/libcxx/test/std/re/re.const/re.matchflag/match_not_null.pass.cpp
index 645f79a0d85c9..2b845c3e1321c 100644
--- a/libcxx/test/std/re/re.const/re.matchflag/match_not_null.pass.cpp
+++ b/libcxx/test/std/re/re.const/re.matchflag/match_not_null.pass.cpp
@@ -15,29 +15,25 @@
 #include <cassert>
 #include <regex>
 
-int main(int, char**)
-{
+int main(int, char**) {
   // When match_not_null is on, the regex engine should reject empty matches and
   // move on to try other solutions.
   std::cmatch m;
-  assert(!std::regex_search("a", m, std::regex("b*"),
-                            std::regex_constants::match_not_null));
-  assert(std::regex_search("aa", m, std::regex("a*?"),
-                           std::regex_constants::match_not_null));
+  assert(!std::regex_search("a", m, std::regex("b*"), std::regex_constants::match_not_null));
+  assert(std::regex_search("aa", m, std::regex("a*?"), std::regex_constants::match_not_null));
   assert(m[0].length() == 1);
-  assert(!std::regex_search("a", m, std::regex("b*", std::regex::extended),
-                            std::regex_constants::match_not_null));
+  assert(!std::regex_search("a", m, std::regex("b*", std::regex::extended), std::regex_constants::match_not_null));
   assert(!std::regex_search(
-      "a", m,
+      "a",
+      m,
       std::regex("b*", std::regex::extended | std::regex_constants::nosubs),
       std::regex_constants::match_not_null));
 
-  assert(!std::regex_match("", m, std::regex("a*"),
-                           std::regex_constants::match_not_null));
-  assert(!std::regex_match("", m, std::regex("a*", std::regex::extended),
-                           std::regex_constants::match_not_null));
+  assert(!std::regex_match("", m, std::regex("a*"), std::regex_constants::match_not_null));
+  assert(!std::regex_match("", m, std::regex("a*", std::regex::extended), std::regex_constants::match_not_null));
   assert(!std::regex_match(
-      "", m,
+      "",
+      m,
       std::regex("a*", std::regex::extended | std::regex_constants::nosubs),
       std::regex_constants::match_not_null));
 
diff --git a/libcxx/test/std/re/re.const/re.matchflag/match_prev_avail.pass.cpp b/libcxx/test/std/re/re.const/re.matchflag/match_prev_avail.pass.cpp
index 508b8dd43be95..f8f1a270e1c25 100644
--- a/libcxx/test/std/re/re.const/re.matchflag/match_prev_avail.pass.cpp
+++ b/libcxx/test/std/re/re.const/re.matchflag/match_prev_avail.pass.cpp
@@ -19,66 +19,66 @@
 #include <string>
 
 int main(int, char**) {
-  char str1[] = "\na";
+  char str1[]    = "\na";
   auto str1_scnd = str1 + 1;
 
   // Assert that match_prev_avail disables match_not_bol and this matches
-  assert(std::regex_match(str1 + 1, str1 + 2, std::regex("^a"),
-                     std::regex_constants::match_not_bol |
-                         std::regex_constants::match_prev_avail));
+  assert(std::regex_match(
+      str1 + 1,
+      str1 + 2,
+      std::regex("^a"),
+      std::regex_constants::match_not_bol | std::regex_constants::match_prev_avail));
   // Manually passing match_prev_avail defines that --str1 is a valid position
-  assert(std::regex_match(str1_scnd, std::regex("a"),
-                     std::regex_constants::match_not_bol |
-                         std::regex_constants::match_prev_avail));
+  assert(std::regex_match(
+      str1_scnd, std::regex("a"), std::regex_constants::match_not_bol | std::regex_constants::match_prev_avail));
 
   //Assert that match_prev_avail disables match_not_bow and this matches
   assert(std::regex_search(str1, std::regex("\\ba")));
-  assert(std::regex_match(str1 + 1, str1 + 2, std::regex("\\ba\\b"),
-                     std::regex_constants::match_not_bow |
-                         std::regex_constants::match_prev_avail));
-  assert(std::regex_search(str1_scnd, std::regex("\\ba"),
-                      std::regex_constants::match_not_bow |
-                          std::regex_constants::match_prev_avail));
+  assert(std::regex_match(
+      str1 + 1,
+      str1 + 2,
+      std::regex("\\ba\\b"),
+      std::regex_constants::match_not_bow | std::regex_constants::match_prev_avail));
+  assert(std::regex_search(
+      str1_scnd, std::regex("\\ba"), std::regex_constants::match_not_bow | std::regex_constants::match_prev_avail));
 
   //Assert that match_prev_avail disables both match_not_bow and match_not_bol
-  assert(std::regex_match(str1 + 1, str1 + 2, std::regex("^a"),
-                     std::regex_constants::match_not_bol |
-                         std::regex_constants::match_not_bow |
-                         std::regex_constants::match_prev_avail));
-  assert(std::regex_match(str1_scnd, std::regex("\\ba"),
-                     std::regex_constants::match_not_bol |
-                         std::regex_constants::match_not_bow |
-                         std::regex_constants::match_prev_avail));
+  assert(std::regex_match(
+      str1 + 1,
+      str1 + 2,
+      std::regex("^a"),
+      std::regex_constants::match_not_bol | std::regex_constants::match_not_bow |
+          std::regex_constants::match_prev_avail));
+  assert(std::regex_match(
+      str1_scnd,
+      std::regex("\\ba"),
+      std::regex_constants::match_not_bol | std::regex_constants::match_not_bow |
+          std::regex_constants::match_prev_avail));
 
   // pr 42199
-  std::string S = " cd";
+  std::string S               = " cd";
   std::string::iterator Start = S.begin() + 1;
-  std::string::iterator End = S.end();
+  std::string::iterator End   = S.end();
   assert(std::regex_search(Start, End, std::regex("^cd")));
 
-  assert(!std::regex_search(Start, End, std::regex("^cd"),
-            std::regex_constants::match_not_bol));
-  assert(!std::regex_search(Start, End, std::regex(".*\\bcd\\b"),
-            std::regex_constants::match_not_bow));
-  assert(!std::regex_search(Start, End, std::regex("^cd"),
-            std::regex_constants::match_not_bol |
-            std::regex_constants::match_not_bow));
-  assert(!std::regex_search(Start, End, std::regex(".*\\bcd\\b"),
-            std::regex_constants::match_not_bol |
-            std::regex_constants::match_not_bow));
+  assert(!std::regex_search(Start, End, std::regex("^cd"), std::regex_constants::match_not_bol));
+  assert(!std::regex_search(Start, End, std::regex(".*\\bcd\\b"), std::regex_constants::match_not_bow));
+  assert(!std::regex_search(
+      Start, End, std::regex("^cd"), std::regex_constants::match_not_bol | std::regex_constants::match_not_bow));
+  assert(!std::regex_search(
+      Start, End, std::regex(".*\\bcd\\b"), std::regex_constants::match_not_bol | std::regex_constants::match_not_bow));
 
-  assert(std::regex_search(Start, End, std::regex("^cd"),
-            std::regex_constants::match_prev_avail));
+  assert(std::regex_search(Start, End, std::regex("^cd"), std::regex_constants::match_prev_avail));
 
-  assert(std::regex_search(Start, End, std::regex("^cd"),
-            std::regex_constants::match_not_bol |
-            std::regex_constants::match_prev_avail));
-  assert(std::regex_search(Start, End, std::regex("^cd"),
-            std::regex_constants::match_not_bow |
-            std::regex_constants::match_prev_avail));
-  assert(std::regex_match(Start, End, std::regex("\\bcd\\b"),
-            std::regex_constants::match_not_bol |
-            std::regex_constants::match_not_bow |
-            std::regex_constants::match_prev_avail));
+  assert(std::regex_search(
+      Start, End, std::regex("^cd"), std::regex_constants::match_not_bol | std::regex_constants::match_prev_avail));
+  assert(std::regex_search(
+      Start, End, std::regex("^cd"), std::regex_constants::match_not_bow | std::regex_constants::match_prev_avail));
+  assert(std::regex_match(
+      Start,
+      End,
+      std::regex("\\bcd\\b"),
+      std::regex_constants::match_not_bol | std::regex_constants::match_not_bow |
+          std::regex_constants::match_prev_avail));
   return 0;
 }
diff --git a/libcxx/test/std/re/re.const/re.synopt/syntax_option_type.pass.cpp b/libcxx/test/std/re/re.const/re.synopt/syntax_option_type.pass.cpp
index 4e2ddb798ba9e..edac2066f5a95 100644
--- a/libcxx/test/std/re/re.const/re.synopt/syntax_option_type.pass.cpp
+++ b/libcxx/test/std/re/re.const/re.synopt/syntax_option_type.pass.cpp
@@ -32,102 +32,102 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    assert(std::regex_constants::icase != 0);
-    assert(std::regex_constants::nosubs != 0);
-    assert(std::regex_constants::optimize != 0);
-    assert(std::regex_constants::collate != 0);
+int main(int, char**) {
+  assert(std::regex_constants::icase != 0);
+  assert(std::regex_constants::nosubs != 0);
+  assert(std::regex_constants::optimize != 0);
+  assert(std::regex_constants::collate != 0);
 #if !defined _LIBCPP_VERSION || defined _LIBCPP_ABI_REGEX_CONSTANTS_NONZERO
-    // https://llvm.org/PR35967
-    assert(std::regex_constants::ECMAScript != 0);
+  // https://llvm.org/PR35967
+  assert(std::regex_constants::ECMAScript != 0);
 #else
-    assert(std::regex_constants::ECMAScript == 0);
+  assert(std::regex_constants::ECMAScript == 0);
 #endif
-    assert(std::regex_constants::basic != 0);
-    assert(std::regex_constants::extended != 0);
-    assert(std::regex_constants::awk != 0);
-    assert(std::regex_constants::grep != 0);
-    assert(std::regex_constants::egrep != 0);
-    assert(std::regex_constants::multiline != 0);
-
-    assert((std::regex_constants::icase & std::regex_constants::nosubs) == 0);
-    assert((std::regex_constants::icase & std::regex_constants::optimize) == 0);
-    assert((std::regex_constants::icase & std::regex_constants::collate) == 0);
-    assert((std::regex_constants::icase & std::regex_constants::ECMAScript) == 0);
-    assert((std::regex_constants::icase & std::regex_constants::basic) == 0);
-    assert((std::regex_constants::icase & std::regex_constants::extended) == 0);
-    assert((std::regex_constants::icase & std::regex_constants::awk) == 0);
-    assert((std::regex_constants::icase & std::regex_constants::grep) == 0);
-    assert((std::regex_constants::icase & std::regex_constants::egrep) == 0);
-    assert((std::regex_constants::icase & std::regex_constants::multiline) == 0);
-
-    assert((std::regex_constants::nosubs & std::regex_constants::optimize) == 0);
-    assert((std::regex_constants::nosubs & std::regex_constants::collate) == 0);
-    assert((std::regex_constants::nosubs & std::regex_constants::ECMAScript) == 0);
-    assert((std::regex_constants::nosubs & std::regex_constants::basic) == 0);
-    assert((std::regex_constants::nosubs & std::regex_constants::extended) == 0);
-    assert((std::regex_constants::nosubs & std::regex_constants::awk) == 0);
-    assert((std::regex_constants::nosubs & std::regex_constants::grep) == 0);
-    assert((std::regex_constants::nosubs & std::regex_constants::egrep) == 0);
-    assert((std::regex_constants::nosubs & std::regex_constants::multiline) == 0);
-
-    assert((std::regex_constants::optimize & std::regex_constants::collate) == 0);
-    assert((std::regex_constants::optimize & std::regex_constants::ECMAScript) == 0);
-    assert((std::regex_constants::optimize & std::regex_constants::basic) == 0);
-    assert((std::regex_constants::optimize & std::regex_constants::extended) == 0);
-    assert((std::regex_constants::optimize & std::regex_constants::awk) == 0);
-    assert((std::regex_constants::optimize & std::regex_constants::grep) == 0);
-    assert((std::regex_constants::optimize & std::regex_constants::egrep) == 0);
-    assert((std::regex_constants::optimize & std::regex_constants::multiline) == 0);
-
-    assert((std::regex_constants::collate & std::regex_constants::ECMAScript) == 0);
-    assert((std::regex_constants::collate & std::regex_constants::basic) == 0);
-    assert((std::regex_constants::collate & std::regex_constants::extended) == 0);
-    assert((std::regex_constants::collate & std::regex_constants::awk) == 0);
-    assert((std::regex_constants::collate & std::regex_constants::grep) == 0);
-    assert((std::regex_constants::collate & std::regex_constants::egrep) == 0);
-    assert((std::regex_constants::collate & std::regex_constants::multiline) == 0);
-
-    assert((std::regex_constants::ECMAScript & std::regex_constants::basic) == 0);
-    assert((std::regex_constants::ECMAScript & std::regex_constants::extended) == 0);
-    assert((std::regex_constants::ECMAScript & std::regex_constants::awk) == 0);
-    assert((std::regex_constants::ECMAScript & std::regex_constants::grep) == 0);
-    assert((std::regex_constants::ECMAScript & std::regex_constants::egrep) == 0);
-    assert((std::regex_constants::ECMAScript & std::regex_constants::multiline) == 0);
-
-    assert((std::regex_constants::basic & std::regex_constants::extended) == 0);
-    assert((std::regex_constants::basic & std::regex_constants::awk) == 0);
-    assert((std::regex_constants::basic & std::regex_constants::grep) == 0);
-    assert((std::regex_constants::basic & std::regex_constants::egrep) == 0);
-    assert((std::regex_constants::basic & std::regex_constants::multiline) == 0);
-
-    assert((std::regex_constants::extended & std::regex_constants::awk) == 0);
-    assert((std::regex_constants::extended & std::regex_constants::grep) == 0);
-    assert((std::regex_constants::extended & std::regex_constants::egrep) == 0);
-    assert((std::regex_constants::extended & std::regex_constants::multiline) == 0);
-
-    assert((std::regex_constants::awk & std::regex_constants::grep) == 0);
-    assert((std::regex_constants::awk & std::regex_constants::egrep) == 0);
-    assert((std::regex_constants::awk & std::regex_constants::multiline) == 0);
-
-    assert((std::regex_constants::grep & std::regex_constants::egrep) == 0);
-    assert((std::regex_constants::grep & std::regex_constants::multiline) == 0);
-
-    assert((std::regex_constants::egrep & std::regex_constants::multiline) == 0);
-
-    assert((std::regex_constants::icase | std::regex_constants::nosubs) != 0);
-    assert((std::regex_constants::icase ^ std::regex_constants::nosubs) != 0);
-
-    std::regex_constants::syntax_option_type e1 = std::regex_constants::icase;
-    std::regex_constants::syntax_option_type e2 = std::regex_constants::nosubs;
-    e1 = ~e1;
-    e1 = e1 & e2;
-    e1 = e1 | e2;
-    e1 = e1 ^ e2;
-    e1 &= e2;
-    e1 |= e2;
-    e1 ^= e2;
+  assert(std::regex_constants::basic != 0);
+  assert(std::regex_constants::extended != 0);
+  assert(std::regex_constants::awk != 0);
+  assert(std::regex_constants::grep != 0);
+  assert(std::regex_constants::egrep != 0);
+  assert(std::regex_constants::multiline != 0);
+
+  assert((std::regex_constants::icase & std::regex_constants::nosubs) == 0);
+  assert((std::regex_constants::icase & std::regex_constants::optimize) == 0);
+  assert((std::regex_constants::icase & std::regex_constants::collate) == 0);
+  assert((std::regex_constants::icase & std::regex_constants::ECMAScript) == 0);
+  assert((std::regex_constants::icase & std::regex_constants::basic) == 0);
+  assert((std::regex_constants::icase & std::regex_constants::extended) == 0);
+  assert((std::regex_constants::icase & std::regex_constants::awk) == 0);
+  assert((std::regex_constants::icase & std::regex_constants::grep) == 0);
+  assert((std::regex_constants::icase & std::regex_constants::egrep) == 0);
+  assert((std::regex_constants::icase & std::regex_constants::multiline) == 0);
+
+  assert((std::regex_constants::nosubs & std::regex_constants::optimize) == 0);
+  assert((std::regex_constants::nosubs & std::regex_constants::collate) == 0);
+  assert((std::regex_constants::nosubs & std::regex_constants::ECMAScript) == 0);
+  assert((std::regex_constants::nosubs & std::regex_constants::basic) == 0);
+  assert((std::regex_constants::nosubs & std::regex_constants::extended) == 0);
+  assert((std::regex_constants::nosubs & std::regex_constants::awk) == 0);
+  assert((std::regex_constants::nosubs & std::regex_constants::grep) == 0);
+  assert((std::regex_constants::nosubs & std::regex_constants::egrep) == 0);
+  assert((std::regex_constants::nosubs & std::regex_constants::multiline) == 0);
+
+  assert((std::regex_constants::optimize & std::regex_constants::collate) == 0);
+  assert((std::regex_constants::optimize & std::regex_constants::ECMAScript) == 0);
+  assert((std::regex_constants::optimize & std::regex_constants::basic) == 0);
+  assert((std::regex_constants::optimize & std::regex_constants::extended) == 0);
+  assert((std::regex_constants::optimize & std::regex_constants::awk) == 0);
+  assert((std::regex_constants::optimize & std::regex_constants::grep) == 0);
+  assert((std::regex_constants::optimize & std::regex_constants::egrep) == 0);
+  assert((std::regex_constants::optimize & std::regex_constants::multiline) == 0);
+
+  assert((std::regex_constants::collate & std::regex_constants::ECMAScript) == 0);
+  assert((std::regex_constants::collate & std::regex_constants::basic) == 0);
+  assert((std::regex_constants::collate & std::regex_constants::extended) == 0);
+  assert((std::regex_constants::collate & std::regex_constants::awk) == 0);
+  assert((std::regex_constants::collate & std::regex_constants::grep) == 0);
+  assert((std::regex_constants::collate & std::regex_constants::egrep) == 0);
+  assert((std::regex_constants::collate & std::regex_constants::multiline) == 0);
+
+  assert((std::regex_constants::ECMAScript & std::regex_constants::basic) == 0);
+  assert((std::regex_constants::ECMAScript & std::regex_constants::extended) == 0);
+  assert((std::regex_constants::ECMAScript & std::regex_constants::awk) == 0);
+  assert((std::regex_constants::ECMAScript & std::regex_constants::grep) == 0);
+  assert((std::regex_constants::ECMAScript & std::regex_constants::egrep) == 0);
+  assert((std::regex_constants::ECMAScript & std::regex_constants::multiline) == 0);
+
+  assert((std::regex_constants::basic & std::regex_constants::extended) == 0);
+  assert((std::regex_constants::basic & std::regex_constants::awk) == 0);
+  assert((std::regex_constants::basic & std::regex_constants::grep) == 0);
+  assert((std::regex_constants::basic & std::regex_constants::egrep) == 0);
+  assert((std::regex_constants::basic & std::regex_constants::multiline) == 0);
+
+  assert((std::regex_constants::extended & std::regex_constants::awk) == 0);
+  assert((std::regex_constants::extended & std::regex_constants::grep) == 0);
+  assert((std::regex_constants::extended & std::regex_constants::egrep) == 0);
+  assert((std::regex_constants::extended & std::regex_constants::multiline) == 0);
+
+  assert((std::regex_constants::awk & std::regex_constants::grep) == 0);
+  assert((std::regex_constants::awk & std::regex_constants::egrep) == 0);
+  assert((std::regex_constants::awk & std::regex_constants::multiline) == 0);
+
+  assert((std::regex_constants::grep & std::regex_constants::egrep) == 0);
+  assert((std::regex_constants::grep & std::regex_constants::multiline) == 0);
+
+  assert((std::regex_constants::egrep & std::regex_constants::multiline) == 0);
+
+  assert((std::regex_constants::icase | std::regex_constants::nosubs) != 0);
+  assert((std::regex_constants::icase ^ std::regex_constants::nosubs) != 0);
+
+  std::regex_constants::syntax_option_type e1 = std::regex_constants::icase;
+  std::regex_constants::syntax_option_type e2 = std::regex_constants::nosubs;
+
+  e1 = ~e1;
+  e1 = e1 & e2;
+  e1 = e1 | e2;
+  e1 = e1 ^ e2;
+  e1 &= e2;
+  e1 |= e2;
+  e1 ^= e2;
 
   return 0;
 }
diff --git a/libcxx/test/std/re/re.def/defns.regex.collating.element/nothing_to_do.pass.cpp b/libcxx/test/std/re/re.def/defns.regex.collating.element/nothing_to_do.pass.cpp
index 1f764da05d6b5..3e0d2a6570f42 100644
--- a/libcxx/test/std/re/re.def/defns.regex.collating.element/nothing_to_do.pass.cpp
+++ b/libcxx/test/std/re/re.def/defns.regex.collating.element/nothing_to_do.pass.cpp
@@ -6,8 +6,4 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main(int, char**)
-{
-
-  return 0;
-}
+int main(int, char**) { return 0; }
diff --git a/libcxx/test/std/re/re.def/defns.regex.finite.state.machine/nothing_to_do.pass.cpp b/libcxx/test/std/re/re.def/defns.regex.finite.state.machine/nothing_to_do.pass.cpp
index 1f764da05d6b5..3e0d2a6570f42 100644
--- a/libcxx/test/std/re/re.def/defns.regex.finite.state.machine/nothing_to_do.pass.cpp
+++ b/libcxx/test/std/re/re.def/defns.regex.finite.state.machine/nothing_to_do.pass.cpp
@@ -6,8 +6,4 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main(int, char**)
-{
-
-  return 0;
-}
+int main(int, char**) { return 0; }
diff --git a/libcxx/test/std/re/re.def/defns.regex.format.specifier/nothing_to_do.pass.cpp b/libcxx/test/std/re/re.def/defns.regex.format.specifier/nothing_to_do.pass.cpp
index 1f764da05d6b5..3e0d2a6570f42 100644
--- a/libcxx/test/std/re/re.def/defns.regex.format.specifier/nothing_to_do.pass.cpp
+++ b/libcxx/test/std/re/re.def/defns.regex.format.specifier/nothing_to_do.pass.cpp
@@ -6,8 +6,4 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main(int, char**)
-{
-
-  return 0;
-}
+int main(int, char**) { return 0; }
diff --git a/libcxx/test/std/re/re.def/defns.regex.matched/nothing_to_do.pass.cpp b/libcxx/test/std/re/re.def/defns.regex.matched/nothing_to_do.pass.cpp
index 1f764da05d6b5..3e0d2a6570f42 100644
--- a/libcxx/test/std/re/re.def/defns.regex.matched/nothing_to_do.pass.cpp
+++ b/libcxx/test/std/re/re.def/defns.regex.matched/nothing_to_do.pass.cpp
@@ -6,8 +6,4 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main(int, char**)
-{
-
-  return 0;
-}
+int main(int, char**) { return 0; }
diff --git a/libcxx/test/std/re/re.def/defns.regex.primary.equivalence.class/nothing_to_do.pass.cpp b/libcxx/test/std/re/re.def/defns.regex.primary.equivalence.class/nothing_to_do.pass.cpp
index 1f764da05d6b5..3e0d2a6570f42 100644
--- a/libcxx/test/std/re/re.def/defns.regex.primary.equivalence.class/nothing_to_do.pass.cpp
+++ b/libcxx/test/std/re/re.def/defns.regex.primary.equivalence.class/nothing_to_do.pass.cpp
@@ -6,8 +6,4 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main(int, char**)
-{
-
-  return 0;
-}
+int main(int, char**) { return 0; }
diff --git a/libcxx/test/std/re/re.def/defns.regex.regular.expression/nothing_to_do.pass.cpp b/libcxx/test/std/re/re.def/defns.regex.regular.expression/nothing_to_do.pass.cpp
index 1f764da05d6b5..3e0d2a6570f42 100644
--- a/libcxx/test/std/re/re.def/defns.regex.regular.expression/nothing_to_do.pass.cpp
+++ b/libcxx/test/std/re/re.def/defns.regex.regular.expression/nothing_to_do.pass.cpp
@@ -6,8 +6,4 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main(int, char**)
-{
-
-  return 0;
-}
+int main(int, char**) { return 0; }
diff --git a/libcxx/test/std/re/re.def/defns.regex.subexpression/nothing_to_do.pass.cpp b/libcxx/test/std/re/re.def/defns.regex.subexpression/nothing_to_do.pass.cpp
index 1f764da05d6b5..3e0d2a6570f42 100644
--- a/libcxx/test/std/re/re.def/defns.regex.subexpression/nothing_to_do.pass.cpp
+++ b/libcxx/test/std/re/re.def/defns.regex.subexpression/nothing_to_do.pass.cpp
@@ -6,8 +6,4 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main(int, char**)
-{
-
-  return 0;
-}
+int main(int, char**) { return 0; }
diff --git a/libcxx/test/std/re/re.general/nothing_to_do.pass.cpp b/libcxx/test/std/re/re.general/nothing_to_do.pass.cpp
index 1f764da05d6b5..3e0d2a6570f42 100644
--- a/libcxx/test/std/re/re.general/nothing_to_do.pass.cpp
+++ b/libcxx/test/std/re/re.general/nothing_to_do.pass.cpp
@@ -6,8 +6,4 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main(int, char**)
-{
-
-  return 0;
-}
+int main(int, char**) { return 0; }
diff --git a/libcxx/test/std/re/re.grammar/excessive_brace_count.pass.cpp b/libcxx/test/std/re/re.grammar/excessive_brace_count.pass.cpp
index 6ed2645be89b5..1da1921425671 100644
--- a/libcxx/test/std/re/re.grammar/excessive_brace_count.pass.cpp
+++ b/libcxx/test/std/re/re.grammar/excessive_brace_count.pass.cpp
@@ -17,22 +17,20 @@
 #include "test_macros.h"
 
 int main(int, char**) {
-  for (std::regex_constants::syntax_option_type op :
-       {std::regex::basic, std::regex::grep}) {
+  for (std::regex_constants::syntax_option_type op : {std::regex::basic, std::regex::grep}) {
     try {
       TEST_IGNORE_NODISCARD std::regex("a\\{100000000000000000\\}", op);
       assert(false);
-    } catch (const std::regex_error &e) {
+    } catch (const std::regex_error& e) {
       assert(e.code() == std::regex_constants::error_badbrace);
     }
   }
   for (std::regex_constants::syntax_option_type op :
-       {std::regex::ECMAScript, std::regex::extended, std::regex::egrep,
-        std::regex::awk}) {
+       {std::regex::ECMAScript, std::regex::extended, std::regex::egrep, std::regex::awk}) {
     try {
       TEST_IGNORE_NODISCARD std::regex("a{100000000000000000}", op);
       assert(false);
-    } catch (const std::regex_error &e) {
+    } catch (const std::regex_error& e) {
       assert(e.code() == std::regex_constants::error_badbrace);
     }
   }
diff --git a/libcxx/test/std/re/re.grammar/excessive_brace_min_max.pass.cpp b/libcxx/test/std/re/re.grammar/excessive_brace_min_max.pass.cpp
index d8f0502e67c9f..7b7182a9e6738 100644
--- a/libcxx/test/std/re/re.grammar/excessive_brace_min_max.pass.cpp
+++ b/libcxx/test/std/re/re.grammar/excessive_brace_min_max.pass.cpp
@@ -19,46 +19,42 @@
 
 int main(int, char**) {
   // test that `n <= m`
-  for (std::regex_constants::syntax_option_type op :
-       {std::regex::basic}) {
+  for (std::regex_constants::syntax_option_type op : {std::regex::basic}) {
     try {
       TEST_IGNORE_NODISCARD std::regex("a\\{3,2\\}", op);
       assert(false);
-    } catch (const std::regex_error &e) {
+    } catch (const std::regex_error& e) {
       assert(e.code() == std::regex_constants::error_badbrace);
       LIBCPP_ASSERT(e.code() == std::regex_constants::error_badbrace);
     }
   }
   for (std::regex_constants::syntax_option_type op :
-       {std::regex::ECMAScript, std::regex::extended, std::regex::egrep,
-        std::regex::awk}) {
+       {std::regex::ECMAScript, std::regex::extended, std::regex::egrep, std::regex::awk}) {
     try {
       TEST_IGNORE_NODISCARD std::regex("a{3,2}", op);
       assert(false);
-    } catch (const std::regex_error &e) {
+    } catch (const std::regex_error& e) {
       assert(e.code() == std::regex_constants::error_badbrace);
       LIBCPP_ASSERT(e.code() == std::regex_constants::error_badbrace);
     }
   }
 
   // test that both bounds are within the limit
-  for (std::regex_constants::syntax_option_type op :
-       {std::regex::basic}) {
+  for (std::regex_constants::syntax_option_type op : {std::regex::basic}) {
     try {
       TEST_IGNORE_NODISCARD std::regex("a\\{100000000000000000000,10000000000000000000\\}", op);
       assert(false);
-    } catch (const std::regex_error &e) {
+    } catch (const std::regex_error& e) {
       assert(e.code() == std::regex_constants::error_badbrace);
       LIBCPP_ASSERT(e.code() == std::regex_constants::error_badbrace);
     }
   }
   for (std::regex_constants::syntax_option_type op :
-       {std::regex::ECMAScript, std::regex::extended, std::regex::egrep,
-        std::regex::awk}) {
+       {std::regex::ECMAScript, std::regex::extended, std::regex::egrep, std::regex::awk}) {
     try {
       TEST_IGNORE_NODISCARD std::regex("a{100000000000000000000,10000000000000000000}", op);
       assert(false);
-    } catch (const std::regex_error &e) {
+    } catch (const std::regex_error& e) {
       assert(e.code() == std::regex_constants::error_badbrace);
       LIBCPP_ASSERT(e.code() == std::regex_constants::error_badbrace);
     }
diff --git a/libcxx/test/std/re/re.iter/re.regiter/re.regiter.cnstr/cnstr.compile.fail.cpp b/libcxx/test/std/re/re.iter/re.regiter/re.regiter.cnstr/cnstr.compile.fail.cpp
index 34d1ce6ed8e6d..1533c1bf69f37 100644
--- a/libcxx/test/std/re/re.iter/re.regiter/re.regiter.cnstr/cnstr.compile.fail.cpp
+++ b/libcxx/test/std/re/re.iter/re.regiter/re.regiter.cnstr/cnstr.compile.fail.cpp
@@ -21,17 +21,14 @@
 #include "test_macros.h"
 
 #if TEST_STD_VER < 14
-#error
+#  error
 #endif
 
-int main(int, char**)
-{
-    {
-        const char phone_book[] = "555-1234, 555-2345, 555-3456";
-        std::cregex_iterator i(
-            std::begin(phone_book), std::end(phone_book),
-            std::regex("\\d{3}-\\d{4}"));
-    }
+int main(int, char**) {
+  {
+    const char phone_book[] = "555-1234, 555-2345, 555-3456";
+    std::cregex_iterator i(std::begin(phone_book), std::end(phone_book), std::regex("\\d{3}-\\d{4}"));
+  }
 
   return 0;
 }
diff --git a/libcxx/test/std/re/re.iter/re.regiter/re.regiter.cnstr/cnstr.pass.cpp b/libcxx/test/std/re/re.iter/re.regiter/re.regiter.cnstr/cnstr.pass.cpp
index a6d1059745105..ef3fb0dd08646 100644
--- a/libcxx/test/std/re/re.iter/re.regiter/re.regiter.cnstr/cnstr.pass.cpp
+++ b/libcxx/test/std/re/re.iter/re.regiter/re.regiter.cnstr/cnstr.pass.cpp
@@ -18,29 +18,28 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    {
-        std::regex phone_numbers("\\d{3}-\\d{4}");
-        const char phone_book[] = "555-1234, 555-2345, 555-3456";
-        std::cregex_iterator i(std::begin(phone_book), std::end(phone_book), phone_numbers);
-        assert(i != std::cregex_iterator());
-        assert(i->size() == 1);
-        assert(i->position() == 0);
-        assert(i->str() == "555-1234");
-        ++i;
-        assert(i != std::cregex_iterator());
-        assert(i->size() == 1);
-        assert(i->position() == 10);
-        assert(i->str() == "555-2345");
-        ++i;
-        assert(i != std::cregex_iterator());
-        assert(i->size() == 1);
-        assert(i->position() == 20);
-        assert(i->str() == "555-3456");
-        ++i;
-        assert(i == std::cregex_iterator());
-    }
+int main(int, char**) {
+  {
+    std::regex phone_numbers("\\d{3}-\\d{4}");
+    const char phone_book[] = "555-1234, 555-2345, 555-3456";
+    std::cregex_iterator i(std::begin(phone_book), std::end(phone_book), phone_numbers);
+    assert(i != std::cregex_iterator());
+    assert(i->size() == 1);
+    assert(i->position() == 0);
+    assert(i->str() == "555-1234");
+    ++i;
+    assert(i != std::cregex_iterator());
+    assert(i->size() == 1);
+    assert(i->position() == 10);
+    assert(i->str() == "555-2345");
+    ++i;
+    assert(i != std::cregex_iterator());
+    assert(i->size() == 1);
+    assert(i->position() == 20);
+    assert(i->str() == "555-3456");
+    ++i;
+    assert(i == std::cregex_iterator());
+  }
 
   return 0;
 }
diff --git a/libcxx/test/std/re/re.iter/re.regiter/re.regiter.cnstr/default.pass.cpp b/libcxx/test/std/re/re.iter/re.regiter/re.regiter.cnstr/default.pass.cpp
index 52b33097ae9b9..52be11c96ca8f 100644
--- a/libcxx/test/std/re/re.iter/re.regiter/re.regiter.cnstr/default.pass.cpp
+++ b/libcxx/test/std/re/re.iter/re.regiter/re.regiter.cnstr/default.pass.cpp
@@ -17,19 +17,16 @@
 #include "test_macros.h"
 
 template <class CharT>
-void
-test()
-{
-    typedef std::regex_iterator<const CharT*> I;
-    I i1;
-    assert(i1 == I());
+void test() {
+  typedef std::regex_iterator<const CharT*> I;
+  I i1;
+  assert(i1 == I());
 }
 
-int main(int, char**)
-{
-    test<char>();
+int main(int, char**) {
+  test<char>();
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-    test<wchar_t>();
+  test<wchar_t>();
 #endif
 
   return 0;
diff --git a/libcxx/test/std/re/re.iter/re.regiter/re.regiter.comp/tested_elsewhere.pass.cpp b/libcxx/test/std/re/re.iter/re.regiter/re.regiter.comp/tested_elsewhere.pass.cpp
index 80f6aa3c75051..5b5b12c15a4d5 100644
--- a/libcxx/test/std/re/re.iter/re.regiter/re.regiter.comp/tested_elsewhere.pass.cpp
+++ b/libcxx/test/std/re/re.iter/re.regiter/re.regiter.comp/tested_elsewhere.pass.cpp
@@ -13,8 +13,4 @@
 // bool operator==(const regex_iterator& right) const;
 // bool operator!=(const regex_iterator& right) const; // generated by the compiler in C++20
 
-int main(int, char**)
-{
-
-  return 0;
-}
+int main(int, char**) { return 0; }
diff --git a/libcxx/test/std/re/re.iter/re.regiter/re.regiter.deref/deref.pass.cpp b/libcxx/test/std/re/re.iter/re.regiter/re.regiter.deref/deref.pass.cpp
index 11b12b2eef8c4..b9c6dfa8a6286 100644
--- a/libcxx/test/std/re/re.iter/re.regiter/re.regiter.deref/deref.pass.cpp
+++ b/libcxx/test/std/re/re.iter/re.regiter/re.regiter.deref/deref.pass.cpp
@@ -16,29 +16,28 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    {
-        std::regex phone_numbers("\\d{3}-\\d{4}");
-        const char phone_book[] = "555-1234, 555-2345, 555-3456";
-        std::cregex_iterator i(std::begin(phone_book), std::end(phone_book), phone_numbers);
-        assert(i != std::cregex_iterator());
-        assert((*i).size() == 1);
-        assert((*i).position() == 0);
-        assert((*i).str() == "555-1234");
-        ++i;
-        assert(i != std::cregex_iterator());
-        assert((*i).size() == 1);
-        assert((*i).position() == 10);
-        assert((*i).str() == "555-2345");
-        ++i;
-        assert(i != std::cregex_iterator());
-        assert((*i).size() == 1);
-        assert((*i).position() == 20);
-        assert((*i).str() == "555-3456");
-        ++i;
-        assert(i == std::cregex_iterator());
-    }
+int main(int, char**) {
+  {
+    std::regex phone_numbers("\\d{3}-\\d{4}");
+    const char phone_book[] = "555-1234, 555-2345, 555-3456";
+    std::cregex_iterator i(std::begin(phone_book), std::end(phone_book), phone_numbers);
+    assert(i != std::cregex_iterator());
+    assert((*i).size() == 1);
+    assert((*i).position() == 0);
+    assert((*i).str() == "555-1234");
+    ++i;
+    assert(i != std::cregex_iterator());
+    assert((*i).size() == 1);
+    assert((*i).position() == 10);
+    assert((*i).str() == "555-2345");
+    ++i;
+    assert(i != std::cregex_iterator());
+    assert((*i).size() == 1);
+    assert((*i).position() == 20);
+    assert((*i).str() == "555-3456");
+    ++i;
+    assert(i == std::cregex_iterator());
+  }
 
   return 0;
 }
diff --git a/libcxx/test/std/re/re.iter/re.regiter/types.pass.cpp b/libcxx/test/std/re/re.iter/re.regiter/types.pass.cpp
index 8ee2c5006d31c..9cb1c0fda2511 100644
--- a/libcxx/test/std/re/re.iter/re.regiter/types.pass.cpp
+++ b/libcxx/test/std/re/re.iter/re.regiter/types.pass.cpp
@@ -27,26 +27,23 @@
 #include "test_macros.h"
 
 template <class CharT>
-void
-test()
-{
-    typedef std::regex_iterator<const CharT*> I;
-    static_assert((std::is_same<typename I::regex_type, std::basic_regex<CharT> >::value), "");
-    static_assert((std::is_same<typename I::value_type, std::match_results<const CharT*> >::value), "");
-    static_assert((std::is_same<typename I::difference_type, std::ptrdiff_t>::value), "");
-    static_assert((std::is_same<typename I::pointer, const std::match_results<const CharT*>*>::value), "");
-    static_assert((std::is_same<typename I::reference, const std::match_results<const CharT*>&>::value), "");
-    static_assert((std::is_same<typename I::iterator_category, std::forward_iterator_tag>::value), "");
+void test() {
+  typedef std::regex_iterator<const CharT*> I;
+  static_assert((std::is_same<typename I::regex_type, std::basic_regex<CharT> >::value), "");
+  static_assert((std::is_same<typename I::value_type, std::match_results<const CharT*> >::value), "");
+  static_assert((std::is_same<typename I::difference_type, std::ptrdiff_t>::value), "");
+  static_assert((std::is_same<typename I::pointer, const std::match_results<const CharT*>*>::value), "");
+  static_assert((std::is_same<typename I::reference, const std::match_results<const CharT*>&>::value), "");
+  static_assert((std::is_same<typename I::iterator_category, std::forward_iterator_tag>::value), "");
 #if TEST_STD_VER >= 20
-    static_assert(std::is_same_v<typename I::iterator_concept, std::input_iterator_tag>);
+  static_assert(std::is_same_v<typename I::iterator_concept, std::input_iterator_tag>);
 #endif
 }
 
-int main(int, char**)
-{
-    test<char>();
+int main(int, char**) {
+  test<char>();
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-    test<wchar_t>();
+  test<wchar_t>();
 #endif
 
   return 0;
diff --git a/libcxx/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/array.compile.fail.cpp b/libcxx/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/array.compile.fail.cpp
index a03fd52c03562..0dd7518f2eb48 100644
--- a/libcxx/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/array.compile.fail.cpp
+++ b/libcxx/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/array.compile.fail.cpp
@@ -23,18 +23,17 @@
 #include "test_macros.h"
 
 #if TEST_STD_VER < 14
-#error
+#  error
 #endif
 
-int main(int, char**)
-{
-    {
-        std::regex phone_numbers("\\d{3}-(\\d{4})");
-        const char phone_book[] = "start 555-1234, 555-2345, 555-3456 end";
-        const int indices[] = {-1, 0, 1};
-        std::cregex_token_iterator i(std::begin(phone_book), std::end(phone_book)-1,
-                                     std::regex("\\d{3}-\\d{4}"), indices);
-    }
+int main(int, char**) {
+  {
+    std::regex phone_numbers("\\d{3}-(\\d{4})");
+    const char phone_book[] = "start 555-1234, 555-2345, 555-3456 end";
+    const int indices[]     = {-1, 0, 1};
+    std::cregex_token_iterator i(
+        std::begin(phone_book), std::end(phone_book) - 1, std::regex("\\d{3}-\\d{4}"), indices);
+  }
 
   return 0;
 }
diff --git a/libcxx/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/array.pass.cpp b/libcxx/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/array.pass.cpp
index ed1d5ee963389..0bba3460ecf55 100644
--- a/libcxx/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/array.pass.cpp
+++ b/libcxx/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/array.pass.cpp
@@ -23,46 +23,44 @@
 
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    {
-        std::regex phone_numbers("\\d{3}-(\\d{4})");
-        const char phone_book[] = "start 555-1234, 555-2345, 555-3456 end";
-        const int indices[] = {-1, 0, 1};
-        std::cregex_token_iterator i(std::begin(phone_book), std::end(phone_book)-1,
-                                     phone_numbers, indices);
-        assert(i != std::cregex_token_iterator());
-        assert(i->str() == "start ");
-        ++i;
-        assert(i != std::cregex_token_iterator());
-        assert(i->str() == "555-1234");
-        ++i;
-        assert(i != std::cregex_token_iterator());
-        assert(i->str() == "1234");
-        ++i;
-        assert(i != std::cregex_token_iterator());
-        assert(i->str() == ", ");
-        ++i;
-        assert(i != std::cregex_token_iterator());
-        assert(i->str() == "555-2345");
-        ++i;
-        assert(i != std::cregex_token_iterator());
-        assert(i->str() == "2345");
-        ++i;
-        assert(i != std::cregex_token_iterator());
-        assert(i->str() == ", ");
-        ++i;
-        assert(i != std::cregex_token_iterator());
-        assert(i->str() == "555-3456");
-        ++i;
-        assert(i != std::cregex_token_iterator());
-        assert(i->str() == "3456");
-        ++i;
-        assert(i != std::cregex_token_iterator());
-        assert(i->str() == " end");
-        ++i;
-        assert(i == std::cregex_token_iterator());
-    }
+int main(int, char**) {
+  {
+    std::regex phone_numbers("\\d{3}-(\\d{4})");
+    const char phone_book[] = "start 555-1234, 555-2345, 555-3456 end";
+    const int indices[]     = {-1, 0, 1};
+    std::cregex_token_iterator i(std::begin(phone_book), std::end(phone_book) - 1, phone_numbers, indices);
+    assert(i != std::cregex_token_iterator());
+    assert(i->str() == "start ");
+    ++i;
+    assert(i != std::cregex_token_iterator());
+    assert(i->str() == "555-1234");
+    ++i;
+    assert(i != std::cregex_token_iterator());
+    assert(i->str() == "1234");
+    ++i;
+    assert(i != std::cregex_token_iterator());
+    assert(i->str() == ", ");
+    ++i;
+    assert(i != std::cregex_token_iterator());
+    assert(i->str() == "555-2345");
+    ++i;
+    assert(i != std::cregex_token_iterator());
+    assert(i->str() == "2345");
+    ++i;
+    assert(i != std::cregex_token_iterator());
+    assert(i->str() == ", ");
+    ++i;
+    assert(i != std::cregex_token_iterator());
+    assert(i->str() == "555-3456");
+    ++i;
+    assert(i != std::cregex_token_iterator());
+    assert(i->str() == "3456");
+    ++i;
+    assert(i != std::cregex_token_iterator());
+    assert(i->str() == " end");
+    ++i;
+    assert(i == std::cregex_token_iterator());
+  }
 
   return 0;
 }
diff --git a/libcxx/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/default.pass.cpp b/libcxx/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/default.pass.cpp
index 4a028fce54b3f..3e21fc61b7f5b 100644
--- a/libcxx/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/default.pass.cpp
+++ b/libcxx/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/default.pass.cpp
@@ -17,20 +17,17 @@
 #include "test_macros.h"
 
 template <class CharT>
-void
-test()
-{
-    typedef std::regex_token_iterator<const CharT*> I;
-    I i1;
-    assert(i1 == I());
+void test() {
+  typedef std::regex_token_iterator<const CharT*> I;
+  I i1;
+  assert(i1 == I());
 }
 
-int main(int, char**)
-{
-    test<char>();
+int main(int, char**) {
+  test<char>();
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-    test<wchar_t>();
+  test<wchar_t>();
 #endif
 
-    return 0;
+  return 0;
 }
diff --git a/libcxx/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/init.compile.fail.cpp b/libcxx/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/init.compile.fail.cpp
index b6913e6b32d12..c4d34bfc2158f 100644
--- a/libcxx/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/init.compile.fail.cpp
+++ b/libcxx/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/init.compile.fail.cpp
@@ -21,17 +21,16 @@
 #include "test_macros.h"
 
 #if TEST_STD_VER < 14
-#error
+#  error
 #endif
 
-int main(int, char**)
-{
-    {
-        std::regex phone_numbers("\\d{3}-(\\d{4})");
-        const char phone_book[] = "start 555-1234, 555-2345, 555-3456 end";
-        std::cregex_token_iterator i(std::begin(phone_book), std::end(phone_book)-1,
-                                      std::regex("\\d{3}-\\d{4}"), {-1, 0, 1});
-    }
+int main(int, char**) {
+  {
+    std::regex phone_numbers("\\d{3}-(\\d{4})");
+    const char phone_book[] = "start 555-1234, 555-2345, 555-3456 end";
+    std::cregex_token_iterator i(
+        std::begin(phone_book), std::end(phone_book) - 1, std::regex("\\d{3}-\\d{4}"), {-1, 0, 1});
+  }
 
   return 0;
 }
diff --git a/libcxx/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/init.pass.cpp b/libcxx/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/init.pass.cpp
index 2f9f6360a8b8e..73a2ad3ce8621 100644
--- a/libcxx/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/init.pass.cpp
+++ b/libcxx/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/init.pass.cpp
@@ -26,45 +26,43 @@
 
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    {
-        std::regex phone_numbers("\\d{3}-(\\d{4})");
-        const char phone_book[] = "start 555-1234, 555-2345, 555-3456 end";
-        std::cregex_token_iterator i(std::begin(phone_book), std::end(phone_book)-1,
-                                     phone_numbers, {-1, 0, 1});
-        assert(i != std::cregex_token_iterator());
-        assert(i->str() == "start ");
-        ++i;
-        assert(i != std::cregex_token_iterator());
-        assert(i->str() == "555-1234");
-        ++i;
-        assert(i != std::cregex_token_iterator());
-        assert(i->str() == "1234");
-        ++i;
-        assert(i != std::cregex_token_iterator());
-        assert(i->str() == ", ");
-        ++i;
-        assert(i != std::cregex_token_iterator());
-        assert(i->str() == "555-2345");
-        ++i;
-        assert(i != std::cregex_token_iterator());
-        assert(i->str() == "2345");
-        ++i;
-        assert(i != std::cregex_token_iterator());
-        assert(i->str() == ", ");
-        ++i;
-        assert(i != std::cregex_token_iterator());
-        assert(i->str() == "555-3456");
-        ++i;
-        assert(i != std::cregex_token_iterator());
-        assert(i->str() == "3456");
-        ++i;
-        assert(i != std::cregex_token_iterator());
-        assert(i->str() == " end");
-        ++i;
-        assert(i == std::cregex_token_iterator());
-    }
+int main(int, char**) {
+  {
+    std::regex phone_numbers("\\d{3}-(\\d{4})");
+    const char phone_book[] = "start 555-1234, 555-2345, 555-3456 end";
+    std::cregex_token_iterator i(std::begin(phone_book), std::end(phone_book) - 1, phone_numbers, {-1, 0, 1});
+    assert(i != std::cregex_token_iterator());
+    assert(i->str() == "start ");
+    ++i;
+    assert(i != std::cregex_token_iterator());
+    assert(i->str() == "555-1234");
+    ++i;
+    assert(i != std::cregex_token_iterator());
+    assert(i->str() == "1234");
+    ++i;
+    assert(i != std::cregex_token_iterator());
+    assert(i->str() == ", ");
+    ++i;
+    assert(i != std::cregex_token_iterator());
+    assert(i->str() == "555-2345");
+    ++i;
+    assert(i != std::cregex_token_iterator());
+    assert(i->str() == "2345");
+    ++i;
+    assert(i != std::cregex_token_iterator());
+    assert(i->str() == ", ");
+    ++i;
+    assert(i != std::cregex_token_iterator());
+    assert(i->str() == "555-3456");
+    ++i;
+    assert(i != std::cregex_token_iterator());
+    assert(i->str() == "3456");
+    ++i;
+    assert(i != std::cregex_token_iterator());
+    assert(i->str() == " end");
+    ++i;
+    assert(i == std::cregex_token_iterator());
+  }
 
   return 0;
 }
diff --git a/libcxx/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/int.compile.fail.cpp b/libcxx/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/int.compile.fail.cpp
index 3c39d4983e26c..2231c2ea1085f 100644
--- a/libcxx/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/int.compile.fail.cpp
+++ b/libcxx/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/int.compile.fail.cpp
@@ -20,17 +20,15 @@
 #include "test_macros.h"
 
 #if TEST_STD_VER < 14
-#error
+#  error
 #endif
 
-int main(int, char**)
-{
-    {
-        std::regex phone_numbers("\\d{3}-\\d{4}");
-        const char phone_book[] = "start 555-1234, 555-2345, 555-3456 end";
-        std::cregex_token_iterator i(std::begin(phone_book), std::end(phone_book)-1,
-                                     std::regex("\\d{3}-\\d{4}"), -1);
-    }
+int main(int, char**) {
+  {
+    std::regex phone_numbers("\\d{3}-\\d{4}");
+    const char phone_book[] = "start 555-1234, 555-2345, 555-3456 end";
+    std::cregex_token_iterator i(std::begin(phone_book), std::end(phone_book) - 1, std::regex("\\d{3}-\\d{4}"), -1);
+  }
 
   return 0;
 }
diff --git a/libcxx/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/int.pass.cpp b/libcxx/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/int.pass.cpp
index 2abed8e827cd9..ff4bfea84af5e 100644
--- a/libcxx/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/int.pass.cpp
+++ b/libcxx/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/int.pass.cpp
@@ -21,59 +21,55 @@
 
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    {
-        std::regex phone_numbers("\\d{3}-\\d{4}");
-        const char phone_book[] = "start 555-1234, 555-2345, 555-3456 end";
-        std::cregex_token_iterator i(std::begin(phone_book), std::end(phone_book)-1,
-                                     phone_numbers, -1);
-        assert(i != std::cregex_token_iterator());
-        assert(i->str() == "start ");
-        ++i;
-        assert(i != std::cregex_token_iterator());
-        assert(i->str() == ", ");
-        ++i;
-        assert(i != std::cregex_token_iterator());
-        assert(i->str() == ", ");
-        ++i;
-        assert(i != std::cregex_token_iterator());
-        assert(i->str() == " end");
-        ++i;
-        assert(i == std::cregex_token_iterator());
-    }
-    {
-        std::regex phone_numbers("\\d{3}-\\d{4}");
-        const char phone_book[] = "start 555-1234, 555-2345, 555-3456 end";
-        std::cregex_token_iterator i(std::begin(phone_book), std::end(phone_book)-1,
-                                     phone_numbers);
-        assert(i != std::cregex_token_iterator());
-        assert(i->str() == "555-1234");
-        ++i;
-        assert(i != std::cregex_token_iterator());
-        assert(i->str() == "555-2345");
-        ++i;
-        assert(i != std::cregex_token_iterator());
-        assert(i->str() == "555-3456");
-        ++i;
-        assert(i == std::cregex_token_iterator());
-    }
-    {
-        std::regex phone_numbers("\\d{3}-(\\d{4})");
-        const char phone_book[] = "start 555-1234, 555-2345, 555-3456 end";
-        std::cregex_token_iterator i(std::begin(phone_book), std::end(phone_book)-1,
-                                     phone_numbers, 1);
-        assert(i != std::cregex_token_iterator());
-        assert(i->str() == "1234");
-        ++i;
-        assert(i != std::cregex_token_iterator());
-        assert(i->str() == "2345");
-        ++i;
-        assert(i != std::cregex_token_iterator());
-        assert(i->str() == "3456");
-        ++i;
-        assert(i == std::cregex_token_iterator());
-    }
+int main(int, char**) {
+  {
+    std::regex phone_numbers("\\d{3}-\\d{4}");
+    const char phone_book[] = "start 555-1234, 555-2345, 555-3456 end";
+    std::cregex_token_iterator i(std::begin(phone_book), std::end(phone_book) - 1, phone_numbers, -1);
+    assert(i != std::cregex_token_iterator());
+    assert(i->str() == "start ");
+    ++i;
+    assert(i != std::cregex_token_iterator());
+    assert(i->str() == ", ");
+    ++i;
+    assert(i != std::cregex_token_iterator());
+    assert(i->str() == ", ");
+    ++i;
+    assert(i != std::cregex_token_iterator());
+    assert(i->str() == " end");
+    ++i;
+    assert(i == std::cregex_token_iterator());
+  }
+  {
+    std::regex phone_numbers("\\d{3}-\\d{4}");
+    const char phone_book[] = "start 555-1234, 555-2345, 555-3456 end";
+    std::cregex_token_iterator i(std::begin(phone_book), std::end(phone_book) - 1, phone_numbers);
+    assert(i != std::cregex_token_iterator());
+    assert(i->str() == "555-1234");
+    ++i;
+    assert(i != std::cregex_token_iterator());
+    assert(i->str() == "555-2345");
+    ++i;
+    assert(i != std::cregex_token_iterator());
+    assert(i->str() == "555-3456");
+    ++i;
+    assert(i == std::cregex_token_iterator());
+  }
+  {
+    std::regex phone_numbers("\\d{3}-(\\d{4})");
+    const char phone_book[] = "start 555-1234, 555-2345, 555-3456 end";
+    std::cregex_token_iterator i(std::begin(phone_book), std::end(phone_book) - 1, phone_numbers, 1);
+    assert(i != std::cregex_token_iterator());
+    assert(i->str() == "1234");
+    ++i;
+    assert(i != std::cregex_token_iterator());
+    assert(i->str() == "2345");
+    ++i;
+    assert(i != std::cregex_token_iterator());
+    assert(i->str() == "3456");
+    ++i;
+    assert(i == std::cregex_token_iterator());
+  }
 
   return 0;
 }
diff --git a/libcxx/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/vector.compile.fail.cpp b/libcxx/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/vector.compile.fail.cpp
index 9b07df9d1a783..8988051ae5445 100644
--- a/libcxx/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/vector.compile.fail.cpp
+++ b/libcxx/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/vector.compile.fail.cpp
@@ -22,20 +22,18 @@
 #include "test_macros.h"
 
 #if TEST_STD_VER < 14
-#error
+#  error
 #endif
 
-int main(int, char**)
-{
-    {
-         std::regex phone_numbers("\\d{3}-(\\d{4})");
-        const char phone_book[] = "start 555-1234, 555-2345, 555-3456 end";
-        std::vector<int> v;
-        v.push_back(-1);
-        v.push_back(-1);
-        std::cregex_token_iterator i(std::begin(phone_book), std::end(phone_book)-1,
-                                     std::regex("\\d{3}-\\d{4}"), v);
-    }
+int main(int, char**) {
+  {
+    std::regex phone_numbers("\\d{3}-(\\d{4})");
+    const char phone_book[] = "start 555-1234, 555-2345, 555-3456 end";
+    std::vector<int> v;
+    v.push_back(-1);
+    v.push_back(-1);
+    std::cregex_token_iterator i(std::begin(phone_book), std::end(phone_book) - 1, std::regex("\\d{3}-\\d{4}"), v);
+  }
 
   return 0;
 }
diff --git a/libcxx/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/vector.pass.cpp b/libcxx/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/vector.pass.cpp
index b2ef0b23e528e..1af18ffe84120 100644
--- a/libcxx/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/vector.pass.cpp
+++ b/libcxx/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/vector.pass.cpp
@@ -22,111 +22,107 @@
 
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    {
-        std::regex phone_numbers("\\d{3}-(\\d{4})");
-        const char phone_book[] = "start 555-1234, 555-2345, 555-3456 end";
-        std::vector<int> v;
-        v.push_back(-1);
-        v.push_back(-1);
-        std::cregex_token_iterator i(std::begin(phone_book), std::end(phone_book)-1,
-                                     phone_numbers, v);
-        assert(i != std::cregex_token_iterator());
-        assert(i->str() == "start ");
-        ++i;
-        assert(i != std::cregex_token_iterator());
-        assert(i->str() == "start ");
-        ++i;
-        assert(i != std::cregex_token_iterator());
-        assert(i->str() == ", ");
-        ++i;
-        assert(i != std::cregex_token_iterator());
-        assert(i->str() == ", ");
-        ++i;
-        assert(i != std::cregex_token_iterator());
-        assert(i->str() == ", ");
-        ++i;
-        assert(i != std::cregex_token_iterator());
-        assert(i->str() == ", ");
-        ++i;
-        assert(i != std::cregex_token_iterator());
-        assert(i->str() == " end");
-        ++i;
-        assert(i == std::cregex_token_iterator());
-    }
-    {
-        std::regex phone_numbers("\\d{3}-(\\d{4})");
-        const char phone_book[] = "start 555-1234, 555-2345, 555-3456 end";
-        std::vector<int> v;
-        v.push_back(-1);
-        v.push_back(0);
-        std::cregex_token_iterator i(std::begin(phone_book), std::end(phone_book)-1,
-                                     phone_numbers, v);
-        assert(i != std::cregex_token_iterator());
-        assert(i->str() == "start ");
-        ++i;
-        assert(i != std::cregex_token_iterator());
-        assert(i->str() == "555-1234");
-        ++i;
-        assert(i != std::cregex_token_iterator());
-        assert(i->str() == ", ");
-        ++i;
-        assert(i != std::cregex_token_iterator());
-        assert(i->str() == "555-2345");
-        ++i;
-        assert(i != std::cregex_token_iterator());
-        assert(i->str() == ", ");
-        ++i;
-        assert(i != std::cregex_token_iterator());
-        assert(i->str() == "555-3456");
-        ++i;
-        assert(i != std::cregex_token_iterator());
-        assert(i->str() == " end");
-        ++i;
-        assert(i == std::cregex_token_iterator());
-    }
-    {
-        std::regex phone_numbers("\\d{3}-(\\d{4})");
-        const char phone_book[] = "start 555-1234, 555-2345, 555-3456 end";
-        std::vector<int> v;
-        v.push_back(-1);
-        v.push_back(0);
-        v.push_back(1);
-        std::cregex_token_iterator i(std::begin(phone_book), std::end(phone_book)-1,
-                                     phone_numbers, v);
-        assert(i != std::cregex_token_iterator());
-        assert(i->str() == "start ");
-        ++i;
-        assert(i != std::cregex_token_iterator());
-        assert(i->str() == "555-1234");
-        ++i;
-        assert(i != std::cregex_token_iterator());
-        assert(i->str() == "1234");
-        ++i;
-        assert(i != std::cregex_token_iterator());
-        assert(i->str() == ", ");
-        ++i;
-        assert(i != std::cregex_token_iterator());
-        assert(i->str() == "555-2345");
-        ++i;
-        assert(i != std::cregex_token_iterator());
-        assert(i->str() == "2345");
-        ++i;
-        assert(i != std::cregex_token_iterator());
-        assert(i->str() == ", ");
-        ++i;
-        assert(i != std::cregex_token_iterator());
-        assert(i->str() == "555-3456");
-        ++i;
-        assert(i != std::cregex_token_iterator());
-        assert(i->str() == "3456");
-        ++i;
-        assert(i != std::cregex_token_iterator());
-        assert(i->str() == " end");
-        ++i;
-        assert(i == std::cregex_token_iterator());
-    }
+int main(int, char**) {
+  {
+    std::regex phone_numbers("\\d{3}-(\\d{4})");
+    const char phone_book[] = "start 555-1234, 555-2345, 555-3456 end";
+    std::vector<int> v;
+    v.push_back(-1);
+    v.push_back(-1);
+    std::cregex_token_iterator i(std::begin(phone_book), std::end(phone_book) - 1, phone_numbers, v);
+    assert(i != std::cregex_token_iterator());
+    assert(i->str() == "start ");
+    ++i;
+    assert(i != std::cregex_token_iterator());
+    assert(i->str() == "start ");
+    ++i;
+    assert(i != std::cregex_token_iterator());
+    assert(i->str() == ", ");
+    ++i;
+    assert(i != std::cregex_token_iterator());
+    assert(i->str() == ", ");
+    ++i;
+    assert(i != std::cregex_token_iterator());
+    assert(i->str() == ", ");
+    ++i;
+    assert(i != std::cregex_token_iterator());
+    assert(i->str() == ", ");
+    ++i;
+    assert(i != std::cregex_token_iterator());
+    assert(i->str() == " end");
+    ++i;
+    assert(i == std::cregex_token_iterator());
+  }
+  {
+    std::regex phone_numbers("\\d{3}-(\\d{4})");
+    const char phone_book[] = "start 555-1234, 555-2345, 555-3456 end";
+    std::vector<int> v;
+    v.push_back(-1);
+    v.push_back(0);
+    std::cregex_token_iterator i(std::begin(phone_book), std::end(phone_book) - 1, phone_numbers, v);
+    assert(i != std::cregex_token_iterator());
+    assert(i->str() == "start ");
+    ++i;
+    assert(i != std::cregex_token_iterator());
+    assert(i->str() == "555-1234");
+    ++i;
+    assert(i != std::cregex_token_iterator());
+    assert(i->str() == ", ");
+    ++i;
+    assert(i != std::cregex_token_iterator());
+    assert(i->str() == "555-2345");
+    ++i;
+    assert(i != std::cregex_token_iterator());
+    assert(i->str() == ", ");
+    ++i;
+    assert(i != std::cregex_token_iterator());
+    assert(i->str() == "555-3456");
+    ++i;
+    assert(i != std::cregex_token_iterator());
+    assert(i->str() == " end");
+    ++i;
+    assert(i == std::cregex_token_iterator());
+  }
+  {
+    std::regex phone_numbers("\\d{3}-(\\d{4})");
+    const char phone_book[] = "start 555-1234, 555-2345, 555-3456 end";
+    std::vector<int> v;
+    v.push_back(-1);
+    v.push_back(0);
+    v.push_back(1);
+    std::cregex_token_iterator i(std::begin(phone_book), std::end(phone_book) - 1, phone_numbers, v);
+    assert(i != std::cregex_token_iterator());
+    assert(i->str() == "start ");
+    ++i;
+    assert(i != std::cregex_token_iterator());
+    assert(i->str() == "555-1234");
+    ++i;
+    assert(i != std::cregex_token_iterator());
+    assert(i->str() == "1234");
+    ++i;
+    assert(i != std::cregex_token_iterator());
+    assert(i->str() == ", ");
+    ++i;
+    assert(i != std::cregex_token_iterator());
+    assert(i->str() == "555-2345");
+    ++i;
+    assert(i != std::cregex_token_iterator());
+    assert(i->str() == "2345");
+    ++i;
+    assert(i != std::cregex_token_iterator());
+    assert(i->str() == ", ");
+    ++i;
+    assert(i != std::cregex_token_iterator());
+    assert(i->str() == "555-3456");
+    ++i;
+    assert(i != std::cregex_token_iterator());
+    assert(i->str() == "3456");
+    ++i;
+    assert(i != std::cregex_token_iterator());
+    assert(i->str() == " end");
+    ++i;
+    assert(i == std::cregex_token_iterator());
+  }
 
   return 0;
 }
diff --git a/libcxx/test/std/re/re.iter/re.tokiter/re.tokiter.deref/deref.pass.cpp b/libcxx/test/std/re/re.iter/re.tokiter/re.tokiter.deref/deref.pass.cpp
index 1785df2abe181..054d27961d539 100644
--- a/libcxx/test/std/re/re.iter/re.tokiter/re.tokiter.deref/deref.pass.cpp
+++ b/libcxx/test/std/re/re.iter/re.tokiter/re.tokiter.deref/deref.pass.cpp
@@ -18,59 +18,55 @@
 
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    {
-        std::regex phone_numbers("\\d{3}-\\d{4}");
-        const char phone_book[] = "start 555-1234, 555-2345, 555-3456 end";
-        std::cregex_token_iterator i(std::begin(phone_book), std::end(phone_book)-1,
-                                     phone_numbers, -1);
-        assert(i != std::cregex_token_iterator());
-        assert((*i).str() == "start ");
-        ++i;
-        assert(i != std::cregex_token_iterator());
-        assert((*i).str() == ", ");
-        ++i;
-        assert(i != std::cregex_token_iterator());
-        assert((*i).str() == ", ");
-        ++i;
-        assert(i != std::cregex_token_iterator());
-        assert((*i).str() == " end");
-        ++i;
-        assert(i == std::cregex_token_iterator());
-    }
-    {
-        std::regex phone_numbers("\\d{3}-\\d{4}");
-        const char phone_book[] = "start 555-1234, 555-2345, 555-3456 end";
-        std::cregex_token_iterator i(std::begin(phone_book), std::end(phone_book)-1,
-                                     phone_numbers);
-        assert(i != std::cregex_token_iterator());
-        assert((*i).str() == "555-1234");
-        ++i;
-        assert(i != std::cregex_token_iterator());
-        assert((*i).str() == "555-2345");
-        ++i;
-        assert(i != std::cregex_token_iterator());
-        assert((*i).str() == "555-3456");
-        ++i;
-        assert(i == std::cregex_token_iterator());
-    }
-    {
-        std::regex phone_numbers("\\d{3}-(\\d{4})");
-        const char phone_book[] = "start 555-1234, 555-2345, 555-3456 end";
-        std::cregex_token_iterator i(std::begin(phone_book), std::end(phone_book)-1,
-                                     phone_numbers, 1);
-        assert(i != std::cregex_token_iterator());
-        assert((*i).str() == "1234");
-        ++i;
-        assert(i != std::cregex_token_iterator());
-        assert((*i).str() == "2345");
-        ++i;
-        assert(i != std::cregex_token_iterator());
-        assert((*i).str() == "3456");
-        ++i;
-        assert(i == std::cregex_token_iterator());
-    }
+int main(int, char**) {
+  {
+    std::regex phone_numbers("\\d{3}-\\d{4}");
+    const char phone_book[] = "start 555-1234, 555-2345, 555-3456 end";
+    std::cregex_token_iterator i(std::begin(phone_book), std::end(phone_book) - 1, phone_numbers, -1);
+    assert(i != std::cregex_token_iterator());
+    assert((*i).str() == "start ");
+    ++i;
+    assert(i != std::cregex_token_iterator());
+    assert((*i).str() == ", ");
+    ++i;
+    assert(i != std::cregex_token_iterator());
+    assert((*i).str() == ", ");
+    ++i;
+    assert(i != std::cregex_token_iterator());
+    assert((*i).str() == " end");
+    ++i;
+    assert(i == std::cregex_token_iterator());
+  }
+  {
+    std::regex phone_numbers("\\d{3}-\\d{4}");
+    const char phone_book[] = "start 555-1234, 555-2345, 555-3456 end";
+    std::cregex_token_iterator i(std::begin(phone_book), std::end(phone_book) - 1, phone_numbers);
+    assert(i != std::cregex_token_iterator());
+    assert((*i).str() == "555-1234");
+    ++i;
+    assert(i != std::cregex_token_iterator());
+    assert((*i).str() == "555-2345");
+    ++i;
+    assert(i != std::cregex_token_iterator());
+    assert((*i).str() == "555-3456");
+    ++i;
+    assert(i == std::cregex_token_iterator());
+  }
+  {
+    std::regex phone_numbers("\\d{3}-(\\d{4})");
+    const char phone_book[] = "start 555-1234, 555-2345, 555-3456 end";
+    std::cregex_token_iterator i(std::begin(phone_book), std::end(phone_book) - 1, phone_numbers, 1);
+    assert(i != std::cregex_token_iterator());
+    assert((*i).str() == "1234");
+    ++i;
+    assert(i != std::cregex_token_iterator());
+    assert((*i).str() == "2345");
+    ++i;
+    assert(i != std::cregex_token_iterator());
+    assert((*i).str() == "3456");
+    ++i;
+    assert(i == std::cregex_token_iterator());
+  }
 
   return 0;
 }
diff --git a/libcxx/test/std/re/re.iter/re.tokiter/re.tokiter.incr/post.pass.cpp b/libcxx/test/std/re/re.iter/re.tokiter/re.tokiter.incr/post.pass.cpp
index 8d44f3a5ae66c..fae40a5841e32 100644
--- a/libcxx/test/std/re/re.iter/re.tokiter/re.tokiter.incr/post.pass.cpp
+++ b/libcxx/test/std/re/re.iter/re.tokiter/re.tokiter.incr/post.pass.cpp
@@ -18,122 +18,117 @@
 
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    {
-        std::regex phone_numbers("\\d{3}-\\d{4}");
-        const char phone_book[] = "start 555-1234, 555-2345, 555-3456 end";
-        std::cregex_token_iterator i(std::begin(phone_book), std::end(phone_book)-1,
-                                     phone_numbers, -1);
-        std::cregex_token_iterator i2 = i;
-        std::cregex_token_iterator i3;
-        assert(i  != std::cregex_token_iterator());
-        assert(i2 != std::cregex_token_iterator());
-        assert(i->str() == "start ");
-        assert(i2->str() == "start ");
-        i3 = i++;
-        assert(i  != std::cregex_token_iterator());
-        assert(i2 != std::cregex_token_iterator());
-        assert(i3 != std::cregex_token_iterator());
-        assert(i->str() == ", ");
-        assert(i2->str() == "start ");
-        assert(i3->str() == "start ");
-        i3 = i++;
-        assert(i  != std::cregex_token_iterator());
-        assert(i2 != std::cregex_token_iterator());
-        assert(i3 != std::cregex_token_iterator());
-        assert(i->str() == ", ");
-        assert(i2->str() == "start ");
-        assert(i3->str() == ", ");
-        i3 = i++;
-        assert(i  != std::cregex_token_iterator());
-        assert(i2 != std::cregex_token_iterator());
-        assert(i3 != std::cregex_token_iterator());
-        assert(i->str() == " end");
-        assert(i2->str() == "start ");
-        assert(i3->str() == ", ");
-        i3 = i++;
-        assert(i  == std::cregex_token_iterator());
-        assert(i2 != std::cregex_token_iterator());
-        assert(i3 != std::cregex_token_iterator());
-        assert(i2->str() == "start ");
-        assert(i3->str() == " end");
-    }
-    {
-        std::regex phone_numbers("\\d{3}-\\d{4}");
-        const char phone_book[] = "start 555-1234, 555-2345, 555-3456 end";
-        std::cregex_token_iterator i(std::begin(phone_book), std::end(phone_book)-1,
-                                     phone_numbers, -1);
-        std::cregex_token_iterator i2 = i;
-        std::cregex_token_iterator i3;
-        assert(i  != std::cregex_token_iterator());
-        assert(i2 != std::cregex_token_iterator());
-        assert(i->str() == "start ");
-        assert(i2->str() == "start ");
-        i3 = i;
-        ++i;
-        assert(i  != std::cregex_token_iterator());
-        assert(i2 != std::cregex_token_iterator());
-        assert(i3 != std::cregex_token_iterator());
-        assert(i->str() == ", ");
-        assert(i2->str() == "start ");
-        assert(i3->str() == "start ");
-        i3 = i;
-        ++i;
-        assert(i  != std::cregex_token_iterator());
-        assert(i2 != std::cregex_token_iterator());
-        assert(i3 != std::cregex_token_iterator());
-        assert(i->str() == ", ");
-        assert(i2->str() == "start ");
-        assert(i3->str() == ", ");
-        i3 = i;
-        ++i;
-        assert(i  != std::cregex_token_iterator());
-        assert(i2 != std::cregex_token_iterator());
-        assert(i3 != std::cregex_token_iterator());
-        assert(i->str() == " end");
-        assert(i2->str() == "start ");
-        assert(i3->str() == ", ");
-        i3 = i;
-        ++i;
-        assert(i  == std::cregex_token_iterator());
-        assert(i2 != std::cregex_token_iterator());
-        assert(i3 != std::cregex_token_iterator());
-        assert(i2->str() == "start ");
-        assert(i3->str() == " end");
-    }
-    {
-        std::regex phone_numbers("\\d{3}-\\d{4}");
-        const char phone_book[] = "start 555-1234, 555-2345, 555-3456 end";
-        std::cregex_token_iterator i(std::begin(phone_book), std::end(phone_book)-1,
-                                     phone_numbers);
-        assert(i != std::cregex_token_iterator());
-        assert(i->str() == "555-1234");
-        i++;
-        assert(i != std::cregex_token_iterator());
-        assert(i->str() == "555-2345");
-        i++;
-        assert(i != std::cregex_token_iterator());
-        assert(i->str() == "555-3456");
-        i++;
-        assert(i == std::cregex_token_iterator());
-    }
-    {
-        std::regex phone_numbers("\\d{3}-(\\d{4})");
-        const char phone_book[] = "start 555-1234, 555-2345, 555-3456 end";
-        std::cregex_token_iterator i(std::begin(phone_book), std::end(phone_book)-1,
-                                     phone_numbers, 1);
-        assert(i != std::cregex_token_iterator());
-        assert(i->str() == "1234");
-        i++;
-        assert(i != std::cregex_token_iterator());
-        assert(i->str() == "2345");
-        i++;
-        assert(i != std::cregex_token_iterator());
-        assert(i->str() == "3456");
-        i++;
-        assert(i == std::cregex_token_iterator());
-    }
+int main(int, char**) {
+  {
+    std::regex phone_numbers("\\d{3}-\\d{4}");
+    const char phone_book[] = "start 555-1234, 555-2345, 555-3456 end";
+    std::cregex_token_iterator i(std::begin(phone_book), std::end(phone_book) - 1, phone_numbers, -1);
+    std::cregex_token_iterator i2 = i;
+    std::cregex_token_iterator i3;
+    assert(i != std::cregex_token_iterator());
+    assert(i2 != std::cregex_token_iterator());
+    assert(i->str() == "start ");
+    assert(i2->str() == "start ");
+    i3 = i++;
+    assert(i != std::cregex_token_iterator());
+    assert(i2 != std::cregex_token_iterator());
+    assert(i3 != std::cregex_token_iterator());
+    assert(i->str() == ", ");
+    assert(i2->str() == "start ");
+    assert(i3->str() == "start ");
+    i3 = i++;
+    assert(i != std::cregex_token_iterator());
+    assert(i2 != std::cregex_token_iterator());
+    assert(i3 != std::cregex_token_iterator());
+    assert(i->str() == ", ");
+    assert(i2->str() == "start ");
+    assert(i3->str() == ", ");
+    i3 = i++;
+    assert(i != std::cregex_token_iterator());
+    assert(i2 != std::cregex_token_iterator());
+    assert(i3 != std::cregex_token_iterator());
+    assert(i->str() == " end");
+    assert(i2->str() == "start ");
+    assert(i3->str() == ", ");
+    i3 = i++;
+    assert(i == std::cregex_token_iterator());
+    assert(i2 != std::cregex_token_iterator());
+    assert(i3 != std::cregex_token_iterator());
+    assert(i2->str() == "start ");
+    assert(i3->str() == " end");
+  }
+  {
+    std::regex phone_numbers("\\d{3}-\\d{4}");
+    const char phone_book[] = "start 555-1234, 555-2345, 555-3456 end";
+    std::cregex_token_iterator i(std::begin(phone_book), std::end(phone_book) - 1, phone_numbers, -1);
+    std::cregex_token_iterator i2 = i;
+    std::cregex_token_iterator i3;
+    assert(i != std::cregex_token_iterator());
+    assert(i2 != std::cregex_token_iterator());
+    assert(i->str() == "start ");
+    assert(i2->str() == "start ");
+    i3 = i;
+    ++i;
+    assert(i != std::cregex_token_iterator());
+    assert(i2 != std::cregex_token_iterator());
+    assert(i3 != std::cregex_token_iterator());
+    assert(i->str() == ", ");
+    assert(i2->str() == "start ");
+    assert(i3->str() == "start ");
+    i3 = i;
+    ++i;
+    assert(i != std::cregex_token_iterator());
+    assert(i2 != std::cregex_token_iterator());
+    assert(i3 != std::cregex_token_iterator());
+    assert(i->str() == ", ");
+    assert(i2->str() == "start ");
+    assert(i3->str() == ", ");
+    i3 = i;
+    ++i;
+    assert(i != std::cregex_token_iterator());
+    assert(i2 != std::cregex_token_iterator());
+    assert(i3 != std::cregex_token_iterator());
+    assert(i->str() == " end");
+    assert(i2->str() == "start ");
+    assert(i3->str() == ", ");
+    i3 = i;
+    ++i;
+    assert(i == std::cregex_token_iterator());
+    assert(i2 != std::cregex_token_iterator());
+    assert(i3 != std::cregex_token_iterator());
+    assert(i2->str() == "start ");
+    assert(i3->str() == " end");
+  }
+  {
+    std::regex phone_numbers("\\d{3}-\\d{4}");
+    const char phone_book[] = "start 555-1234, 555-2345, 555-3456 end";
+    std::cregex_token_iterator i(std::begin(phone_book), std::end(phone_book) - 1, phone_numbers);
+    assert(i != std::cregex_token_iterator());
+    assert(i->str() == "555-1234");
+    i++;
+    assert(i != std::cregex_token_iterator());
+    assert(i->str() == "555-2345");
+    i++;
+    assert(i != std::cregex_token_iterator());
+    assert(i->str() == "555-3456");
+    i++;
+    assert(i == std::cregex_token_iterator());
+  }
+  {
+    std::regex phone_numbers("\\d{3}-(\\d{4})");
+    const char phone_book[] = "start 555-1234, 555-2345, 555-3456 end";
+    std::cregex_token_iterator i(std::begin(phone_book), std::end(phone_book) - 1, phone_numbers, 1);
+    assert(i != std::cregex_token_iterator());
+    assert(i->str() == "1234");
+    i++;
+    assert(i != std::cregex_token_iterator());
+    assert(i->str() == "2345");
+    i++;
+    assert(i != std::cregex_token_iterator());
+    assert(i->str() == "3456");
+    i++;
+    assert(i == std::cregex_token_iterator());
+  }
 
   return 0;
 }
diff --git a/libcxx/test/std/re/re.iter/re.tokiter/types.pass.cpp b/libcxx/test/std/re/re.iter/re.tokiter/types.pass.cpp
index a9c18e8a1b77a..6bf95e3b42e1f 100644
--- a/libcxx/test/std/re/re.iter/re.tokiter/types.pass.cpp
+++ b/libcxx/test/std/re/re.iter/re.tokiter/types.pass.cpp
@@ -27,25 +27,22 @@
 #include "test_macros.h"
 
 template <class CharT>
-void
-test()
-{
-    typedef std::regex_token_iterator<const CharT*> I;
-    static_assert((std::is_same<typename I::regex_type, std::basic_regex<CharT> >::value), "");
-    static_assert((std::is_same<typename I::value_type, std::sub_match<const CharT*> >::value), "");
-    static_assert((std::is_same<typename I::difference_type, std::ptrdiff_t>::value), "");
-    static_assert((std::is_same<typename I::pointer, const std::sub_match<const CharT*>*>::value), "");
-    static_assert((std::is_same<typename I::reference, const std::sub_match<const CharT*>&>::value), "");
-    static_assert((std::is_same<typename I::iterator_category, std::forward_iterator_tag>::value), "");
+void test() {
+  typedef std::regex_token_iterator<const CharT*> I;
+  static_assert((std::is_same<typename I::regex_type, std::basic_regex<CharT> >::value), "");
+  static_assert((std::is_same<typename I::value_type, std::sub_match<const CharT*> >::value), "");
+  static_assert((std::is_same<typename I::difference_type, std::ptrdiff_t>::value), "");
+  static_assert((std::is_same<typename I::pointer, const std::sub_match<const CharT*>*>::value), "");
+  static_assert((std::is_same<typename I::reference, const std::sub_match<const CharT*>&>::value), "");
+  static_assert((std::is_same<typename I::iterator_category, std::forward_iterator_tag>::value), "");
 #if TEST_STD_VER >= 20
-    static_assert(std::is_same_v<typename I::iterator_concept, std::input_iterator_tag>);
+  static_assert(std::is_same_v<typename I::iterator_concept, std::input_iterator_tag>);
 #endif
 }
 
-int main(int, char**)
-{
-    test<char>();
-    test<wchar_t>();
+int main(int, char**) {
+  test<char>();
+  test<wchar_t>();
 
   return 0;
 }
diff --git a/libcxx/test/std/re/re.regex/re.regex.assign/assign.il.pass.cpp b/libcxx/test/std/re/re.regex/re.regex.assign/assign.il.pass.cpp
index f26f02b4dd72d..477bfdef63c83 100644
--- a/libcxx/test/std/re/re.regex/re.regex.assign/assign.il.pass.cpp
+++ b/libcxx/test/std/re/re.regex/re.regex.assign/assign.il.pass.cpp
@@ -20,16 +20,15 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    std::regex r2;
-    r2.assign({'(', 'a', '(', '[', 'b', 'c', ']', ')', ')'});
-    assert(r2.flags() == std::regex::ECMAScript);
-    assert(r2.mark_count() == 2);
-
-    r2.assign({'(', 'a', '(', '[', 'b', 'c', ']', ')', ')'}, std::regex::extended);
-    assert(r2.flags() == std::regex::extended);
-    assert(r2.mark_count() == 2);
+int main(int, char**) {
+  std::regex r2;
+  r2.assign({'(', 'a', '(', '[', 'b', 'c', ']', ')', ')'});
+  assert(r2.flags() == std::regex::ECMAScript);
+  assert(r2.mark_count() == 2);
+
+  r2.assign({'(', 'a', '(', '[', 'b', 'c', ']', ')', ')'}, std::regex::extended);
+  assert(r2.flags() == std::regex::extended);
+  assert(r2.mark_count() == 2);
 
   return 0;
 }
diff --git a/libcxx/test/std/re/re.regex/re.regex.assign/assign.pass.cpp b/libcxx/test/std/re/re.regex/re.regex.assign/assign.pass.cpp
index c580ab96cbab0..c6a2c7bcb0de7 100644
--- a/libcxx/test/std/re/re.regex/re.regex.assign/assign.pass.cpp
+++ b/libcxx/test/std/re/re.regex/re.regex.assign/assign.pass.cpp
@@ -16,23 +16,25 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    std::regex r1("(a([bc]))");
-    std::regex r2;
-    r2.assign(r1);
-    assert(r2.flags() == std::regex::ECMAScript);
-    assert(r2.mark_count() == 2);
-    assert(std::regex_search("ab", r2));
+int main(int, char**) {
+  std::regex r1("(a([bc]))");
+  std::regex r2;
+  r2.assign(r1);
+  assert(r2.flags() == std::regex::ECMAScript);
+  assert(r2.mark_count() == 2);
+  assert(std::regex_search("ab", r2));
 
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    bool caught = false;
-    try { r2.assign("(def", std::regex::extended); }
-    catch(std::regex_error &) { caught = true; }
-    assert(caught);
-    assert(r2.flags() == std::regex::ECMAScript);
-    assert(r2.mark_count() == 2);
-    assert(std::regex_search("ab", r2));
+  bool caught = false;
+  try {
+    r2.assign("(def", std::regex::extended);
+  } catch (std::regex_error&) {
+    caught = true;
+  }
+  assert(caught);
+  assert(r2.flags() == std::regex::ECMAScript);
+  assert(r2.mark_count() == 2);
+  assert(std::regex_search("ab", r2));
 #endif
 
   return 0;
diff --git a/libcxx/test/std/re/re.regex/re.regex.assign/assign_iter_iter_flag.pass.cpp b/libcxx/test/std/re/re.regex/re.regex.assign/assign_iter_iter_flag.pass.cpp
index 21717cfd1f7ba..b6b386657141d 100644
--- a/libcxx/test/std/re/re.regex/re.regex.assign/assign_iter_iter_flag.pass.cpp
+++ b/libcxx/test/std/re/re.regex/re.regex.assign/assign_iter_iter_flag.pass.cpp
@@ -22,28 +22,27 @@
 #include "test_macros.h"
 #include "test_iterators.h"
 
-int main(int, char**)
-{
-    typedef cpp17_input_iterator<std::string::const_iterator> I;
-    typedef forward_iterator<std::string::const_iterator> F;
-    std::string s4("(a([bc]))");
-    std::regex r2;
-
-    r2.assign(I(s4.begin()), I(s4.end()));
-    assert(r2.flags() == std::regex::ECMAScript);
-    assert(r2.mark_count() == 2);
-
-    r2.assign(I(s4.begin()), I(s4.end()), std::regex::extended);
-    assert(r2.flags() == std::regex::extended);
-    assert(r2.mark_count() == 2);
-
-    r2.assign(F(s4.begin()), F(s4.end()));
-    assert(r2.flags() == std::regex::ECMAScript);
-    assert(r2.mark_count() == 2);
-
-    r2.assign(F(s4.begin()), F(s4.end()), std::regex::extended);
-    assert(r2.flags() == std::regex::extended);
-    assert(r2.mark_count() == 2);
+int main(int, char**) {
+  typedef cpp17_input_iterator<std::string::const_iterator> I;
+  typedef forward_iterator<std::string::const_iterator> F;
+  std::string s4("(a([bc]))");
+  std::regex r2;
+
+  r2.assign(I(s4.begin()), I(s4.end()));
+  assert(r2.flags() == std::regex::ECMAScript);
+  assert(r2.mark_count() == 2);
+
+  r2.assign(I(s4.begin()), I(s4.end()), std::regex::extended);
+  assert(r2.flags() == std::regex::extended);
+  assert(r2.mark_count() == 2);
+
+  r2.assign(F(s4.begin()), F(s4.end()));
+  assert(r2.flags() == std::regex::ECMAScript);
+  assert(r2.mark_count() == 2);
+
+  r2.assign(F(s4.begin()), F(s4.end()), std::regex::extended);
+  assert(r2.flags() == std::regex::extended);
+  assert(r2.mark_count() == 2);
 
   return 0;
 }
diff --git a/libcxx/test/std/re/re.regex/re.regex.assign/assign_ptr_flag.pass.cpp b/libcxx/test/std/re/re.regex/re.regex.assign/assign_ptr_flag.pass.cpp
index 9445bbaf9ff6f..0f8cf57170d07 100644
--- a/libcxx/test/std/re/re.regex/re.regex.assign/assign_ptr_flag.pass.cpp
+++ b/libcxx/test/std/re/re.regex/re.regex.assign/assign_ptr_flag.pass.cpp
@@ -16,16 +16,15 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    std::regex r2;
-    r2.assign("(a([bc]))");
-    assert(r2.flags() == std::regex::ECMAScript);
-    assert(r2.mark_count() == 2);
+int main(int, char**) {
+  std::regex r2;
+  r2.assign("(a([bc]))");
+  assert(r2.flags() == std::regex::ECMAScript);
+  assert(r2.mark_count() == 2);
 
-    r2.assign("(a([bc]))", std::regex::extended);
-    assert(r2.flags() == std::regex::extended);
-    assert(r2.mark_count() == 2);
+  r2.assign("(a([bc]))", std::regex::extended);
+  assert(r2.flags() == std::regex::extended);
+  assert(r2.mark_count() == 2);
 
   return 0;
 }
diff --git a/libcxx/test/std/re/re.regex/re.regex.assign/assign_ptr_size_flag.pass.cpp b/libcxx/test/std/re/re.regex/re.regex.assign/assign_ptr_size_flag.pass.cpp
index e74a42b693409..9521071f7ca71 100644
--- a/libcxx/test/std/re/re.regex/re.regex.assign/assign_ptr_size_flag.pass.cpp
+++ b/libcxx/test/std/re/re.regex/re.regex.assign/assign_ptr_size_flag.pass.cpp
@@ -16,22 +16,21 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    std::regex r0;
-    r0.assign("(a([bc]))", 9);
-    assert(r0.flags() == std::regex::ECMAScript);
-    assert(r0.mark_count() == 2);
-
-    std::regex r1;
-    r1.assign("(a([bc]))", 9, std::regex::ECMAScript);
-    assert(r1.flags() == std::regex::ECMAScript);
-    assert(r1.mark_count() == 2);
-
-    std::regex r2;
-    r2.assign("(a([bc]))", 9, std::regex::extended);
-    assert(r2.flags() == std::regex::extended);
-    assert(r2.mark_count() == 2);
+int main(int, char**) {
+  std::regex r0;
+  r0.assign("(a([bc]))", 9);
+  assert(r0.flags() == std::regex::ECMAScript);
+  assert(r0.mark_count() == 2);
+
+  std::regex r1;
+  r1.assign("(a([bc]))", 9, std::regex::ECMAScript);
+  assert(r1.flags() == std::regex::ECMAScript);
+  assert(r1.mark_count() == 2);
+
+  std::regex r2;
+  r2.assign("(a([bc]))", 9, std::regex::extended);
+  assert(r2.flags() == std::regex::extended);
+  assert(r2.mark_count() == 2);
 
   return 0;
 }
diff --git a/libcxx/test/std/re/re.regex/re.regex.assign/assign_string_flag.pass.cpp b/libcxx/test/std/re/re.regex/re.regex.assign/assign_string_flag.pass.cpp
index 4f09e3d6e4269..dd1b8151f9f2f 100644
--- a/libcxx/test/std/re/re.regex/re.regex.assign/assign_string_flag.pass.cpp
+++ b/libcxx/test/std/re/re.regex/re.regex.assign/assign_string_flag.pass.cpp
@@ -20,16 +20,15 @@
 
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    std::regex r2;
-    r2.assign(std::string("(a([bc]))"));
-    assert(r2.flags() == std::regex::ECMAScript);
-    assert(r2.mark_count() == 2);
-
-    r2.assign(std::string("(a([bc]))"), std::regex::extended);
-    assert(r2.flags() == std::regex::extended);
-    assert(r2.mark_count() == 2);
+int main(int, char**) {
+  std::regex r2;
+  r2.assign(std::string("(a([bc]))"));
+  assert(r2.flags() == std::regex::ECMAScript);
+  assert(r2.mark_count() == 2);
+
+  r2.assign(std::string("(a([bc]))"), std::regex::extended);
+  assert(r2.flags() == std::regex::extended);
+  assert(r2.mark_count() == 2);
 
   return 0;
 }
diff --git a/libcxx/test/std/re/re.regex/re.regex.assign/copy.pass.cpp b/libcxx/test/std/re/re.regex/re.regex.assign/copy.pass.cpp
index 1abb721516516..b9d6d39efadd4 100644
--- a/libcxx/test/std/re/re.regex/re.regex.assign/copy.pass.cpp
+++ b/libcxx/test/std/re/re.regex/re.regex.assign/copy.pass.cpp
@@ -16,13 +16,12 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    std::regex r1("(a([bc]))");
-    std::regex r2;
-    r2 = r1;
-    assert(r2.flags() == std::regex::ECMAScript);
-    assert(r2.mark_count() == 2);
+int main(int, char**) {
+  std::regex r1("(a([bc]))");
+  std::regex r2;
+  r2 = r1;
+  assert(r2.flags() == std::regex::ECMAScript);
+  assert(r2.mark_count() == 2);
 
   return 0;
 }
diff --git a/libcxx/test/std/re/re.regex/re.regex.assign/il.pass.cpp b/libcxx/test/std/re/re.regex/re.regex.assign/il.pass.cpp
index c2a0de3f3fe1d..fb4887c07bb55 100644
--- a/libcxx/test/std/re/re.regex/re.regex.assign/il.pass.cpp
+++ b/libcxx/test/std/re/re.regex/re.regex.assign/il.pass.cpp
@@ -18,12 +18,11 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    std::regex r2;
-    r2 = {'(', 'a', '(', '[', 'b', 'c', ']', ')', ')'};
-    assert(r2.flags() == std::regex::ECMAScript);
-    assert(r2.mark_count() == 2);
+int main(int, char**) {
+  std::regex r2;
+  r2 = {'(', 'a', '(', '[', 'b', 'c', ']', ')', ')'};
+  assert(r2.flags() == std::regex::ECMAScript);
+  assert(r2.mark_count() == 2);
 
   return 0;
 }
diff --git a/libcxx/test/std/re/re.regex/re.regex.assign/ptr.pass.cpp b/libcxx/test/std/re/re.regex/re.regex.assign/ptr.pass.cpp
index 3791f81527283..b6aa419770520 100644
--- a/libcxx/test/std/re/re.regex/re.regex.assign/ptr.pass.cpp
+++ b/libcxx/test/std/re/re.regex/re.regex.assign/ptr.pass.cpp
@@ -16,12 +16,11 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    std::regex r2;
-    r2 = "(a([bc]))";
-    assert(r2.flags() == std::regex::ECMAScript);
-    assert(r2.mark_count() == 2);
+int main(int, char**) {
+  std::regex r2;
+  r2 = "(a([bc]))";
+  assert(r2.flags() == std::regex::ECMAScript);
+  assert(r2.mark_count() == 2);
 
   return 0;
 }
diff --git a/libcxx/test/std/re/re.regex/re.regex.assign/string.pass.cpp b/libcxx/test/std/re/re.regex/re.regex.assign/string.pass.cpp
index e33819ab3c37e..24546ae8daa46 100644
--- a/libcxx/test/std/re/re.regex/re.regex.assign/string.pass.cpp
+++ b/libcxx/test/std/re/re.regex/re.regex.assign/string.pass.cpp
@@ -17,12 +17,11 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    std::regex r2;
-    r2 = std::string("(a([bc]))");
-    assert(r2.flags() == std::regex::ECMAScript);
-    assert(r2.mark_count() == 2);
+int main(int, char**) {
+  std::regex r2;
+  r2 = std::string("(a([bc]))");
+  assert(r2.flags() == std::regex::ECMAScript);
+  assert(r2.mark_count() == 2);
 
   return 0;
 }
diff --git a/libcxx/test/std/re/re.regex/re.regex.const/constants.pass.cpp b/libcxx/test/std/re/re.regex/re.regex.const/constants.pass.cpp
index 5d8d48d0590da..e0008f770ab0f 100644
--- a/libcxx/test/std/re/re.regex/re.regex.const/constants.pass.cpp
+++ b/libcxx/test/std/re/re.regex/re.regex.const/constants.pass.cpp
@@ -29,39 +29,36 @@
 #include "test_macros.h"
 
 template <class T>
-void where(const T &) {}
+void where(const T&) {}
 
 template <class CharT>
-void
-test()
-{
-    typedef std::basic_regex<CharT> BR;
-    static_assert((BR::icase == std::regex_constants::icase), "");
-    static_assert((BR::nosubs == std::regex_constants::nosubs), "");
-    static_assert((BR::optimize == std::regex_constants::optimize), "");
-    static_assert((BR::collate == std::regex_constants::collate), "");
-    static_assert((BR::ECMAScript == std::regex_constants::ECMAScript), "");
-    static_assert((BR::basic == std::regex_constants::basic), "");
-    static_assert((BR::extended == std::regex_constants::extended), "");
-    static_assert((BR::awk == std::regex_constants::awk), "");
-    static_assert((BR::grep == std::regex_constants::grep), "");
-    static_assert((BR::egrep == std::regex_constants::egrep), "");
-    where(BR::icase);
-    where(BR::nosubs);
-    where(BR::optimize);
-    where(BR::collate);
-    where(BR::ECMAScript);
-    where(BR::basic);
-    where(BR::extended);
-    where(BR::awk);
-    where(BR::grep);
-    where(BR::egrep);
+void test() {
+  typedef std::basic_regex<CharT> BR;
+  static_assert((BR::icase == std::regex_constants::icase), "");
+  static_assert((BR::nosubs == std::regex_constants::nosubs), "");
+  static_assert((BR::optimize == std::regex_constants::optimize), "");
+  static_assert((BR::collate == std::regex_constants::collate), "");
+  static_assert((BR::ECMAScript == std::regex_constants::ECMAScript), "");
+  static_assert((BR::basic == std::regex_constants::basic), "");
+  static_assert((BR::extended == std::regex_constants::extended), "");
+  static_assert((BR::awk == std::regex_constants::awk), "");
+  static_assert((BR::grep == std::regex_constants::grep), "");
+  static_assert((BR::egrep == std::regex_constants::egrep), "");
+  where(BR::icase);
+  where(BR::nosubs);
+  where(BR::optimize);
+  where(BR::collate);
+  where(BR::ECMAScript);
+  where(BR::basic);
+  where(BR::extended);
+  where(BR::awk);
+  where(BR::grep);
+  where(BR::egrep);
 }
 
-int main(int, char**)
-{
-    test<char>();
-    test<wchar_t>();
+int main(int, char**) {
+  test<char>();
+  test<wchar_t>();
 
   return 0;
 }
diff --git a/libcxx/test/std/re/re.regex/re.regex.construct/awk_oct.pass.cpp b/libcxx/test/std/re/re.regex/re.regex.construct/awk_oct.pass.cpp
index 2e7eed350c030..36cd0abb0abf8 100644
--- a/libcxx/test/std/re/re.regex/re.regex.construct/awk_oct.pass.cpp
+++ b/libcxx/test/std/re/re.regex/re.regex.construct/awk_oct.pass.cpp
@@ -17,14 +17,15 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    using std::regex_constants::awk;
+int main(int, char**) {
+  using std::regex_constants::awk;
 
-    assert(std::regex_match("\4", std::regex("\\4", awk)));
-    assert(std::regex_match("\41", std::regex("\\41", awk)));
-    assert(std::regex_match("\141", std::regex("\\141", awk)));
-    assert(std::regex_match("\141" "1", std::regex("\\1411", awk)));
+  assert(std::regex_match("\4", std::regex("\\4", awk)));
+  assert(std::regex_match("\41", std::regex("\\41", awk)));
+  assert(std::regex_match("\141", std::regex("\\141", awk)));
+  // clang-format off
+  assert(std::regex_match("\141" "1", std::regex("\\1411", awk)));
+  // clang-format on
 
   return 0;
 }
diff --git a/libcxx/test/std/re/re.regex/re.regex.construct/bad_backref.pass.cpp b/libcxx/test/std/re/re.regex/re.regex.construct/bad_backref.pass.cpp
index 09b9e89521e1b..e95c1fdb61c59 100644
--- a/libcxx/test/std/re/re.regex/re.regex.construct/bad_backref.pass.cpp
+++ b/libcxx/test/std/re/re.regex/re.regex.construct/bad_backref.pass.cpp
@@ -18,75 +18,72 @@
 #include <cassert>
 #include "test_macros.h"
 
-static bool error_badbackref_thrown(const char *pat, std::regex::flag_type f)
-{
-    bool result = false;
-    try {
-        std::regex re(pat, f);
-    } catch (const std::regex_error &ex) {
-        result = (ex.code() == std::regex_constants::error_backref);
-    }
-    return result;
+static bool error_badbackref_thrown(const char* pat, std::regex::flag_type f) {
+  bool result = false;
+  try {
+    std::regex re(pat, f);
+  } catch (const std::regex_error& ex) {
+    result = (ex.code() == std::regex_constants::error_backref);
+  }
+  return result;
 }
 
-int main(int, char**)
-{
-//  no references
-    assert(error_badbackref_thrown("\\1abc", std::regex_constants::ECMAScript));
-    assert(error_badbackref_thrown("\\1abd", std::regex::basic));
-    assert(error_badbackref_thrown("\\1abd", std::regex::extended));
-    assert(error_badbackref_thrown("\\1abd", std::regex::awk) == false);
-    assert(error_badbackref_thrown("\\1abd", std::regex::grep));
-    assert(error_badbackref_thrown("\\1abd", std::regex::egrep));
+int main(int, char**) {
+  //  no references
+  assert(error_badbackref_thrown("\\1abc", std::regex_constants::ECMAScript));
+  assert(error_badbackref_thrown("\\1abd", std::regex::basic));
+  assert(error_badbackref_thrown("\\1abd", std::regex::extended));
+  assert(error_badbackref_thrown("\\1abd", std::regex::awk) == false);
+  assert(error_badbackref_thrown("\\1abd", std::regex::grep));
+  assert(error_badbackref_thrown("\\1abd", std::regex::egrep));
 
-//  only one reference
-    assert(error_badbackref_thrown("ab(c)\\2def", std::regex_constants::ECMAScript));
-    assert(error_badbackref_thrown("ab\\(c\\)\\2def", std::regex_constants::basic));
-    assert(error_badbackref_thrown("ab(c)\\2def", std::regex_constants::extended));
-    assert(error_badbackref_thrown("ab\\(c\\)\\2def", std::regex_constants::awk) == false);
-    assert(error_badbackref_thrown("ab(c)\\2def", std::regex_constants::awk) == false);
-    assert(error_badbackref_thrown("ab\\(c\\)\\2def", std::regex_constants::grep));
-    assert(error_badbackref_thrown("ab(c)\\2def", std::regex_constants::egrep));
+  //  only one reference
+  assert(error_badbackref_thrown("ab(c)\\2def", std::regex_constants::ECMAScript));
+  assert(error_badbackref_thrown("ab\\(c\\)\\2def", std::regex_constants::basic));
+  assert(error_badbackref_thrown("ab(c)\\2def", std::regex_constants::extended));
+  assert(error_badbackref_thrown("ab\\(c\\)\\2def", std::regex_constants::awk) == false);
+  assert(error_badbackref_thrown("ab(c)\\2def", std::regex_constants::awk) == false);
+  assert(error_badbackref_thrown("ab\\(c\\)\\2def", std::regex_constants::grep));
+  assert(error_badbackref_thrown("ab(c)\\2def", std::regex_constants::egrep));
 
+  assert(error_badbackref_thrown("\\800000000000000000000000000000", std::regex_constants::ECMAScript)); // overflows
 
-    assert(error_badbackref_thrown("\\800000000000000000000000000000", std::regex_constants::ECMAScript)); // overflows
-
-//  this should NOT throw, because we only should look at the '1'
-//  See https://llvm.org/PR31387
-    {
-    const char *pat1 = "a(b)c\\1234";
+  //  this should NOT throw, because we only should look at the '1'
+  //  See https://llvm.org/PR31387
+  {
+    const char* pat1 = "a(b)c\\1234";
     std::regex re(pat1, pat1 + 7); // extra chars after the end.
-    }
+  }
 
-//  reference before group
-    assert(error_badbackref_thrown("\\1(abc)", std::regex_constants::ECMAScript));
-    assert(error_badbackref_thrown("\\1\\(abd\\)", std::regex::basic));
-    assert(error_badbackref_thrown("\\1(abd)", std::regex::extended));
-    assert(error_badbackref_thrown("\\1(abd)", std::regex::awk) == false);
-    assert(error_badbackref_thrown("\\1\\(abd\\)", std::regex::awk) == false);
-    assert(error_badbackref_thrown("\\1\\(abd\\)", std::regex::grep));
-    assert(error_badbackref_thrown("\\1(abd)", std::regex::egrep));
+  //  reference before group
+  assert(error_badbackref_thrown("\\1(abc)", std::regex_constants::ECMAScript));
+  assert(error_badbackref_thrown("\\1\\(abd\\)", std::regex::basic));
+  assert(error_badbackref_thrown("\\1(abd)", std::regex::extended));
+  assert(error_badbackref_thrown("\\1(abd)", std::regex::awk) == false);
+  assert(error_badbackref_thrown("\\1\\(abd\\)", std::regex::awk) == false);
+  assert(error_badbackref_thrown("\\1\\(abd\\)", std::regex::grep));
+  assert(error_badbackref_thrown("\\1(abd)", std::regex::egrep));
 
-//  reference limit
-    assert(error_badbackref_thrown("(cat)\\10", std::regex::ECMAScript));
-    assert(error_badbackref_thrown("\\(cat\\)\\10", std::regex::basic) == false);
-    assert(error_badbackref_thrown("(cat)\\10", std::regex::extended) == false);
-    assert(error_badbackref_thrown("\\(cat\\)\\10", std::regex::awk) == false);
-    assert(error_badbackref_thrown("(cat)\\10", std::regex::awk) == false);
-    assert(error_badbackref_thrown("\\(cat\\)\\10", std::regex::grep) == false);
-    assert(error_badbackref_thrown("(cat)\\10", std::regex::egrep) == false);
+  //  reference limit
+  assert(error_badbackref_thrown("(cat)\\10", std::regex::ECMAScript));
+  assert(error_badbackref_thrown("\\(cat\\)\\10", std::regex::basic) == false);
+  assert(error_badbackref_thrown("(cat)\\10", std::regex::extended) == false);
+  assert(error_badbackref_thrown("\\(cat\\)\\10", std::regex::awk) == false);
+  assert(error_badbackref_thrown("(cat)\\10", std::regex::awk) == false);
+  assert(error_badbackref_thrown("\\(cat\\)\\10", std::regex::grep) == false);
+  assert(error_badbackref_thrown("(cat)\\10", std::regex::egrep) == false);
 
-//  https://llvm.org/PR34297
-    assert(error_badbackref_thrown("(cat)\\1", std::regex::basic));
-    assert(error_badbackref_thrown("\\(cat\\)\\1", std::regex::basic) == false);
-    assert(error_badbackref_thrown("(cat)\\1", std::regex::extended) == false);
-    assert(error_badbackref_thrown("\\(cat\\)\\1", std::regex::extended));
-    assert(error_badbackref_thrown("(cat)\\1", std::regex::awk) == false);
-    assert(error_badbackref_thrown("\\(cat\\)\\1", std::regex::awk) == false);
-    assert(error_badbackref_thrown("(cat)\\1", std::regex::grep));
-    assert(error_badbackref_thrown("\\(cat\\)\\1", std::regex::grep) == false);
-    assert(error_badbackref_thrown("(cat)\\1", std::regex::egrep) == false);
-    assert(error_badbackref_thrown("\\(cat\\)\\1", std::regex::egrep));
+  //  https://llvm.org/PR34297
+  assert(error_badbackref_thrown("(cat)\\1", std::regex::basic));
+  assert(error_badbackref_thrown("\\(cat\\)\\1", std::regex::basic) == false);
+  assert(error_badbackref_thrown("(cat)\\1", std::regex::extended) == false);
+  assert(error_badbackref_thrown("\\(cat\\)\\1", std::regex::extended));
+  assert(error_badbackref_thrown("(cat)\\1", std::regex::awk) == false);
+  assert(error_badbackref_thrown("\\(cat\\)\\1", std::regex::awk) == false);
+  assert(error_badbackref_thrown("(cat)\\1", std::regex::grep));
+  assert(error_badbackref_thrown("\\(cat\\)\\1", std::regex::grep) == false);
+  assert(error_badbackref_thrown("(cat)\\1", std::regex::egrep) == false);
+  assert(error_badbackref_thrown("\\(cat\\)\\1", std::regex::egrep));
 
   return 0;
 }
diff --git a/libcxx/test/std/re/re.regex/re.regex.construct/bad_ctype.pass.cpp b/libcxx/test/std/re/re.regex/re.regex.construct/bad_ctype.pass.cpp
index 31f6e9a711ba7..ef6da4aedfaa0 100644
--- a/libcxx/test/std/re/re.regex/re.regex.construct/bad_ctype.pass.cpp
+++ b/libcxx/test/std/re/re.regex/re.regex.construct/bad_ctype.pass.cpp
@@ -18,21 +18,19 @@
 #include <cassert>
 #include "test_macros.h"
 
-static bool error_ctype_thrown(const char *pat)
-{
-    bool result = false;
-    try {
-        std::regex re(pat);
-    } catch (const std::regex_error &ex) {
-        result = (ex.code() == std::regex_constants::error_ctype);
-    }
-    return result;
+static bool error_ctype_thrown(const char* pat) {
+  bool result = false;
+  try {
+    std::regex re(pat);
+  } catch (const std::regex_error& ex) {
+    result = (ex.code() == std::regex_constants::error_ctype);
+  }
+  return result;
 }
 
-int main(int, char**)
-{
-    assert(error_ctype_thrown("[[::]]"));
-    assert(error_ctype_thrown("[[:error:]]"));
+int main(int, char**) {
+  assert(error_ctype_thrown("[[::]]"));
+  assert(error_ctype_thrown("[[:error:]]"));
 
   return 0;
 }
diff --git a/libcxx/test/std/re/re.regex/re.regex.construct/bad_escape.pass.cpp b/libcxx/test/std/re/re.regex/re.regex.construct/bad_escape.pass.cpp
index abb854e44f692..686947726f227 100644
--- a/libcxx/test/std/re/re.regex/re.regex.construct/bad_escape.pass.cpp
+++ b/libcxx/test/std/re/re.regex/re.regex.construct/bad_escape.pass.cpp
@@ -18,32 +18,29 @@
 #include <cassert>
 #include "test_macros.h"
 
-static bool error_escape_thrown(const char *pat)
-{
-    bool result = false;
-    try {
-        std::regex re(pat);
-    } catch (const std::regex_error &ex) {
-        result = (ex.code() == std::regex_constants::error_escape);
-    }
-    return result;
+static bool error_escape_thrown(const char* pat) {
+  bool result = false;
+  try {
+    std::regex re(pat);
+  } catch (const std::regex_error& ex) {
+    result = (ex.code() == std::regex_constants::error_escape);
+  }
+  return result;
 }
 
-int main(int, char**)
-{
-    assert(error_escape_thrown("[\\a]"));
-    assert(error_escape_thrown("\\a"));
-    assert(error_escape_thrown("\\"));
+int main(int, char**) {
+  assert(error_escape_thrown("[\\a]"));
+  assert(error_escape_thrown("\\a"));
+  assert(error_escape_thrown("\\"));
 
-    assert(error_escape_thrown("[\\e]"));
-    assert(error_escape_thrown("\\e"));
-
-    assert(error_escape_thrown("[\\c:]"));
-    assert(error_escape_thrown("\\c:"));
-    assert(error_escape_thrown("\\c"));
-    assert(!error_escape_thrown("[\\cA]"));
-    assert(!error_escape_thrown("\\cA"));
+  assert(error_escape_thrown("[\\e]"));
+  assert(error_escape_thrown("\\e"));
 
+  assert(error_escape_thrown("[\\c:]"));
+  assert(error_escape_thrown("\\c:"));
+  assert(error_escape_thrown("\\c"));
+  assert(!error_escape_thrown("[\\cA]"));
+  assert(!error_escape_thrown("\\cA"));
 
   return 0;
 }
diff --git a/libcxx/test/std/re/re.regex/re.regex.construct/bad_range.pass.cpp b/libcxx/test/std/re/re.regex/re.regex.construct/bad_range.pass.cpp
index cabd9ebec520e..c05b606d84901 100644
--- a/libcxx/test/std/re/re.regex/re.regex.construct/bad_range.pass.cpp
+++ b/libcxx/test/std/re/re.regex/re.regex.construct/bad_range.pass.cpp
@@ -18,22 +18,20 @@
 #include <cassert>
 #include "test_macros.h"
 
-static bool error_range_thrown(const char *pat)
-{
-    bool result = false;
-    try {
-        std::regex re(pat);
-    } catch (const std::regex_error &ex) {
-        result = (ex.code() == std::regex_constants::error_range);
-    }
-    return result;
+static bool error_range_thrown(const char* pat) {
+  bool result = false;
+  try {
+    std::regex re(pat);
+  } catch (const std::regex_error& ex) {
+    result = (ex.code() == std::regex_constants::error_range);
+  }
+  return result;
 }
 
-int main(int, char**)
-{
-    assert(error_range_thrown("([\\w-a])"));
-    assert(error_range_thrown("([a-\\w])"));
-    assert(error_range_thrown("([w-a])"));
+int main(int, char**) {
+  assert(error_range_thrown("([\\w-a])"));
+  assert(error_range_thrown("([a-\\w])"));
+  assert(error_range_thrown("([w-a])"));
 
-    return 0;
+  return 0;
 }
diff --git a/libcxx/test/std/re/re.regex/re.regex.construct/bad_repeat.pass.cpp b/libcxx/test/std/re/re.regex/re.regex.construct/bad_repeat.pass.cpp
index b600ef70e176a..b6190cc13cfbc 100644
--- a/libcxx/test/std/re/re.regex/re.regex.construct/bad_repeat.pass.cpp
+++ b/libcxx/test/std/re/re.regex/re.regex.construct/bad_repeat.pass.cpp
@@ -18,28 +18,26 @@
 #include <cassert>
 #include "test_macros.h"
 
-static bool error_badrepeat_thrown(const char *pat)
-{
-    bool result = false;
-    try {
-        std::regex re(pat);
-    } catch (const std::regex_error &ex) {
-        result = (ex.code() == std::regex_constants::error_badrepeat);
-    }
-    return result;
+static bool error_badrepeat_thrown(const char* pat) {
+  bool result = false;
+  try {
+    std::regex re(pat);
+  } catch (const std::regex_error& ex) {
+    result = (ex.code() == std::regex_constants::error_badrepeat);
+  }
+  return result;
 }
 
-int main(int, char**)
-{
-    assert(error_badrepeat_thrown("?a"));
-    assert(error_badrepeat_thrown("*a"));
-    assert(error_badrepeat_thrown("+a"));
-    assert(error_badrepeat_thrown("{a"));
-
-    assert(error_badrepeat_thrown("?(a+)"));
-    assert(error_badrepeat_thrown("*(a+)"));
-    assert(error_badrepeat_thrown("+(a+)"));
-    assert(error_badrepeat_thrown("{(a+)"));
+int main(int, char**) {
+  assert(error_badrepeat_thrown("?a"));
+  assert(error_badrepeat_thrown("*a"));
+  assert(error_badrepeat_thrown("+a"));
+  assert(error_badrepeat_thrown("{a"));
+
+  assert(error_badrepeat_thrown("?(a+)"));
+  assert(error_badrepeat_thrown("*(a+)"));
+  assert(error_badrepeat_thrown("+(a+)"));
+  assert(error_badrepeat_thrown("{(a+)"));
 
   return 0;
 }
diff --git a/libcxx/test/std/re/re.regex/re.regex.construct/copy.pass.cpp b/libcxx/test/std/re/re.regex/re.regex.construct/copy.pass.cpp
index f3db8fe06113b..b15b9d65ca2c7 100644
--- a/libcxx/test/std/re/re.regex/re.regex.construct/copy.pass.cpp
+++ b/libcxx/test/std/re/re.regex/re.regex.construct/copy.pass.cpp
@@ -16,12 +16,11 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    std::regex r1("(a([bc]))");
-    std::regex r2 = r1;
-    assert(r2.flags() == std::regex::ECMAScript);
-    assert(r2.mark_count() == 2);
+int main(int, char**) {
+  std::regex r1("(a([bc]))");
+  std::regex r2 = r1;
+  assert(r2.flags() == std::regex::ECMAScript);
+  assert(r2.mark_count() == 2);
 
   return 0;
 }
diff --git a/libcxx/test/std/re/re.regex/re.regex.construct/deduct.pass.cpp b/libcxx/test/std/re/re.regex/re.regex.construct/deduct.pass.cpp
index db4fba0e2495a..58df5b3beb564 100644
--- a/libcxx/test/std/re/re.regex/re.regex.construct/deduct.pass.cpp
+++ b/libcxx/test/std/re/re.regex/re.regex.construct/deduct.pass.cpp
@@ -28,117 +28,115 @@ using namespace std::literals;
 
 struct A {};
 
-int main(int, char**)
-{
-
-//  Test the explicit deduction guides
-    {
-//  basic_regex(ForwardIterator, ForwardIterator)
+int main(int, char**) {
+  //  Test the explicit deduction guides
+  {
+    //  basic_regex(ForwardIterator, ForwardIterator)
     std::string s1("\\(a\\)");
     std::basic_regex re(s1.begin(), s1.end());
 
     static_assert(std::is_same_v<decltype(re), std::basic_regex<char>>, "");
     assert(re.flags() == std::regex_constants::ECMAScript);
     assert(re.mark_count() == 0);
-    }
+  }
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-    {
+  {
     std::wstring s1(L"\\(a\\)");
     std::basic_regex re(s1.begin(), s1.end(), std::regex_constants::basic);
 
     static_assert(std::is_same_v<decltype(re), std::basic_regex<wchar_t>>, "");
     assert(re.flags() == std::regex_constants::basic);
     assert(re.mark_count() == 1);
-    }
+  }
 #endif
 
-//  Test the implicit deduction guides
-    {
-//  basic_regex(string);
+  //  Test the implicit deduction guides
+  {
+    //  basic_regex(string);
     std::basic_regex re("(a([bc]))"s);
     static_assert(std::is_same_v<decltype(re), std::basic_regex<char>>, "");
     assert(re.flags() == std::regex_constants::ECMAScript);
     assert(re.mark_count() == 2);
-    }
+  }
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-    {
-//  basic_regex(string, flag_type);
+  {
+    //  basic_regex(string, flag_type);
     std::basic_regex re(L"(a([bc]))"s, std::regex_constants::awk);
     static_assert(std::is_same_v<decltype(re), std::basic_regex<wchar_t>>, "");
     assert(re.flags() == std::regex_constants::awk);
     assert(re.mark_count() == 2);
-    }
+  }
 #endif
 
-    {
-//  basic_regex(const charT*);
+  {
+    //  basic_regex(const charT*);
     std::basic_regex re("ABCDE");
     static_assert(std::is_same_v<decltype(re), std::basic_regex<char>>, "");
     assert(re.flags() == std::regex_constants::ECMAScript);
     assert(re.mark_count() == 0);
-    }
+  }
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-    {
-//  basic_regex(const charT*, flag_type);
+  {
+    //  basic_regex(const charT*, flag_type);
     std::basic_regex re(L"ABCDE", std::regex_constants::grep);
     static_assert(std::is_same_v<decltype(re), std::basic_regex<wchar_t>>, "");
     assert(re.flags() == std::regex_constants::grep);
     assert(re.mark_count() == 0);
-    }
+  }
 #endif
 
-    {
-//  basic_regex(const charT*, size_t);
+  {
+    //  basic_regex(const charT*, size_t);
     std::basic_regex re("ABCDEDEF", 7);
     static_assert(std::is_same_v<decltype(re), std::basic_regex<char>>, "");
     assert(re.flags() == std::regex_constants::ECMAScript);
     assert(re.mark_count() == 0);
-    }
+  }
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-    {
-//  basic_regex(const charT*, size_t, flag_type);
+  {
+    //  basic_regex(const charT*, size_t, flag_type);
     std::basic_regex re(L"ABCDEDEF", 8, std::regex_constants::awk);
     static_assert(std::is_same_v<decltype(re), std::basic_regex<wchar_t>>, "");
     assert(re.flags() == std::regex_constants::awk);
     assert(re.mark_count() == 0);
-    }
+  }
 #endif
 
-    {
-//  basic_regex(const basic_regex &);
+  {
+    //  basic_regex(const basic_regex &);
     std::basic_regex<char> source;
     std::basic_regex re(source);
     static_assert(std::is_same_v<decltype(re), std::basic_regex<char>>, "");
     assert(re.flags() == source.flags());
     assert(re.mark_count() == source.mark_count());
-    }
+  }
 
-    {
-//  template<class ST, class SA>
-//         explicit basic_regex(const basic_string<charT, ST, SA>& p,
-//                              flag_type f = regex_constants::ECMAScript);
-    }
+  {
+    //  template<class ST, class SA>
+    //         explicit basic_regex(const basic_string<charT, ST, SA>& p,
+    //                              flag_type f = regex_constants::ECMAScript);
+  }
 
-    {
-//  basic_regex(initializer_list);
+  {
+    //  basic_regex(initializer_list);
     std::basic_regex re({'A', 'B', 'F', 'E', 'D'});
     static_assert(std::is_same_v<decltype(re), std::basic_regex<char>>, "");
     assert(re.flags() == std::regex_constants::ECMAScript);
     assert(re.mark_count() == 0);
-    }
+  }
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-    {
-//  basic_regex(initializer_list, flag_type);
+  {
+    //  basic_regex(initializer_list, flag_type);
     std::basic_regex re({L'A', L'B', L'F', L'E', L'D'}, std::regex_constants::grep);
     static_assert(std::is_same_v<decltype(re), std::basic_regex<wchar_t>>, "");
     assert(re.flags() == std::regex_constants::grep);
     assert(re.mark_count() == 0);
-    }
+  }
 #endif
 
   return 0;
diff --git a/libcxx/test/std/re/re.regex/re.regex.construct/deduct.verify.cpp b/libcxx/test/std/re/re.regex/re.regex.construct/deduct.verify.cpp
index 8ef87cfc6468f..75bd1becac187 100644
--- a/libcxx/test/std/re/re.regex/re.regex.construct/deduct.verify.cpp
+++ b/libcxx/test/std/re/re.regex/re.regex.construct/deduct.verify.cpp
@@ -20,21 +20,25 @@
 #include <cassert>
 #include <cstddef>
 
-
-int main(int, char**)
-{
-    // Test the explicit deduction guides
-    {
+int main(int, char**) {
+  // Test the explicit deduction guides
+  {
     // basic_regex(ForwardIterator, ForwardIterator)
     // <int> is not an iterator
+
+    // clang-format off
     std::basic_regex re(23, 34);   // expected-error-re {{no viable constructor or deduction guide for deduction of template arguments of '{{(std::)?}}basic_regex'}}
-    }
+    // clang-format on
+  }
 
-    {
+  {
     // basic_regex(ForwardIterator, ForwardIterator, flag_type)
     // <double> is not an iterator
+
+    // clang-format off
     std::basic_regex re(23.0, 34.0, std::regex_constants::basic);   // expected-error-re {{no viable constructor or deduction guide for deduction of template arguments of '{{(std::)?}}basic_regex'}}
-    }
+    // clang-format on
+  }
 
-    return 0;
+  return 0;
 }
diff --git a/libcxx/test/std/re/re.regex/re.regex.construct/default.pass.cpp b/libcxx/test/std/re/re.regex/re.regex.construct/default.pass.cpp
index f0abdbfb98b54..a5dfee41bfac4 100644
--- a/libcxx/test/std/re/re.regex/re.regex.construct/default.pass.cpp
+++ b/libcxx/test/std/re/re.regex/re.regex.construct/default.pass.cpp
@@ -17,19 +17,16 @@
 #include "test_macros.h"
 
 template <class CharT>
-void
-test()
-{
-    std::basic_regex<CharT> r;
-    assert(r.flags() == std::regex_constants::ECMAScript);
-    assert(r.mark_count() == 0);
+void test() {
+  std::basic_regex<CharT> r;
+  assert(r.flags() == std::regex_constants::ECMAScript);
+  assert(r.mark_count() == 0);
 }
 
-int main(int, char**)
-{
-    test<char>();
+int main(int, char**) {
+  test<char>();
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-    test<wchar_t>();
+  test<wchar_t>();
 #endif
 
   return 0;
diff --git a/libcxx/test/std/re/re.regex/re.regex.construct/il_flg.pass.cpp b/libcxx/test/std/re/re.regex/re.regex.construct/il_flg.pass.cpp
index d57c0f700b8a5..f324f949b818a 100644
--- a/libcxx/test/std/re/re.regex/re.regex.construct/il_flg.pass.cpp
+++ b/libcxx/test/std/re/re.regex/re.regex.construct/il_flg.pass.cpp
@@ -19,52 +19,47 @@
 #include <cassert>
 #include "test_macros.h"
 
-
-void
-test(std::initializer_list<char> il, std::regex_constants::syntax_option_type f, unsigned mc)
-{
-    std::basic_regex<char> r(il, f);
-    assert(r.flags() == f);
-    assert(r.mark_count() == mc);
+void test(std::initializer_list<char> il, std::regex_constants::syntax_option_type f, unsigned mc) {
+  std::basic_regex<char> r(il, f);
+  assert(r.flags() == f);
+  assert(r.mark_count() == mc);
 }
 
-
-int main(int, char**)
-{
-    std::string s1("\\(a\\)");
-    std::string s2("\\(a[bc]\\)");
-    std::string s3("\\(a\\([bc]\\)\\)");
-    std::string s4("(a([bc]))");
-
-    test({'\\', '(', 'a', '\\', ')'}, std::regex_constants::basic, 1);
-    test({'\\', '(', 'a', '[', 'b', 'c', ']', '\\', ')'}, std::regex_constants::basic, 1);
-    test({'\\', '(', 'a', '\\', '(', '[', 'b', 'c', ']', '\\', ')', '\\', ')'}, std::regex_constants::basic, 2);
-    test({'(', 'a', '(', '[', 'b', 'c', ']', ')', ')'}, std::regex_constants::basic, 0);
-
-    test({'\\', '(', 'a', '\\', ')'}, std::regex_constants::extended, 0);
-    test({'\\', '(', 'a', '[', 'b', 'c', ']', '\\', ')'}, std::regex_constants::extended, 0);
-    test({'\\', '(', 'a', '\\', '(', '[', 'b', 'c', ']', '\\', ')', '\\', ')'}, std::regex_constants::extended, 0);
-    test({'(', 'a', '(', '[', 'b', 'c', ']', ')', ')'}, std::regex_constants::extended, 2);
-
-    test({'\\', '(', 'a', '\\', ')'}, std::regex_constants::ECMAScript, 0);
-    test({'\\', '(', 'a', '[', 'b', 'c', ']', '\\', ')'}, std::regex_constants::ECMAScript, 0);
-    test({'\\', '(', 'a', '\\', '(', '[', 'b', 'c', ']', '\\', ')', '\\', ')'}, std::regex_constants::ECMAScript, 0);
-    test({'(', 'a', '(', '[', 'b', 'c', ']', ')', ')'}, std::regex_constants::ECMAScript, 2);
-
-    test({'\\', '(', 'a', '\\', ')'}, std::regex_constants::awk, 0);
-    test({'\\', '(', 'a', '[', 'b', 'c', ']', '\\', ')'}, std::regex_constants::awk, 0);
-    test({'\\', '(', 'a', '\\', '(', '[', 'b', 'c', ']', '\\', ')', '\\', ')'}, std::regex_constants::awk, 0);
-    test({'(', 'a', '(', '[', 'b', 'c', ']', ')', ')'}, std::regex_constants::awk, 2);
-
-    test({'\\', '(', 'a', '\\', ')'}, std::regex_constants::grep, 1);
-    test({'\\', '(', 'a', '[', 'b', 'c', ']', '\\', ')'}, std::regex_constants::grep, 1);
-    test({'\\', '(', 'a', '\\', '(', '[', 'b', 'c', ']', '\\', ')', '\\', ')'}, std::regex_constants::grep, 2);
-    test({'(', 'a', '(', '[', 'b', 'c', ']', ')', ')'}, std::regex_constants::grep, 0);
-
-    test({'\\', '(', 'a', '\\', ')'}, std::regex_constants::egrep, 0);
-    test({'\\', '(', 'a', '[', 'b', 'c', ']', '\\', ')'}, std::regex_constants::egrep, 0);
-    test({'\\', '(', 'a', '\\', '(', '[', 'b', 'c', ']', '\\', ')', '\\', ')'}, std::regex_constants::egrep, 0);
-    test({'(', 'a', '(', '[', 'b', 'c', ']', ')', ')'}, std::regex_constants::egrep, 2);
+int main(int, char**) {
+  std::string s1("\\(a\\)");
+  std::string s2("\\(a[bc]\\)");
+  std::string s3("\\(a\\([bc]\\)\\)");
+  std::string s4("(a([bc]))");
+
+  test({'\\', '(', 'a', '\\', ')'}, std::regex_constants::basic, 1);
+  test({'\\', '(', 'a', '[', 'b', 'c', ']', '\\', ')'}, std::regex_constants::basic, 1);
+  test({'\\', '(', 'a', '\\', '(', '[', 'b', 'c', ']', '\\', ')', '\\', ')'}, std::regex_constants::basic, 2);
+  test({'(', 'a', '(', '[', 'b', 'c', ']', ')', ')'}, std::regex_constants::basic, 0);
+
+  test({'\\', '(', 'a', '\\', ')'}, std::regex_constants::extended, 0);
+  test({'\\', '(', 'a', '[', 'b', 'c', ']', '\\', ')'}, std::regex_constants::extended, 0);
+  test({'\\', '(', 'a', '\\', '(', '[', 'b', 'c', ']', '\\', ')', '\\', ')'}, std::regex_constants::extended, 0);
+  test({'(', 'a', '(', '[', 'b', 'c', ']', ')', ')'}, std::regex_constants::extended, 2);
+
+  test({'\\', '(', 'a', '\\', ')'}, std::regex_constants::ECMAScript, 0);
+  test({'\\', '(', 'a', '[', 'b', 'c', ']', '\\', ')'}, std::regex_constants::ECMAScript, 0);
+  test({'\\', '(', 'a', '\\', '(', '[', 'b', 'c', ']', '\\', ')', '\\', ')'}, std::regex_constants::ECMAScript, 0);
+  test({'(', 'a', '(', '[', 'b', 'c', ']', ')', ')'}, std::regex_constants::ECMAScript, 2);
+
+  test({'\\', '(', 'a', '\\', ')'}, std::regex_constants::awk, 0);
+  test({'\\', '(', 'a', '[', 'b', 'c', ']', '\\', ')'}, std::regex_constants::awk, 0);
+  test({'\\', '(', 'a', '\\', '(', '[', 'b', 'c', ']', '\\', ')', '\\', ')'}, std::regex_constants::awk, 0);
+  test({'(', 'a', '(', '[', 'b', 'c', ']', ')', ')'}, std::regex_constants::awk, 2);
+
+  test({'\\', '(', 'a', '\\', ')'}, std::regex_constants::grep, 1);
+  test({'\\', '(', 'a', '[', 'b', 'c', ']', '\\', ')'}, std::regex_constants::grep, 1);
+  test({'\\', '(', 'a', '\\', '(', '[', 'b', 'c', ']', '\\', ')', '\\', ')'}, std::regex_constants::grep, 2);
+  test({'(', 'a', '(', '[', 'b', 'c', ']', ')', ')'}, std::regex_constants::grep, 0);
+
+  test({'\\', '(', 'a', '\\', ')'}, std::regex_constants::egrep, 0);
+  test({'\\', '(', 'a', '[', 'b', 'c', ']', '\\', ')'}, std::regex_constants::egrep, 0);
+  test({'\\', '(', 'a', '\\', '(', '[', 'b', 'c', ']', '\\', ')', '\\', ')'}, std::regex_constants::egrep, 0);
+  test({'(', 'a', '(', '[', 'b', 'c', ']', ')', ')'}, std::regex_constants::egrep, 2);
 
   return 0;
 }
diff --git a/libcxx/test/std/re/re.regex/re.regex.construct/iter_iter.pass.cpp b/libcxx/test/std/re/re.regex/re.regex.construct/iter_iter.pass.cpp
index 3dcf29fa00965..eaeb26e0595fb 100644
--- a/libcxx/test/std/re/re.regex/re.regex.construct/iter_iter.pass.cpp
+++ b/libcxx/test/std/re/re.regex/re.regex.construct/iter_iter.pass.cpp
@@ -20,26 +20,23 @@
 #include "test_macros.h"
 
 template <class Iter>
-void
-test(Iter first, Iter last, unsigned mc)
-{
-    std::basic_regex<typename std::iterator_traits<Iter>::value_type> r(first, last);
-    assert(r.flags() == std::regex_constants::ECMAScript);
-    assert(r.mark_count() == mc);
+void test(Iter first, Iter last, unsigned mc) {
+  std::basic_regex<typename std::iterator_traits<Iter>::value_type> r(first, last);
+  assert(r.flags() == std::regex_constants::ECMAScript);
+  assert(r.mark_count() == mc);
 }
 
-int main(int, char**)
-{
-    typedef forward_iterator<std::string::const_iterator> F;
-    std::string s1("\\(a\\)");
-    std::string s2("\\(a[bc]\\)");
-    std::string s3("\\(a\\([bc]\\)\\)");
-    std::string s4("(a([bc]))");
-
-    test(F(s1.begin()), F(s1.end()), 0);
-    test(F(s2.begin()), F(s2.end()), 0);
-    test(F(s3.begin()), F(s3.end()), 0);
-    test(F(s4.begin()), F(s4.end()), 2);
+int main(int, char**) {
+  typedef forward_iterator<std::string::const_iterator> F;
+  std::string s1("\\(a\\)");
+  std::string s2("\\(a[bc]\\)");
+  std::string s3("\\(a\\([bc]\\)\\)");
+  std::string s4("(a([bc]))");
+
+  test(F(s1.begin()), F(s1.end()), 0);
+  test(F(s2.begin()), F(s2.end()), 0);
+  test(F(s3.begin()), F(s3.end()), 0);
+  test(F(s4.begin()), F(s4.end()), 2);
 
   return 0;
 }
diff --git a/libcxx/test/std/re/re.regex/re.regex.construct/iter_iter_flg.pass.cpp b/libcxx/test/std/re/re.regex/re.regex.construct/iter_iter_flg.pass.cpp
index 22423c0928207..1f2e977b39219 100644
--- a/libcxx/test/std/re/re.regex/re.regex.construct/iter_iter_flg.pass.cpp
+++ b/libcxx/test/std/re/re.regex/re.regex.construct/iter_iter_flg.pass.cpp
@@ -21,51 +21,48 @@
 #include "test_macros.h"
 
 template <class Iter>
-void
-test(Iter first, Iter last, std::regex_constants::syntax_option_type f, unsigned mc)
-{
-    std::basic_regex<typename std::iterator_traits<Iter>::value_type> r(first, last, f);
-    assert(r.flags() == f);
-    assert(r.mark_count() == mc);
+void test(Iter first, Iter last, std::regex_constants::syntax_option_type f, unsigned mc) {
+  std::basic_regex<typename std::iterator_traits<Iter>::value_type> r(first, last, f);
+  assert(r.flags() == f);
+  assert(r.mark_count() == mc);
 }
 
-int main(int, char**)
-{
-    typedef forward_iterator<std::string::const_iterator> F;
-    std::string s1("\\(a\\)");
-    std::string s2("\\(a[bc]\\)");
-    std::string s3("\\(a\\([bc]\\)\\)");
-    std::string s4("(a([bc]))");
+int main(int, char**) {
+  typedef forward_iterator<std::string::const_iterator> F;
+  std::string s1("\\(a\\)");
+  std::string s2("\\(a[bc]\\)");
+  std::string s3("\\(a\\([bc]\\)\\)");
+  std::string s4("(a([bc]))");
 
-    test(F(s1.begin()), F(s1.end()), std::regex_constants::basic, 1);
-    test(F(s2.begin()), F(s2.end()), std::regex_constants::basic, 1);
-    test(F(s3.begin()), F(s3.end()), std::regex_constants::basic, 2);
-    test(F(s4.begin()), F(s4.end()), std::regex_constants::basic, 0);
+  test(F(s1.begin()), F(s1.end()), std::regex_constants::basic, 1);
+  test(F(s2.begin()), F(s2.end()), std::regex_constants::basic, 1);
+  test(F(s3.begin()), F(s3.end()), std::regex_constants::basic, 2);
+  test(F(s4.begin()), F(s4.end()), std::regex_constants::basic, 0);
 
-    test(F(s1.begin()), F(s1.end()), std::regex_constants::extended, 0);
-    test(F(s2.begin()), F(s2.end()), std::regex_constants::extended, 0);
-    test(F(s3.begin()), F(s3.end()), std::regex_constants::extended, 0);
-    test(F(s4.begin()), F(s4.end()), std::regex_constants::extended, 2);
+  test(F(s1.begin()), F(s1.end()), std::regex_constants::extended, 0);
+  test(F(s2.begin()), F(s2.end()), std::regex_constants::extended, 0);
+  test(F(s3.begin()), F(s3.end()), std::regex_constants::extended, 0);
+  test(F(s4.begin()), F(s4.end()), std::regex_constants::extended, 2);
 
-    test(F(s1.begin()), F(s1.end()), std::regex_constants::ECMAScript, 0);
-    test(F(s2.begin()), F(s2.end()), std::regex_constants::ECMAScript, 0);
-    test(F(s3.begin()), F(s3.end()), std::regex_constants::ECMAScript, 0);
-    test(F(s4.begin()), F(s4.end()), std::regex_constants::ECMAScript, 2);
+  test(F(s1.begin()), F(s1.end()), std::regex_constants::ECMAScript, 0);
+  test(F(s2.begin()), F(s2.end()), std::regex_constants::ECMAScript, 0);
+  test(F(s3.begin()), F(s3.end()), std::regex_constants::ECMAScript, 0);
+  test(F(s4.begin()), F(s4.end()), std::regex_constants::ECMAScript, 2);
 
-    test(F(s1.begin()), F(s1.end()), std::regex_constants::awk, 0);
-    test(F(s2.begin()), F(s2.end()), std::regex_constants::awk, 0);
-    test(F(s3.begin()), F(s3.end()), std::regex_constants::awk, 0);
-    test(F(s4.begin()), F(s4.end()), std::regex_constants::awk, 2);
+  test(F(s1.begin()), F(s1.end()), std::regex_constants::awk, 0);
+  test(F(s2.begin()), F(s2.end()), std::regex_constants::awk, 0);
+  test(F(s3.begin()), F(s3.end()), std::regex_constants::awk, 0);
+  test(F(s4.begin()), F(s4.end()), std::regex_constants::awk, 2);
 
-    test(F(s1.begin()), F(s1.end()), std::regex_constants::grep, 1);
-    test(F(s2.begin()), F(s2.end()), std::regex_constants::grep, 1);
-    test(F(s3.begin()), F(s3.end()), std::regex_constants::grep, 2);
-    test(F(s4.begin()), F(s4.end()), std::regex_constants::grep, 0);
+  test(F(s1.begin()), F(s1.end()), std::regex_constants::grep, 1);
+  test(F(s2.begin()), F(s2.end()), std::regex_constants::grep, 1);
+  test(F(s3.begin()), F(s3.end()), std::regex_constants::grep, 2);
+  test(F(s4.begin()), F(s4.end()), std::regex_constants::grep, 0);
 
-    test(F(s1.begin()), F(s1.end()), std::regex_constants::egrep, 0);
-    test(F(s2.begin()), F(s2.end()), std::regex_constants::egrep, 0);
-    test(F(s3.begin()), F(s3.end()), std::regex_constants::egrep, 0);
-    test(F(s4.begin()), F(s4.end()), std::regex_constants::egrep, 2);
+  test(F(s1.begin()), F(s1.end()), std::regex_constants::egrep, 0);
+  test(F(s2.begin()), F(s2.end()), std::regex_constants::egrep, 0);
+  test(F(s3.begin()), F(s3.end()), std::regex_constants::egrep, 0);
+  test(F(s4.begin()), F(s4.end()), std::regex_constants::egrep, 2);
 
   return 0;
 }
diff --git a/libcxx/test/std/re/re.regex/re.regex.construct/ptr.pass.cpp b/libcxx/test/std/re/re.regex/re.regex.construct/ptr.pass.cpp
index b71d9eb7f497c..5473bb8b8a8cc 100644
--- a/libcxx/test/std/re/re.regex/re.regex.construct/ptr.pass.cpp
+++ b/libcxx/test/std/re/re.regex/re.regex.construct/ptr.pass.cpp
@@ -17,20 +17,17 @@
 #include "test_macros.h"
 
 template <class CharT>
-void
-test(const CharT* p, unsigned mc)
-{
-    std::basic_regex<CharT> r(p);
-    assert(r.flags() == std::regex_constants::ECMAScript);
-    assert(r.mark_count() == mc);
+void test(const CharT* p, unsigned mc) {
+  std::basic_regex<CharT> r(p);
+  assert(r.flags() == std::regex_constants::ECMAScript);
+  assert(r.mark_count() == mc);
 }
 
-int main(int, char**)
-{
-    test("\\(a\\)", 0);
-    test("\\(a[bc]\\)", 0);
-    test("\\(a\\([bc]\\)\\)", 0);
-    test("(a([bc]))", 2);
+int main(int, char**) {
+  test("\\(a\\)", 0);
+  test("\\(a[bc]\\)", 0);
+  test("\\(a\\([bc]\\)\\)", 0);
+  test("(a([bc]))", 2);
 
   return 0;
 }
diff --git a/libcxx/test/std/re/re.regex/re.regex.construct/ptr_flg.pass.cpp b/libcxx/test/std/re/re.regex/re.regex.construct/ptr_flg.pass.cpp
index e918b03116ba9..a0fc488f9e304 100644
--- a/libcxx/test/std/re/re.regex/re.regex.construct/ptr_flg.pass.cpp
+++ b/libcxx/test/std/re/re.regex/re.regex.construct/ptr_flg.pass.cpp
@@ -17,45 +17,42 @@
 #include "test_macros.h"
 
 template <class CharT>
-void
-test(const CharT* p, std::regex_constants::syntax_option_type f, unsigned mc)
-{
-    std::basic_regex<CharT> r(p, f);
-    assert(r.flags() == f);
-    assert(r.mark_count() == mc);
+void test(const CharT* p, std::regex_constants::syntax_option_type f, unsigned mc) {
+  std::basic_regex<CharT> r(p, f);
+  assert(r.flags() == f);
+  assert(r.mark_count() == mc);
 }
 
-int main(int, char**)
-{
-    test("\\(a\\)", std::regex_constants::basic, 1);
-    test("\\(a[bc]\\)", std::regex_constants::basic, 1);
-    test("\\(a\\([bc]\\)\\)", std::regex_constants::basic, 2);
-    test("(a([bc]))", std::regex_constants::basic, 0);
-
-    test("\\(a\\)", std::regex_constants::extended, 0);
-    test("\\(a[bc]\\)", std::regex_constants::extended, 0);
-    test("\\(a\\([bc]\\)\\)", std::regex_constants::extended, 0);
-    test("(a([bc]))", std::regex_constants::extended, 2);
-
-    test("\\(a\\)", std::regex_constants::ECMAScript, 0);
-    test("\\(a[bc]\\)", std::regex_constants::ECMAScript, 0);
-    test("\\(a\\([bc]\\)\\)", std::regex_constants::ECMAScript, 0);
-    test("(a([bc]))", std::regex_constants::ECMAScript, 2);
-
-    test("\\(a\\)", std::regex_constants::awk, 0);
-    test("\\(a[bc]\\)", std::regex_constants::awk, 0);
-    test("\\(a\\([bc]\\)\\)", std::regex_constants::awk, 0);
-    test("(a([bc]))", std::regex_constants::awk, 2);
-
-    test("\\(a\\)", std::regex_constants::grep, 1);
-    test("\\(a[bc]\\)", std::regex_constants::grep, 1);
-    test("\\(a\\([bc]\\)\\)", std::regex_constants::grep, 2);
-    test("(a([bc]))", std::regex_constants::grep, 0);
-
-    test("\\(a\\)", std::regex_constants::egrep, 0);
-    test("\\(a[bc]\\)", std::regex_constants::egrep, 0);
-    test("\\(a\\([bc]\\)\\)", std::regex_constants::egrep, 0);
-    test("(a([bc]))", std::regex_constants::egrep, 2);
+int main(int, char**) {
+  test("\\(a\\)", std::regex_constants::basic, 1);
+  test("\\(a[bc]\\)", std::regex_constants::basic, 1);
+  test("\\(a\\([bc]\\)\\)", std::regex_constants::basic, 2);
+  test("(a([bc]))", std::regex_constants::basic, 0);
+
+  test("\\(a\\)", std::regex_constants::extended, 0);
+  test("\\(a[bc]\\)", std::regex_constants::extended, 0);
+  test("\\(a\\([bc]\\)\\)", std::regex_constants::extended, 0);
+  test("(a([bc]))", std::regex_constants::extended, 2);
+
+  test("\\(a\\)", std::regex_constants::ECMAScript, 0);
+  test("\\(a[bc]\\)", std::regex_constants::ECMAScript, 0);
+  test("\\(a\\([bc]\\)\\)", std::regex_constants::ECMAScript, 0);
+  test("(a([bc]))", std::regex_constants::ECMAScript, 2);
+
+  test("\\(a\\)", std::regex_constants::awk, 0);
+  test("\\(a[bc]\\)", std::regex_constants::awk, 0);
+  test("\\(a\\([bc]\\)\\)", std::regex_constants::awk, 0);
+  test("(a([bc]))", std::regex_constants::awk, 2);
+
+  test("\\(a\\)", std::regex_constants::grep, 1);
+  test("\\(a[bc]\\)", std::regex_constants::grep, 1);
+  test("\\(a\\([bc]\\)\\)", std::regex_constants::grep, 2);
+  test("(a([bc]))", std::regex_constants::grep, 0);
+
+  test("\\(a\\)", std::regex_constants::egrep, 0);
+  test("\\(a[bc]\\)", std::regex_constants::egrep, 0);
+  test("\\(a\\([bc]\\)\\)", std::regex_constants::egrep, 0);
+  test("(a([bc]))", std::regex_constants::egrep, 2);
 
   return 0;
 }
diff --git a/libcxx/test/std/re/re.regex/re.regex.construct/ptr_size.pass.cpp b/libcxx/test/std/re/re.regex/re.regex.construct/ptr_size.pass.cpp
index 1d99069f1b0de..7a9e579434e65 100644
--- a/libcxx/test/std/re/re.regex/re.regex.construct/ptr_size.pass.cpp
+++ b/libcxx/test/std/re/re.regex/re.regex.construct/ptr_size.pass.cpp
@@ -18,25 +18,22 @@
 #include "test_macros.h"
 
 template <class CharT>
-void
-test(const CharT* p, std::size_t len, unsigned mc)
-{
-    std::basic_regex<CharT> r(p, len);
-    assert(r.flags() == std::regex_constants::ECMAScript);
-    assert(r.mark_count() == mc);
+void test(const CharT* p, std::size_t len, unsigned mc) {
+  std::basic_regex<CharT> r(p, len);
+  assert(r.flags() == std::regex_constants::ECMAScript);
+  assert(r.mark_count() == mc);
 }
 
-int main(int, char**)
-{
-    test("\\(a\\)", 5, 0);
-    test("\\(a[bc]\\)", 9, 0);
-    test("\\(a\\([bc]\\)\\)", 13, 0);
-    test("(a([bc]))", 9, 2);
-
-    test("(\0)(b)(c)(d)", 12, 4);
-    test("(\0)(b)(c)(d)", 9, 3);
-    test("(\0)(b)(c)(d)", 3, 1);
-    test("(\0)(b)(c)(d)", 0, 0);
+int main(int, char**) {
+  test("\\(a\\)", 5, 0);
+  test("\\(a[bc]\\)", 9, 0);
+  test("\\(a\\([bc]\\)\\)", 13, 0);
+  test("(a([bc]))", 9, 2);
+
+  test("(\0)(b)(c)(d)", 12, 4);
+  test("(\0)(b)(c)(d)", 9, 3);
+  test("(\0)(b)(c)(d)", 3, 1);
+  test("(\0)(b)(c)(d)", 0, 0);
 
   return 0;
 }
diff --git a/libcxx/test/std/re/re.regex/re.regex.construct/ptr_size_flg.pass.cpp b/libcxx/test/std/re/re.regex/re.regex.construct/ptr_size_flg.pass.cpp
index 07f3947318ed3..73296efa87d83 100644
--- a/libcxx/test/std/re/re.regex/re.regex.construct/ptr_size_flg.pass.cpp
+++ b/libcxx/test/std/re/re.regex/re.regex.construct/ptr_size_flg.pass.cpp
@@ -17,46 +17,42 @@
 #include "test_macros.h"
 
 template <class CharT>
-void
-test(const CharT* p, std::size_t len, std::regex_constants::syntax_option_type f,
-     unsigned mc)
-{
-    std::basic_regex<CharT> r(p, len, f);
-    assert(r.flags() == f);
-    assert(r.mark_count() == mc);
+void test(const CharT* p, std::size_t len, std::regex_constants::syntax_option_type f, unsigned mc) {
+  std::basic_regex<CharT> r(p, len, f);
+  assert(r.flags() == f);
+  assert(r.mark_count() == mc);
 }
 
-int main(int, char**)
-{
-    test("\\(a\\)", 5, std::regex_constants::basic, 1);
-    test("\\(a[bc]\\)", 9, std::regex_constants::basic, 1);
-    test("\\(a\\([bc]\\)\\)", 13, std::regex_constants::basic, 2);
-    test("(a([bc]))", 9, std::regex_constants::basic, 0);
-
-    test("\\(a\\)", 5, std::regex_constants::extended, 0);
-    test("\\(a[bc]\\)", 9, std::regex_constants::extended, 0);
-    test("\\(a\\([bc]\\)\\)", 13, std::regex_constants::extended, 0);
-    test("(a([bc]))", 9, std::regex_constants::extended, 2);
-
-    test("\\(a\\)", 5, std::regex_constants::ECMAScript, 0);
-    test("\\(a[bc]\\)", 9, std::regex_constants::ECMAScript, 0);
-    test("\\(a\\([bc]\\)\\)", 13, std::regex_constants::ECMAScript, 0);
-    test("(a([bc]))", 9, std::regex_constants::ECMAScript, 2);
-
-    test("\\(a\\)", 5, std::regex_constants::awk, 0);
-    test("\\(a[bc]\\)", 9, std::regex_constants::awk, 0);
-    test("\\(a\\([bc]\\)\\)", 13, std::regex_constants::awk, 0);
-    test("(a([bc]))", 9, std::regex_constants::awk, 2);
-
-    test("\\(a\\)", 5, std::regex_constants::grep, 1);
-    test("\\(a[bc]\\)", 9, std::regex_constants::grep, 1);
-    test("\\(a\\([bc]\\)\\)", 13, std::regex_constants::grep, 2);
-    test("(a([bc]))", 9, std::regex_constants::grep, 0);
-
-    test("\\(a\\)", 5, std::regex_constants::egrep, 0);
-    test("\\(a[bc]\\)", 9, std::regex_constants::egrep, 0);
-    test("\\(a\\([bc]\\)\\)", 13, std::regex_constants::egrep, 0);
-    test("(a([bc]))", 9, std::regex_constants::egrep, 2);
+int main(int, char**) {
+  test("\\(a\\)", 5, std::regex_constants::basic, 1);
+  test("\\(a[bc]\\)", 9, std::regex_constants::basic, 1);
+  test("\\(a\\([bc]\\)\\)", 13, std::regex_constants::basic, 2);
+  test("(a([bc]))", 9, std::regex_constants::basic, 0);
+
+  test("\\(a\\)", 5, std::regex_constants::extended, 0);
+  test("\\(a[bc]\\)", 9, std::regex_constants::extended, 0);
+  test("\\(a\\([bc]\\)\\)", 13, std::regex_constants::extended, 0);
+  test("(a([bc]))", 9, std::regex_constants::extended, 2);
+
+  test("\\(a\\)", 5, std::regex_constants::ECMAScript, 0);
+  test("\\(a[bc]\\)", 9, std::regex_constants::ECMAScript, 0);
+  test("\\(a\\([bc]\\)\\)", 13, std::regex_constants::ECMAScript, 0);
+  test("(a([bc]))", 9, std::regex_constants::ECMAScript, 2);
+
+  test("\\(a\\)", 5, std::regex_constants::awk, 0);
+  test("\\(a[bc]\\)", 9, std::regex_constants::awk, 0);
+  test("\\(a\\([bc]\\)\\)", 13, std::regex_constants::awk, 0);
+  test("(a([bc]))", 9, std::regex_constants::awk, 2);
+
+  test("\\(a\\)", 5, std::regex_constants::grep, 1);
+  test("\\(a[bc]\\)", 9, std::regex_constants::grep, 1);
+  test("\\(a\\([bc]\\)\\)", 13, std::regex_constants::grep, 2);
+  test("(a([bc]))", 9, std::regex_constants::grep, 0);
+
+  test("\\(a\\)", 5, std::regex_constants::egrep, 0);
+  test("\\(a[bc]\\)", 9, std::regex_constants::egrep, 0);
+  test("\\(a\\([bc]\\)\\)", 13, std::regex_constants::egrep, 0);
+  test("(a([bc]))", 9, std::regex_constants::egrep, 2);
 
   return 0;
 }
diff --git a/libcxx/test/std/re/re.regex/re.regex.construct/string.pass.cpp b/libcxx/test/std/re/re.regex/re.regex.construct/string.pass.cpp
index ecd0451d82b82..d10e7ca7a0a6f 100644
--- a/libcxx/test/std/re/re.regex/re.regex.construct/string.pass.cpp
+++ b/libcxx/test/std/re/re.regex/re.regex.construct/string.pass.cpp
@@ -18,20 +18,17 @@
 #include "test_macros.h"
 
 template <class String>
-void
-test(const String& p, unsigned mc)
-{
-    std::basic_regex<typename String::value_type> r(p);
-    assert(r.flags() == std::regex_constants::ECMAScript);
-    assert(r.mark_count() == mc);
+void test(const String& p, unsigned mc) {
+  std::basic_regex<typename String::value_type> r(p);
+  assert(r.flags() == std::regex_constants::ECMAScript);
+  assert(r.mark_count() == mc);
 }
 
-int main(int, char**)
-{
-    test(std::string("\\(a\\)"), 0);
-    test(std::string("\\(a[bc]\\)"), 0);
-    test(std::string("\\(a\\([bc]\\)\\)"), 0);
-    test(std::string("(a([bc]))"), 2);
+int main(int, char**) {
+  test(std::string("\\(a\\)"), 0);
+  test(std::string("\\(a[bc]\\)"), 0);
+  test(std::string("\\(a\\([bc]\\)\\)"), 0);
+  test(std::string("(a([bc]))"), 2);
 
   return 0;
 }
diff --git a/libcxx/test/std/re/re.regex/re.regex.construct/string_flg.pass.cpp b/libcxx/test/std/re/re.regex/re.regex.construct/string_flg.pass.cpp
index b6bd8c53c5ae2..882b7f9f90156 100644
--- a/libcxx/test/std/re/re.regex/re.regex.construct/string_flg.pass.cpp
+++ b/libcxx/test/std/re/re.regex/re.regex.construct/string_flg.pass.cpp
@@ -19,45 +19,42 @@
 #include "test_macros.h"
 
 template <class String>
-void
-test(const String& p, std::regex_constants::syntax_option_type f, unsigned mc)
-{
-    std::basic_regex<typename String::value_type> r(p, f);
-    assert(r.flags() == f);
-    assert(r.mark_count() == mc);
+void test(const String& p, std::regex_constants::syntax_option_type f, unsigned mc) {
+  std::basic_regex<typename String::value_type> r(p, f);
+  assert(r.flags() == f);
+  assert(r.mark_count() == mc);
 }
 
-int main(int, char**)
-{
-    test(std::string("\\(a\\)"), std::regex_constants::basic, 1);
-    test(std::string("\\(a[bc]\\)"), std::regex_constants::basic, 1);
-    test(std::string("\\(a\\([bc]\\)\\)"), std::regex_constants::basic, 2);
-    test(std::string("(a([bc]))"), std::regex_constants::basic, 0);
-
-    test(std::string("\\(a\\)"), std::regex_constants::extended, 0);
-    test(std::string("\\(a[bc]\\)"), std::regex_constants::extended, 0);
-    test(std::string("\\(a\\([bc]\\)\\)"), std::regex_constants::extended, 0);
-    test(std::string("(a([bc]))"), std::regex_constants::extended, 2);
-
-    test(std::string("\\(a\\)"), std::regex_constants::ECMAScript, 0);
-    test(std::string("\\(a[bc]\\)"), std::regex_constants::ECMAScript, 0);
-    test(std::string("\\(a\\([bc]\\)\\)"), std::regex_constants::ECMAScript, 0);
-    test(std::string("(a([bc]))"), std::regex_constants::ECMAScript, 2);
-
-    test(std::string("\\(a\\)"), std::regex_constants::awk, 0);
-    test(std::string("\\(a[bc]\\)"), std::regex_constants::awk, 0);
-    test(std::string("\\(a\\([bc]\\)\\)"), std::regex_constants::awk, 0);
-    test(std::string("(a([bc]))"), std::regex_constants::awk, 2);
-
-    test(std::string("\\(a\\)"), std::regex_constants::grep, 1);
-    test(std::string("\\(a[bc]\\)"), std::regex_constants::grep, 1);
-    test(std::string("\\(a\\([bc]\\)\\)"), std::regex_constants::grep, 2);
-    test(std::string("(a([bc]))"), std::regex_constants::grep, 0);
-
-    test(std::string("\\(a\\)"), std::regex_constants::egrep, 0);
-    test(std::string("\\(a[bc]\\)"), std::regex_constants::egrep, 0);
-    test(std::string("\\(a\\([bc]\\)\\)"), std::regex_constants::egrep, 0);
-    test(std::string("(a([bc]))"), std::regex_constants::egrep, 2);
+int main(int, char**) {
+  test(std::string("\\(a\\)"), std::regex_constants::basic, 1);
+  test(std::string("\\(a[bc]\\)"), std::regex_constants::basic, 1);
+  test(std::string("\\(a\\([bc]\\)\\)"), std::regex_constants::basic, 2);
+  test(std::string("(a([bc]))"), std::regex_constants::basic, 0);
+
+  test(std::string("\\(a\\)"), std::regex_constants::extended, 0);
+  test(std::string("\\(a[bc]\\)"), std::regex_constants::extended, 0);
+  test(std::string("\\(a\\([bc]\\)\\)"), std::regex_constants::extended, 0);
+  test(std::string("(a([bc]))"), std::regex_constants::extended, 2);
+
+  test(std::string("\\(a\\)"), std::regex_constants::ECMAScript, 0);
+  test(std::string("\\(a[bc]\\)"), std::regex_constants::ECMAScript, 0);
+  test(std::string("\\(a\\([bc]\\)\\)"), std::regex_constants::ECMAScript, 0);
+  test(std::string("(a([bc]))"), std::regex_constants::ECMAScript, 2);
+
+  test(std::string("\\(a\\)"), std::regex_constants::awk, 0);
+  test(std::string("\\(a[bc]\\)"), std::regex_constants::awk, 0);
+  test(std::string("\\(a\\([bc]\\)\\)"), std::regex_constants::awk, 0);
+  test(std::string("(a([bc]))"), std::regex_constants::awk, 2);
+
+  test(std::string("\\(a\\)"), std::regex_constants::grep, 1);
+  test(std::string("\\(a[bc]\\)"), std::regex_constants::grep, 1);
+  test(std::string("\\(a\\([bc]\\)\\)"), std::regex_constants::grep, 2);
+  test(std::string("(a([bc]))"), std::regex_constants::grep, 0);
+
+  test(std::string("\\(a\\)"), std::regex_constants::egrep, 0);
+  test(std::string("\\(a[bc]\\)"), std::regex_constants::egrep, 0);
+  test(std::string("\\(a\\([bc]\\)\\)"), std::regex_constants::egrep, 0);
+  test(std::string("(a([bc]))"), std::regex_constants::egrep, 2);
 
   return 0;
 }
diff --git a/libcxx/test/std/re/re.regex/re.regex.locale/imbue.pass.cpp b/libcxx/test/std/re/re.regex/re.regex.locale/imbue.pass.cpp
index 27647f1238b42..ae4ec6dfc70dc 100644
--- a/libcxx/test/std/re/re.regex/re.regex.locale/imbue.pass.cpp
+++ b/libcxx/test/std/re/re.regex/re.regex.locale/imbue.pass.cpp
@@ -21,15 +21,14 @@
 #include "test_macros.h"
 #include "platform_support.h" // locale name macros
 
-int main(int, char**)
-{
-    std::regex r;
-    std::locale loc = r.imbue(std::locale(LOCALE_en_US_UTF_8));
-    assert(loc.name() == "C");
-    assert(r.getloc().name() == LOCALE_en_US_UTF_8);
-    loc = r.imbue(std::locale("C"));
-    assert(loc.name() == LOCALE_en_US_UTF_8);
-    assert(r.getloc().name() == "C");
+int main(int, char**) {
+  std::regex r;
+  std::locale loc = r.imbue(std::locale(LOCALE_en_US_UTF_8));
+  assert(loc.name() == "C");
+  assert(r.getloc().name() == LOCALE_en_US_UTF_8);
+  loc = r.imbue(std::locale("C"));
+  assert(loc.name() == LOCALE_en_US_UTF_8);
+  assert(r.getloc().name() == "C");
 
   return 0;
 }
diff --git a/libcxx/test/std/re/re.regex/re.regex.nonmemb/re.regex.nmswap/swap.pass.cpp b/libcxx/test/std/re/re.regex/re.regex.nonmemb/re.regex.nmswap/swap.pass.cpp
index bb3291be6f05f..6218845bf79f8 100644
--- a/libcxx/test/std/re/re.regex/re.regex.nonmemb/re.regex.nmswap/swap.pass.cpp
+++ b/libcxx/test/std/re/re.regex/re.regex.nonmemb/re.regex.nmswap/swap.pass.cpp
@@ -17,15 +17,14 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    std::regex r1("(a([bc]))");
-    std::regex r2;
-    swap(r2, r1);
-    assert(r1.flags() == std::regex::ECMAScript);
-    assert(r1.mark_count() == 0);
-    assert(r2.flags() == std::regex::ECMAScript);
-    assert(r2.mark_count() == 2);
+int main(int, char**) {
+  std::regex r1("(a([bc]))");
+  std::regex r2;
+  swap(r2, r1);
+  assert(r1.flags() == std::regex::ECMAScript);
+  assert(r1.mark_count() == 0);
+  assert(r2.flags() == std::regex::ECMAScript);
+  assert(r2.mark_count() == 2);
 
   return 0;
 }
diff --git a/libcxx/test/std/re/re.regex/re.regex.operations/tested_elsewhere.pass.cpp b/libcxx/test/std/re/re.regex/re.regex.operations/tested_elsewhere.pass.cpp
index 1f764da05d6b5..3e0d2a6570f42 100644
--- a/libcxx/test/std/re/re.regex/re.regex.operations/tested_elsewhere.pass.cpp
+++ b/libcxx/test/std/re/re.regex/re.regex.operations/tested_elsewhere.pass.cpp
@@ -6,8 +6,4 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main(int, char**)
-{
-
-  return 0;
-}
+int main(int, char**) { return 0; }
diff --git a/libcxx/test/std/re/re.regex/re.regex.swap/swap.pass.cpp b/libcxx/test/std/re/re.regex/re.regex.swap/swap.pass.cpp
index 5092d57c14811..8d8285ff93dff 100644
--- a/libcxx/test/std/re/re.regex/re.regex.swap/swap.pass.cpp
+++ b/libcxx/test/std/re/re.regex/re.regex.swap/swap.pass.cpp
@@ -16,15 +16,14 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    std::regex r1("(a([bc]))");
-    std::regex r2;
-    r2.swap(r1);
-    assert(r1.flags() == std::regex::ECMAScript);
-    assert(r1.mark_count() == 0);
-    assert(r2.flags() == std::regex::ECMAScript);
-    assert(r2.mark_count() == 2);
+int main(int, char**) {
+  std::regex r1("(a([bc]))");
+  std::regex r2;
+  r2.swap(r1);
+  assert(r1.flags() == std::regex::ECMAScript);
+  assert(r1.mark_count() == 0);
+  assert(r2.flags() == std::regex::ECMAScript);
+  assert(r2.mark_count() == 2);
 
   return 0;
 }
diff --git a/libcxx/test/std/re/re.regex/types.pass.cpp b/libcxx/test/std/re/re.regex/types.pass.cpp
index a13ad180d3cb4..6ceb6da72196b 100644
--- a/libcxx/test/std/re/re.regex/types.pass.cpp
+++ b/libcxx/test/std/re/re.regex/types.pass.cpp
@@ -23,21 +23,19 @@
 #include <type_traits>
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    static_assert((std::is_same<std::basic_regex<char>::value_type, char>::value), "");
-    static_assert((std::is_same<std::basic_regex<char>::traits_type, std::regex_traits<char> >::value), "");
-    static_assert((std::is_same<std::basic_regex<char>::string_type, std::basic_string<char> >::value), "");
-    static_assert((std::is_same<std::basic_regex<char>::flag_type,
-                                std::regex_constants::syntax_option_type>::value), "");
-    static_assert((std::is_same<std::basic_regex<char>::locale_type, std::locale>::value), "");
+int main(int, char**) {
+  static_assert((std::is_same<std::basic_regex<char>::value_type, char>::value), "");
+  static_assert((std::is_same<std::basic_regex<char>::traits_type, std::regex_traits<char> >::value), "");
+  static_assert((std::is_same<std::basic_regex<char>::string_type, std::basic_string<char> >::value), "");
+  static_assert((std::is_same<std::basic_regex<char>::flag_type, std::regex_constants::syntax_option_type>::value), "");
+  static_assert((std::is_same<std::basic_regex<char>::locale_type, std::locale>::value), "");
 
-    static_assert((std::is_same<std::basic_regex<wchar_t>::value_type, wchar_t>::value), "");
-    static_assert((std::is_same<std::basic_regex<wchar_t>::traits_type, std::regex_traits<wchar_t> >::value), "");
-    static_assert((std::is_same<std::basic_regex<wchar_t>::string_type, std::basic_string<wchar_t> >::value), "");
-    static_assert((std::is_same<std::basic_regex<wchar_t>::flag_type,
-                                std::regex_constants::syntax_option_type>::value), "");
-    static_assert((std::is_same<std::basic_regex<wchar_t>::locale_type, std::locale>::value), "");
+  static_assert((std::is_same<std::basic_regex<wchar_t>::value_type, wchar_t>::value), "");
+  static_assert((std::is_same<std::basic_regex<wchar_t>::traits_type, std::regex_traits<wchar_t> >::value), "");
+  static_assert((std::is_same<std::basic_regex<wchar_t>::string_type, std::basic_string<wchar_t> >::value), "");
+  static_assert(
+      (std::is_same<std::basic_regex<wchar_t>::flag_type, std::regex_constants::syntax_option_type>::value), "");
+  static_assert((std::is_same<std::basic_regex<wchar_t>::locale_type, std::locale>::value), "");
 
   return 0;
 }
diff --git a/libcxx/test/std/re/re.req/nothing_to_do.pass.cpp b/libcxx/test/std/re/re.req/nothing_to_do.pass.cpp
index 1f764da05d6b5..3e0d2a6570f42 100644
--- a/libcxx/test/std/re/re.req/nothing_to_do.pass.cpp
+++ b/libcxx/test/std/re/re.req/nothing_to_do.pass.cpp
@@ -6,8 +6,4 @@
 //
 //===----------------------------------------------------------------------===//
 
-int main(int, char**)
-{
-
-  return 0;
-}
+int main(int, char**) { return 0; }
diff --git a/libcxx/test/std/re/re.results/range_concept_conformance.compile.pass.cpp b/libcxx/test/std/re/re.results/range_concept_conformance.compile.pass.cpp
index 9f012d430c7e3..caf6eb08274d4 100644
--- a/libcxx/test/std/re/re.results/range_concept_conformance.compile.pass.cpp
+++ b/libcxx/test/std/re/re.results/range_concept_conformance.compile.pass.cpp
@@ -15,8 +15,6 @@
 #include <concepts>
 #include <ranges>
 
-
-
 static_assert(std::same_as<std::ranges::iterator_t<std::cmatch>, std::cmatch::iterator>);
 static_assert(std::ranges::common_range<std::cmatch>);
 static_assert(std::ranges::random_access_range<std::cmatch>);
diff --git a/libcxx/test/std/re/re.results/re.results.acc/begin_end.pass.cpp b/libcxx/test/std/re/re.results/re.results.acc/begin_end.pass.cpp
index 48fff58b019ee..1ae4f2d31df19 100644
--- a/libcxx/test/std/re/re.results/re.results.acc/begin_end.pass.cpp
+++ b/libcxx/test/std/re/re.results/re.results.acc/begin_end.pass.cpp
@@ -18,24 +18,21 @@
 #include <cstddef>
 #include "test_macros.h"
 
-void
-test()
-{
-    std::match_results<const char*> m;
-    const char s[] = "abcdefghijk";
-    assert(std::regex_search(s, m, std::regex("cd((e)fg)hi")));
-
-    std::match_results<const char*>::const_iterator i = m.begin();
-    std::match_results<const char*>::const_iterator e = m.end();
-
-    assert(static_cast<std::size_t>(e - i) == m.size());
-    for (int j = 0; i != e; ++i, ++j)
-        assert(*i == m[j]);
+void test() {
+  std::match_results<const char*> m;
+  const char s[] = "abcdefghijk";
+  assert(std::regex_search(s, m, std::regex("cd((e)fg)hi")));
+
+  std::match_results<const char*>::const_iterator i = m.begin();
+  std::match_results<const char*>::const_iterator e = m.end();
+
+  assert(static_cast<std::size_t>(e - i) == m.size());
+  for (int j = 0; i != e; ++i, ++j)
+    assert(*i == m[j]);
 }
 
-int main(int, char**)
-{
-    test();
+int main(int, char**) {
+  test();
 
   return 0;
 }
diff --git a/libcxx/test/std/re/re.results/re.results.acc/cbegin_cend.pass.cpp b/libcxx/test/std/re/re.results/re.results.acc/cbegin_cend.pass.cpp
index bd9009a8a447c..1d4ad403f01d5 100644
--- a/libcxx/test/std/re/re.results/re.results.acc/cbegin_cend.pass.cpp
+++ b/libcxx/test/std/re/re.results/re.results.acc/cbegin_cend.pass.cpp
@@ -18,24 +18,21 @@
 #include <cstddef>
 #include "test_macros.h"
 
-void
-test()
-{
-    std::match_results<const char*> m;
-    const char s[] = "abcdefghijk";
-    assert(std::regex_search(s, m, std::regex("cd((e)fg)hi")));
-
-    std::match_results<const char*>::const_iterator i = m.cbegin();
-    std::match_results<const char*>::const_iterator e = m.cend();
-
-    assert(static_cast<std::size_t>(e - i) == m.size());
-    for (int j = 0; i != e; ++i, ++j)
-        assert(*i == m[j]);
+void test() {
+  std::match_results<const char*> m;
+  const char s[] = "abcdefghijk";
+  assert(std::regex_search(s, m, std::regex("cd((e)fg)hi")));
+
+  std::match_results<const char*>::const_iterator i = m.cbegin();
+  std::match_results<const char*>::const_iterator e = m.cend();
+
+  assert(static_cast<std::size_t>(e - i) == m.size());
+  for (int j = 0; i != e; ++i, ++j)
+    assert(*i == m[j]);
 }
 
-int main(int, char**)
-{
-    test();
+int main(int, char**) {
+  test();
 
   return 0;
 }
diff --git a/libcxx/test/std/re/re.results/re.results.acc/index.pass.cpp b/libcxx/test/std/re/re.results/re.results.acc/index.pass.cpp
index a5c25a82c81b1..ed885ecbbb128 100644
--- a/libcxx/test/std/re/re.results/re.results.acc/index.pass.cpp
+++ b/libcxx/test/std/re/re.results/re.results.acc/index.pass.cpp
@@ -16,40 +16,37 @@
 #include <cassert>
 #include "test_macros.h"
 
-void
-test(std::regex_constants::syntax_option_type syntax)
-{
-    std::match_results<const char*> m;
-    const char s[] = "abcdefghijk";
-    assert(std::regex_search(s, m, std::regex("cd((e)fg)hi|(z)", syntax)));
-
-    assert(m.size() == 4);
-
-    assert(m[0].first == s+2);
-    assert(m[0].second == s+9);
-    assert(m[0].matched == true);
-
-    assert(m[1].first == s+4);
-    assert(m[1].second == s+7);
-    assert(m[1].matched == true);
-
-    assert(m[2].first == s+4);
-    assert(m[2].second == s+5);
-    assert(m[2].matched == true);
-
-    assert(m[3].first == s+11);
-    assert(m[3].second == s+11);
-    assert(m[3].matched == false);
-
-    assert(m[4].first == s+11);
-    assert(m[4].second == s+11);
-    assert(m[4].matched == false);
+void test(std::regex_constants::syntax_option_type syntax) {
+  std::match_results<const char*> m;
+  const char s[] = "abcdefghijk";
+  assert(std::regex_search(s, m, std::regex("cd((e)fg)hi|(z)", syntax)));
+
+  assert(m.size() == 4);
+
+  assert(m[0].first == s + 2);
+  assert(m[0].second == s + 9);
+  assert(m[0].matched == true);
+
+  assert(m[1].first == s + 4);
+  assert(m[1].second == s + 7);
+  assert(m[1].matched == true);
+
+  assert(m[2].first == s + 4);
+  assert(m[2].second == s + 5);
+  assert(m[2].matched == true);
+
+  assert(m[3].first == s + 11);
+  assert(m[3].second == s + 11);
+  assert(m[3].matched == false);
+
+  assert(m[4].first == s + 11);
+  assert(m[4].second == s + 11);
+  assert(m[4].matched == false);
 }
 
-int main(int, char**)
-{
-    test(std::regex_constants::ECMAScript);
-    test(std::regex_constants::extended);
+int main(int, char**) {
+  test(std::regex_constants::ECMAScript);
+  test(std::regex_constants::extended);
 
   return 0;
 }
diff --git a/libcxx/test/std/re/re.results/re.results.acc/length.pass.cpp b/libcxx/test/std/re/re.results/re.results.acc/length.pass.cpp
index 266ba692ff4dc..ff6f94bb6c4b8 100644
--- a/libcxx/test/std/re/re.results/re.results.acc/length.pass.cpp
+++ b/libcxx/test/std/re/re.results/re.results.acc/length.pass.cpp
@@ -16,23 +16,20 @@
 #include <cassert>
 #include "test_macros.h"
 
-void
-test()
-{
-    std::match_results<const char*> m;
-    const char s[] = "abcdefghijk";
-    assert(std::regex_search(s, m, std::regex("cd((e)fg)hi")));
-    assert(m.length() == m[0].length());
-    assert(m.length(0) == m[0].length());
-    assert(m.length(1) == m[1].length());
-    assert(m.length(2) == m[2].length());
-    assert(m.length(3) == m[3].length());
-    assert(m.length(4) == m[4].length());
+void test() {
+  std::match_results<const char*> m;
+  const char s[] = "abcdefghijk";
+  assert(std::regex_search(s, m, std::regex("cd((e)fg)hi")));
+  assert(m.length() == m[0].length());
+  assert(m.length(0) == m[0].length());
+  assert(m.length(1) == m[1].length());
+  assert(m.length(2) == m[2].length());
+  assert(m.length(3) == m[3].length());
+  assert(m.length(4) == m[4].length());
 }
 
-int main(int, char**)
-{
-    test();
+int main(int, char**) {
+  test();
 
   return 0;
 }
diff --git a/libcxx/test/std/re/re.results/re.results.acc/position.pass.cpp b/libcxx/test/std/re/re.results/re.results.acc/position.pass.cpp
index 34256de3585cc..13db9ad72e03e 100644
--- a/libcxx/test/std/re/re.results/re.results.acc/position.pass.cpp
+++ b/libcxx/test/std/re/re.results/re.results.acc/position.pass.cpp
@@ -16,23 +16,20 @@
 #include <cassert>
 #include "test_macros.h"
 
-void
-test()
-{
-    std::match_results<const char*> m;
-    const char s[] = "abcdefghijk";
-    assert(std::regex_search(s, m, std::regex("cd((e)fg)hi")));
-    assert(m.position() == std::distance(s, m[0].first));
-    assert(m.position(0) == std::distance(s, m[0].first));
-    assert(m.position(1) == std::distance(s, m[1].first));
-    assert(m.position(2) == std::distance(s, m[2].first));
-    assert(m.position(3) == std::distance(s, m[3].first));
-    assert(m.position(4) == std::distance(s, m[4].first));
+void test() {
+  std::match_results<const char*> m;
+  const char s[] = "abcdefghijk";
+  assert(std::regex_search(s, m, std::regex("cd((e)fg)hi")));
+  assert(m.position() == std::distance(s, m[0].first));
+  assert(m.position(0) == std::distance(s, m[0].first));
+  assert(m.position(1) == std::distance(s, m[1].first));
+  assert(m.position(2) == std::distance(s, m[2].first));
+  assert(m.position(3) == std::distance(s, m[3].first));
+  assert(m.position(4) == std::distance(s, m[4].first));
 }
 
-int main(int, char**)
-{
-    test();
+int main(int, char**) {
+  test();
 
   return 0;
 }
diff --git a/libcxx/test/std/re/re.results/re.results.acc/prefix.pass.cpp b/libcxx/test/std/re/re.results/re.results.acc/prefix.pass.cpp
index b2cd48d4db60a..5737182bb3ac7 100644
--- a/libcxx/test/std/re/re.results/re.results.acc/prefix.pass.cpp
+++ b/libcxx/test/std/re/re.results/re.results.acc/prefix.pass.cpp
@@ -16,21 +16,18 @@
 #include <cassert>
 #include "test_macros.h"
 
-void
-test()
-{
-    std::match_results<const char*> m;
-    const char s[] = "abcdefghijk";
-    assert(std::regex_search(s, m, std::regex("cd((e)fg)hi")));
-
-    assert(m.prefix().first == s);
-    assert(m.prefix().second == s+2);
-    assert(m.prefix().matched == true);
+void test() {
+  std::match_results<const char*> m;
+  const char s[] = "abcdefghijk";
+  assert(std::regex_search(s, m, std::regex("cd((e)fg)hi")));
+
+  assert(m.prefix().first == s);
+  assert(m.prefix().second == s + 2);
+  assert(m.prefix().matched == true);
 }
 
-int main(int, char**)
-{
-    test();
+int main(int, char**) {
+  test();
 
   return 0;
 }
diff --git a/libcxx/test/std/re/re.results/re.results.acc/str.pass.cpp b/libcxx/test/std/re/re.results/re.results.acc/str.pass.cpp
index ae4387d463aa6..705ba2fcd4581 100644
--- a/libcxx/test/std/re/re.results/re.results.acc/str.pass.cpp
+++ b/libcxx/test/std/re/re.results/re.results.acc/str.pass.cpp
@@ -16,23 +16,20 @@
 #include <cassert>
 #include "test_macros.h"
 
-void
-test()
-{
-    std::match_results<const char*> m;
-    const char s[] = "abcdefghijk";
-    assert(std::regex_search(s, m, std::regex("cd((e)fg)hi")));
-    assert(m.str() == std::string(m[0]));
-    assert(m.str(0) == std::string(m[0]));
-    assert(m.str(1) == std::string(m[1]));
-    assert(m.str(2) == std::string(m[2]));
-    assert(m.str(3) == std::string(m[3]));
-    assert(m.str(4) == std::string(m[4]));
+void test() {
+  std::match_results<const char*> m;
+  const char s[] = "abcdefghijk";
+  assert(std::regex_search(s, m, std::regex("cd((e)fg)hi")));
+  assert(m.str() == std::string(m[0]));
+  assert(m.str(0) == std::string(m[0]));
+  assert(m.str(1) == std::string(m[1]));
+  assert(m.str(2) == std::string(m[2]));
+  assert(m.str(3) == std::string(m[3]));
+  assert(m.str(4) == std::string(m[4]));
 }
 
-int main(int, char**)
-{
-    test();
+int main(int, char**) {
+  test();
 
   return 0;
 }
diff --git a/libcxx/test/std/re/re.results/re.results.acc/suffix.pass.cpp b/libcxx/test/std/re/re.results/re.results.acc/suffix.pass.cpp
index c9d3855e9bd74..6ec1e0700cd71 100644
--- a/libcxx/test/std/re/re.results/re.results.acc/suffix.pass.cpp
+++ b/libcxx/test/std/re/re.results/re.results.acc/suffix.pass.cpp
@@ -16,21 +16,18 @@
 #include <cassert>
 #include "test_macros.h"
 
-void
-test()
-{
-    std::match_results<const char*> m;
-    const char s[] = "abcdefghijk";
-    assert(std::regex_search(s, m, std::regex("cd((e)fg)hi")));
-
-    assert(m.suffix().first == s+9);
-    assert(m.suffix().second == s+11);
-    assert(m.suffix().matched == true);
+void test() {
+  std::match_results<const char*> m;
+  const char s[] = "abcdefghijk";
+  assert(std::regex_search(s, m, std::regex("cd((e)fg)hi")));
+
+  assert(m.suffix().first == s + 9);
+  assert(m.suffix().second == s + 11);
+  assert(m.suffix().matched == true);
 }
 
-int main(int, char**)
-{
-    test();
+int main(int, char**) {
+  test();
 
   return 0;
 }
diff --git a/libcxx/test/std/re/re.results/re.results.all/get_allocator.pass.cpp b/libcxx/test/std/re/re.results/re.results.all/get_allocator.pass.cpp
index 84ef708c29681..b66329e36c751 100644
--- a/libcxx/test/std/re/re.results/re.results.all/get_allocator.pass.cpp
+++ b/libcxx/test/std/re/re.results/re.results.all/get_allocator.pass.cpp
@@ -19,20 +19,17 @@
 #include "test_allocator.h"
 
 template <class CharT, class Allocator>
-void
-test(const Allocator& a)
-{
-    std::match_results<const CharT*, Allocator> m(a);
-    assert(m.size() == 0);
-    assert(!m.ready());
-    assert(m.get_allocator() == a);
+void test(const Allocator& a) {
+  std::match_results<const CharT*, Allocator> m(a);
+  assert(m.size() == 0);
+  assert(!m.ready());
+  assert(m.get_allocator() == a);
 }
 
-int main(int, char**)
-{
-    test<char>(test_allocator<std::sub_match<const char*> >(3));
+int main(int, char**) {
+  test<char>(test_allocator<std::sub_match<const char*> >(3));
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-    test<wchar_t>(test_allocator<std::sub_match<const wchar_t*> >(3));
+  test<wchar_t>(test_allocator<std::sub_match<const wchar_t*> >(3));
 #endif
 
   return 0;
diff --git a/libcxx/test/std/re/re.results/re.results.const/allocator.pass.cpp b/libcxx/test/std/re/re.results/re.results.const/allocator.pass.cpp
index 5d152c4a8e048..2d2482b0d210d 100644
--- a/libcxx/test/std/re/re.results/re.results.const/allocator.pass.cpp
+++ b/libcxx/test/std/re/re.results/re.results.const/allocator.pass.cpp
@@ -19,20 +19,17 @@
 #include "test_allocator.h"
 
 template <class CharT, class Allocator>
-void
-test(const Allocator& a)
-{
-    std::match_results<const CharT*, Allocator> m(a);
-    assert(m.size() == 0);
-    assert(!m.ready());
-    assert(m.get_allocator() == a);
+void test(const Allocator& a) {
+  std::match_results<const CharT*, Allocator> m(a);
+  assert(m.size() == 0);
+  assert(!m.ready());
+  assert(m.get_allocator() == a);
 }
 
-int main(int, char**)
-{
-    test<char>(test_allocator<std::sub_match<const char*> >(3));
+int main(int, char**) {
+  test<char>(test_allocator<std::sub_match<const char*> >(3));
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-    test<wchar_t>(test_allocator<std::sub_match<const wchar_t*> >(3));
+  test<wchar_t>(test_allocator<std::sub_match<const wchar_t*> >(3));
 #endif
 
   return 0;
diff --git a/libcxx/test/std/re/re.results/re.results.const/copy.pass.cpp b/libcxx/test/std/re/re.results/re.results.const/copy.pass.cpp
index be9585edc7778..8229f21cf4278 100644
--- a/libcxx/test/std/re/re.results/re.results.const/copy.pass.cpp
+++ b/libcxx/test/std/re/re.results/re.results.const/copy.pass.cpp
@@ -18,28 +18,25 @@
 #include "test_allocator.h"
 
 template <class CharT, class Allocator>
-void
-test(const Allocator& a)
-{
-    typedef std::match_results<const CharT*, Allocator> SM;
-    SM m0(a);
-    SM m1(m0);
-
-    assert(m1.size()          == m0.size());
-    assert(m1.ready()         == m0.ready());
-    assert(m1.get_allocator() == m0.get_allocator());
+void test(const Allocator& a) {
+  typedef std::match_results<const CharT*, Allocator> SM;
+  SM m0(a);
+  SM m1(m0);
+
+  assert(m1.size() == m0.size());
+  assert(m1.ready() == m0.ready());
+  assert(m1.get_allocator() == m0.get_allocator());
 }
 
-int main(int, char**)
-{
-    test<char>   (std::allocator<std::sub_match<const char *> >());
+int main(int, char**) {
+  test<char>(std::allocator<std::sub_match<const char*> >());
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-    test<wchar_t>(std::allocator<std::sub_match<const wchar_t *> >());
+  test<wchar_t>(std::allocator<std::sub_match<const wchar_t*> >());
 #endif
 
-    test<char>   (test_allocator<std::sub_match<const char*> >(3));
+  test<char>(test_allocator<std::sub_match<const char*> >(3));
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-    test<wchar_t>(test_allocator<std::sub_match<const wchar_t*> >(3));
+  test<wchar_t>(test_allocator<std::sub_match<const wchar_t*> >(3));
 #endif
 
   return 0;
diff --git a/libcxx/test/std/re/re.results/re.results.const/copy_assign.pass.cpp b/libcxx/test/std/re/re.results/re.results.const/copy_assign.pass.cpp
index 33dbeb9e556f7..cc824ab104ccc 100644
--- a/libcxx/test/std/re/re.results/re.results.const/copy_assign.pass.cpp
+++ b/libcxx/test/std/re/re.results/re.results.const/copy_assign.pass.cpp
@@ -18,39 +18,36 @@
 #include "test_allocator.h"
 
 template <class CharT, class Allocator>
-void
-test(const Allocator& a)
-{
-    typedef std::match_results<const CharT*, Allocator> SM;
-    SM m0(a);
-    SM m1;
-
-    m1 = m0;
-    assert(m1.size()          == m0.size());
-    assert(m1.ready()         == m0.ready());
-    if (std::allocator_traits<Allocator>::propagate_on_container_copy_assignment::value)
-        assert(m1.get_allocator() == m0.get_allocator());
-    else
-        assert(m1.get_allocator() == Allocator());
+void test(const Allocator& a) {
+  typedef std::match_results<const CharT*, Allocator> SM;
+  SM m0(a);
+  SM m1;
+
+  m1 = m0;
+  assert(m1.size() == m0.size());
+  assert(m1.ready() == m0.ready());
+  if (std::allocator_traits<Allocator>::propagate_on_container_copy_assignment::value)
+    assert(m1.get_allocator() == m0.get_allocator());
+  else
+    assert(m1.get_allocator() == Allocator());
 }
 
-int main(int, char**)
-{
-    test<char>   (std::allocator<std::sub_match<const char *> >());
+int main(int, char**) {
+  test<char>(std::allocator<std::sub_match<const char*> >());
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-    test<wchar_t>(std::allocator<std::sub_match<const wchar_t *> >());
+  test<wchar_t>(std::allocator<std::sub_match<const wchar_t*> >());
 #endif
 
-    // test_allocator has POCCA -> false
-    test<char>   (test_allocator<std::sub_match<const char*> >(3));
+  // test_allocator has POCCA -> false
+  test<char>(test_allocator<std::sub_match<const char*> >(3));
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-    test<wchar_t>(test_allocator<std::sub_match<const wchar_t*> >(3));
+  test<wchar_t>(test_allocator<std::sub_match<const wchar_t*> >(3));
 #endif
 
-    // other_allocator has POCCA -> true
-    test<char>   (other_allocator<std::sub_match<const char*> >(3));
+  // other_allocator has POCCA -> true
+  test<char>(other_allocator<std::sub_match<const char*> >(3));
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-    test<wchar_t>(other_allocator<std::sub_match<const wchar_t*> >(3));
+  test<wchar_t>(other_allocator<std::sub_match<const wchar_t*> >(3));
 #endif
 
   return 0;
diff --git a/libcxx/test/std/re/re.results/re.results.const/default.pass.cpp b/libcxx/test/std/re/re.results/re.results.const/default.pass.cpp
index bcb2462610ee1..b452f0e7af7af 100644
--- a/libcxx/test/std/re/re.results/re.results.const/default.pass.cpp
+++ b/libcxx/test/std/re/re.results/re.results.const/default.pass.cpp
@@ -18,7 +18,7 @@
 #include <cassert>
 #include "test_macros.h"
 #if TEST_STD_VER >= 11
-#include "test_convertible.h"
+#  include "test_convertible.h"
 
 template <typename T>
 void test_implicit() {
@@ -28,26 +28,23 @@ void test_implicit() {
 #endif
 
 template <class CharT>
-void
-test()
-{
-    typedef std::match_results<const CharT*> M;
-    typedef std::allocator<std::sub_match<const CharT*> > Alloc;
-    M m;
-    assert(m.size() == 0);
-    assert(!m.ready());
-    assert(m.get_allocator() == Alloc());
+void test() {
+  typedef std::match_results<const CharT*> M;
+  typedef std::allocator<std::sub_match<const CharT*> > Alloc;
+  M m;
+  assert(m.size() == 0);
+  assert(!m.ready());
+  assert(m.get_allocator() == Alloc());
 
 #if TEST_STD_VER >= 11
-    test_implicit<M>();
+  test_implicit<M>();
 #endif
 }
 
-int main(int, char**)
-{
-    test<char>();
+int main(int, char**) {
+  test<char>();
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-    test<wchar_t>();
+  test<wchar_t>();
 #endif
 
   return 0;
diff --git a/libcxx/test/std/re/re.results/re.results.const/move.pass.cpp b/libcxx/test/std/re/re.results/re.results.const/move.pass.cpp
index 0806edef1429b..2114d72fc0646 100644
--- a/libcxx/test/std/re/re.results/re.results.const/move.pass.cpp
+++ b/libcxx/test/std/re/re.results/re.results.const/move.pass.cpp
@@ -20,34 +20,31 @@
 #include "test_allocator.h"
 
 template <class CharT, class Allocator>
-void
-test(const Allocator& a)
-{
-    typedef std::match_results<const CharT*, Allocator> SM;
-    ASSERT_NOEXCEPT(SM(std::declval<SM&&>()));
-
-    SM m0(a);
-    assert(m0.get_allocator() == a);
-
-    SM m1(std::move(m0));
-    assert(m1.size() == 0);
-    assert(!m1.ready());
-    assert(m1.get_allocator() == a);
+void test(const Allocator& a) {
+  typedef std::match_results<const CharT*, Allocator> SM;
+  ASSERT_NOEXCEPT(SM(std::declval<SM&&>()));
+
+  SM m0(a);
+  assert(m0.get_allocator() == a);
+
+  SM m1(std::move(m0));
+  assert(m1.size() == 0);
+  assert(!m1.ready());
+  assert(m1.get_allocator() == a);
 }
 
-int main(int, char**)
-{
-    test_allocator_statistics alloc_stats;
-    test<char>   (std::allocator<std::sub_match<const char *> >());
+int main(int, char**) {
+  test_allocator_statistics alloc_stats;
+  test<char>(std::allocator<std::sub_match<const char*> >());
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-    test<wchar_t>(std::allocator<std::sub_match<const wchar_t *> >());
+  test<wchar_t>(std::allocator<std::sub_match<const wchar_t*> >());
 #endif
 
-    test<char>   (test_allocator<std::sub_match<const char*> >(3, &alloc_stats));
-    assert(alloc_stats.moved == 1);
+  test<char>(test_allocator<std::sub_match<const char*> >(3, &alloc_stats));
+  assert(alloc_stats.moved == 1);
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-    test<wchar_t>(test_allocator<std::sub_match<const wchar_t*> >(3, &alloc_stats));
-    assert(alloc_stats.moved == 2);
+  test<wchar_t>(test_allocator<std::sub_match<const wchar_t*> >(3, &alloc_stats));
+  assert(alloc_stats.moved == 2);
 #endif
 
   return 0;
diff --git a/libcxx/test/std/re/re.results/re.results.const/move_assign.pass.cpp b/libcxx/test/std/re/re.results/re.results.const/move_assign.pass.cpp
index a8c269db70b75..7bcbc85513208 100644
--- a/libcxx/test/std/re/re.results/re.results.const/move_assign.pass.cpp
+++ b/libcxx/test/std/re/re.results/re.results.const/move_assign.pass.cpp
@@ -19,39 +19,36 @@
 #include "test_allocator.h"
 
 template <class CharT, class Allocator>
-void
-test(const Allocator& a)
-{
-    typedef std::match_results<const CharT*, Allocator> SM;
-    SM m0(a);
-    SM m1;
-
-    m1 = std::move(m0);
-    assert(m1.size()          == 0);
-    assert(!m1.ready());
-    if (std::allocator_traits<Allocator>::propagate_on_container_move_assignment::value)
-        assert(m1.get_allocator() == a);
-    else
-        assert(m1.get_allocator() == Allocator());
+void test(const Allocator& a) {
+  typedef std::match_results<const CharT*, Allocator> SM;
+  SM m0(a);
+  SM m1;
+
+  m1 = std::move(m0);
+  assert(m1.size() == 0);
+  assert(!m1.ready());
+  if (std::allocator_traits<Allocator>::propagate_on_container_move_assignment::value)
+    assert(m1.get_allocator() == a);
+  else
+    assert(m1.get_allocator() == Allocator());
 }
 
-int main(int, char**)
-{
-    test<char>   (std::allocator<std::sub_match<const char *> >());
+int main(int, char**) {
+  test<char>(std::allocator<std::sub_match<const char*> >());
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-    test<wchar_t>(std::allocator<std::sub_match<const wchar_t *> >());
+  test<wchar_t>(std::allocator<std::sub_match<const wchar_t*> >());
 #endif
 
-    // test_allocator has POCMA -> false
-    test<char>   (test_allocator<std::sub_match<const char*> >(3));
+  // test_allocator has POCMA -> false
+  test<char>(test_allocator<std::sub_match<const char*> >(3));
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-    test<wchar_t>(test_allocator<std::sub_match<const wchar_t*> >(3));
+  test<wchar_t>(test_allocator<std::sub_match<const wchar_t*> >(3));
 #endif
 
-    // other_allocator has POCMA -> true
-    test<char>   (other_allocator<std::sub_match<const char*> >(3));
+  // other_allocator has POCMA -> true
+  test<char>(other_allocator<std::sub_match<const char*> >(3));
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-    test<wchar_t>(other_allocator<std::sub_match<const wchar_t*> >(3));
+  test<wchar_t>(other_allocator<std::sub_match<const wchar_t*> >(3));
 #endif
 
   return 0;
diff --git a/libcxx/test/std/re/re.results/re.results.form/form1.pass.cpp b/libcxx/test/std/re/re.results/re.results.form/form1.pass.cpp
index 3ea0362227200..1e81c2d61b376 100644
--- a/libcxx/test/std/re/re.results/re.results.form/form1.pass.cpp
+++ b/libcxx/test/std/re/re.results/re.results.form/form1.pass.cpp
@@ -21,138 +21,143 @@
 #include "test_macros.h"
 #include "test_iterators.h"
 
-int main(int, char**)
-{
-    {
-        std::match_results<const char*> m;
-        const char s[] = "abcdefghijk";
-        assert(std::regex_search(s, m, std::regex("cd((e)fg)hi")));
-
-        char out[100] = {0};
-        const char fmt[] = "prefix: $`, match: $&, suffix: $', m[1]: $1, m[2]: $2";
-        auto r = m.format(cpp17_output_iterator<char*>(out),
-                    fmt, fmt + std::char_traits<char>::length(fmt));
-        assert(base(r) == out + 58);
-        assert(std::string(out) == "prefix: ab, match: cdefghi, suffix: jk, m[1]: efg, m[2]: e");
-    }
-    {
-        std::match_results<const char*> m;
-        const char s[] = "abcdefghijk";
-        assert(std::regex_search(s, m, std::regex("cd((e)fg)hi",
-                                                  std::regex_constants::nosubs)));
-
-        char out[100] = {0};
-        const char fmt[] = "prefix: $`, match: $&, suffix: $', m[1]: $1, m[2]: $2";
-        auto r = m.format(cpp17_output_iterator<char*>(out),
-                    fmt, fmt + std::char_traits<char>::length(fmt));
-        assert(base(r) == out + 54);
-        assert(std::string(out) == "prefix: ab, match: cdefghi, suffix: jk, m[1]: , m[2]: ");
-    }
-    {
-        std::match_results<const char*> m;
-        const char s[] = "abcdefghijk";
-        assert(std::regex_search(s, m, std::regex("cdefghi")));
-
-        char out[100] = {0};
-        const char fmt[] = "prefix: $`, match: $&, suffix: $', m[1]: $1, m[2]: $2";
-        auto r = m.format(cpp17_output_iterator<char*>(out),
-                    fmt, fmt + std::char_traits<char>::length(fmt));
-        assert(base(r) == out + 54);
-        assert(std::string(out) == "prefix: ab, match: cdefghi, suffix: jk, m[1]: , m[2]: ");
-    }
-    {
-        std::match_results<const char*> m;
-        const char s[] = "abcdefghijk";
-        assert(std::regex_search(s, m, std::regex("cd((e)fg)hi")));
-
-        char out[100] = {0};
-        const char fmt[] = "prefix: $`, match: $&, suffix: $', m[1]: $1, m[2]: $2";
-        auto r = m.format(cpp17_output_iterator<char*>(out),
-                    fmt, fmt + std::char_traits<char>::length(fmt),
-                    std::regex_constants::format_sed);
-        assert(base(r) == out + 59);
-        assert(std::string(out) == "prefix: $`, match: $cdefghi, suffix: $', m[1]: $1, m[2]: $2");
-    }
-    {
-        std::match_results<const char*> m;
-        const char s[] = "abcdefghijk";
-        assert(std::regex_search(s, m, std::regex("cd((e)fg)hi")));
-
-        char out[100] = {0};
-        const char fmt[] = "match: &, m[1]: \\1, m[2]: \\2";
-        auto r = m.format(cpp17_output_iterator<char*>(out),
-                    fmt, fmt + std::char_traits<char>::length(fmt),
-                    std::regex_constants::format_sed);
-        assert(base(r) == out + 34);
-        assert(std::string(out) == "match: cdefghi, m[1]: efg, m[2]: e");
-    }
-    {
-        std::match_results<const char*> m;
-        const char s[] = "abcdefghijk";
-        assert(std::regex_search(s, m, std::regex("cd((e)fg)hi",
-                                                  std::regex_constants::nosubs)));
-
-        char out[100] = {0};
-        const char fmt[] = "match: &, m[1]: \\1, m[2]: \\2";
-        auto r = m.format(cpp17_output_iterator<char*>(out),
-                    fmt, fmt + std::char_traits<char>::length(fmt),
-                    std::regex_constants::format_sed);
-        assert(base(r) == out + 30);
-        assert(std::string(out) == "match: cdefghi, m[1]: , m[2]: ");
-    }
-    {
-        std::match_results<const char*> m;
-        const char s[] = "abcdefghijk";
-        assert(std::regex_search(s, m, std::regex("cdefghi")));
-
-        char out[100] = {0};
-        const char fmt[] = "match: &, m[1]: \\1, m[2]: \\2";
-        auto r = m.format(cpp17_output_iterator<char*>(out),
-                    fmt, fmt + std::char_traits<char>::length(fmt),
-                    std::regex_constants::format_sed);
-        assert(base(r) == out + 30);
-        assert(std::string(out) == "match: cdefghi, m[1]: , m[2]: ");
-    }
+int main(int, char**) {
+  {
+    std::match_results<const char*> m;
+    const char s[] = "abcdefghijk";
+    assert(std::regex_search(s, m, std::regex("cd((e)fg)hi")));
+
+    char out[100]    = {0};
+    const char fmt[] = "prefix: $`, match: $&, suffix: $', m[1]: $1, m[2]: $2";
+    auto r           = m.format(cpp17_output_iterator<char*>(out), fmt, fmt + std::char_traits<char>::length(fmt));
+    assert(base(r) == out + 58);
+    assert(std::string(out) == "prefix: ab, match: cdefghi, suffix: jk, m[1]: efg, m[2]: e");
+  }
+  {
+    std::match_results<const char*> m;
+    const char s[] = "abcdefghijk";
+    assert(std::regex_search(s, m, std::regex("cd((e)fg)hi", std::regex_constants::nosubs)));
+
+    char out[100]    = {0};
+    const char fmt[] = "prefix: $`, match: $&, suffix: $', m[1]: $1, m[2]: $2";
+    auto r           = m.format(cpp17_output_iterator<char*>(out), fmt, fmt + std::char_traits<char>::length(fmt));
+    assert(base(r) == out + 54);
+    assert(std::string(out) == "prefix: ab, match: cdefghi, suffix: jk, m[1]: , m[2]: ");
+  }
+  {
+    std::match_results<const char*> m;
+    const char s[] = "abcdefghijk";
+    assert(std::regex_search(s, m, std::regex("cdefghi")));
+
+    char out[100]    = {0};
+    const char fmt[] = "prefix: $`, match: $&, suffix: $', m[1]: $1, m[2]: $2";
+    auto r           = m.format(cpp17_output_iterator<char*>(out), fmt, fmt + std::char_traits<char>::length(fmt));
+    assert(base(r) == out + 54);
+    assert(std::string(out) == "prefix: ab, match: cdefghi, suffix: jk, m[1]: , m[2]: ");
+  }
+  {
+    std::match_results<const char*> m;
+    const char s[] = "abcdefghijk";
+    assert(std::regex_search(s, m, std::regex("cd((e)fg)hi")));
+
+    char out[100]    = {0};
+    const char fmt[] = "prefix: $`, match: $&, suffix: $', m[1]: $1, m[2]: $2";
+    auto r           = m.format(
+        cpp17_output_iterator<char*>(out),
+        fmt,
+        fmt + std::char_traits<char>::length(fmt),
+        std::regex_constants::format_sed);
+    assert(base(r) == out + 59);
+    assert(std::string(out) == "prefix: $`, match: $cdefghi, suffix: $', m[1]: $1, m[2]: $2");
+  }
+  {
+    std::match_results<const char*> m;
+    const char s[] = "abcdefghijk";
+    assert(std::regex_search(s, m, std::regex("cd((e)fg)hi")));
+
+    char out[100]    = {0};
+    const char fmt[] = "match: &, m[1]: \\1, m[2]: \\2";
+    auto r           = m.format(
+        cpp17_output_iterator<char*>(out),
+        fmt,
+        fmt + std::char_traits<char>::length(fmt),
+        std::regex_constants::format_sed);
+    assert(base(r) == out + 34);
+    assert(std::string(out) == "match: cdefghi, m[1]: efg, m[2]: e");
+  }
+  {
+    std::match_results<const char*> m;
+    const char s[] = "abcdefghijk";
+    assert(std::regex_search(s, m, std::regex("cd((e)fg)hi", std::regex_constants::nosubs)));
+
+    char out[100]    = {0};
+    const char fmt[] = "match: &, m[1]: \\1, m[2]: \\2";
+    auto r           = m.format(
+        cpp17_output_iterator<char*>(out),
+        fmt,
+        fmt + std::char_traits<char>::length(fmt),
+        std::regex_constants::format_sed);
+    assert(base(r) == out + 30);
+    assert(std::string(out) == "match: cdefghi, m[1]: , m[2]: ");
+  }
+  {
+    std::match_results<const char*> m;
+    const char s[] = "abcdefghijk";
+    assert(std::regex_search(s, m, std::regex("cdefghi")));
+
+    char out[100]    = {0};
+    const char fmt[] = "match: &, m[1]: \\1, m[2]: \\2";
+    auto r           = m.format(
+        cpp17_output_iterator<char*>(out),
+        fmt,
+        fmt + std::char_traits<char>::length(fmt),
+        std::regex_constants::format_sed);
+    assert(base(r) == out + 30);
+    assert(std::string(out) == "match: cdefghi, m[1]: , m[2]: ");
+  }
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-    {
-        std::match_results<const wchar_t*> m;
-        const wchar_t s[] = L"abcdefghijk";
-        assert(std::regex_search(s, m, std::wregex(L"cd((e)fg)hi")));
-
-        wchar_t out[100] = {0};
-        const wchar_t fmt[] = L"prefix: $`, match: $&, suffix: $', m[1]: $1, m[2]: $2";
-        auto r = m.format(cpp17_output_iterator<wchar_t*>(out),
-                    fmt, fmt + std::char_traits<wchar_t>::length(fmt));
-        assert(base(r) == out + 58);
-        assert(std::wstring(out) == L"prefix: ab, match: cdefghi, suffix: jk, m[1]: efg, m[2]: e");
-    }
-    {
-        std::match_results<const wchar_t*> m;
-        const wchar_t s[] = L"abcdefghijk";
-        assert(std::regex_search(s, m, std::wregex(L"cd((e)fg)hi")));
-
-        wchar_t out[100] = {0};
-        const wchar_t fmt[] = L"prefix: $`, match: $&, suffix: $', m[1]: $1, m[2]: $2";
-        auto r = m.format(cpp17_output_iterator<wchar_t*>(out),
-                    fmt, fmt + std::char_traits<wchar_t>::length(fmt),
-                    std::regex_constants::format_sed);
-        assert(base(r) == out + 59);
-        assert(std::wstring(out) == L"prefix: $`, match: $cdefghi, suffix: $', m[1]: $1, m[2]: $2");
-    }
-    {
-        std::match_results<const wchar_t*> m;
-        const wchar_t s[] = L"abcdefghijk";
-        assert(std::regex_search(s, m, std::wregex(L"cd((e)fg)hi")));
-
-        wchar_t out[100] = {0};
-        const wchar_t fmt[] = L"match: &, m[1]: \\1, m[2]: \\2";
-        auto r = m.format(cpp17_output_iterator<wchar_t*>(out),
-                    fmt, fmt + std::char_traits<wchar_t>::length(fmt),
-                    std::regex_constants::format_sed);
-        assert(base(r) == out + 34);
-        assert(std::wstring(out) == L"match: cdefghi, m[1]: efg, m[2]: e");
-    }
+  {
+    std::match_results<const wchar_t*> m;
+    const wchar_t s[] = L"abcdefghijk";
+    assert(std::regex_search(s, m, std::wregex(L"cd((e)fg)hi")));
+
+    wchar_t out[100]    = {0};
+    const wchar_t fmt[] = L"prefix: $`, match: $&, suffix: $', m[1]: $1, m[2]: $2";
+    auto r = m.format(cpp17_output_iterator<wchar_t*>(out), fmt, fmt + std::char_traits<wchar_t>::length(fmt));
+    assert(base(r) == out + 58);
+    assert(std::wstring(out) == L"prefix: ab, match: cdefghi, suffix: jk, m[1]: efg, m[2]: e");
+  }
+  {
+    std::match_results<const wchar_t*> m;
+    const wchar_t s[] = L"abcdefghijk";
+    assert(std::regex_search(s, m, std::wregex(L"cd((e)fg)hi")));
+
+    wchar_t out[100]    = {0};
+    const wchar_t fmt[] = L"prefix: $`, match: $&, suffix: $', m[1]: $1, m[2]: $2";
+    auto r              = m.format(
+        cpp17_output_iterator<wchar_t*>(out),
+        fmt,
+        fmt + std::char_traits<wchar_t>::length(fmt),
+        std::regex_constants::format_sed);
+    assert(base(r) == out + 59);
+    assert(std::wstring(out) == L"prefix: $`, match: $cdefghi, suffix: $', m[1]: $1, m[2]: $2");
+  }
+  {
+    std::match_results<const wchar_t*> m;
+    const wchar_t s[] = L"abcdefghijk";
+    assert(std::regex_search(s, m, std::wregex(L"cd((e)fg)hi")));
+
+    wchar_t out[100]    = {0};
+    const wchar_t fmt[] = L"match: &, m[1]: \\1, m[2]: \\2";
+    auto r              = m.format(
+        cpp17_output_iterator<wchar_t*>(out),
+        fmt,
+        fmt + std::char_traits<wchar_t>::length(fmt),
+        std::regex_constants::format_sed);
+    assert(base(r) == out + 34);
+    assert(std::wstring(out) == L"match: cdefghi, m[1]: efg, m[2]: e");
+  }
 #endif // TEST_HAS_NO_WIDE_CHARACTERS
 
   return 0;
diff --git a/libcxx/test/std/re/re.results/re.results.form/form2.pass.cpp b/libcxx/test/std/re/re.results/re.results.form/form2.pass.cpp
index 3c9f04a7ca02a..08570930a61b9 100644
--- a/libcxx/test/std/re/re.results/re.results.form/form2.pass.cpp
+++ b/libcxx/test/std/re/re.results/re.results.form/form2.pass.cpp
@@ -22,78 +22,77 @@
 #include "test_iterators.h"
 #include "test_allocator.h"
 
-int main(int, char**)
-{
-    typedef std::basic_string<char, std::char_traits<char>, test_allocator<char> > nstr;
-    {
-        std::match_results<const char*> m;
-        const char s[] = "abcdefghijk";
-        assert(std::regex_search(s, m, std::regex("cd((e)fg)hi")));
+int main(int, char**) {
+  typedef std::basic_string<char, std::char_traits<char>, test_allocator<char> > nstr;
+  {
+    std::match_results<const char*> m;
+    const char s[] = "abcdefghijk";
+    assert(std::regex_search(s, m, std::regex("cd((e)fg)hi")));
 
-        char out[100] = {0};
-        nstr fmt("prefix: $`, match: $&, suffix: $', m[1]: $1, m[2]: $2");
-        auto r = m.format(cpp17_output_iterator<char*>(out), fmt);
-        assert(base(r) == out + 58);
-        assert(std::string(out) == "prefix: ab, match: cdefghi, suffix: jk, m[1]: efg, m[2]: e");
-    }
-    {
-        std::match_results<const char*> m;
-        const char s[] = "abcdefghijk";
-        assert(std::regex_search(s, m, std::regex("cd((e)fg)hi")));
+    char out[100] = {0};
+    nstr fmt("prefix: $`, match: $&, suffix: $', m[1]: $1, m[2]: $2");
+    auto r = m.format(cpp17_output_iterator<char*>(out), fmt);
+    assert(base(r) == out + 58);
+    assert(std::string(out) == "prefix: ab, match: cdefghi, suffix: jk, m[1]: efg, m[2]: e");
+  }
+  {
+    std::match_results<const char*> m;
+    const char s[] = "abcdefghijk";
+    assert(std::regex_search(s, m, std::regex("cd((e)fg)hi")));
 
-        char out[100] = {0};
-        nstr fmt("prefix: $`, match: $&, suffix: $', m[1]: $1, m[2]: $2");
-        auto r = m.format(cpp17_output_iterator<char*>(out), fmt, std::regex_constants::format_sed);
-        assert(base(r) == out + 59);
-        assert(std::string(out) == "prefix: $`, match: $cdefghi, suffix: $', m[1]: $1, m[2]: $2");
-    }
-    {
-        std::match_results<const char*> m;
-        const char s[] = "abcdefghijk";
-        assert(std::regex_search(s, m, std::regex("cd((e)fg)hi")));
+    char out[100] = {0};
+    nstr fmt("prefix: $`, match: $&, suffix: $', m[1]: $1, m[2]: $2");
+    auto r = m.format(cpp17_output_iterator<char*>(out), fmt, std::regex_constants::format_sed);
+    assert(base(r) == out + 59);
+    assert(std::string(out) == "prefix: $`, match: $cdefghi, suffix: $', m[1]: $1, m[2]: $2");
+  }
+  {
+    std::match_results<const char*> m;
+    const char s[] = "abcdefghijk";
+    assert(std::regex_search(s, m, std::regex("cd((e)fg)hi")));
 
-        char out[100] = {0};
-        nstr fmt("match: &, m[1]: \\1, m[2]: \\2");
-        auto r = m.format(cpp17_output_iterator<char*>(out), fmt, std::regex_constants::format_sed);
-        assert(base(r) == out + 34);
-        assert(std::string(out) == "match: cdefghi, m[1]: efg, m[2]: e");
-    }
+    char out[100] = {0};
+    nstr fmt("match: &, m[1]: \\1, m[2]: \\2");
+    auto r = m.format(cpp17_output_iterator<char*>(out), fmt, std::regex_constants::format_sed);
+    assert(base(r) == out + 34);
+    assert(std::string(out) == "match: cdefghi, m[1]: efg, m[2]: e");
+  }
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-    typedef std::basic_string<wchar_t, std::char_traits<wchar_t>, test_allocator<wchar_t> > wstr;
-    {
-        std::match_results<const wchar_t*> m;
-        const wchar_t s[] = L"abcdefghijk";
-        assert(std::regex_search(s, m, std::wregex(L"cd((e)fg)hi")));
+  typedef std::basic_string<wchar_t, std::char_traits<wchar_t>, test_allocator<wchar_t> > wstr;
+  {
+    std::match_results<const wchar_t*> m;
+    const wchar_t s[] = L"abcdefghijk";
+    assert(std::regex_search(s, m, std::wregex(L"cd((e)fg)hi")));
 
-        wchar_t out[100] = {0};
-        wstr fmt(L"prefix: $`, match: $&, suffix: $', m[1]: $1, m[2]: $2");
-        auto r = m.format(cpp17_output_iterator<wchar_t*>(out), fmt);
-        assert(base(r) == out + 58);
-        assert(std::wstring(out) == L"prefix: ab, match: cdefghi, suffix: jk, m[1]: efg, m[2]: e");
-    }
-    {
-        std::match_results<const wchar_t*> m;
-        const wchar_t s[] = L"abcdefghijk";
-        assert(std::regex_search(s, m, std::wregex(L"cd((e)fg)hi")));
+    wchar_t out[100] = {0};
+    wstr fmt(L"prefix: $`, match: $&, suffix: $', m[1]: $1, m[2]: $2");
+    auto r = m.format(cpp17_output_iterator<wchar_t*>(out), fmt);
+    assert(base(r) == out + 58);
+    assert(std::wstring(out) == L"prefix: ab, match: cdefghi, suffix: jk, m[1]: efg, m[2]: e");
+  }
+  {
+    std::match_results<const wchar_t*> m;
+    const wchar_t s[] = L"abcdefghijk";
+    assert(std::regex_search(s, m, std::wregex(L"cd((e)fg)hi")));
 
-        wchar_t out[100] = {0};
-        wstr fmt(L"prefix: $`, match: $&, suffix: $', m[1]: $1, m[2]: $2");
-        auto r = m.format(cpp17_output_iterator<wchar_t*>(out), fmt, std::regex_constants::format_sed);
-        assert(base(r) == out + 59);
-        assert(std::wstring(out) == L"prefix: $`, match: $cdefghi, suffix: $', m[1]: $1, m[2]: $2");
-    }
-    {
-        std::match_results<const wchar_t*> m;
-        const wchar_t s[] = L"abcdefghijk";
-        assert(std::regex_search(s, m, std::wregex(L"cd((e)fg)hi")));
+    wchar_t out[100] = {0};
+    wstr fmt(L"prefix: $`, match: $&, suffix: $', m[1]: $1, m[2]: $2");
+    auto r = m.format(cpp17_output_iterator<wchar_t*>(out), fmt, std::regex_constants::format_sed);
+    assert(base(r) == out + 59);
+    assert(std::wstring(out) == L"prefix: $`, match: $cdefghi, suffix: $', m[1]: $1, m[2]: $2");
+  }
+  {
+    std::match_results<const wchar_t*> m;
+    const wchar_t s[] = L"abcdefghijk";
+    assert(std::regex_search(s, m, std::wregex(L"cd((e)fg)hi")));
 
-        wchar_t out[100] = {0};
-        wstr fmt(L"match: &, m[1]: \\1, m[2]: \\2");
-        auto r = m.format(cpp17_output_iterator<wchar_t*>(out), fmt, std::regex_constants::format_sed);
-        assert(base(r) == out + 34);
-        assert(std::wstring(out) == L"match: cdefghi, m[1]: efg, m[2]: e");
-    }
+    wchar_t out[100] = {0};
+    wstr fmt(L"match: &, m[1]: \\1, m[2]: \\2");
+    auto r = m.format(cpp17_output_iterator<wchar_t*>(out), fmt, std::regex_constants::format_sed);
+    assert(base(r) == out + 34);
+    assert(std::wstring(out) == L"match: cdefghi, m[1]: efg, m[2]: e");
+  }
 #endif // TEST_HAS_NO_WIDE_CHARACTERS
 
   return 0;
diff --git a/libcxx/test/std/re/re.results/re.results.form/form3.pass.cpp b/libcxx/test/std/re/re.results/re.results.form/form3.pass.cpp
index 384cf177b13cb..757dafcc818a0 100644
--- a/libcxx/test/std/re/re.results/re.results.form/form3.pass.cpp
+++ b/libcxx/test/std/re/re.results/re.results.form/form3.pass.cpp
@@ -21,66 +21,65 @@
 #include "test_macros.h"
 #include "test_allocator.h"
 
-int main(int, char**)
-{
-    typedef std::basic_string<char, std::char_traits<char>, test_allocator<char> > nstr;
-    {
-        std::match_results<const char*> m;
-        const char s[] = "abcdefghijk";
-        assert(std::regex_search(s, m, std::regex("cd((e)fg)hi")));
+int main(int, char**) {
+  typedef std::basic_string<char, std::char_traits<char>, test_allocator<char> > nstr;
+  {
+    std::match_results<const char*> m;
+    const char s[] = "abcdefghijk";
+    assert(std::regex_search(s, m, std::regex("cd((e)fg)hi")));
 
-        nstr fmt("prefix: $`, match: $&, suffix: $', m[1]: $1, m[2]: $2");
-        nstr out = m.format(fmt);
-        assert(out == "prefix: ab, match: cdefghi, suffix: jk, m[1]: efg, m[2]: e");
-    }
-    {
-        std::match_results<const char*> m;
-        const char s[] = "abcdefghijk";
-        assert(std::regex_search(s, m, std::regex("cd((e)fg)hi")));
+    nstr fmt("prefix: $`, match: $&, suffix: $', m[1]: $1, m[2]: $2");
+    nstr out = m.format(fmt);
+    assert(out == "prefix: ab, match: cdefghi, suffix: jk, m[1]: efg, m[2]: e");
+  }
+  {
+    std::match_results<const char*> m;
+    const char s[] = "abcdefghijk";
+    assert(std::regex_search(s, m, std::regex("cd((e)fg)hi")));
 
-        nstr fmt("prefix: $`, match: $&, suffix: $', m[1]: $1, m[2]: $2");
-        nstr out = m.format(fmt, std::regex_constants::format_sed);
-        assert(out == "prefix: $`, match: $cdefghi, suffix: $', m[1]: $1, m[2]: $2");
-    }
-    {
-        std::match_results<const char*> m;
-        const char s[] = "abcdefghijk";
-        assert(std::regex_search(s, m, std::regex("cd((e)fg)hi")));
+    nstr fmt("prefix: $`, match: $&, suffix: $', m[1]: $1, m[2]: $2");
+    nstr out = m.format(fmt, std::regex_constants::format_sed);
+    assert(out == "prefix: $`, match: $cdefghi, suffix: $', m[1]: $1, m[2]: $2");
+  }
+  {
+    std::match_results<const char*> m;
+    const char s[] = "abcdefghijk";
+    assert(std::regex_search(s, m, std::regex("cd((e)fg)hi")));
 
-        nstr fmt("match: &, m[1]: \\1, m[2]: \\2");
-        nstr out = m.format(fmt, std::regex_constants::format_sed);
-        assert(out == "match: cdefghi, m[1]: efg, m[2]: e");
-    }
+    nstr fmt("match: &, m[1]: \\1, m[2]: \\2");
+    nstr out = m.format(fmt, std::regex_constants::format_sed);
+    assert(out == "match: cdefghi, m[1]: efg, m[2]: e");
+  }
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-    typedef std::basic_string<wchar_t, std::char_traits<wchar_t>, test_allocator<wchar_t> > wstr;
-    {
-        std::match_results<const wchar_t*> m;
-        const wchar_t s[] = L"abcdefghijk";
-        assert(std::regex_search(s, m, std::wregex(L"cd((e)fg)hi")));
+  typedef std::basic_string<wchar_t, std::char_traits<wchar_t>, test_allocator<wchar_t> > wstr;
+  {
+    std::match_results<const wchar_t*> m;
+    const wchar_t s[] = L"abcdefghijk";
+    assert(std::regex_search(s, m, std::wregex(L"cd((e)fg)hi")));
 
-        wstr fmt(L"prefix: $`, match: $&, suffix: $', m[1]: $1, m[2]: $2");
-        wstr out = m.format(fmt);
-        assert(out == L"prefix: ab, match: cdefghi, suffix: jk, m[1]: efg, m[2]: e");
-    }
-    {
-        std::match_results<const wchar_t*> m;
-        const wchar_t s[] = L"abcdefghijk";
-        assert(std::regex_search(s, m, std::wregex(L"cd((e)fg)hi")));
+    wstr fmt(L"prefix: $`, match: $&, suffix: $', m[1]: $1, m[2]: $2");
+    wstr out = m.format(fmt);
+    assert(out == L"prefix: ab, match: cdefghi, suffix: jk, m[1]: efg, m[2]: e");
+  }
+  {
+    std::match_results<const wchar_t*> m;
+    const wchar_t s[] = L"abcdefghijk";
+    assert(std::regex_search(s, m, std::wregex(L"cd((e)fg)hi")));
 
-        wstr fmt(L"prefix: $`, match: $&, suffix: $', m[1]: $1, m[2]: $2");
-        wstr out = m.format(fmt, std::regex_constants::format_sed);
-        assert(out == L"prefix: $`, match: $cdefghi, suffix: $', m[1]: $1, m[2]: $2");
-    }
-    {
-        std::match_results<const wchar_t*> m;
-        const wchar_t s[] = L"abcdefghijk";
-        assert(std::regex_search(s, m, std::wregex(L"cd((e)fg)hi")));
+    wstr fmt(L"prefix: $`, match: $&, suffix: $', m[1]: $1, m[2]: $2");
+    wstr out = m.format(fmt, std::regex_constants::format_sed);
+    assert(out == L"prefix: $`, match: $cdefghi, suffix: $', m[1]: $1, m[2]: $2");
+  }
+  {
+    std::match_results<const wchar_t*> m;
+    const wchar_t s[] = L"abcdefghijk";
+    assert(std::regex_search(s, m, std::wregex(L"cd((e)fg)hi")));
 
-        wstr fmt(L"match: &, m[1]: \\1, m[2]: \\2");
-        wstr out = m.format(fmt, std::regex_constants::format_sed);
-        assert(out == L"match: cdefghi, m[1]: efg, m[2]: e");
-    }
+    wstr fmt(L"match: &, m[1]: \\1, m[2]: \\2");
+    wstr out = m.format(fmt, std::regex_constants::format_sed);
+    assert(out == L"match: cdefghi, m[1]: efg, m[2]: e");
+  }
 #endif // TEST_HAS_NO_WIDE_CHARACTERS
 
   return 0;
diff --git a/libcxx/test/std/re/re.results/re.results.form/form4.pass.cpp b/libcxx/test/std/re/re.results/re.results.form/form4.pass.cpp
index 7bd25d98b2ba6..0bcaf06218e49 100644
--- a/libcxx/test/std/re/re.results/re.results.form/form4.pass.cpp
+++ b/libcxx/test/std/re/re.results/re.results.form/form4.pass.cpp
@@ -18,64 +18,63 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    {
-        std::match_results<const char*> m;
-        const char s[] = "abcdefghijk";
-        assert(std::regex_search(s, m, std::regex("cd((e)fg)hi")));
+int main(int, char**) {
+  {
+    std::match_results<const char*> m;
+    const char s[] = "abcdefghijk";
+    assert(std::regex_search(s, m, std::regex("cd((e)fg)hi")));
 
-        const char fmt[] = "prefix: $`, match: $&, suffix: $', m[1]: $1, m[2]: $2";
-        std::string out = m.format(fmt);
-        assert(out == "prefix: ab, match: cdefghi, suffix: jk, m[1]: efg, m[2]: e");
-    }
-    {
-        std::match_results<const char*> m;
-        const char s[] = "abcdefghijk";
-        assert(std::regex_search(s, m, std::regex("cd((e)fg)hi")));
+    const char fmt[] = "prefix: $`, match: $&, suffix: $', m[1]: $1, m[2]: $2";
+    std::string out  = m.format(fmt);
+    assert(out == "prefix: ab, match: cdefghi, suffix: jk, m[1]: efg, m[2]: e");
+  }
+  {
+    std::match_results<const char*> m;
+    const char s[] = "abcdefghijk";
+    assert(std::regex_search(s, m, std::regex("cd((e)fg)hi")));
 
-        const char fmt[] = "prefix: $`, match: $&, suffix: $', m[1]: $1, m[2]: $2";
-        std::string out = m.format(fmt, std::regex_constants::format_sed);
-        assert(out == "prefix: $`, match: $cdefghi, suffix: $', m[1]: $1, m[2]: $2");
-    }
-    {
-        std::match_results<const char*> m;
-        const char s[] = "abcdefghijk";
-        assert(std::regex_search(s, m, std::regex("cd((e)fg)hi")));
+    const char fmt[] = "prefix: $`, match: $&, suffix: $', m[1]: $1, m[2]: $2";
+    std::string out  = m.format(fmt, std::regex_constants::format_sed);
+    assert(out == "prefix: $`, match: $cdefghi, suffix: $', m[1]: $1, m[2]: $2");
+  }
+  {
+    std::match_results<const char*> m;
+    const char s[] = "abcdefghijk";
+    assert(std::regex_search(s, m, std::regex("cd((e)fg)hi")));
 
-        const char fmt[] = "match: &, m[1]: \\1, m[2]: \\2";
-        std::string out = m.format(fmt, std::regex_constants::format_sed);
-        assert(out == "match: cdefghi, m[1]: efg, m[2]: e");
-    }
+    const char fmt[] = "match: &, m[1]: \\1, m[2]: \\2";
+    std::string out  = m.format(fmt, std::regex_constants::format_sed);
+    assert(out == "match: cdefghi, m[1]: efg, m[2]: e");
+  }
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-    {
-        std::match_results<const wchar_t*> m;
-        const wchar_t s[] = L"abcdefghijk";
-        assert(std::regex_search(s, m, std::wregex(L"cd((e)fg)hi")));
+  {
+    std::match_results<const wchar_t*> m;
+    const wchar_t s[] = L"abcdefghijk";
+    assert(std::regex_search(s, m, std::wregex(L"cd((e)fg)hi")));
 
-        const wchar_t fmt[] = L"prefix: $`, match: $&, suffix: $', m[1]: $1, m[2]: $2";
-        std::wstring out = m.format(fmt);
-        assert(out == L"prefix: ab, match: cdefghi, suffix: jk, m[1]: efg, m[2]: e");
-    }
-    {
-        std::match_results<const wchar_t*> m;
-        const wchar_t s[] = L"abcdefghijk";
-        assert(std::regex_search(s, m, std::wregex(L"cd((e)fg)hi")));
+    const wchar_t fmt[] = L"prefix: $`, match: $&, suffix: $', m[1]: $1, m[2]: $2";
+    std::wstring out    = m.format(fmt);
+    assert(out == L"prefix: ab, match: cdefghi, suffix: jk, m[1]: efg, m[2]: e");
+  }
+  {
+    std::match_results<const wchar_t*> m;
+    const wchar_t s[] = L"abcdefghijk";
+    assert(std::regex_search(s, m, std::wregex(L"cd((e)fg)hi")));
 
-        const wchar_t fmt[] = L"prefix: $`, match: $&, suffix: $', m[1]: $1, m[2]: $2";
-        std::wstring out = m.format(fmt, std::regex_constants::format_sed);
-        assert(out == L"prefix: $`, match: $cdefghi, suffix: $', m[1]: $1, m[2]: $2");
-    }
-    {
-        std::match_results<const wchar_t*> m;
-        const wchar_t s[] = L"abcdefghijk";
-        assert(std::regex_search(s, m, std::wregex(L"cd((e)fg)hi")));
+    const wchar_t fmt[] = L"prefix: $`, match: $&, suffix: $', m[1]: $1, m[2]: $2";
+    std::wstring out    = m.format(fmt, std::regex_constants::format_sed);
+    assert(out == L"prefix: $`, match: $cdefghi, suffix: $', m[1]: $1, m[2]: $2");
+  }
+  {
+    std::match_results<const wchar_t*> m;
+    const wchar_t s[] = L"abcdefghijk";
+    assert(std::regex_search(s, m, std::wregex(L"cd((e)fg)hi")));
 
-        const wchar_t fmt[] = L"match: &, m[1]: \\1, m[2]: \\2";
-        std::wstring out = m.format(fmt, std::regex_constants::format_sed);
-        assert(out == L"match: cdefghi, m[1]: efg, m[2]: e");
-    }
+    const wchar_t fmt[] = L"match: &, m[1]: \\1, m[2]: \\2";
+    std::wstring out    = m.format(fmt, std::regex_constants::format_sed);
+    assert(out == L"match: cdefghi, m[1]: efg, m[2]: e");
+  }
 #endif // TEST_HAS_NO_WIDE_CHARACTERS
 
   return 0;
diff --git a/libcxx/test/std/re/re.results/re.results.nonmember/equal.pass.cpp b/libcxx/test/std/re/re.results/re.results.nonmember/equal.pass.cpp
index 1f01e95861fbc..52308a97f33c5 100644
--- a/libcxx/test/std/re/re.results/re.results.nonmember/equal.pass.cpp
+++ b/libcxx/test/std/re/re.results/re.results.nonmember/equal.pass.cpp
@@ -24,25 +24,22 @@
 #include <cassert>
 #include "test_macros.h"
 
-void
-test()
-{
-    std::match_results<const char*> m1;
-    const char s[] = "abcdefghijk";
-    assert(std::regex_search(s, m1, std::regex("cd((e)fg)hi")));
-    std::match_results<const char*> m2;
+void test() {
+  std::match_results<const char*> m1;
+  const char s[] = "abcdefghijk";
+  assert(std::regex_search(s, m1, std::regex("cd((e)fg)hi")));
+  std::match_results<const char*> m2;
 
-    assert(m1 == m1);
-    assert(m1 != m2);
+  assert(m1 == m1);
+  assert(m1 != m2);
 
-    m2 = m1;
+  m2 = m1;
 
-    assert(m1 == m2);
+  assert(m1 == m2);
 }
 
-int main(int, char**)
-{
-    test();
+int main(int, char**) {
+  test();
 
   return 0;
 }
diff --git a/libcxx/test/std/re/re.results/re.results.size/empty.pass.cpp b/libcxx/test/std/re/re.results/re.results.size/empty.pass.cpp
index 7eaed34ac6ab8..120f141bb035c 100644
--- a/libcxx/test/std/re/re.results/re.results.size/empty.pass.cpp
+++ b/libcxx/test/std/re/re.results/re.results.size/empty.pass.cpp
@@ -18,21 +18,18 @@
 #include "test_macros.h"
 
 template <class CharT>
-void
-test()
-{
-    std::match_results<const CharT*> m;
-    assert(m.empty());
-    assert(m.size() == 0);
-    const char s[] = "abcdefghijk";
-    assert(std::regex_search(s, m, std::regex("cd((e)fg)hi")));
-    assert(!m.empty());
-    assert(m.size() == 3);
+void test() {
+  std::match_results<const CharT*> m;
+  assert(m.empty());
+  assert(m.size() == 0);
+  const char s[] = "abcdefghijk";
+  assert(std::regex_search(s, m, std::regex("cd((e)fg)hi")));
+  assert(!m.empty());
+  assert(m.size() == 3);
 }
 
-int main(int, char**)
-{
-    test<char>();
+int main(int, char**) {
+  test<char>();
 
   return 0;
 }
diff --git a/libcxx/test/std/re/re.results/re.results.size/empty.verify.cpp b/libcxx/test/std/re/re.results/re.results.size/empty.verify.cpp
index 4087c24024ce3..13d712d710a05 100644
--- a/libcxx/test/std/re/re.results/re.results.size/empty.verify.cpp
+++ b/libcxx/test/std/re/re.results/re.results.size/empty.verify.cpp
@@ -16,6 +16,6 @@
 #include <regex>
 
 void f() {
-    std::match_results<const char*> c;
-    c.empty(); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
+  std::match_results<const char*> c;
+  c.empty(); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
 }
diff --git a/libcxx/test/std/re/re.results/re.results.size/max_size.pass.cpp b/libcxx/test/std/re/re.results/re.results.size/max_size.pass.cpp
index 184933d135c76..bfc2f2c82797b 100644
--- a/libcxx/test/std/re/re.results/re.results.size/max_size.pass.cpp
+++ b/libcxx/test/std/re/re.results/re.results.size/max_size.pass.cpp
@@ -17,17 +17,14 @@
 #include "test_macros.h"
 
 template <class CharT>
-void
-test()
-{
-    std::match_results<const CharT*> m;
-    assert(m.max_size() > 0);
+void test() {
+  std::match_results<const CharT*> m;
+  assert(m.max_size() > 0);
 }
 
-int main(int, char**)
-{
-    test<char>();
-    test<wchar_t>();
+int main(int, char**) {
+  test<char>();
+  test<wchar_t>();
 
   return 0;
 }
diff --git a/libcxx/test/std/re/re.results/re.results.state/ready.pass.cpp b/libcxx/test/std/re/re.results/re.results.state/ready.pass.cpp
index 476a66fdfba47..ce9788d96329c 100644
--- a/libcxx/test/std/re/re.results/re.results.state/ready.pass.cpp
+++ b/libcxx/test/std/re/re.results/re.results.state/ready.pass.cpp
@@ -16,30 +16,25 @@
 #include <cassert>
 #include "test_macros.h"
 
-void
-test1()
-{
-    std::match_results<const char*> m;
-    const char s[] = "abcdefghijk";
-    assert(m.ready() == false);
-    std::regex_search(s, m, std::regex("cd((e)fg)hi"));
-    assert(m.ready() == true);
+void test1() {
+  std::match_results<const char*> m;
+  const char s[] = "abcdefghijk";
+  assert(m.ready() == false);
+  std::regex_search(s, m, std::regex("cd((e)fg)hi"));
+  assert(m.ready() == true);
 }
 
-void
-test2()
-{
-    std::match_results<const char*> m;
-    const char s[] = "abcdefghijk";
-    assert(m.ready() == false);
-    std::regex_search(s, m, std::regex("z"));
-    assert(m.ready() == true);
+void test2() {
+  std::match_results<const char*> m;
+  const char s[] = "abcdefghijk";
+  assert(m.ready() == false);
+  std::regex_search(s, m, std::regex("z"));
+  assert(m.ready() == true);
 }
 
-int main(int, char**)
-{
-    test1();
-    test2();
+int main(int, char**) {
+  test1();
+  test2();
 
   return 0;
 }
diff --git a/libcxx/test/std/re/re.results/re.results.swap/member_swap.pass.cpp b/libcxx/test/std/re/re.results/re.results.swap/member_swap.pass.cpp
index 967fe11c5ac4b..97ba3c35c621c 100644
--- a/libcxx/test/std/re/re.results/re.results.swap/member_swap.pass.cpp
+++ b/libcxx/test/std/re/re.results/re.results.swap/member_swap.pass.cpp
@@ -16,26 +16,23 @@
 #include <cassert>
 #include "test_macros.h"
 
-void
-test()
-{
-    std::match_results<const char*> m1;
-    const char s[] = "abcdefghijk";
-    assert(std::regex_search(s, m1, std::regex("cd((e)fg)hi")));
-    std::match_results<const char*> m2;
+void test() {
+  std::match_results<const char*> m1;
+  const char s[] = "abcdefghijk";
+  assert(std::regex_search(s, m1, std::regex("cd((e)fg)hi")));
+  std::match_results<const char*> m2;
 
-    std::match_results<const char*> m1_save = m1;
-    std::match_results<const char*> m2_save = m2;
+  std::match_results<const char*> m1_save = m1;
+  std::match_results<const char*> m2_save = m2;
 
-    m1.swap(m2);
+  m1.swap(m2);
 
-    assert(m1 == m2_save);
-    assert(m2 == m1_save);
+  assert(m1 == m2_save);
+  assert(m2 == m1_save);
 }
 
-int main(int, char**)
-{
-    test();
+int main(int, char**) {
+  test();
 
   return 0;
 }
diff --git a/libcxx/test/std/re/re.results/re.results.swap/non_member_swap.pass.cpp b/libcxx/test/std/re/re.results/re.results.swap/non_member_swap.pass.cpp
index 59ba59f3d6493..af3e765693b7b 100644
--- a/libcxx/test/std/re/re.results/re.results.swap/non_member_swap.pass.cpp
+++ b/libcxx/test/std/re/re.results/re.results.swap/non_member_swap.pass.cpp
@@ -18,26 +18,23 @@
 #include <cassert>
 #include "test_macros.h"
 
-void
-test()
-{
-    std::match_results<const char*> m1;
-    const char s[] = "abcdefghijk";
-    assert(std::regex_search(s, m1, std::regex("cd((e)fg)hi")));
-    std::match_results<const char*> m2;
+void test() {
+  std::match_results<const char*> m1;
+  const char s[] = "abcdefghijk";
+  assert(std::regex_search(s, m1, std::regex("cd((e)fg)hi")));
+  std::match_results<const char*> m2;
 
-    std::match_results<const char*> m1_save = m1;
-    std::match_results<const char*> m2_save = m2;
+  std::match_results<const char*> m1_save = m1;
+  std::match_results<const char*> m2_save = m2;
 
-    swap(m1, m2);
+  swap(m1, m2);
 
-    assert(m1 == m2_save);
-    assert(m2 == m1_save);
+  assert(m1 == m2_save);
+  assert(m2 == m1_save);
 }
 
-int main(int, char**)
-{
-    test();
+int main(int, char**) {
+  test();
 
   return 0;
 }
diff --git a/libcxx/test/std/re/re.results/types.pass.cpp b/libcxx/test/std/re/re.results/types.pass.cpp
index 0fd8220843b17..3f4cb3dc61137 100644
--- a/libcxx/test/std/re/re.results/types.pass.cpp
+++ b/libcxx/test/std/re/re.results/types.pass.cpp
@@ -29,25 +29,22 @@
 #include "test_macros.h"
 
 template <class CharT>
-void
-test()
-{
-    typedef std::match_results<CharT*> MR;
-    static_assert((std::is_same<typename MR::value_type, std::sub_match<CharT*> >::value), "");
-    static_assert((std::is_same<typename MR::const_reference, const std::sub_match<CharT*>& >::value), "");
-    static_assert((std::is_same<typename MR::reference, std::sub_match<CharT*>& >::value), "");
-    static_assert((!std::is_same<typename MR::const_iterator, void>::value), "");
-    static_assert((std::is_same<typename MR::difference_type, std::ptrdiff_t>::value), "");
-    static_assert((std::is_same<typename MR::size_type, std::size_t>::value), "");
-    static_assert((std::is_same<typename MR::allocator_type, std::allocator<std::sub_match<CharT*> > >::value), "");
-    static_assert((std::is_same<typename MR::char_type, CharT>::value), "");
-    static_assert((std::is_same<typename MR::string_type, std::basic_string<CharT> >::value), "");
+void test() {
+  typedef std::match_results<CharT*> MR;
+  static_assert((std::is_same<typename MR::value_type, std::sub_match<CharT*> >::value), "");
+  static_assert((std::is_same<typename MR::const_reference, const std::sub_match<CharT*>& >::value), "");
+  static_assert((std::is_same<typename MR::reference, std::sub_match<CharT*>& >::value), "");
+  static_assert((!std::is_same<typename MR::const_iterator, void>::value), "");
+  static_assert((std::is_same<typename MR::difference_type, std::ptrdiff_t>::value), "");
+  static_assert((std::is_same<typename MR::size_type, std::size_t>::value), "");
+  static_assert((std::is_same<typename MR::allocator_type, std::allocator<std::sub_match<CharT*> > >::value), "");
+  static_assert((std::is_same<typename MR::char_type, CharT>::value), "");
+  static_assert((std::is_same<typename MR::string_type, std::basic_string<CharT> >::value), "");
 }
 
-int main(int, char**)
-{
-    test<char>();
-    test<wchar_t>();
+int main(int, char**) {
+  test<char>();
+  test<wchar_t>();
 
   return 0;
 }
diff --git a/libcxx/test/std/re/re.submatch/re.submatch.members/compare_string_type.pass.cpp b/libcxx/test/std/re/re.submatch/re.submatch.members/compare_string_type.pass.cpp
index 31f273749afdd..64385e333f6fd 100644
--- a/libcxx/test/std/re/re.submatch/re.submatch.members/compare_string_type.pass.cpp
+++ b/libcxx/test/std/re/re.submatch/re.submatch.members/compare_string_type.pass.cpp
@@ -16,35 +16,34 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    {
-        typedef char CharT;
-        typedef std::sub_match<const CharT*> SM;
-        typedef SM::string_type string;
-        SM sm = SM();
-        assert(sm.compare(string()) == 0);
-        const CharT s[] = {'1', '2', '3', 0};
-        sm.first = s;
-        sm.second = s + 3;
-        sm.matched = true;
-        assert(sm.compare(string()) > 0);
-        assert(sm.compare(string("123")) == 0);
-    }
+int main(int, char**) {
+  {
+    typedef char CharT;
+    typedef std::sub_match<const CharT*> SM;
+    typedef SM::string_type string;
+    SM sm = SM();
+    assert(sm.compare(string()) == 0);
+    const CharT s[] = {'1', '2', '3', 0};
+    sm.first        = s;
+    sm.second       = s + 3;
+    sm.matched      = true;
+    assert(sm.compare(string()) > 0);
+    assert(sm.compare(string("123")) == 0);
+  }
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-    {
-        typedef wchar_t CharT;
-        typedef std::sub_match<const CharT*> SM;
-        typedef SM::string_type string;
-        SM sm = SM();
-        assert(sm.compare(string()) == 0);
-        const CharT s[] = {'1', '2', '3', 0};
-        sm.first = s;
-        sm.second = s + 3;
-        sm.matched = true;
-        assert(sm.compare(string()) > 0);
-        assert(sm.compare(string(L"123")) == 0);
-    }
+  {
+    typedef wchar_t CharT;
+    typedef std::sub_match<const CharT*> SM;
+    typedef SM::string_type string;
+    SM sm = SM();
+    assert(sm.compare(string()) == 0);
+    const CharT s[] = {'1', '2', '3', 0};
+    sm.first        = s;
+    sm.second       = s + 3;
+    sm.matched      = true;
+    assert(sm.compare(string()) > 0);
+    assert(sm.compare(string(L"123")) == 0);
+  }
 #endif
 
   return 0;
diff --git a/libcxx/test/std/re/re.submatch/re.submatch.members/compare_sub_match.pass.cpp b/libcxx/test/std/re/re.submatch/re.submatch.members/compare_sub_match.pass.cpp
index fbd21e32195a0..6fdaf34be2d42 100644
--- a/libcxx/test/std/re/re.submatch/re.submatch.members/compare_sub_match.pass.cpp
+++ b/libcxx/test/std/re/re.submatch/re.submatch.members/compare_sub_match.pass.cpp
@@ -16,41 +16,40 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    {
-        typedef char CharT;
-        typedef std::sub_match<const CharT*> SM;
-        SM sm = SM();
-        SM sm2 = SM();
-        assert(sm.compare(sm2) == 0);
-        const CharT s[] = {'1', '2', '3', 0};
-        sm.first = s;
-        sm.second = s + 3;
-        sm.matched = true;
-        assert(sm.compare(sm2) > 0);
-        sm2.first = s;
-        sm2.second = s + 3;
-        sm2.matched = true;
-        assert(sm.compare(sm2) == 0);
-    }
+int main(int, char**) {
+  {
+    typedef char CharT;
+    typedef std::sub_match<const CharT*> SM;
+    SM sm  = SM();
+    SM sm2 = SM();
+    assert(sm.compare(sm2) == 0);
+    const CharT s[] = {'1', '2', '3', 0};
+    sm.first        = s;
+    sm.second       = s + 3;
+    sm.matched      = true;
+    assert(sm.compare(sm2) > 0);
+    sm2.first   = s;
+    sm2.second  = s + 3;
+    sm2.matched = true;
+    assert(sm.compare(sm2) == 0);
+  }
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-    {
-        typedef wchar_t CharT;
-        typedef std::sub_match<const CharT*> SM;
-        SM sm = SM();
-        SM sm2 = SM();
-        assert(sm.compare(sm2) == 0);
-        const CharT s[] = {'1', '2', '3', 0};
-        sm.first = s;
-        sm.second = s + 3;
-        sm.matched = true;
-        assert(sm.compare(sm2) > 0);
-        sm2.first = s;
-        sm2.second = s + 3;
-        sm2.matched = true;
-        assert(sm.compare(sm2) == 0);
-    }
+  {
+    typedef wchar_t CharT;
+    typedef std::sub_match<const CharT*> SM;
+    SM sm  = SM();
+    SM sm2 = SM();
+    assert(sm.compare(sm2) == 0);
+    const CharT s[] = {'1', '2', '3', 0};
+    sm.first        = s;
+    sm.second       = s + 3;
+    sm.matched      = true;
+    assert(sm.compare(sm2) > 0);
+    sm2.first   = s;
+    sm2.second  = s + 3;
+    sm2.matched = true;
+    assert(sm.compare(sm2) == 0);
+  }
 #endif
 
   return 0;
diff --git a/libcxx/test/std/re/re.submatch/re.submatch.members/compare_value_type_ptr.pass.cpp b/libcxx/test/std/re/re.submatch/re.submatch.members/compare_value_type_ptr.pass.cpp
index b213a51323d6f..25e08058596ea 100644
--- a/libcxx/test/std/re/re.submatch/re.submatch.members/compare_value_type_ptr.pass.cpp
+++ b/libcxx/test/std/re/re.submatch/re.submatch.members/compare_value_type_ptr.pass.cpp
@@ -16,33 +16,32 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    {
-        typedef char CharT;
-        typedef std::sub_match<const CharT*> SM;
-        SM sm = SM();
-        assert(sm.compare("") == 0);
-        const CharT s[] = {'1', '2', '3', 0};
-        sm.first = s;
-        sm.second = s + 3;
-        sm.matched = true;
-        assert(sm.compare("") > 0);
-        assert(sm.compare("123") == 0);
-    }
+int main(int, char**) {
+  {
+    typedef char CharT;
+    typedef std::sub_match<const CharT*> SM;
+    SM sm = SM();
+    assert(sm.compare("") == 0);
+    const CharT s[] = {'1', '2', '3', 0};
+    sm.first        = s;
+    sm.second       = s + 3;
+    sm.matched      = true;
+    assert(sm.compare("") > 0);
+    assert(sm.compare("123") == 0);
+  }
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-    {
-        typedef wchar_t CharT;
-        typedef std::sub_match<const CharT*> SM;
-        SM sm = SM();
-        assert(sm.compare(L"") == 0);
-        const CharT s[] = {'1', '2', '3', 0};
-        sm.first = s;
-        sm.second = s + 3;
-        sm.matched = true;
-        assert(sm.compare(L"") > 0);
-        assert(sm.compare(L"123") == 0);
-    }
+  {
+    typedef wchar_t CharT;
+    typedef std::sub_match<const CharT*> SM;
+    SM sm = SM();
+    assert(sm.compare(L"") == 0);
+    const CharT s[] = {'1', '2', '3', 0};
+    sm.first        = s;
+    sm.second       = s + 3;
+    sm.matched      = true;
+    assert(sm.compare(L"") > 0);
+    assert(sm.compare(L"123") == 0);
+  }
 #endif
 
   return 0;
diff --git a/libcxx/test/std/re/re.submatch/re.submatch.members/default.pass.cpp b/libcxx/test/std/re/re.submatch/re.submatch.members/default.pass.cpp
index c828f4942be50..98edfdfd496b4 100644
--- a/libcxx/test/std/re/re.submatch/re.submatch.members/default.pass.cpp
+++ b/libcxx/test/std/re/re.submatch/re.submatch.members/default.pass.cpp
@@ -16,21 +16,20 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    {
-        typedef char CharT;
-        typedef std::sub_match<const CharT*> SM;
-        SM sm;
-        assert(sm.matched == false);
-    }
+int main(int, char**) {
+  {
+    typedef char CharT;
+    typedef std::sub_match<const CharT*> SM;
+    SM sm;
+    assert(sm.matched == false);
+  }
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-    {
-        typedef wchar_t CharT;
-        typedef std::sub_match<const CharT*> SM;
-        SM sm;
-        assert(sm.matched == false);
-    }
+  {
+    typedef wchar_t CharT;
+    typedef std::sub_match<const CharT*> SM;
+    SM sm;
+    assert(sm.matched == false);
+  }
 #endif
 
   return 0;
diff --git a/libcxx/test/std/re/re.submatch/re.submatch.members/length.pass.cpp b/libcxx/test/std/re/re.submatch/re.submatch.members/length.pass.cpp
index 1027bd775a27a..fc5eddcd42e53 100644
--- a/libcxx/test/std/re/re.submatch/re.submatch.members/length.pass.cpp
+++ b/libcxx/test/std/re/re.submatch/re.submatch.members/length.pass.cpp
@@ -16,31 +16,30 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    {
-        typedef char CharT;
-        typedef std::sub_match<const CharT*> SM;
-        SM sm = SM();
-        assert(sm.length() == 0);
-        const CharT s[] = {'1', '2', '3', 0};
-        sm.first = s;
-        sm.second = s + 3;
-        sm.matched = true;
-        assert(sm.length() == 3);
-    }
+int main(int, char**) {
+  {
+    typedef char CharT;
+    typedef std::sub_match<const CharT*> SM;
+    SM sm = SM();
+    assert(sm.length() == 0);
+    const CharT s[] = {'1', '2', '3', 0};
+    sm.first        = s;
+    sm.second       = s + 3;
+    sm.matched      = true;
+    assert(sm.length() == 3);
+  }
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-    {
-        typedef wchar_t CharT;
-        typedef std::sub_match<const CharT*> SM;
-        SM sm = SM();
-        assert(sm.length() == 0);
-        const CharT s[] = {'1', '2', '3', 0};
-        sm.first = s;
-        sm.second = s + 3;
-        sm.matched = true;
-        assert(sm.length() == 3);
-    }
+  {
+    typedef wchar_t CharT;
+    typedef std::sub_match<const CharT*> SM;
+    SM sm = SM();
+    assert(sm.length() == 0);
+    const CharT s[] = {'1', '2', '3', 0};
+    sm.first        = s;
+    sm.second       = s + 3;
+    sm.matched      = true;
+    assert(sm.length() == 3);
+  }
 #endif
 
   return 0;
diff --git a/libcxx/test/std/re/re.submatch/re.submatch.members/operator_string.pass.cpp b/libcxx/test/std/re/re.submatch/re.submatch.members/operator_string.pass.cpp
index 08a9dbfbadd8d..c50683701ebfb 100644
--- a/libcxx/test/std/re/re.submatch/re.submatch.members/operator_string.pass.cpp
+++ b/libcxx/test/std/re/re.submatch/re.submatch.members/operator_string.pass.cpp
@@ -16,35 +16,34 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    {
-        typedef char CharT;
-        typedef std::sub_match<const CharT*> SM;
-        SM sm = SM();
-        SM::string_type str = sm;
-        assert(str.empty());
-        const CharT s[] = {'1', '2', '3', 0};
-        sm.first = s;
-        sm.second = s + 3;
-        sm.matched = true;
-        str = sm;
-        assert(str == std::string("123"));
-    }
+int main(int, char**) {
+  {
+    typedef char CharT;
+    typedef std::sub_match<const CharT*> SM;
+    SM sm               = SM();
+    SM::string_type str = sm;
+    assert(str.empty());
+    const CharT s[] = {'1', '2', '3', 0};
+    sm.first        = s;
+    sm.second       = s + 3;
+    sm.matched      = true;
+    str             = sm;
+    assert(str == std::string("123"));
+  }
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-    {
-        typedef wchar_t CharT;
-        typedef std::sub_match<const CharT*> SM;
-        SM sm = SM();
-        SM::string_type str = sm;
-        assert(str.empty());
-        const CharT s[] = {'1', '2', '3', 0};
-        sm.first = s;
-        sm.second = s + 3;
-        sm.matched = true;
-        str = sm;
-        assert(str == std::wstring(L"123"));
-    }
+  {
+    typedef wchar_t CharT;
+    typedef std::sub_match<const CharT*> SM;
+    SM sm               = SM();
+    SM::string_type str = sm;
+    assert(str.empty());
+    const CharT s[] = {'1', '2', '3', 0};
+    sm.first        = s;
+    sm.second       = s + 3;
+    sm.matched      = true;
+    str             = sm;
+    assert(str == std::wstring(L"123"));
+  }
 #endif
 
   return 0;
diff --git a/libcxx/test/std/re/re.submatch/re.submatch.members/str.pass.cpp b/libcxx/test/std/re/re.submatch/re.submatch.members/str.pass.cpp
index ffdcbaabb44f7..0b0427160a73f 100644
--- a/libcxx/test/std/re/re.submatch/re.submatch.members/str.pass.cpp
+++ b/libcxx/test/std/re/re.submatch/re.submatch.members/str.pass.cpp
@@ -16,35 +16,34 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    {
-        typedef char CharT;
-        typedef std::sub_match<const CharT*> SM;
-        SM sm = SM();
-        SM::string_type str = sm.str();
-        assert(str.empty());
-        const CharT s[] = {'1', '2', '3', 0};
-        sm.first = s;
-        sm.second = s + 3;
-        sm.matched = true;
-        str = sm.str();
-        assert(str == std::string("123"));
-    }
+int main(int, char**) {
+  {
+    typedef char CharT;
+    typedef std::sub_match<const CharT*> SM;
+    SM sm               = SM();
+    SM::string_type str = sm.str();
+    assert(str.empty());
+    const CharT s[] = {'1', '2', '3', 0};
+    sm.first        = s;
+    sm.second       = s + 3;
+    sm.matched      = true;
+    str             = sm.str();
+    assert(str == std::string("123"));
+  }
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-    {
-        typedef wchar_t CharT;
-        typedef std::sub_match<const CharT*> SM;
-        SM sm = SM();
-        SM::string_type str = sm.str();
-        assert(str.empty());
-        const CharT s[] = {'1', '2', '3', 0};
-        sm.first = s;
-        sm.second = s + 3;
-        sm.matched = true;
-        str = sm.str();
-        assert(str == std::wstring(L"123"));
-    }
+  {
+    typedef wchar_t CharT;
+    typedef std::sub_match<const CharT*> SM;
+    SM sm               = SM();
+    SM::string_type str = sm.str();
+    assert(str.empty());
+    const CharT s[] = {'1', '2', '3', 0};
+    sm.first        = s;
+    sm.second       = s + 3;
+    sm.matched      = true;
+    str             = sm.str();
+    assert(str == std::wstring(L"123"));
+  }
 #endif
 
   return 0;
diff --git a/libcxx/test/std/re/re.submatch/re.submatch.op/compare.pass.cpp b/libcxx/test/std/re/re.submatch/re.submatch.op/compare.pass.cpp
index 6e51825185d88..008b86035233f 100644
--- a/libcxx/test/std/re/re.submatch/re.submatch.op/compare.pass.cpp
+++ b/libcxx/test/std/re/re.submatch/re.submatch.op/compare.pass.cpp
@@ -243,61 +243,58 @@
 #include "test_comparisons.h"
 #include "test_macros.h"
 
-
 #define SV(S) MAKE_STRING_VIEW(CharT, S)
 
 template <class CharT>
-void
-test(const std::basic_string<CharT>& x, const std::basic_string<CharT>& y, bool doCStrTests = true)
-{
-    typedef std::basic_string<CharT> string;
-    typedef std::sub_match<typename string::const_iterator> sub_match;
+void test(const std::basic_string<CharT>& x, const std::basic_string<CharT>& y, bool doCStrTests = true) {
+  typedef std::basic_string<CharT> string;
+  typedef std::sub_match<typename string::const_iterator> sub_match;
 #if TEST_STD_VER > 17
-    AssertOrderReturn<std::strong_ordering, sub_match>();
-    AssertOrderReturn<std::strong_ordering, sub_match, string>();
+  AssertOrderReturn<std::strong_ordering, sub_match>();
+  AssertOrderReturn<std::strong_ordering, sub_match, string>();
 #else
-    AssertComparisonsReturnBool<sub_match>();
-    AssertComparisonsReturnBool<sub_match, string>();
+  AssertComparisonsReturnBool<sub_match>();
+  AssertComparisonsReturnBool<sub_match, string>();
 #endif
-    sub_match sm1;
-    sm1.first = x.begin();
-    sm1.second = x.end();
-    sm1.matched = true;
-    sub_match sm2;
-    sm2.first = y.begin();
-    sm2.second = y.end();
-    sm2.matched = true;
+  sub_match sm1;
+  sm1.first   = x.begin();
+  sm1.second  = x.end();
+  sm1.matched = true;
+  sub_match sm2;
+  sm2.first   = y.begin();
+  sm2.second  = y.end();
+  sm2.matched = true;
 
-    assert(testComparisons(sm1, sm2, x == y, x < y));
-    assert(testComparisons(x, sm2, x == y, x < y));
-    assert(testComparisons(sm1, y, x == y, x < y));
+  assert(testComparisons(sm1, sm2, x == y, x < y));
+  assert(testComparisons(x, sm2, x == y, x < y));
+  assert(testComparisons(sm1, y, x == y, x < y));
 #if TEST_STD_VER > 17
-    assert(testOrder(sm1, sm2, x <=> y));
-    assert(testOrder(x, sm2, x <=> y));
-    assert(testOrder(sm1, y, x <=> y));
+  assert(testOrder(sm1, sm2, x <=> y));
+  assert(testOrder(x, sm2, x <=> y));
+  assert(testOrder(sm1, y, x <=> y));
 #endif
 
-    if (doCStrTests) {
-        assert(testComparisons(x.c_str(), sm2, x == y, x < y));
-        assert(testComparisons(sm1, y.c_str(), x == y, x < y));
+  if (doCStrTests) {
+    assert(testComparisons(x.c_str(), sm2, x == y, x < y));
+    assert(testComparisons(sm1, y.c_str(), x == y, x < y));
 #if TEST_STD_VER > 17
-        assert(testOrder(x.c_str(), sm2, x <=> y));
-        assert(testOrder(sm1, y.c_str(), x <=> y));
+    assert(testOrder(x.c_str(), sm2, x <=> y));
+    assert(testOrder(sm1, y.c_str(), x <=> y));
 #endif
-    }
+  }
 
-    assert(testComparisons(x[0], sm2, string(1, x[0]) == y, string(1, x[0]) < y));
-    assert(testComparisons(sm1, y[0], x == string(1, y[0]), x < string(1, y[0])));
+  assert(testComparisons(x[0], sm2, string(1, x[0]) == y, string(1, x[0]) < y));
+  assert(testComparisons(sm1, y[0], x == string(1, y[0]), x < string(1, y[0])));
 #if TEST_STD_VER > 17
-    assert(testOrder(x[0], sm2, (string(1, x[0]) <=> y)));
-    assert(testOrder(sm1, y[0], x <=> (string(1, y[0]))));
+  assert(testOrder(x[0], sm2, (string(1, x[0]) <=> y)));
+  assert(testOrder(sm1, y[0], x <=> (string(1, y[0]))));
 #endif
 }
 
 #if TEST_STD_VER > 17
 template <class CharT, class Ordering>
 struct char_traits : public constexpr_char_traits<CharT> {
-    using comparison_category = Ordering;
+  using comparison_category = Ordering;
 };
 
 template <class T, class Ordering = std::strong_ordering>
@@ -339,22 +336,33 @@ constexpr void test_all_orderings() {
 }
 #endif //  TEST_STD_VER > 17
 
-int main(int, char**)
-{
-    test(std::string("123"), std::string("123"));
-    test(std::string("1234"), std::string("123"));
-    test(std::string("123\000" "56", 6), std::string("123\000" "56", 6), false);
+int main(int, char**) {
+  test(std::string("123"), std::string("123"));
+  test(std::string("1234"), std::string("123"));
+  test(std::string("123\000"
+                   "56",
+                   6),
+       std::string("123\000"
+                   "56",
+                   6),
+       false);
 #if TEST_STD_VER > 17
-    test_all_orderings<char>();
+  test_all_orderings<char>();
 #endif
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-    test(std::wstring(L"123"), std::wstring(L"123"));
-    test(std::wstring(L"1234"), std::wstring(L"123"));
-    test(std::wstring(L"123\000" L"56", 6), std::wstring(L"123\000" L"56", 6), false);
-#if TEST_STD_VER > 17
-    test_all_orderings<wchar_t>();
-#endif
+  test(std::wstring(L"123"), std::wstring(L"123"));
+  test(std::wstring(L"1234"), std::wstring(L"123"));
+  test(std::wstring(L"123\000"
+                    L"56",
+                    6),
+       std::wstring(L"123\000"
+                    L"56",
+                    6),
+       false);
+#  if TEST_STD_VER > 17
+  test_all_orderings<wchar_t>();
+#  endif
 #endif // TEST_HAS_NO_WIDE_CHARACTERS
 
   return 0;
diff --git a/libcxx/test/std/re/re.submatch/re.submatch.op/stream.pass.cpp b/libcxx/test/std/re/re.submatch/re.submatch.op/stream.pass.cpp
index 244d78d120f35..c21a977ad4dd7 100644
--- a/libcxx/test/std/re/re.submatch/re.submatch.op/stream.pass.cpp
+++ b/libcxx/test/std/re/re.submatch/re.submatch.op/stream.pass.cpp
@@ -20,26 +20,23 @@
 #include "test_macros.h"
 
 template <class CharT>
-void
-test(const std::basic_string<CharT>& s)
-{
-    typedef std::basic_string<CharT> string;
-    typedef std::sub_match<typename string::const_iterator> SM;
-    typedef std::basic_ostringstream<CharT> ostringstream;
-    SM sm;
-    sm.first = s.begin();
-    sm.second = s.end();
-    sm.matched = true;
-    ostringstream os;
-    os << sm;
-    assert(os.str() == s);
+void test(const std::basic_string<CharT>& s) {
+  typedef std::basic_string<CharT> string;
+  typedef std::sub_match<typename string::const_iterator> SM;
+  typedef std::basic_ostringstream<CharT> ostringstream;
+  SM sm;
+  sm.first   = s.begin();
+  sm.second  = s.end();
+  sm.matched = true;
+  ostringstream os;
+  os << sm;
+  assert(os.str() == s);
 }
 
-int main(int, char**)
-{
-    test(std::string("123"));
+int main(int, char**) {
+  test(std::string("123"));
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-    test(std::wstring(L"123"));
+  test(std::wstring(L"123"));
 #endif
 
   return 0;
diff --git a/libcxx/test/std/re/re.submatch/types.pass.cpp b/libcxx/test/std/re/re.submatch/types.pass.cpp
index 3c23d72eb9aa7..d3de4a007ae6f 100644
--- a/libcxx/test/std/re/re.submatch/types.pass.cpp
+++ b/libcxx/test/std/re/re.submatch/types.pass.cpp
@@ -27,42 +27,41 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    {
-        typedef std::sub_match<char*> SM;
-        static_assert((std::is_same<SM::iterator, char*>::value), "");
-        static_assert((std::is_same<SM::value_type, char>::value), "");
-        static_assert((std::is_same<SM::difference_type, std::ptrdiff_t>::value), "");
-        static_assert((std::is_same<SM::string_type, std::string>::value), "");
-        static_assert((std::is_convertible<SM*, std::pair<char*, char*>*>::value), "");
+int main(int, char**) {
+  {
+    typedef std::sub_match<char*> SM;
+    static_assert((std::is_same<SM::iterator, char*>::value), "");
+    static_assert((std::is_same<SM::value_type, char>::value), "");
+    static_assert((std::is_same<SM::difference_type, std::ptrdiff_t>::value), "");
+    static_assert((std::is_same<SM::string_type, std::string>::value), "");
+    static_assert((std::is_convertible<SM*, std::pair<char*, char*>*>::value), "");
 
-        static_assert((std::is_same<std::csub_match, std::sub_match<const char*> >::value), "");
-        static_assert((std::is_same<std::ssub_match, std::sub_match<std::string::const_iterator> >::value), "");
+    static_assert((std::is_same<std::csub_match, std::sub_match<const char*> >::value), "");
+    static_assert((std::is_same<std::ssub_match, std::sub_match<std::string::const_iterator> >::value), "");
 
-        SM sm;
-        sm.first = nullptr;
-        sm.second = nullptr;
-        sm.matched = false;
-    }
+    SM sm;
+    sm.first   = nullptr;
+    sm.second  = nullptr;
+    sm.matched = false;
+  }
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-    {
-        typedef std::sub_match<wchar_t*> SM;
-        static_assert((std::is_same<SM::iterator, wchar_t*>::value), "");
-        static_assert((std::is_same<SM::value_type, wchar_t>::value), "");
-        static_assert((std::is_same<SM::difference_type, std::ptrdiff_t>::value), "");
-        static_assert((std::is_same<SM::string_type, std::wstring>::value), "");
-        static_assert((std::is_convertible<SM*, std::pair<wchar_t*, wchar_t*>*>::value), "");
+  {
+    typedef std::sub_match<wchar_t*> SM;
+    static_assert((std::is_same<SM::iterator, wchar_t*>::value), "");
+    static_assert((std::is_same<SM::value_type, wchar_t>::value), "");
+    static_assert((std::is_same<SM::difference_type, std::ptrdiff_t>::value), "");
+    static_assert((std::is_same<SM::string_type, std::wstring>::value), "");
+    static_assert((std::is_convertible<SM*, std::pair<wchar_t*, wchar_t*>*>::value), "");
 
-        static_assert((std::is_same<std::wcsub_match, std::sub_match<const wchar_t*> >::value), "");
-        static_assert((std::is_same<std::wssub_match, std::sub_match<std::wstring::const_iterator> >::value), "");
+    static_assert((std::is_same<std::wcsub_match, std::sub_match<const wchar_t*> >::value), "");
+    static_assert((std::is_same<std::wssub_match, std::sub_match<std::wstring::const_iterator> >::value), "");
 
-        SM sm;
-        sm.first = nullptr;
-        sm.second = nullptr;
-        sm.matched = false;
-    }
+    SM sm;
+    sm.first   = nullptr;
+    sm.second  = nullptr;
+    sm.matched = false;
+  }
 #endif
 
   return 0;
diff --git a/libcxx/test/std/re/re.syn/cmatch.pass.cpp b/libcxx/test/std/re/re.syn/cmatch.pass.cpp
index 7b85a69a2ff82..011d159c41eac 100644
--- a/libcxx/test/std/re/re.syn/cmatch.pass.cpp
+++ b/libcxx/test/std/re/re.syn/cmatch.pass.cpp
@@ -14,9 +14,8 @@
 #include <type_traits>
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    static_assert((std::is_same<std::match_results<const char*>, std::cmatch>::value), "");
+int main(int, char**) {
+  static_assert((std::is_same<std::match_results<const char*>, std::cmatch>::value), "");
 
   return 0;
 }
diff --git a/libcxx/test/std/re/re.syn/cregex_iterator.pass.cpp b/libcxx/test/std/re/re.syn/cregex_iterator.pass.cpp
index 29fdadeb66921..5bf5ce50cba8f 100644
--- a/libcxx/test/std/re/re.syn/cregex_iterator.pass.cpp
+++ b/libcxx/test/std/re/re.syn/cregex_iterator.pass.cpp
@@ -14,9 +14,8 @@
 #include <type_traits>
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    static_assert((std::is_same<std::regex_iterator<const char*>, std::cregex_iterator>::value), "");
+int main(int, char**) {
+  static_assert((std::is_same<std::regex_iterator<const char*>, std::cregex_iterator>::value), "");
 
   return 0;
 }
diff --git a/libcxx/test/std/re/re.syn/cregex_token_iterator.pass.cpp b/libcxx/test/std/re/re.syn/cregex_token_iterator.pass.cpp
index 7ca531dfe6333..c89bacb6fe66e 100644
--- a/libcxx/test/std/re/re.syn/cregex_token_iterator.pass.cpp
+++ b/libcxx/test/std/re/re.syn/cregex_token_iterator.pass.cpp
@@ -14,9 +14,8 @@
 #include <type_traits>
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    static_assert((std::is_same<std::regex_token_iterator<const char*>, std::cregex_token_iterator>::value), "");
+int main(int, char**) {
+  static_assert((std::is_same<std::regex_token_iterator<const char*>, std::cregex_token_iterator>::value), "");
 
   return 0;
 }
diff --git a/libcxx/test/std/re/re.syn/csub_match.pass.cpp b/libcxx/test/std/re/re.syn/csub_match.pass.cpp
index 2ace0b983bf07..002f62a0f4213 100644
--- a/libcxx/test/std/re/re.syn/csub_match.pass.cpp
+++ b/libcxx/test/std/re/re.syn/csub_match.pass.cpp
@@ -14,9 +14,8 @@
 #include <type_traits>
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    static_assert((std::is_same<std::sub_match<const char*>, std::csub_match>::value), "");
+int main(int, char**) {
+  static_assert((std::is_same<std::sub_match<const char*>, std::csub_match>::value), "");
 
   return 0;
 }
diff --git a/libcxx/test/std/re/re.syn/regex.pass.cpp b/libcxx/test/std/re/re.syn/regex.pass.cpp
index 0b4c07b6ff181..754a39a341f93 100644
--- a/libcxx/test/std/re/re.syn/regex.pass.cpp
+++ b/libcxx/test/std/re/re.syn/regex.pass.cpp
@@ -14,9 +14,8 @@
 #include <type_traits>
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    static_assert((std::is_same<std::basic_regex<char>, std::regex>::value), "");
+int main(int, char**) {
+  static_assert((std::is_same<std::basic_regex<char>, std::regex>::value), "");
 
   return 0;
 }
diff --git a/libcxx/test/std/re/re.syn/smatch.pass.cpp b/libcxx/test/std/re/re.syn/smatch.pass.cpp
index 01fa1e95552b7..aa6bfb93ff467 100644
--- a/libcxx/test/std/re/re.syn/smatch.pass.cpp
+++ b/libcxx/test/std/re/re.syn/smatch.pass.cpp
@@ -14,9 +14,8 @@
 #include <type_traits>
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    static_assert((std::is_same<std::match_results<std::string::const_iterator>, std::smatch>::value), "");
+int main(int, char**) {
+  static_assert((std::is_same<std::match_results<std::string::const_iterator>, std::smatch>::value), "");
 
   return 0;
 }
diff --git a/libcxx/test/std/re/re.syn/sregex_iterator.pass.cpp b/libcxx/test/std/re/re.syn/sregex_iterator.pass.cpp
index 1ae462c6b7788..645393d6672e1 100644
--- a/libcxx/test/std/re/re.syn/sregex_iterator.pass.cpp
+++ b/libcxx/test/std/re/re.syn/sregex_iterator.pass.cpp
@@ -14,9 +14,8 @@
 #include <type_traits>
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    static_assert((std::is_same<std::regex_iterator<std::string::const_iterator>, std::sregex_iterator>::value), "");
+int main(int, char**) {
+  static_assert((std::is_same<std::regex_iterator<std::string::const_iterator>, std::sregex_iterator>::value), "");
 
   return 0;
 }
diff --git a/libcxx/test/std/re/re.syn/sregex_token_iterator.pass.cpp b/libcxx/test/std/re/re.syn/sregex_token_iterator.pass.cpp
index 4b67b66f2914c..8eb48c61925fa 100644
--- a/libcxx/test/std/re/re.syn/sregex_token_iterator.pass.cpp
+++ b/libcxx/test/std/re/re.syn/sregex_token_iterator.pass.cpp
@@ -14,9 +14,9 @@
 #include <type_traits>
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    static_assert((std::is_same<std::regex_token_iterator<std::string::const_iterator>, std::sregex_token_iterator>::value), "");
+int main(int, char**) {
+  static_assert(
+      (std::is_same<std::regex_token_iterator<std::string::const_iterator>, std::sregex_token_iterator>::value), "");
 
   return 0;
 }
diff --git a/libcxx/test/std/re/re.syn/ssub_match.pass.cpp b/libcxx/test/std/re/re.syn/ssub_match.pass.cpp
index fe3312968498e..41d629aaec95b 100644
--- a/libcxx/test/std/re/re.syn/ssub_match.pass.cpp
+++ b/libcxx/test/std/re/re.syn/ssub_match.pass.cpp
@@ -14,9 +14,8 @@
 #include <type_traits>
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    static_assert((std::is_same<std::sub_match<std::string::const_iterator>, std::ssub_match>::value), "");
+int main(int, char**) {
+  static_assert((std::is_same<std::sub_match<std::string::const_iterator>, std::ssub_match>::value), "");
 
   return 0;
 }
diff --git a/libcxx/test/std/re/re.syn/wcmatch.pass.cpp b/libcxx/test/std/re/re.syn/wcmatch.pass.cpp
index 5b23042c520c9..89348a575482b 100644
--- a/libcxx/test/std/re/re.syn/wcmatch.pass.cpp
+++ b/libcxx/test/std/re/re.syn/wcmatch.pass.cpp
@@ -16,9 +16,8 @@
 #include <type_traits>
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    static_assert((std::is_same<std::match_results<const wchar_t*>, std::wcmatch>::value), "");
+int main(int, char**) {
+  static_assert((std::is_same<std::match_results<const wchar_t*>, std::wcmatch>::value), "");
 
   return 0;
 }
diff --git a/libcxx/test/std/re/re.syn/wcregex_iterator.pass.cpp b/libcxx/test/std/re/re.syn/wcregex_iterator.pass.cpp
index c0f2e8aca2411..ae8a02524ba6a 100644
--- a/libcxx/test/std/re/re.syn/wcregex_iterator.pass.cpp
+++ b/libcxx/test/std/re/re.syn/wcregex_iterator.pass.cpp
@@ -16,9 +16,8 @@
 #include <type_traits>
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    static_assert((std::is_same<std::regex_iterator<const wchar_t*>, std::wcregex_iterator>::value), "");
+int main(int, char**) {
+  static_assert((std::is_same<std::regex_iterator<const wchar_t*>, std::wcregex_iterator>::value), "");
 
   return 0;
 }
diff --git a/libcxx/test/std/re/re.syn/wcregex_token_iterator.pass.cpp b/libcxx/test/std/re/re.syn/wcregex_token_iterator.pass.cpp
index 5fd0ecb485a52..e390a3764bfd7 100644
--- a/libcxx/test/std/re/re.syn/wcregex_token_iterator.pass.cpp
+++ b/libcxx/test/std/re/re.syn/wcregex_token_iterator.pass.cpp
@@ -16,9 +16,8 @@
 #include <type_traits>
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    static_assert((std::is_same<std::regex_token_iterator<const wchar_t*>, std::wcregex_token_iterator>::value), "");
+int main(int, char**) {
+  static_assert((std::is_same<std::regex_token_iterator<const wchar_t*>, std::wcregex_token_iterator>::value), "");
 
   return 0;
 }
diff --git a/libcxx/test/std/re/re.syn/wcsub_match.pass.cpp b/libcxx/test/std/re/re.syn/wcsub_match.pass.cpp
index 6f86199978d46..f6e362a32f8a5 100644
--- a/libcxx/test/std/re/re.syn/wcsub_match.pass.cpp
+++ b/libcxx/test/std/re/re.syn/wcsub_match.pass.cpp
@@ -16,9 +16,8 @@
 #include <type_traits>
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    static_assert((std::is_same<std::sub_match<const wchar_t*>, std::wcsub_match>::value), "");
+int main(int, char**) {
+  static_assert((std::is_same<std::sub_match<const wchar_t*>, std::wcsub_match>::value), "");
 
   return 0;
 }
diff --git a/libcxx/test/std/re/re.syn/wregex.pass.cpp b/libcxx/test/std/re/re.syn/wregex.pass.cpp
index 1bb2af9d816f1..96779dee1eef9 100644
--- a/libcxx/test/std/re/re.syn/wregex.pass.cpp
+++ b/libcxx/test/std/re/re.syn/wregex.pass.cpp
@@ -16,9 +16,8 @@
 #include <type_traits>
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    static_assert((std::is_same<std::basic_regex<wchar_t>, std::wregex>::value), "");
+int main(int, char**) {
+  static_assert((std::is_same<std::basic_regex<wchar_t>, std::wregex>::value), "");
 
   return 0;
 }
diff --git a/libcxx/test/std/re/re.syn/wsmatch.pass.cpp b/libcxx/test/std/re/re.syn/wsmatch.pass.cpp
index 2c26ddad8264f..dec869ccc2728 100644
--- a/libcxx/test/std/re/re.syn/wsmatch.pass.cpp
+++ b/libcxx/test/std/re/re.syn/wsmatch.pass.cpp
@@ -16,9 +16,8 @@
 #include <type_traits>
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    static_assert((std::is_same<std::match_results<std::wstring::const_iterator>, std::wsmatch>::value), "");
+int main(int, char**) {
+  static_assert((std::is_same<std::match_results<std::wstring::const_iterator>, std::wsmatch>::value), "");
 
   return 0;
 }
diff --git a/libcxx/test/std/re/re.syn/wsregex_iterator.pass.cpp b/libcxx/test/std/re/re.syn/wsregex_iterator.pass.cpp
index 5e0fa272ce9bf..69d661fa0939c 100644
--- a/libcxx/test/std/re/re.syn/wsregex_iterator.pass.cpp
+++ b/libcxx/test/std/re/re.syn/wsregex_iterator.pass.cpp
@@ -16,9 +16,8 @@
 #include <type_traits>
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    static_assert((std::is_same<std::regex_iterator<std::wstring::const_iterator>, std::wsregex_iterator>::value), "");
+int main(int, char**) {
+  static_assert((std::is_same<std::regex_iterator<std::wstring::const_iterator>, std::wsregex_iterator>::value), "");
 
   return 0;
 }
diff --git a/libcxx/test/std/re/re.syn/wsregex_token_iterator.pass.cpp b/libcxx/test/std/re/re.syn/wsregex_token_iterator.pass.cpp
index 9a33568cb33d3..322b2748503ca 100644
--- a/libcxx/test/std/re/re.syn/wsregex_token_iterator.pass.cpp
+++ b/libcxx/test/std/re/re.syn/wsregex_token_iterator.pass.cpp
@@ -16,9 +16,9 @@
 #include <type_traits>
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    static_assert((std::is_same<std::regex_token_iterator<std::wstring::const_iterator>, std::wsregex_token_iterator>::value), "");
+int main(int, char**) {
+  static_assert(
+      (std::is_same<std::regex_token_iterator<std::wstring::const_iterator>, std::wsregex_token_iterator>::value), "");
 
   return 0;
 }
diff --git a/libcxx/test/std/re/re.syn/wssub_match.pass.cpp b/libcxx/test/std/re/re.syn/wssub_match.pass.cpp
index f963c70bbfabc..7027c3365f45e 100644
--- a/libcxx/test/std/re/re.syn/wssub_match.pass.cpp
+++ b/libcxx/test/std/re/re.syn/wssub_match.pass.cpp
@@ -16,9 +16,8 @@
 #include <type_traits>
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    static_assert((std::is_same<std::sub_match<std::wstring::const_iterator>, std::wssub_match>::value), "");
+int main(int, char**) {
+  static_assert((std::is_same<std::sub_match<std::wstring::const_iterator>, std::wssub_match>::value), "");
 
   return 0;
 }
diff --git a/libcxx/test/std/re/re.traits/default.pass.cpp b/libcxx/test/std/re/re.traits/default.pass.cpp
index ff817cb56f2c8..28f734f269adb 100644
--- a/libcxx/test/std/re/re.traits/default.pass.cpp
+++ b/libcxx/test/std/re/re.traits/default.pass.cpp
@@ -20,29 +20,28 @@
 #include "test_macros.h"
 #include "platform_support.h" // locale name macros
 
-int main(int, char**)
-{
-    {
-        std::regex_traits<char> t;
-        assert(t.getloc().name() == "C");
-    }
+int main(int, char**) {
+  {
+    std::regex_traits<char> t;
+    assert(t.getloc().name() == "C");
+  }
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-    {
-        std::regex_traits<wchar_t> t;
-        assert(t.getloc().name() == "C");
-    }
+  {
+    std::regex_traits<wchar_t> t;
+    assert(t.getloc().name() == "C");
+  }
 #endif
-    {
-        std::locale::global(std::locale(LOCALE_en_US_UTF_8));
-        std::regex_traits<char> t;
-        assert(t.getloc().name() == LOCALE_en_US_UTF_8);
-    }
+  {
+    std::locale::global(std::locale(LOCALE_en_US_UTF_8));
+    std::regex_traits<char> t;
+    assert(t.getloc().name() == LOCALE_en_US_UTF_8);
+  }
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-    {
-        std::locale::global(std::locale(LOCALE_en_US_UTF_8));
-        std::regex_traits<wchar_t> t;
-        assert(t.getloc().name() == LOCALE_en_US_UTF_8);
-    }
+  {
+    std::locale::global(std::locale(LOCALE_en_US_UTF_8));
+    std::regex_traits<wchar_t> t;
+    assert(t.getloc().name() == LOCALE_en_US_UTF_8);
+  }
 #endif
 
   return 0;
diff --git a/libcxx/test/std/re/re.traits/getloc.pass.cpp b/libcxx/test/std/re/re.traits/getloc.pass.cpp
index 55820cc0cc611..90132765e4b48 100644
--- a/libcxx/test/std/re/re.traits/getloc.pass.cpp
+++ b/libcxx/test/std/re/re.traits/getloc.pass.cpp
@@ -20,29 +20,28 @@
 #include "test_macros.h"
 #include "platform_support.h" // locale name macros
 
-int main(int, char**)
-{
-    {
-        std::regex_traits<char> t;
-        assert(t.getloc().name() == "C");
-    }
+int main(int, char**) {
+  {
+    std::regex_traits<char> t;
+    assert(t.getloc().name() == "C");
+  }
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-    {
-        std::regex_traits<wchar_t> t;
-        assert(t.getloc().name() == "C");
-    }
+  {
+    std::regex_traits<wchar_t> t;
+    assert(t.getloc().name() == "C");
+  }
 #endif
-    {
-        std::locale::global(std::locale(LOCALE_en_US_UTF_8));
-        std::regex_traits<char> t;
-        assert(t.getloc().name() == LOCALE_en_US_UTF_8);
-    }
+  {
+    std::locale::global(std::locale(LOCALE_en_US_UTF_8));
+    std::regex_traits<char> t;
+    assert(t.getloc().name() == LOCALE_en_US_UTF_8);
+  }
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-    {
-        std::locale::global(std::locale(LOCALE_en_US_UTF_8));
-        std::regex_traits<wchar_t> t;
-        assert(t.getloc().name() == LOCALE_en_US_UTF_8);
-    }
+  {
+    std::locale::global(std::locale(LOCALE_en_US_UTF_8));
+    std::regex_traits<wchar_t> t;
+    assert(t.getloc().name() == LOCALE_en_US_UTF_8);
+  }
 #endif
 
   return 0;
diff --git a/libcxx/test/std/re/re.traits/imbue.pass.cpp b/libcxx/test/std/re/re.traits/imbue.pass.cpp
index 0200ce01e3c0f..02a3017590292 100644
--- a/libcxx/test/std/re/re.traits/imbue.pass.cpp
+++ b/libcxx/test/std/re/re.traits/imbue.pass.cpp
@@ -21,14 +21,13 @@
 #include "test_macros.h"
 #include "platform_support.h" // locale name macros
 
-int main(int, char**)
-{
-    {
-        std::regex_traits<char> t;
-        std::locale loc = t.imbue(std::locale(LOCALE_en_US_UTF_8));
-        assert(loc.name() == "C");
-        assert(t.getloc().name() == LOCALE_en_US_UTF_8);
-    }
+int main(int, char**) {
+  {
+    std::regex_traits<char> t;
+    std::locale loc = t.imbue(std::locale(LOCALE_en_US_UTF_8));
+    assert(loc.name() == "C");
+    assert(t.getloc().name() == LOCALE_en_US_UTF_8);
+  }
 
   return 0;
 }
diff --git a/libcxx/test/std/re/re.traits/isctype.pass.cpp b/libcxx/test/std/re/re.traits/isctype.pass.cpp
index e49221101d151..2f159eae7b181 100644
--- a/libcxx/test/std/re/re.traits/isctype.pass.cpp
+++ b/libcxx/test/std/re/re.traits/isctype.pass.cpp
@@ -12,273 +12,271 @@
 
 // bool isctype(charT c, char_class_type f) const;
 
-
 #include <regex>
 #include <cassert>
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    {
-        std::regex_traits<char> t;
-
-        std::string s("w");
-        assert( t.isctype('_', t.lookup_classname(s.begin(), s.end())));
-        assert( t.isctype('a', t.lookup_classname(s.begin(), s.end())));
-        assert( t.isctype('Z', t.lookup_classname(s.begin(), s.end())));
-        assert( t.isctype('5', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype(' ', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype('-', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype('@', t.lookup_classname(s.begin(), s.end())));
-
-        s = "alnum";
-        assert(!t.isctype('_', t.lookup_classname(s.begin(), s.end())));
-        assert( t.isctype('a', t.lookup_classname(s.begin(), s.end())));
-        assert( t.isctype('Z', t.lookup_classname(s.begin(), s.end())));
-        assert( t.isctype('5', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype(' ', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype('-', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype('@', t.lookup_classname(s.begin(), s.end())));
-
-        s = "alpha";
-        assert(!t.isctype('_', t.lookup_classname(s.begin(), s.end())));
-        assert( t.isctype('a', t.lookup_classname(s.begin(), s.end())));
-        assert( t.isctype('Z', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype('5', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype(' ', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype('-', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype('@', t.lookup_classname(s.begin(), s.end())));
-
-        s = "blank";
-        assert(!t.isctype('_', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype('a', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype('Z', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype('5', t.lookup_classname(s.begin(), s.end())));
-        assert( t.isctype(' ', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype('-', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype('@', t.lookup_classname(s.begin(), s.end())));
-
-        s = "cntrl";
-        assert( t.isctype('\n', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype('_', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype('a', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype('Z', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype('5', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype(' ', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype('-', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype('@', t.lookup_classname(s.begin(), s.end())));
-
-        s = "digit";
-        assert(!t.isctype('\n', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype('_', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype('a', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype('Z', t.lookup_classname(s.begin(), s.end())));
-        assert( t.isctype('5', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype(' ', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype('-', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype('@', t.lookup_classname(s.begin(), s.end())));
-
-        s = "graph";
-        assert(!t.isctype('\n', t.lookup_classname(s.begin(), s.end())));
-        assert( t.isctype('_', t.lookup_classname(s.begin(), s.end())));
-        assert( t.isctype('a', t.lookup_classname(s.begin(), s.end())));
-        assert( t.isctype('Z', t.lookup_classname(s.begin(), s.end())));
-        assert( t.isctype('5', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype(' ', t.lookup_classname(s.begin(), s.end())));
-        assert( t.isctype('-', t.lookup_classname(s.begin(), s.end())));
-        assert( t.isctype('@', t.lookup_classname(s.begin(), s.end())));
-
-        s = "lower";
-        assert(!t.isctype('\n', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype('_', t.lookup_classname(s.begin(), s.end())));
-        assert( t.isctype('a', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype('Z', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype('5', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype(' ', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype('-', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype('@', t.lookup_classname(s.begin(), s.end())));
-
-        s = "print";
-        assert(!t.isctype('\n', t.lookup_classname(s.begin(), s.end())));
-        assert( t.isctype('_', t.lookup_classname(s.begin(), s.end())));
-        assert( t.isctype('a', t.lookup_classname(s.begin(), s.end())));
-        assert( t.isctype('Z', t.lookup_classname(s.begin(), s.end())));
-        assert( t.isctype('5', t.lookup_classname(s.begin(), s.end())));
-        assert( t.isctype(' ', t.lookup_classname(s.begin(), s.end())));
-        assert( t.isctype('-', t.lookup_classname(s.begin(), s.end())));
-        assert( t.isctype('@', t.lookup_classname(s.begin(), s.end())));
-
-        s = "punct";
-        assert(!t.isctype('\n', t.lookup_classname(s.begin(), s.end())));
-        assert( t.isctype('_', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype('a', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype('Z', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype('5', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype(' ', t.lookup_classname(s.begin(), s.end())));
-        assert( t.isctype('-', t.lookup_classname(s.begin(), s.end())));
-        assert( t.isctype('@', t.lookup_classname(s.begin(), s.end())));
-
-        s = "space";
-        assert( t.isctype('\n', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype('_', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype('a', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype('Z', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype('5', t.lookup_classname(s.begin(), s.end())));
-        assert( t.isctype(' ', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype('-', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype('@', t.lookup_classname(s.begin(), s.end())));
-
-        s = "upper";
-        assert(!t.isctype('\n', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype('_', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype('a', t.lookup_classname(s.begin(), s.end())));
-        assert( t.isctype('Z', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype('5', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype(' ', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype('-', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype('@', t.lookup_classname(s.begin(), s.end())));
-
-        s = "xdigit";
-        assert(!t.isctype('\n', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype('_', t.lookup_classname(s.begin(), s.end())));
-        assert( t.isctype('a', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype('Z', t.lookup_classname(s.begin(), s.end())));
-        assert( t.isctype('5', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype(' ', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype('-', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype('@', t.lookup_classname(s.begin(), s.end())));
-    }
+int main(int, char**) {
+  {
+    std::regex_traits<char> t;
+
+    std::string s("w");
+    assert(t.isctype('_', t.lookup_classname(s.begin(), s.end())));
+    assert(t.isctype('a', t.lookup_classname(s.begin(), s.end())));
+    assert(t.isctype('Z', t.lookup_classname(s.begin(), s.end())));
+    assert(t.isctype('5', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype(' ', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype('-', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype('@', t.lookup_classname(s.begin(), s.end())));
+
+    s = "alnum";
+    assert(!t.isctype('_', t.lookup_classname(s.begin(), s.end())));
+    assert(t.isctype('a', t.lookup_classname(s.begin(), s.end())));
+    assert(t.isctype('Z', t.lookup_classname(s.begin(), s.end())));
+    assert(t.isctype('5', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype(' ', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype('-', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype('@', t.lookup_classname(s.begin(), s.end())));
+
+    s = "alpha";
+    assert(!t.isctype('_', t.lookup_classname(s.begin(), s.end())));
+    assert(t.isctype('a', t.lookup_classname(s.begin(), s.end())));
+    assert(t.isctype('Z', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype('5', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype(' ', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype('-', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype('@', t.lookup_classname(s.begin(), s.end())));
+
+    s = "blank";
+    assert(!t.isctype('_', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype('a', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype('Z', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype('5', t.lookup_classname(s.begin(), s.end())));
+    assert(t.isctype(' ', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype('-', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype('@', t.lookup_classname(s.begin(), s.end())));
+
+    s = "cntrl";
+    assert(t.isctype('\n', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype('_', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype('a', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype('Z', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype('5', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype(' ', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype('-', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype('@', t.lookup_classname(s.begin(), s.end())));
+
+    s = "digit";
+    assert(!t.isctype('\n', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype('_', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype('a', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype('Z', t.lookup_classname(s.begin(), s.end())));
+    assert(t.isctype('5', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype(' ', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype('-', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype('@', t.lookup_classname(s.begin(), s.end())));
+
+    s = "graph";
+    assert(!t.isctype('\n', t.lookup_classname(s.begin(), s.end())));
+    assert(t.isctype('_', t.lookup_classname(s.begin(), s.end())));
+    assert(t.isctype('a', t.lookup_classname(s.begin(), s.end())));
+    assert(t.isctype('Z', t.lookup_classname(s.begin(), s.end())));
+    assert(t.isctype('5', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype(' ', t.lookup_classname(s.begin(), s.end())));
+    assert(t.isctype('-', t.lookup_classname(s.begin(), s.end())));
+    assert(t.isctype('@', t.lookup_classname(s.begin(), s.end())));
+
+    s = "lower";
+    assert(!t.isctype('\n', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype('_', t.lookup_classname(s.begin(), s.end())));
+    assert(t.isctype('a', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype('Z', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype('5', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype(' ', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype('-', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype('@', t.lookup_classname(s.begin(), s.end())));
+
+    s = "print";
+    assert(!t.isctype('\n', t.lookup_classname(s.begin(), s.end())));
+    assert(t.isctype('_', t.lookup_classname(s.begin(), s.end())));
+    assert(t.isctype('a', t.lookup_classname(s.begin(), s.end())));
+    assert(t.isctype('Z', t.lookup_classname(s.begin(), s.end())));
+    assert(t.isctype('5', t.lookup_classname(s.begin(), s.end())));
+    assert(t.isctype(' ', t.lookup_classname(s.begin(), s.end())));
+    assert(t.isctype('-', t.lookup_classname(s.begin(), s.end())));
+    assert(t.isctype('@', t.lookup_classname(s.begin(), s.end())));
+
+    s = "punct";
+    assert(!t.isctype('\n', t.lookup_classname(s.begin(), s.end())));
+    assert(t.isctype('_', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype('a', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype('Z', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype('5', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype(' ', t.lookup_classname(s.begin(), s.end())));
+    assert(t.isctype('-', t.lookup_classname(s.begin(), s.end())));
+    assert(t.isctype('@', t.lookup_classname(s.begin(), s.end())));
+
+    s = "space";
+    assert(t.isctype('\n', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype('_', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype('a', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype('Z', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype('5', t.lookup_classname(s.begin(), s.end())));
+    assert(t.isctype(' ', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype('-', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype('@', t.lookup_classname(s.begin(), s.end())));
+
+    s = "upper";
+    assert(!t.isctype('\n', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype('_', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype('a', t.lookup_classname(s.begin(), s.end())));
+    assert(t.isctype('Z', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype('5', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype(' ', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype('-', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype('@', t.lookup_classname(s.begin(), s.end())));
+
+    s = "xdigit";
+    assert(!t.isctype('\n', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype('_', t.lookup_classname(s.begin(), s.end())));
+    assert(t.isctype('a', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype('Z', t.lookup_classname(s.begin(), s.end())));
+    assert(t.isctype('5', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype(' ', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype('-', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype('@', t.lookup_classname(s.begin(), s.end())));
+  }
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-    {
-        std::regex_traits<wchar_t> t;
-
-        std::wstring s(L"w");
-        assert( t.isctype(L'_', t.lookup_classname(s.begin(), s.end())));
-        assert( t.isctype(L'a', t.lookup_classname(s.begin(), s.end())));
-        assert( t.isctype(L'Z', t.lookup_classname(s.begin(), s.end())));
-        assert( t.isctype(L'5', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype(L' ', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype(L'-', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype(L'@', t.lookup_classname(s.begin(), s.end())));
-
-        s = L"alnum";
-        assert(!t.isctype(L'_', t.lookup_classname(s.begin(), s.end())));
-        assert( t.isctype(L'a', t.lookup_classname(s.begin(), s.end())));
-        assert( t.isctype(L'Z', t.lookup_classname(s.begin(), s.end())));
-        assert( t.isctype(L'5', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype(L' ', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype(L'-', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype(L'@', t.lookup_classname(s.begin(), s.end())));
-
-        s = L"alpha";
-        assert(!t.isctype(L'_', t.lookup_classname(s.begin(), s.end())));
-        assert( t.isctype(L'a', t.lookup_classname(s.begin(), s.end())));
-        assert( t.isctype(L'Z', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype(L'5', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype(L' ', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype(L'-', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype(L'@', t.lookup_classname(s.begin(), s.end())));
-
-        s = L"blank";
-        assert(!t.isctype(L'_', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype(L'a', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype(L'Z', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype(L'5', t.lookup_classname(s.begin(), s.end())));
-        assert( t.isctype(L' ', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype(L'-', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype(L'@', t.lookup_classname(s.begin(), s.end())));
-
-        s = L"cntrl";
-        assert( t.isctype(L'\n', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype(L'_', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype(L'a', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype(L'Z', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype(L'5', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype(L' ', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype(L'-', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype(L'@', t.lookup_classname(s.begin(), s.end())));
-
-        s = L"digit";
-        assert(!t.isctype(L'\n', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype(L'_', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype(L'a', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype(L'Z', t.lookup_classname(s.begin(), s.end())));
-        assert( t.isctype(L'5', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype(L' ', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype(L'-', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype(L'@', t.lookup_classname(s.begin(), s.end())));
-
-        s = L"graph";
-        assert(!t.isctype(L'\n', t.lookup_classname(s.begin(), s.end())));
-        assert( t.isctype(L'_', t.lookup_classname(s.begin(), s.end())));
-        assert( t.isctype(L'a', t.lookup_classname(s.begin(), s.end())));
-        assert( t.isctype(L'Z', t.lookup_classname(s.begin(), s.end())));
-        assert( t.isctype(L'5', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype(L' ', t.lookup_classname(s.begin(), s.end())));
-        assert( t.isctype(L'-', t.lookup_classname(s.begin(), s.end())));
-        assert( t.isctype(L'@', t.lookup_classname(s.begin(), s.end())));
-
-        s = L"lower";
-        assert(!t.isctype(L'\n', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype(L'_', t.lookup_classname(s.begin(), s.end())));
-        assert( t.isctype(L'a', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype(L'Z', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype(L'5', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype(L' ', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype(L'-', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype(L'@', t.lookup_classname(s.begin(), s.end())));
-
-        s = L"print";
-        assert(!t.isctype(L'\n', t.lookup_classname(s.begin(), s.end())));
-        assert( t.isctype(L'_', t.lookup_classname(s.begin(), s.end())));
-        assert( t.isctype(L'a', t.lookup_classname(s.begin(), s.end())));
-        assert( t.isctype(L'Z', t.lookup_classname(s.begin(), s.end())));
-        assert( t.isctype(L'5', t.lookup_classname(s.begin(), s.end())));
-        assert( t.isctype(L' ', t.lookup_classname(s.begin(), s.end())));
-        assert( t.isctype(L'-', t.lookup_classname(s.begin(), s.end())));
-        assert( t.isctype(L'@', t.lookup_classname(s.begin(), s.end())));
-
-        s = L"punct";
-        assert(!t.isctype(L'\n', t.lookup_classname(s.begin(), s.end())));
-        assert( t.isctype(L'_', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype(L'a', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype(L'Z', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype(L'5', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype(L' ', t.lookup_classname(s.begin(), s.end())));
-        assert( t.isctype(L'-', t.lookup_classname(s.begin(), s.end())));
-        assert( t.isctype(L'@', t.lookup_classname(s.begin(), s.end())));
-
-        s = L"space";
-        assert( t.isctype(L'\n', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype(L'_', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype(L'a', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype(L'Z', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype(L'5', t.lookup_classname(s.begin(), s.end())));
-        assert( t.isctype(L' ', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype(L'-', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype(L'@', t.lookup_classname(s.begin(), s.end())));
-
-        s = L"upper";
-        assert(!t.isctype(L'\n', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype(L'_', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype(L'a', t.lookup_classname(s.begin(), s.end())));
-        assert( t.isctype(L'Z', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype(L'5', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype(L' ', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype(L'-', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype(L'@', t.lookup_classname(s.begin(), s.end())));
-
-        s = L"xdigit";
-        assert(!t.isctype(L'\n', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype(L'_', t.lookup_classname(s.begin(), s.end())));
-        assert( t.isctype(L'a', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype(L'Z', t.lookup_classname(s.begin(), s.end())));
-        assert( t.isctype(L'5', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype(L' ', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype(L'-', t.lookup_classname(s.begin(), s.end())));
-        assert(!t.isctype(L'@', t.lookup_classname(s.begin(), s.end())));
-    }
+  {
+    std::regex_traits<wchar_t> t;
+
+    std::wstring s(L"w");
+    assert(t.isctype(L'_', t.lookup_classname(s.begin(), s.end())));
+    assert(t.isctype(L'a', t.lookup_classname(s.begin(), s.end())));
+    assert(t.isctype(L'Z', t.lookup_classname(s.begin(), s.end())));
+    assert(t.isctype(L'5', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype(L' ', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype(L'-', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype(L'@', t.lookup_classname(s.begin(), s.end())));
+
+    s = L"alnum";
+    assert(!t.isctype(L'_', t.lookup_classname(s.begin(), s.end())));
+    assert(t.isctype(L'a', t.lookup_classname(s.begin(), s.end())));
+    assert(t.isctype(L'Z', t.lookup_classname(s.begin(), s.end())));
+    assert(t.isctype(L'5', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype(L' ', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype(L'-', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype(L'@', t.lookup_classname(s.begin(), s.end())));
+
+    s = L"alpha";
+    assert(!t.isctype(L'_', t.lookup_classname(s.begin(), s.end())));
+    assert(t.isctype(L'a', t.lookup_classname(s.begin(), s.end())));
+    assert(t.isctype(L'Z', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype(L'5', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype(L' ', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype(L'-', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype(L'@', t.lookup_classname(s.begin(), s.end())));
+
+    s = L"blank";
+    assert(!t.isctype(L'_', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype(L'a', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype(L'Z', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype(L'5', t.lookup_classname(s.begin(), s.end())));
+    assert(t.isctype(L' ', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype(L'-', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype(L'@', t.lookup_classname(s.begin(), s.end())));
+
+    s = L"cntrl";
+    assert(t.isctype(L'\n', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype(L'_', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype(L'a', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype(L'Z', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype(L'5', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype(L' ', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype(L'-', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype(L'@', t.lookup_classname(s.begin(), s.end())));
+
+    s = L"digit";
+    assert(!t.isctype(L'\n', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype(L'_', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype(L'a', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype(L'Z', t.lookup_classname(s.begin(), s.end())));
+    assert(t.isctype(L'5', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype(L' ', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype(L'-', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype(L'@', t.lookup_classname(s.begin(), s.end())));
+
+    s = L"graph";
+    assert(!t.isctype(L'\n', t.lookup_classname(s.begin(), s.end())));
+    assert(t.isctype(L'_', t.lookup_classname(s.begin(), s.end())));
+    assert(t.isctype(L'a', t.lookup_classname(s.begin(), s.end())));
+    assert(t.isctype(L'Z', t.lookup_classname(s.begin(), s.end())));
+    assert(t.isctype(L'5', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype(L' ', t.lookup_classname(s.begin(), s.end())));
+    assert(t.isctype(L'-', t.lookup_classname(s.begin(), s.end())));
+    assert(t.isctype(L'@', t.lookup_classname(s.begin(), s.end())));
+
+    s = L"lower";
+    assert(!t.isctype(L'\n', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype(L'_', t.lookup_classname(s.begin(), s.end())));
+    assert(t.isctype(L'a', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype(L'Z', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype(L'5', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype(L' ', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype(L'-', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype(L'@', t.lookup_classname(s.begin(), s.end())));
+
+    s = L"print";
+    assert(!t.isctype(L'\n', t.lookup_classname(s.begin(), s.end())));
+    assert(t.isctype(L'_', t.lookup_classname(s.begin(), s.end())));
+    assert(t.isctype(L'a', t.lookup_classname(s.begin(), s.end())));
+    assert(t.isctype(L'Z', t.lookup_classname(s.begin(), s.end())));
+    assert(t.isctype(L'5', t.lookup_classname(s.begin(), s.end())));
+    assert(t.isctype(L' ', t.lookup_classname(s.begin(), s.end())));
+    assert(t.isctype(L'-', t.lookup_classname(s.begin(), s.end())));
+    assert(t.isctype(L'@', t.lookup_classname(s.begin(), s.end())));
+
+    s = L"punct";
+    assert(!t.isctype(L'\n', t.lookup_classname(s.begin(), s.end())));
+    assert(t.isctype(L'_', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype(L'a', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype(L'Z', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype(L'5', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype(L' ', t.lookup_classname(s.begin(), s.end())));
+    assert(t.isctype(L'-', t.lookup_classname(s.begin(), s.end())));
+    assert(t.isctype(L'@', t.lookup_classname(s.begin(), s.end())));
+
+    s = L"space";
+    assert(t.isctype(L'\n', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype(L'_', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype(L'a', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype(L'Z', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype(L'5', t.lookup_classname(s.begin(), s.end())));
+    assert(t.isctype(L' ', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype(L'-', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype(L'@', t.lookup_classname(s.begin(), s.end())));
+
+    s = L"upper";
+    assert(!t.isctype(L'\n', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype(L'_', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype(L'a', t.lookup_classname(s.begin(), s.end())));
+    assert(t.isctype(L'Z', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype(L'5', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype(L' ', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype(L'-', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype(L'@', t.lookup_classname(s.begin(), s.end())));
+
+    s = L"xdigit";
+    assert(!t.isctype(L'\n', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype(L'_', t.lookup_classname(s.begin(), s.end())));
+    assert(t.isctype(L'a', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype(L'Z', t.lookup_classname(s.begin(), s.end())));
+    assert(t.isctype(L'5', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype(L' ', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype(L'-', t.lookup_classname(s.begin(), s.end())));
+    assert(!t.isctype(L'@', t.lookup_classname(s.begin(), s.end())));
+  }
 #endif // TEST_HAS_NO_WIDE_CHARACTERS
 
   return 0;
diff --git a/libcxx/test/std/re/re.traits/length.pass.cpp b/libcxx/test/std/re/re.traits/length.pass.cpp
index e14df640197b2..ec39070b3c837 100644
--- a/libcxx/test/std/re/re.traits/length.pass.cpp
+++ b/libcxx/test/std/re/re.traits/length.pass.cpp
@@ -16,18 +16,17 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    assert(std::regex_traits<char>::length("") == 0);
-    assert(std::regex_traits<char>::length("1") == 1);
-    assert(std::regex_traits<char>::length("12") == 2);
-    assert(std::regex_traits<char>::length("123") == 3);
+int main(int, char**) {
+  assert(std::regex_traits<char>::length("") == 0);
+  assert(std::regex_traits<char>::length("1") == 1);
+  assert(std::regex_traits<char>::length("12") == 2);
+  assert(std::regex_traits<char>::length("123") == 3);
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-    assert(std::regex_traits<wchar_t>::length(L"") == 0);
-    assert(std::regex_traits<wchar_t>::length(L"1") == 1);
-    assert(std::regex_traits<wchar_t>::length(L"12") == 2);
-    assert(std::regex_traits<wchar_t>::length(L"123") == 3);
+  assert(std::regex_traits<wchar_t>::length(L"") == 0);
+  assert(std::regex_traits<wchar_t>::length(L"1") == 1);
+  assert(std::regex_traits<wchar_t>::length(L"12") == 2);
+  assert(std::regex_traits<wchar_t>::length(L"123") == 3);
 #endif
 
   return 0;
diff --git a/libcxx/test/std/re/re.traits/lookup_classname.pass.cpp b/libcxx/test/std/re/re.traits/lookup_classname.pass.cpp
index caa04c775ffff..b782b27aec4e8 100644
--- a/libcxx/test/std/re/re.traits/lookup_classname.pass.cpp
+++ b/libcxx/test/std/re/re.traits/lookup_classname.pass.cpp
@@ -21,229 +21,212 @@
 #include "test_iterators.h"
 
 template <class char_type>
-void
-test(const char_type* A,
-     typename std::regex_traits<char_type>::char_class_type expected,
-     bool icase = false)
-{
-    typedef typename std::regex_traits<char_type>::char_class_type char_class_type;
-    std::regex_traits<char_type> t;
-    typedef forward_iterator<const char_type*> F;
-    char_class_type result = t.lookup_classname(F(A), F(A + t.length(A)), icase);
-    assert(result == expected);
+void test(const char_type* A, typename std::regex_traits<char_type>::char_class_type expected, bool icase = false) {
+  typedef typename std::regex_traits<char_type>::char_class_type char_class_type;
+  std::regex_traits<char_type> t;
+  typedef forward_iterator<const char_type*> F;
+  char_class_type result = t.lookup_classname(F(A), F(A + t.length(A)), icase);
+  assert(result == expected);
 }
 
 template <class char_type>
-void
-test_w(const char_type* A,
-       typename std::regex_traits<char_type>::char_class_type expected,
-        bool icase = false)
-{
-    typedef typename std::regex_traits<char_type>::char_class_type char_class_type;
-    std::regex_traits<char_type> t;
-    typedef forward_iterator<const char_type*> F;
-    char_class_type result = t.lookup_classname(F(A), F(A + t.length(A)), icase);
-    assert((result & expected) == expected);
-    LIBCPP_ASSERT((expected | std::regex_traits<char_type>::__regex_word) == result);
-
-    const bool matches_underscore = t.isctype('_', result);
-    if (result != expected)
-      assert(matches_underscore && "expected to match underscore");
-    else
-      assert(!matches_underscore && "should not match underscore");
+void test_w(const char_type* A, typename std::regex_traits<char_type>::char_class_type expected, bool icase = false) {
+  typedef typename std::regex_traits<char_type>::char_class_type char_class_type;
+  std::regex_traits<char_type> t;
+  typedef forward_iterator<const char_type*> F;
+  char_class_type result = t.lookup_classname(F(A), F(A + t.length(A)), icase);
+  assert((result & expected) == expected);
+  LIBCPP_ASSERT((expected | std::regex_traits<char_type>::__regex_word) == result);
+
+  const bool matches_underscore = t.isctype('_', result);
+  if (result != expected)
+    assert(matches_underscore && "expected to match underscore");
+  else
+    assert(!matches_underscore && "should not match underscore");
 }
 
-int main(int, char**)
-{
-//  if __regex_word is not distinct from all the classes, bad things happen
-//  See https://llvm.org/PR26476 for an example.
-    LIBCPP_ASSERT((std::ctype_base::space  & std::regex_traits<char>::__regex_word) == 0);
-    LIBCPP_ASSERT((std::ctype_base::print  & std::regex_traits<char>::__regex_word) == 0);
-    LIBCPP_ASSERT((std::ctype_base::cntrl  & std::regex_traits<char>::__regex_word) == 0);
-    LIBCPP_ASSERT((std::ctype_base::upper  & std::regex_traits<char>::__regex_word) == 0);
-    LIBCPP_ASSERT((std::ctype_base::lower  & std::regex_traits<char>::__regex_word) == 0);
-    LIBCPP_ASSERT((std::ctype_base::alpha  & std::regex_traits<char>::__regex_word) == 0);
-    LIBCPP_ASSERT((std::ctype_base::digit  & std::regex_traits<char>::__regex_word) == 0);
-    LIBCPP_ASSERT((std::ctype_base::punct  & std::regex_traits<char>::__regex_word) == 0);
-    LIBCPP_ASSERT((std::ctype_base::xdigit & std::regex_traits<char>::__regex_word) == 0);
-    LIBCPP_ASSERT((std::ctype_base::blank  & std::regex_traits<char>::__regex_word) == 0);
-
-    test("d", std::ctype_base::digit);
-    test("D", std::ctype_base::digit);
-    test("d", std::ctype_base::digit, true);
-    test("D", std::ctype_base::digit, true);
-
-    test_w("w", std::ctype_base::alnum
-              | std::ctype_base::upper | std::ctype_base::lower);
-    test_w("W", std::ctype_base::alnum
-              | std::ctype_base::upper | std::ctype_base::lower);
-    test_w("w", std::ctype_base::alnum
-              | std::ctype_base::upper | std::ctype_base::lower, true);
-    test_w("W", std::ctype_base::alnum
-              | std::ctype_base::upper | std::ctype_base::lower, true);
-
-    test("s", std::ctype_base::space);
-    test("S", std::ctype_base::space);
-    test("s", std::ctype_base::space, true);
-    test("S", std::ctype_base::space, true);
-
-    test("alnum", std::ctype_base::alnum);
-    test("AlNum", std::ctype_base::alnum);
-    test("alnum", std::ctype_base::alnum, true);
-    test("AlNum", std::ctype_base::alnum, true);
-
-    test("alpha", std::ctype_base::alpha);
-    test("Alpha", std::ctype_base::alpha);
-    test("alpha", std::ctype_base::alpha, true);
-    test("Alpha", std::ctype_base::alpha, true);
-
-    test("blank", std::ctype_base::blank);
-    test("Blank", std::ctype_base::blank);
-    test("blank", std::ctype_base::blank, true);
-    test("Blank", std::ctype_base::blank, true);
-
-    test("cntrl", std::ctype_base::cntrl);
-    test("Cntrl", std::ctype_base::cntrl);
-    test("cntrl", std::ctype_base::cntrl, true);
-    test("Cntrl", std::ctype_base::cntrl, true);
-
-    test("digit", std::ctype_base::digit);
-    test("Digit", std::ctype_base::digit);
-    test("digit", std::ctype_base::digit, true);
-    test("Digit", std::ctype_base::digit, true);
-
-    test("digit", std::ctype_base::digit);
-    test("DIGIT", std::ctype_base::digit);
-    test("digit", std::ctype_base::digit, true);
-    test("Digit", std::ctype_base::digit, true);
-
-    test("graph", std::ctype_base::graph);
-    test("GRAPH", std::ctype_base::graph);
-    test("graph", std::ctype_base::graph, true);
-    test("Graph", std::ctype_base::graph, true);
-
-    test("lower", std::ctype_base::lower);
-    test("LOWER", std::ctype_base::lower);
-    test("lower", std::ctype_base::lower | std::ctype_base::alpha, true);
-    test("Lower", std::ctype_base::lower | std::ctype_base::alpha, true);
-
-    test("print", std::ctype_base::print);
-    test("PRINT", std::ctype_base::print);
-    test("print", std::ctype_base::print, true);
-    test("Print", std::ctype_base::print, true);
-
-    test("punct", std::ctype_base::punct);
-    test("PUNCT", std::ctype_base::punct);
-    test("punct", std::ctype_base::punct, true);
-    test("Punct", std::ctype_base::punct, true);
-
-    test("space", std::ctype_base::space);
-    test("SPACE", std::ctype_base::space);
-    test("space", std::ctype_base::space, true);
-    test("Space", std::ctype_base::space, true);
-
-    test("upper", std::ctype_base::upper);
-    test("UPPER", std::ctype_base::upper);
-    test("upper", std::ctype_base::upper | std::ctype_base::alpha, true);
-    test("Upper", std::ctype_base::upper | std::ctype_base::alpha, true);
-
-    test("xdigit", std::ctype_base::xdigit);
-    test("XDIGIT", std::ctype_base::xdigit);
-    test("xdigit", std::ctype_base::xdigit, true);
-    test("Xdigit", std::ctype_base::xdigit, true);
-
-    test("dig", std::ctype_base::mask());
-    test("", std::ctype_base::mask());
-    test("digits", std::ctype_base::mask());
+int main(int, char**) {
+  //  if __regex_word is not distinct from all the classes, bad things happen
+  //  See https://llvm.org/PR26476 for an example.
+  LIBCPP_ASSERT((std::ctype_base::space & std::regex_traits<char>::__regex_word) == 0);
+  LIBCPP_ASSERT((std::ctype_base::print & std::regex_traits<char>::__regex_word) == 0);
+  LIBCPP_ASSERT((std::ctype_base::cntrl & std::regex_traits<char>::__regex_word) == 0);
+  LIBCPP_ASSERT((std::ctype_base::upper & std::regex_traits<char>::__regex_word) == 0);
+  LIBCPP_ASSERT((std::ctype_base::lower & std::regex_traits<char>::__regex_word) == 0);
+  LIBCPP_ASSERT((std::ctype_base::alpha & std::regex_traits<char>::__regex_word) == 0);
+  LIBCPP_ASSERT((std::ctype_base::digit & std::regex_traits<char>::__regex_word) == 0);
+  LIBCPP_ASSERT((std::ctype_base::punct & std::regex_traits<char>::__regex_word) == 0);
+  LIBCPP_ASSERT((std::ctype_base::xdigit & std::regex_traits<char>::__regex_word) == 0);
+  LIBCPP_ASSERT((std::ctype_base::blank & std::regex_traits<char>::__regex_word) == 0);
+
+  test("d", std::ctype_base::digit);
+  test("D", std::ctype_base::digit);
+  test("d", std::ctype_base::digit, true);
+  test("D", std::ctype_base::digit, true);
+
+  test_w("w", std::ctype_base::alnum | std::ctype_base::upper | std::ctype_base::lower);
+  test_w("W", std::ctype_base::alnum | std::ctype_base::upper | std::ctype_base::lower);
+  test_w("w", std::ctype_base::alnum | std::ctype_base::upper | std::ctype_base::lower, true);
+  test_w("W", std::ctype_base::alnum | std::ctype_base::upper | std::ctype_base::lower, true);
+
+  test("s", std::ctype_base::space);
+  test("S", std::ctype_base::space);
+  test("s", std::ctype_base::space, true);
+  test("S", std::ctype_base::space, true);
+
+  test("alnum", std::ctype_base::alnum);
+  test("AlNum", std::ctype_base::alnum);
+  test("alnum", std::ctype_base::alnum, true);
+  test("AlNum", std::ctype_base::alnum, true);
+
+  test("alpha", std::ctype_base::alpha);
+  test("Alpha", std::ctype_base::alpha);
+  test("alpha", std::ctype_base::alpha, true);
+  test("Alpha", std::ctype_base::alpha, true);
+
+  test("blank", std::ctype_base::blank);
+  test("Blank", std::ctype_base::blank);
+  test("blank", std::ctype_base::blank, true);
+  test("Blank", std::ctype_base::blank, true);
+
+  test("cntrl", std::ctype_base::cntrl);
+  test("Cntrl", std::ctype_base::cntrl);
+  test("cntrl", std::ctype_base::cntrl, true);
+  test("Cntrl", std::ctype_base::cntrl, true);
+
+  test("digit", std::ctype_base::digit);
+  test("Digit", std::ctype_base::digit);
+  test("digit", std::ctype_base::digit, true);
+  test("Digit", std::ctype_base::digit, true);
+
+  test("digit", std::ctype_base::digit);
+  test("DIGIT", std::ctype_base::digit);
+  test("digit", std::ctype_base::digit, true);
+  test("Digit", std::ctype_base::digit, true);
+
+  test("graph", std::ctype_base::graph);
+  test("GRAPH", std::ctype_base::graph);
+  test("graph", std::ctype_base::graph, true);
+  test("Graph", std::ctype_base::graph, true);
+
+  test("lower", std::ctype_base::lower);
+  test("LOWER", std::ctype_base::lower);
+  test("lower", std::ctype_base::lower | std::ctype_base::alpha, true);
+  test("Lower", std::ctype_base::lower | std::ctype_base::alpha, true);
+
+  test("print", std::ctype_base::print);
+  test("PRINT", std::ctype_base::print);
+  test("print", std::ctype_base::print, true);
+  test("Print", std::ctype_base::print, true);
+
+  test("punct", std::ctype_base::punct);
+  test("PUNCT", std::ctype_base::punct);
+  test("punct", std::ctype_base::punct, true);
+  test("Punct", std::ctype_base::punct, true);
+
+  test("space", std::ctype_base::space);
+  test("SPACE", std::ctype_base::space);
+  test("space", std::ctype_base::space, true);
+  test("Space", std::ctype_base::space, true);
+
+  test("upper", std::ctype_base::upper);
+  test("UPPER", std::ctype_base::upper);
+  test("upper", std::ctype_base::upper | std::ctype_base::alpha, true);
+  test("Upper", std::ctype_base::upper | std::ctype_base::alpha, true);
+
+  test("xdigit", std::ctype_base::xdigit);
+  test("XDIGIT", std::ctype_base::xdigit);
+  test("xdigit", std::ctype_base::xdigit, true);
+  test("Xdigit", std::ctype_base::xdigit, true);
+
+  test("dig", std::ctype_base::mask());
+  test("", std::ctype_base::mask());
+  test("digits", std::ctype_base::mask());
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-    test(L"d", std::ctype_base::digit);
-    test(L"D", std::ctype_base::digit);
-    test(L"d", std::ctype_base::digit, true);
-    test(L"D", std::ctype_base::digit, true);
-
-    test_w(L"w", std::ctype_base::alnum
-                      | std::ctype_base::upper | std::ctype_base::lower);
-    test_w(L"W", std::ctype_base::alnum
-                      | std::ctype_base::upper | std::ctype_base::lower);
-    test_w(L"w", std::ctype_base::alnum
-                      | std::ctype_base::upper | std::ctype_base::lower, true);
-    test_w(L"W", std::ctype_base::alnum
-                      | std::ctype_base::upper | std::ctype_base::lower, true);
-
-    test(L"s", std::ctype_base::space);
-    test(L"S", std::ctype_base::space);
-    test(L"s", std::ctype_base::space, true);
-    test(L"S", std::ctype_base::space, true);
-
-    test(L"alnum", std::ctype_base::alnum);
-    test(L"AlNum", std::ctype_base::alnum);
-    test(L"alnum", std::ctype_base::alnum, true);
-    test(L"AlNum", std::ctype_base::alnum, true);
-
-    test(L"alpha", std::ctype_base::alpha);
-    test(L"Alpha", std::ctype_base::alpha);
-    test(L"alpha", std::ctype_base::alpha, true);
-    test(L"Alpha", std::ctype_base::alpha, true);
-
-    test(L"blank", std::ctype_base::blank);
-    test(L"Blank", std::ctype_base::blank);
-    test(L"blank", std::ctype_base::blank, true);
-    test(L"Blank", std::ctype_base::blank, true);
-
-    test(L"cntrl", std::ctype_base::cntrl);
-    test(L"Cntrl", std::ctype_base::cntrl);
-    test(L"cntrl", std::ctype_base::cntrl, true);
-    test(L"Cntrl", std::ctype_base::cntrl, true);
-
-    test(L"digit", std::ctype_base::digit);
-    test(L"Digit", std::ctype_base::digit);
-    test(L"digit", std::ctype_base::digit, true);
-    test(L"Digit", std::ctype_base::digit, true);
-
-    test(L"digit", std::ctype_base::digit);
-    test(L"DIGIT", std::ctype_base::digit);
-    test(L"digit", std::ctype_base::digit, true);
-    test(L"Digit", std::ctype_base::digit, true);
-
-    test(L"graph", std::ctype_base::graph);
-    test(L"GRAPH", std::ctype_base::graph);
-    test(L"graph", std::ctype_base::graph, true);
-    test(L"Graph", std::ctype_base::graph, true);
-
-    test(L"lower", std::ctype_base::lower);
-    test(L"LOWER", std::ctype_base::lower);
-    test(L"lower", std::ctype_base::lower | std::ctype_base::alpha, true);
-    test(L"Lower", std::ctype_base::lower | std::ctype_base::alpha, true);
-
-    test(L"print", std::ctype_base::print);
-    test(L"PRINT", std::ctype_base::print);
-    test(L"print", std::ctype_base::print, true);
-    test(L"Print", std::ctype_base::print, true);
-
-    test(L"punct", std::ctype_base::punct);
-    test(L"PUNCT", std::ctype_base::punct);
-    test(L"punct", std::ctype_base::punct, true);
-    test(L"Punct", std::ctype_base::punct, true);
-
-    test(L"space", std::ctype_base::space);
-    test(L"SPACE", std::ctype_base::space);
-    test(L"space", std::ctype_base::space, true);
-    test(L"Space", std::ctype_base::space, true);
-
-    test(L"upper", std::ctype_base::upper);
-    test(L"UPPER", std::ctype_base::upper);
-    test(L"upper", std::ctype_base::upper | std::ctype_base::alpha, true);
-    test(L"Upper", std::ctype_base::upper | std::ctype_base::alpha, true);
-
-    test(L"xdigit", std::ctype_base::xdigit);
-    test(L"XDIGIT", std::ctype_base::xdigit);
-    test(L"xdigit", std::ctype_base::xdigit, true);
-    test(L"Xdigit", std::ctype_base::xdigit, true);
-
-    test(L"dig", std::ctype_base::mask());
-    test(L"", std::ctype_base::mask());
-    test(L"digits", std::ctype_base::mask());
+  test(L"d", std::ctype_base::digit);
+  test(L"D", std::ctype_base::digit);
+  test(L"d", std::ctype_base::digit, true);
+  test(L"D", std::ctype_base::digit, true);
+
+  test_w(L"w", std::ctype_base::alnum | std::ctype_base::upper | std::ctype_base::lower);
+  test_w(L"W", std::ctype_base::alnum | std::ctype_base::upper | std::ctype_base::lower);
+  test_w(L"w", std::ctype_base::alnum | std::ctype_base::upper | std::ctype_base::lower, true);
+  test_w(L"W", std::ctype_base::alnum | std::ctype_base::upper | std::ctype_base::lower, true);
+
+  test(L"s", std::ctype_base::space);
+  test(L"S", std::ctype_base::space);
+  test(L"s", std::ctype_base::space, true);
+  test(L"S", std::ctype_base::space, true);
+
+  test(L"alnum", std::ctype_base::alnum);
+  test(L"AlNum", std::ctype_base::alnum);
+  test(L"alnum", std::ctype_base::alnum, true);
+  test(L"AlNum", std::ctype_base::alnum, true);
+
+  test(L"alpha", std::ctype_base::alpha);
+  test(L"Alpha", std::ctype_base::alpha);
+  test(L"alpha", std::ctype_base::alpha, true);
+  test(L"Alpha", std::ctype_base::alpha, true);
+
+  test(L"blank", std::ctype_base::blank);
+  test(L"Blank", std::ctype_base::blank);
+  test(L"blank", std::ctype_base::blank, true);
+  test(L"Blank", std::ctype_base::blank, true);
+
+  test(L"cntrl", std::ctype_base::cntrl);
+  test(L"Cntrl", std::ctype_base::cntrl);
+  test(L"cntrl", std::ctype_base::cntrl, true);
+  test(L"Cntrl", std::ctype_base::cntrl, true);
+
+  test(L"digit", std::ctype_base::digit);
+  test(L"Digit", std::ctype_base::digit);
+  test(L"digit", std::ctype_base::digit, true);
+  test(L"Digit", std::ctype_base::digit, true);
+
+  test(L"digit", std::ctype_base::digit);
+  test(L"DIGIT", std::ctype_base::digit);
+  test(L"digit", std::ctype_base::digit, true);
+  test(L"Digit", std::ctype_base::digit, true);
+
+  test(L"graph", std::ctype_base::graph);
+  test(L"GRAPH", std::ctype_base::graph);
+  test(L"graph", std::ctype_base::graph, true);
+  test(L"Graph", std::ctype_base::graph, true);
+
+  test(L"lower", std::ctype_base::lower);
+  test(L"LOWER", std::ctype_base::lower);
+  test(L"lower", std::ctype_base::lower | std::ctype_base::alpha, true);
+  test(L"Lower", std::ctype_base::lower | std::ctype_base::alpha, true);
+
+  test(L"print", std::ctype_base::print);
+  test(L"PRINT", std::ctype_base::print);
+  test(L"print", std::ctype_base::print, true);
+  test(L"Print", std::ctype_base::print, true);
+
+  test(L"punct", std::ctype_base::punct);
+  test(L"PUNCT", std::ctype_base::punct);
+  test(L"punct", std::ctype_base::punct, true);
+  test(L"Punct", std::ctype_base::punct, true);
+
+  test(L"space", std::ctype_base::space);
+  test(L"SPACE", std::ctype_base::space);
+  test(L"space", std::ctype_base::space, true);
+  test(L"Space", std::ctype_base::space, true);
+
+  test(L"upper", std::ctype_base::upper);
+  test(L"UPPER", std::ctype_base::upper);
+  test(L"upper", std::ctype_base::upper | std::ctype_base::alpha, true);
+  test(L"Upper", std::ctype_base::upper | std::ctype_base::alpha, true);
+
+  test(L"xdigit", std::ctype_base::xdigit);
+  test(L"XDIGIT", std::ctype_base::xdigit);
+  test(L"xdigit", std::ctype_base::xdigit, true);
+  test(L"Xdigit", std::ctype_base::xdigit, true);
+
+  test(L"dig", std::ctype_base::mask());
+  test(L"", std::ctype_base::mask());
+  test(L"digits", std::ctype_base::mask());
 #endif
 
   return 0;
diff --git a/libcxx/test/std/re/re.traits/lookup_collatename.pass.cpp b/libcxx/test/std/re/re.traits/lookup_collatename.pass.cpp
index 5c690d5cfa480..21abe70a7821f 100644
--- a/libcxx/test/std/re/re.traits/lookup_collatename.pass.cpp
+++ b/libcxx/test/std/re/re.traits/lookup_collatename.pass.cpp
@@ -22,162 +22,155 @@
 #include "test_iterators.h"
 
 template <class char_type>
-void
-test(const char_type* A, const std::basic_string<char_type>& expected)
-{
-    std::regex_traits<char_type> t;
-    typedef forward_iterator<const char_type*> F;
-    assert(t.lookup_collatename(F(A), F(A + t.length(A))) == expected);
+void test(const char_type* A, const std::basic_string<char_type>& expected) {
+  std::regex_traits<char_type> t;
+  typedef forward_iterator<const char_type*> F;
+  assert(t.lookup_collatename(F(A), F(A + t.length(A))) == expected);
 }
 
-int main(int, char**)
-{
-    test("NUL", std::string("\x00", 1));
-    test("alert", std::string("\x07"));
-    test("backspace", std::string("\x08"));
-    test("tab", std::string("\x09"));
-    test("carriage-return", std::string("\x0D"));
-    test("newline", std::string("\x0A"));
-    test("vertical-tab", std::string("\x0B"));
-    test("form-feed", std::string("\x0C"));
-    test("space", std::string(" "));
-    test("exclamation-mark", std::string("!"));
-    test("quotation-mark", std::string("\""));
-    test("number-sign", std::string("#"));
-    test("dollar-sign", std::string("$"));
-    test("percent-sign", std::string("%"));
-    test("ampersand", std::string("&"));
-    test("apostrophe", std::string("\'"));
-    test("left-parenthesis", std::string("("));
-    test("right-parenthesis", std::string(")"));
-    test("asterisk", std::string("*"));
-    test("plus-sign", std::string("+"));
-    test("comma", std::string(","));
-    test("hyphen-minus", std::string("-"));
-    test("hyphen", std::string("-"));
-    test("full-stop", std::string("."));
-    test("period", std::string("."));
-    test("slash", std::string("/"));
-    test("solidus", std::string("/"));
-    test("zero", std::string("0"));
-    test("one", std::string("1"));
-    test("two", std::string("2"));
-    test("three", std::string("3"));
-    test("four", std::string("4"));
-    test("five", std::string("5"));
-    test("six", std::string("6"));
-    test("seven", std::string("7"));
-    test("eight", std::string("8"));
-    test("nine", std::string("9"));
-    test("colon", std::string(":"));
-    test("semicolon", std::string(";"));
-    test("less-than-sign", std::string("<"));
-    test("equals-sign", std::string("="));
-    test("greater-than-sign", std::string(">"));
-    test("question-mark", std::string("?"));
-    test("commercial-at", std::string("@"));
-    for (char c = 'A'; c <= 'Z'; ++c)
-    {
-        const char a[2] = {c};
-        test(a, std::string(a));
-    }
-    test("left-square-bracket", std::string("["));
-    test("backslash", std::string("\\"));
-    test("reverse-solidus", std::string("\\"));
-    test("right-square-bracket", std::string("]"));
-    test("circumflex-accent", std::string("^"));
-    test("circumflex", std::string("^"));
-    test("low-line", std::string("_"));
-    test("underscore", std::string("_"));
-    test("grave-accent", std::string("`"));
-    for (char c = 'a'; c <= 'z'; ++c)
-    {
-        const char a[2] = {c};
-        test(a, std::string(a));
-    }
-    test("left-brace", std::string("{"));
-    test("left-curly-bracket", std::string("{"));
-    test("vertical-line", std::string("|"));
-    test("right-brace", std::string("}"));
-    test("right-curly-bracket", std::string("}"));
-    test("tilde", std::string("~"));
+int main(int, char**) {
+  test("NUL", std::string("\x00", 1));
+  test("alert", std::string("\x07"));
+  test("backspace", std::string("\x08"));
+  test("tab", std::string("\x09"));
+  test("carriage-return", std::string("\x0D"));
+  test("newline", std::string("\x0A"));
+  test("vertical-tab", std::string("\x0B"));
+  test("form-feed", std::string("\x0C"));
+  test("space", std::string(" "));
+  test("exclamation-mark", std::string("!"));
+  test("quotation-mark", std::string("\""));
+  test("number-sign", std::string("#"));
+  test("dollar-sign", std::string("$"));
+  test("percent-sign", std::string("%"));
+  test("ampersand", std::string("&"));
+  test("apostrophe", std::string("\'"));
+  test("left-parenthesis", std::string("("));
+  test("right-parenthesis", std::string(")"));
+  test("asterisk", std::string("*"));
+  test("plus-sign", std::string("+"));
+  test("comma", std::string(","));
+  test("hyphen-minus", std::string("-"));
+  test("hyphen", std::string("-"));
+  test("full-stop", std::string("."));
+  test("period", std::string("."));
+  test("slash", std::string("/"));
+  test("solidus", std::string("/"));
+  test("zero", std::string("0"));
+  test("one", std::string("1"));
+  test("two", std::string("2"));
+  test("three", std::string("3"));
+  test("four", std::string("4"));
+  test("five", std::string("5"));
+  test("six", std::string("6"));
+  test("seven", std::string("7"));
+  test("eight", std::string("8"));
+  test("nine", std::string("9"));
+  test("colon", std::string(":"));
+  test("semicolon", std::string(";"));
+  test("less-than-sign", std::string("<"));
+  test("equals-sign", std::string("="));
+  test("greater-than-sign", std::string(">"));
+  test("question-mark", std::string("?"));
+  test("commercial-at", std::string("@"));
+  for (char c = 'A'; c <= 'Z'; ++c) {
+    const char a[2] = {c};
+    test(a, std::string(a));
+  }
+  test("left-square-bracket", std::string("["));
+  test("backslash", std::string("\\"));
+  test("reverse-solidus", std::string("\\"));
+  test("right-square-bracket", std::string("]"));
+  test("circumflex-accent", std::string("^"));
+  test("circumflex", std::string("^"));
+  test("low-line", std::string("_"));
+  test("underscore", std::string("_"));
+  test("grave-accent", std::string("`"));
+  for (char c = 'a'; c <= 'z'; ++c) {
+    const char a[2] = {c};
+    test(a, std::string(a));
+  }
+  test("left-brace", std::string("{"));
+  test("left-curly-bracket", std::string("{"));
+  test("vertical-line", std::string("|"));
+  test("right-brace", std::string("}"));
+  test("right-curly-bracket", std::string("}"));
+  test("tilde", std::string("~"));
 
-    test("tild", std::string(""));
-    test("ch", std::string(""));
+  test("tild", std::string(""));
+  test("ch", std::string(""));
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-    test(L"NUL", std::wstring(L"\x00", 1));
-    test(L"alert", std::wstring(L"\x07"));
-    test(L"backspace", std::wstring(L"\x08"));
-    test(L"tab", std::wstring(L"\x09"));
-    test(L"carriage-return", std::wstring(L"\x0D"));
-    test(L"newline", std::wstring(L"\x0A"));
-    test(L"vertical-tab", std::wstring(L"\x0B"));
-    test(L"form-feed", std::wstring(L"\x0C"));
-    test(L"space", std::wstring(L" "));
-    test(L"exclamation-mark", std::wstring(L"!"));
-    test(L"quotation-mark", std::wstring(L"\""));
-    test(L"number-sign", std::wstring(L"#"));
-    test(L"dollar-sign", std::wstring(L"$"));
-    test(L"percent-sign", std::wstring(L"%"));
-    test(L"ampersand", std::wstring(L"&"));
-    test(L"apostrophe", std::wstring(L"\'"));
-    test(L"left-parenthesis", std::wstring(L"("));
-    test(L"right-parenthesis", std::wstring(L")"));
-    test(L"asterisk", std::wstring(L"*"));
-    test(L"plus-sign", std::wstring(L"+"));
-    test(L"comma", std::wstring(L","));
-    test(L"hyphen-minus", std::wstring(L"-"));
-    test(L"hyphen", std::wstring(L"-"));
-    test(L"full-stop", std::wstring(L"."));
-    test(L"period", std::wstring(L"."));
-    test(L"slash", std::wstring(L"/"));
-    test(L"solidus", std::wstring(L"/"));
-    test(L"zero", std::wstring(L"0"));
-    test(L"one", std::wstring(L"1"));
-    test(L"two", std::wstring(L"2"));
-    test(L"three", std::wstring(L"3"));
-    test(L"four", std::wstring(L"4"));
-    test(L"five", std::wstring(L"5"));
-    test(L"six", std::wstring(L"6"));
-    test(L"seven", std::wstring(L"7"));
-    test(L"eight", std::wstring(L"8"));
-    test(L"nine", std::wstring(L"9"));
-    test(L"colon", std::wstring(L":"));
-    test(L"semicolon", std::wstring(L";"));
-    test(L"less-than-sign", std::wstring(L"<"));
-    test(L"equals-sign", std::wstring(L"="));
-    test(L"greater-than-sign", std::wstring(L">"));
-    test(L"question-mark", std::wstring(L"?"));
-    test(L"commercial-at", std::wstring(L"@"));
-    for (wchar_t c = L'A'; c <= L'Z'; ++c)
-    {
-        const wchar_t a[2] = {c};
-        test(a, std::wstring(a));
-    }
-    test(L"left-square-bracket", std::wstring(L"["));
-    test(L"backslash", std::wstring(L"\\"));
-    test(L"reverse-solidus", std::wstring(L"\\"));
-    test(L"right-square-bracket", std::wstring(L"]"));
-    test(L"circumflex-accent", std::wstring(L"^"));
-    test(L"circumflex", std::wstring(L"^"));
-    test(L"low-line", std::wstring(L"_"));
-    test(L"underscore", std::wstring(L"_"));
-    test(L"grave-accent", std::wstring(L"`"));
-    for (wchar_t c = L'a'; c <= L'z'; ++c)
-    {
-        const wchar_t a[2] = {c};
-        test(a, std::wstring(a));
-    }
-    test(L"left-brace", std::wstring(L"{"));
-    test(L"left-curly-bracket", std::wstring(L"{"));
-    test(L"vertical-line", std::wstring(L"|"));
-    test(L"right-brace", std::wstring(L"}"));
-    test(L"right-curly-bracket", std::wstring(L"}"));
-    test(L"tilde", std::wstring(L"~"));
+  test(L"NUL", std::wstring(L"\x00", 1));
+  test(L"alert", std::wstring(L"\x07"));
+  test(L"backspace", std::wstring(L"\x08"));
+  test(L"tab", std::wstring(L"\x09"));
+  test(L"carriage-return", std::wstring(L"\x0D"));
+  test(L"newline", std::wstring(L"\x0A"));
+  test(L"vertical-tab", std::wstring(L"\x0B"));
+  test(L"form-feed", std::wstring(L"\x0C"));
+  test(L"space", std::wstring(L" "));
+  test(L"exclamation-mark", std::wstring(L"!"));
+  test(L"quotation-mark", std::wstring(L"\""));
+  test(L"number-sign", std::wstring(L"#"));
+  test(L"dollar-sign", std::wstring(L"$"));
+  test(L"percent-sign", std::wstring(L"%"));
+  test(L"ampersand", std::wstring(L"&"));
+  test(L"apostrophe", std::wstring(L"\'"));
+  test(L"left-parenthesis", std::wstring(L"("));
+  test(L"right-parenthesis", std::wstring(L")"));
+  test(L"asterisk", std::wstring(L"*"));
+  test(L"plus-sign", std::wstring(L"+"));
+  test(L"comma", std::wstring(L","));
+  test(L"hyphen-minus", std::wstring(L"-"));
+  test(L"hyphen", std::wstring(L"-"));
+  test(L"full-stop", std::wstring(L"."));
+  test(L"period", std::wstring(L"."));
+  test(L"slash", std::wstring(L"/"));
+  test(L"solidus", std::wstring(L"/"));
+  test(L"zero", std::wstring(L"0"));
+  test(L"one", std::wstring(L"1"));
+  test(L"two", std::wstring(L"2"));
+  test(L"three", std::wstring(L"3"));
+  test(L"four", std::wstring(L"4"));
+  test(L"five", std::wstring(L"5"));
+  test(L"six", std::wstring(L"6"));
+  test(L"seven", std::wstring(L"7"));
+  test(L"eight", std::wstring(L"8"));
+  test(L"nine", std::wstring(L"9"));
+  test(L"colon", std::wstring(L":"));
+  test(L"semicolon", std::wstring(L";"));
+  test(L"less-than-sign", std::wstring(L"<"));
+  test(L"equals-sign", std::wstring(L"="));
+  test(L"greater-than-sign", std::wstring(L">"));
+  test(L"question-mark", std::wstring(L"?"));
+  test(L"commercial-at", std::wstring(L"@"));
+  for (wchar_t c = L'A'; c <= L'Z'; ++c) {
+    const wchar_t a[2] = {c};
+    test(a, std::wstring(a));
+  }
+  test(L"left-square-bracket", std::wstring(L"["));
+  test(L"backslash", std::wstring(L"\\"));
+  test(L"reverse-solidus", std::wstring(L"\\"));
+  test(L"right-square-bracket", std::wstring(L"]"));
+  test(L"circumflex-accent", std::wstring(L"^"));
+  test(L"circumflex", std::wstring(L"^"));
+  test(L"low-line", std::wstring(L"_"));
+  test(L"underscore", std::wstring(L"_"));
+  test(L"grave-accent", std::wstring(L"`"));
+  for (wchar_t c = L'a'; c <= L'z'; ++c) {
+    const wchar_t a[2] = {c};
+    test(a, std::wstring(a));
+  }
+  test(L"left-brace", std::wstring(L"{"));
+  test(L"left-curly-bracket", std::wstring(L"{"));
+  test(L"vertical-line", std::wstring(L"|"));
+  test(L"right-brace", std::wstring(L"}"));
+  test(L"right-curly-bracket", std::wstring(L"}"));
+  test(L"tilde", std::wstring(L"~"));
 
-    test(L"tild", std::wstring(L""));
-    test(L"ch", std::wstring(L""));
+  test(L"tild", std::wstring(L""));
+  test(L"ch", std::wstring(L""));
 #endif // TEST_HAS_NO_WIDE_CHARACTERS
 
   return 0;
diff --git a/libcxx/test/std/re/re.traits/transform.pass.cpp b/libcxx/test/std/re/re.traits/transform.pass.cpp
index 80cd3f01faff2..7587c448b1cdb 100644
--- a/libcxx/test/std/re/re.traits/transform.pass.cpp
+++ b/libcxx/test/std/re/re.traits/transform.pass.cpp
@@ -24,27 +24,26 @@
 #include "test_iterators.h"
 #include "platform_support.h" // locale name macros
 
-int main(int, char**)
-{
-    {
-        std::regex_traits<char> t;
-        const char a[] = "a";
-        const char B[] = "B";
-        typedef forward_iterator<const char*> F;
-        assert(t.transform(F(a), F(a+1)) > t.transform(F(B), F(B+1)));
-        t.imbue(std::locale(LOCALE_cs_CZ_ISO8859_2));
-        assert(t.transform(F(a), F(a+1)) < t.transform(F(B), F(B+1)));
-    }
+int main(int, char**) {
+  {
+    std::regex_traits<char> t;
+    const char a[] = "a";
+    const char B[] = "B";
+    typedef forward_iterator<const char*> F;
+    assert(t.transform(F(a), F(a + 1)) > t.transform(F(B), F(B + 1)));
+    t.imbue(std::locale(LOCALE_cs_CZ_ISO8859_2));
+    assert(t.transform(F(a), F(a + 1)) < t.transform(F(B), F(B + 1)));
+  }
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-    {
-        std::regex_traits<wchar_t> t;
-        const wchar_t a[] = L"a";
-        const wchar_t B[] = L"B";
-        typedef forward_iterator<const wchar_t*> F;
-        assert(t.transform(F(a), F(a+1)) > t.transform(F(B), F(B+1)));
-        t.imbue(std::locale(LOCALE_cs_CZ_ISO8859_2));
-        assert(t.transform(F(a), F(a+1)) < t.transform(F(B), F(B+1)));
-    }
+  {
+    std::regex_traits<wchar_t> t;
+    const wchar_t a[] = L"a";
+    const wchar_t B[] = L"B";
+    typedef forward_iterator<const wchar_t*> F;
+    assert(t.transform(F(a), F(a + 1)) > t.transform(F(B), F(B + 1)));
+    t.imbue(std::locale(LOCALE_cs_CZ_ISO8859_2));
+    assert(t.transform(F(a), F(a + 1)) < t.transform(F(B), F(B + 1)));
+  }
 #endif
 
   return 0;
diff --git a/libcxx/test/std/re/re.traits/transform_primary.pass.cpp b/libcxx/test/std/re/re.traits/transform_primary.pass.cpp
index 422e3a591e643..dc91a5cb2a29b 100644
--- a/libcxx/test/std/re/re.traits/transform_primary.pass.cpp
+++ b/libcxx/test/std/re/re.traits/transform_primary.pass.cpp
@@ -29,31 +29,26 @@
 #include "test_iterators.h"
 #include "platform_support.h" // locale name macros
 
-int main(int, char**)
-{
-    {
-        std::regex_traits<char> t;
-        const char A[] = "A";
-        const char Aacute[] = "\xC1";
-        typedef forward_iterator<const char*> F;
-        assert(t.transform_primary(F(A), F(A+1)) !=
-               t.transform_primary(F(Aacute), F(Aacute+1)));
-        t.imbue(std::locale(LOCALE_cs_CZ_ISO8859_2));
-        assert(t.transform_primary(F(A), F(A+1)) ==
-               t.transform_primary(F(Aacute), F(Aacute+1)));
-    }
+int main(int, char**) {
+  {
+    std::regex_traits<char> t;
+    const char A[]      = "A";
+    const char Aacute[] = "\xC1";
+    typedef forward_iterator<const char*> F;
+    assert(t.transform_primary(F(A), F(A + 1)) != t.transform_primary(F(Aacute), F(Aacute + 1)));
+    t.imbue(std::locale(LOCALE_cs_CZ_ISO8859_2));
+    assert(t.transform_primary(F(A), F(A + 1)) == t.transform_primary(F(Aacute), F(Aacute + 1)));
+  }
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-    {
-        std::regex_traits<wchar_t> t;
-        const wchar_t A[] = L"A";
-        const wchar_t Aacute[] = L"\xC1";
-        typedef forward_iterator<const wchar_t*> F;
-        assert(t.transform_primary(F(A), F(A+1)) !=
-               t.transform_primary(F(Aacute), F(Aacute+1)));
-        t.imbue(std::locale(LOCALE_cs_CZ_ISO8859_2));
-        assert(t.transform_primary(F(A), F(A+1)) ==
-               t.transform_primary(F(Aacute), F(Aacute+1)));
-    }
+  {
+    std::regex_traits<wchar_t> t;
+    const wchar_t A[]      = L"A";
+    const wchar_t Aacute[] = L"\xC1";
+    typedef forward_iterator<const wchar_t*> F;
+    assert(t.transform_primary(F(A), F(A + 1)) != t.transform_primary(F(Aacute), F(Aacute + 1)));
+    t.imbue(std::locale(LOCALE_cs_CZ_ISO8859_2));
+    assert(t.transform_primary(F(A), F(A + 1)) == t.transform_primary(F(Aacute), F(Aacute + 1)));
+  }
 #endif
 
   return 0;
diff --git a/libcxx/test/std/re/re.traits/translate.pass.cpp b/libcxx/test/std/re/re.traits/translate.pass.cpp
index a3e597863eda2..33aeb6aca4c5b 100644
--- a/libcxx/test/std/re/re.traits/translate.pass.cpp
+++ b/libcxx/test/std/re/re.traits/translate.pass.cpp
@@ -16,21 +16,20 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    {
-        std::regex_traits<char> t;
-        assert(t.translate('a') == 'a');
-        assert(t.translate('B') == 'B');
-        assert(t.translate('c') == 'c');
-    }
+int main(int, char**) {
+  {
+    std::regex_traits<char> t;
+    assert(t.translate('a') == 'a');
+    assert(t.translate('B') == 'B');
+    assert(t.translate('c') == 'c');
+  }
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-    {
-        std::regex_traits<wchar_t> t;
-        assert(t.translate(L'a') == L'a');
-        assert(t.translate(L'B') == L'B');
-        assert(t.translate(L'c') == L'c');
-    }
+  {
+    std::regex_traits<wchar_t> t;
+    assert(t.translate(L'a') == L'a');
+    assert(t.translate(L'B') == L'B');
+    assert(t.translate(L'c') == L'c');
+  }
 #endif
 
   return 0;
diff --git a/libcxx/test/std/re/re.traits/translate_nocase.pass.cpp b/libcxx/test/std/re/re.traits/translate_nocase.pass.cpp
index be81286e72cbd..2bb1566ca6f76 100644
--- a/libcxx/test/std/re/re.traits/translate_nocase.pass.cpp
+++ b/libcxx/test/std/re/re.traits/translate_nocase.pass.cpp
@@ -25,47 +25,46 @@
 #include "test_macros.h"
 #include "platform_support.h"
 
-int main(int, char**)
-{
-    {
-        std::regex_traits<char> t;
-        assert(t.translate_nocase(' ') == ' ');
-        assert(t.translate_nocase('A') == 'a');
-        assert(t.translate_nocase('\x07') == '\x07');
-        assert(t.translate_nocase('.') == '.');
-        assert(t.translate_nocase('a') == 'a');
-        assert(t.translate_nocase('1') == '1');
-        assert(t.translate_nocase('\xDA') == '\xDA');
-        assert(t.translate_nocase('\xFA') == '\xFA');
-        t.imbue(std::locale(LOCALE_en_US_UTF_8));
-        assert(t.translate_nocase(' ') == ' ');
-        assert(t.translate_nocase('A') == 'a');
-        assert(t.translate_nocase('\x07') == '\x07');
-        assert(t.translate_nocase('.') == '.');
-        assert(t.translate_nocase('a') == 'a');
-        assert(t.translate_nocase('1') == '1');
-    }
+int main(int, char**) {
+  {
+    std::regex_traits<char> t;
+    assert(t.translate_nocase(' ') == ' ');
+    assert(t.translate_nocase('A') == 'a');
+    assert(t.translate_nocase('\x07') == '\x07');
+    assert(t.translate_nocase('.') == '.');
+    assert(t.translate_nocase('a') == 'a');
+    assert(t.translate_nocase('1') == '1');
+    assert(t.translate_nocase('\xDA') == '\xDA');
+    assert(t.translate_nocase('\xFA') == '\xFA');
+    t.imbue(std::locale(LOCALE_en_US_UTF_8));
+    assert(t.translate_nocase(' ') == ' ');
+    assert(t.translate_nocase('A') == 'a');
+    assert(t.translate_nocase('\x07') == '\x07');
+    assert(t.translate_nocase('.') == '.');
+    assert(t.translate_nocase('a') == 'a');
+    assert(t.translate_nocase('1') == '1');
+  }
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-    {
-        std::regex_traits<wchar_t> t;
-        assert(t.translate_nocase(L' ') == L' ');
-        assert(t.translate_nocase(L'A') == L'a');
-        assert(t.translate_nocase(L'\x07') == L'\x07');
-        assert(t.translate_nocase(L'.') == L'.');
-        assert(t.translate_nocase(L'a') == L'a');
-        assert(t.translate_nocase(L'1') == L'1');
-        assert(t.translate_nocase(L'\xDA') == L'\xDA');
-        assert(t.translate_nocase(L'\xFA') == L'\xFA');
-        t.imbue(std::locale(LOCALE_en_US_UTF_8));
-        assert(t.translate_nocase(L' ') == L' ');
-        assert(t.translate_nocase(L'A') == L'a');
-        assert(t.translate_nocase(L'\x07') == L'\x07');
-        assert(t.translate_nocase(L'.') == L'.');
-        assert(t.translate_nocase(L'a') == L'a');
-        assert(t.translate_nocase(L'1') == L'1');
-        assert(t.translate_nocase(L'\xDA') == L'\xFA');
-        assert(t.translate_nocase(L'\xFA') == L'\xFA');
-    }
+  {
+    std::regex_traits<wchar_t> t;
+    assert(t.translate_nocase(L' ') == L' ');
+    assert(t.translate_nocase(L'A') == L'a');
+    assert(t.translate_nocase(L'\x07') == L'\x07');
+    assert(t.translate_nocase(L'.') == L'.');
+    assert(t.translate_nocase(L'a') == L'a');
+    assert(t.translate_nocase(L'1') == L'1');
+    assert(t.translate_nocase(L'\xDA') == L'\xDA');
+    assert(t.translate_nocase(L'\xFA') == L'\xFA');
+    t.imbue(std::locale(LOCALE_en_US_UTF_8));
+    assert(t.translate_nocase(L' ') == L' ');
+    assert(t.translate_nocase(L'A') == L'a');
+    assert(t.translate_nocase(L'\x07') == L'\x07');
+    assert(t.translate_nocase(L'.') == L'.');
+    assert(t.translate_nocase(L'a') == L'a');
+    assert(t.translate_nocase(L'1') == L'1');
+    assert(t.translate_nocase(L'\xDA') == L'\xFA');
+    assert(t.translate_nocase(L'\xFA') == L'\xFA');
+  }
 #endif
 
   return 0;
diff --git a/libcxx/test/std/re/re.traits/types.pass.cpp b/libcxx/test/std/re/re.traits/types.pass.cpp
index f15a6476d50ce..828e0a999cc8a 100644
--- a/libcxx/test/std/re/re.traits/types.pass.cpp
+++ b/libcxx/test/std/re/re.traits/types.pass.cpp
@@ -20,15 +20,14 @@
 #include <type_traits>
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    static_assert((std::is_same<std::regex_traits<char>::char_type, char>::value), "");
-    static_assert((std::is_same<std::regex_traits<char>::string_type, std::string>::value), "");
-    static_assert((std::is_same<std::regex_traits<char>::locale_type, std::locale>::value), "");
+int main(int, char**) {
+  static_assert((std::is_same<std::regex_traits<char>::char_type, char>::value), "");
+  static_assert((std::is_same<std::regex_traits<char>::string_type, std::string>::value), "");
+  static_assert((std::is_same<std::regex_traits<char>::locale_type, std::locale>::value), "");
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-    static_assert((std::is_same<std::regex_traits<wchar_t>::char_type, wchar_t>::value), "");
-    static_assert((std::is_same<std::regex_traits<wchar_t>::string_type, std::wstring>::value), "");
-    static_assert((std::is_same<std::regex_traits<wchar_t>::locale_type, std::locale>::value), "");
+  static_assert((std::is_same<std::regex_traits<wchar_t>::char_type, wchar_t>::value), "");
+  static_assert((std::is_same<std::regex_traits<wchar_t>::string_type, std::wstring>::value), "");
+  static_assert((std::is_same<std::regex_traits<wchar_t>::locale_type, std::locale>::value), "");
 #endif
 
   return 0;
diff --git a/libcxx/test/std/re/re.traits/value.pass.cpp b/libcxx/test/std/re/re.traits/value.pass.cpp
index d4b7b0a131bdf..7ba508e2b7d0b 100644
--- a/libcxx/test/std/re/re.traits/value.pass.cpp
+++ b/libcxx/test/std/re/re.traits/value.pass.cpp
@@ -16,113 +16,96 @@
 #include <cassert>
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    {
-        std::regex_traits<char> t;
+int main(int, char**) {
+  {
+    std::regex_traits<char> t;
 
-        for (char c = 0; c < '0'; ++c)
-        {
-            assert(t.value(c, 8) == -1);
-            assert(t.value(c, 10) == -1);
-            assert(t.value(c, 16) == -1);
-        }
-        for (char c = '0'; c < '8'; ++c)
-        {
-            assert(t.value(c, 8) == c - '0');
-            assert(t.value(c, 10) == c - '0');
-            assert(t.value(c, 16) == c - '0');
-        }
-        for (char c = '8'; c < ':'; ++c)
-        {
-            assert(t.value(c, 8) == -1);
-            assert(t.value(c, 10) == c - '0');
-            assert(t.value(c, 16) == c - '0');
-        }
-        for (char c = ':'; c < 'A'; ++c)
-        {
-            assert(t.value(c, 8) == -1);
-            assert(t.value(c, 10) == -1);
-            assert(t.value(c, 16) == -1);
-        }
-        for (char c = 'A'; c < 'G'; ++c)
-        {
-            assert(t.value(c, 8) == -1);
-            assert(t.value(c, 10) == -1);
-            assert(t.value(c, 16) == c - 'A' +10);
-        }
-        for (char c = 'G'; c < 'a'; ++c)
-        {
-            assert(t.value(c, 8) == -1);
-            assert(t.value(c, 10) == -1);
-            assert(t.value(c, 16) == -1);
-        }
-        for (char c = 'a'; c < 'g'; ++c)
-        {
-            assert(t.value(c, 8) == -1);
-            assert(t.value(c, 10) == -1);
-            assert(t.value(c, 16) == c - 'a' +10);
-        }
-        for (int c = 'g'; c < 256; ++c)
-        {
-            assert(t.value(char(c), 8) == -1);
-            assert(t.value(char(c), 10) == -1);
-            assert(t.value(char(c), 16) == -1);
-        }
+    for (char c = 0; c < '0'; ++c) {
+      assert(t.value(c, 8) == -1);
+      assert(t.value(c, 10) == -1);
+      assert(t.value(c, 16) == -1);
     }
+    for (char c = '0'; c < '8'; ++c) {
+      assert(t.value(c, 8) == c - '0');
+      assert(t.value(c, 10) == c - '0');
+      assert(t.value(c, 16) == c - '0');
+    }
+    for (char c = '8'; c < ':'; ++c) {
+      assert(t.value(c, 8) == -1);
+      assert(t.value(c, 10) == c - '0');
+      assert(t.value(c, 16) == c - '0');
+    }
+    for (char c = ':'; c < 'A'; ++c) {
+      assert(t.value(c, 8) == -1);
+      assert(t.value(c, 10) == -1);
+      assert(t.value(c, 16) == -1);
+    }
+    for (char c = 'A'; c < 'G'; ++c) {
+      assert(t.value(c, 8) == -1);
+      assert(t.value(c, 10) == -1);
+      assert(t.value(c, 16) == c - 'A' + 10);
+    }
+    for (char c = 'G'; c < 'a'; ++c) {
+      assert(t.value(c, 8) == -1);
+      assert(t.value(c, 10) == -1);
+      assert(t.value(c, 16) == -1);
+    }
+    for (char c = 'a'; c < 'g'; ++c) {
+      assert(t.value(c, 8) == -1);
+      assert(t.value(c, 10) == -1);
+      assert(t.value(c, 16) == c - 'a' + 10);
+    }
+    for (int c = 'g'; c < 256; ++c) {
+      assert(t.value(char(c), 8) == -1);
+      assert(t.value(char(c), 10) == -1);
+      assert(t.value(char(c), 16) == -1);
+    }
+  }
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-    {
-        std::regex_traits<wchar_t> t;
+  {
+    std::regex_traits<wchar_t> t;
 
-        for (wchar_t c = 0; c < '0'; ++c)
-        {
-            assert(t.value(c, 8) == -1);
-            assert(t.value(c, 10) == -1);
-            assert(t.value(c, 16) == -1);
-        }
-        for (wchar_t c = '0'; c < '8'; ++c)
-        {
-            assert(t.value(c, 8) ==  static_cast<int>(c - '0'));
-            assert(t.value(c, 10) == static_cast<int>(c - '0'));
-            assert(t.value(c, 16) == static_cast<int>(c - '0'));
-        }
-        for (wchar_t c = '8'; c < ':'; ++c)
-        {
-            assert(t.value(c, 8) == -1);
-            assert(t.value(c, 10) == static_cast<int>(c - '0'));
-            assert(t.value(c, 16) == static_cast<int>(c - '0'));
-        }
-        for (wchar_t c = ':'; c < 'A'; ++c)
-        {
-            assert(t.value(c, 8) == -1);
-            assert(t.value(c, 10) == -1);
-            assert(t.value(c, 16) == -1);
-        }
-        for (wchar_t c = 'A'; c < 'G'; ++c)
-        {
-            assert(t.value(c, 8) == -1);
-            assert(t.value(c, 10) == -1);
-            assert(t.value(c, 16) == static_cast<int>(c - 'A' +10));
-        }
-        for (wchar_t c = 'G'; c < 'a'; ++c)
-        {
-            assert(t.value(c, 8) == -1);
-            assert(t.value(c, 10) == -1);
-            assert(t.value(c, 16) == -1);
-        }
-        for (wchar_t c = 'a'; c < 'g'; ++c)
-        {
-            assert(t.value(c, 8) == -1);
-            assert(t.value(c, 10) == -1);
-            assert(t.value(c, 16) == static_cast<int>(c - 'a' +10));
-        }
-        for (wchar_t c = 'g'; c < 0xFFFF; ++c)
-        {
-            assert(t.value(c, 8) == -1);
-            assert(t.value(c, 10) == -1);
-            assert(t.value(c, 16) == -1);
-        }
+    for (wchar_t c = 0; c < '0'; ++c) {
+      assert(t.value(c, 8) == -1);
+      assert(t.value(c, 10) == -1);
+      assert(t.value(c, 16) == -1);
+    }
+    for (wchar_t c = '0'; c < '8'; ++c) {
+      assert(t.value(c, 8) == static_cast<int>(c - '0'));
+      assert(t.value(c, 10) == static_cast<int>(c - '0'));
+      assert(t.value(c, 16) == static_cast<int>(c - '0'));
+    }
+    for (wchar_t c = '8'; c < ':'; ++c) {
+      assert(t.value(c, 8) == -1);
+      assert(t.value(c, 10) == static_cast<int>(c - '0'));
+      assert(t.value(c, 16) == static_cast<int>(c - '0'));
+    }
+    for (wchar_t c = ':'; c < 'A'; ++c) {
+      assert(t.value(c, 8) == -1);
+      assert(t.value(c, 10) == -1);
+      assert(t.value(c, 16) == -1);
+    }
+    for (wchar_t c = 'A'; c < 'G'; ++c) {
+      assert(t.value(c, 8) == -1);
+      assert(t.value(c, 10) == -1);
+      assert(t.value(c, 16) == static_cast<int>(c - 'A' + 10));
+    }
+    for (wchar_t c = 'G'; c < 'a'; ++c) {
+      assert(t.value(c, 8) == -1);
+      assert(t.value(c, 10) == -1);
+      assert(t.value(c, 16) == -1);
+    }
+    for (wchar_t c = 'a'; c < 'g'; ++c) {
+      assert(t.value(c, 8) == -1);
+      assert(t.value(c, 10) == -1);
+      assert(t.value(c, 16) == static_cast<int>(c - 'a' + 10));
+    }
+    for (wchar_t c = 'g'; c < 0xFFFF; ++c) {
+      assert(t.value(c, 8) == -1);
+      assert(t.value(c, 10) == -1);
+      assert(t.value(c, 16) == -1);
     }
+  }
 #endif
 
   return 0;