[libc++] Split re.alg tests into locale-dependent and independent tests

[arichardson]

Summary

Currently all these tests are XFAILED on Linux even though the problem
only seems to be with the few checks that look at collation. To retain
test coverage this splits the locale-dependent tests into a separate
.pass.cpp that is XFAILed as before.
This commit also XFAILs the locale-dependent tests on FreeBSD since the
[=M=] and [.ch.] behaviour for cs_CZ also doesn't seem to match the
behaviour that is expected by these tests.

[ldionne]

LGTM once CI passes!

libcxx/test/std/re/re.alg/re.alg.match/awk.locale.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// <regex>
+
+// template <class BidirectionalIterator, class Allocator, class charT,
+//           class traits>
+//   bool regex_match(BidirectionalIterator first, BidirectionalIterator last,
+//                    match_results<BidirectionalIterator, Allocator>& m,
+//                    const basic_regex<charT, traits>& e,
+//                    regex_constants::match_flag_type flags
+//                                            = regex_constants::match_default);
+
+// TODO: investigation needed
+// TODO(netbsd): incomplete support for locales
+// XFAIL: linux-gnu, netbsd, freebsd
+// REQUIRES: locale.cs_CZ.ISO8859-2
+
+#include <regex>
+#include <cassert>
+#include "test_macros.h"
+#include "test_iterators.h"
+
+#include "platform_support.h" // locale name macros
+
+int main(int, char**)
+{
+    std::locale::global(std::locale(LOCALE_cs_CZ_ISO8859_2));
+    {
+        std::cmatch m;
+        const char s[] = "m";
+        assert(std::regex_match(s, m,
+                      std::regex("[a[=M=]z]", std::regex_constants::awk)));
+        assert(m.size() == 1);
+        assert(!m.prefix().matched);
+        assert(m.prefix().first == s);
+        assert(m.prefix().second == m[0].first);
+        assert(!m.suffix().matched);
+        assert(m.suffix().first == m[0].second);
+        assert(m.suffix().second == m[0].second);
+        assert((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[] = "Ch";
+        assert(std::regex_match(s, m, std::regex("[a[.ch.]z]",
+                   std::regex_constants::awk | std::regex_constants::icase)));
+        assert(m.size() == 1);
+        assert(!m.prefix().matched);
+        assert(m.prefix().first == s);
+        assert(m.prefix().second == m[0].first);
+        assert(!m.suffix().matched);
+        assert(m.suffix().first == m[0].second);
+        assert(m.suffix().second == m[0].second);
+        assert((size_t)m.length(0) == std::char_traits<char>::length(s));
+        assert(m.position(0) == 0);
+        assert(m.str(0) == s);
+    }
+    std::locale::global(std::locale("C"));
+    {
+        std::cmatch m;
+        const char s[] = "m";
+        assert(!std::regex_match(s, m, std::regex("[a[=M=]z]",
+                                                 std::regex_constants::awk)));
+        assert(m.size() == 0);
+    }
+    std::locale::global(std::locale(LOCALE_cs_CZ_ISO8859_2));
+    {
+        std::wcmatch m;
+        const wchar_t s[] = L"m";
+        assert(std::regex_match(s, m, std::wregex(L"[a[=M=]z]",
+                                                 std::regex_constants::awk)));
+        assert(m.size() == 1);
+        assert(!m.prefix().matched);
+        assert(m.prefix().first == s);
+        assert(m.prefix().second == m[0].first);
+        assert(!m.suffix().matched);
+        assert(m.suffix().first == m[0].second);
+        assert(m.suffix().second == m[0].second);
+        assert((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"Ch";
+        assert(std::regex_match(s, m, std::wregex(L"[a[.ch.]z]",
+                   std::regex_constants::awk | std::regex_constants::icase)));
+        assert(m.size() == 1);
+        assert(!m.prefix().matched);
+        assert(m.prefix().first == s);
+        assert(m.prefix().second == m[0].first);
+        assert(!m.suffix().matched);
+        assert(m.suffix().first == m[0].second);
+        assert(m.suffix().second == m[0].second);
+        assert((size_t)m.length(0) == std::char_traits<wchar_t>::length(s));
+        assert(m.position(0) == 0);
+        assert(m.str(0) == s);
+    }
+    std::locale::global(std::locale("C"));
+    {
+        std::wcmatch m;
+        const wchar_t s[] = L"m";
+        assert(!std::regex_match(s, m, std::wregex(L"[a[=M=]z]",
+                                                 std::regex_constants::awk)));
+        assert(m.size() == 0);
+    }
+    return 0;
+}

libcxx/test/std/re/re.alg/re.alg.match/awk.pass.cpp

 // template <class BidirectionalIterator, class Allocator, class charT,
 //           class traits>
 //   bool regex_match(BidirectionalIterator first, BidirectionalIterator last,
 //                    match_results<BidirectionalIterator, Allocator>& m,
 //                    const basic_regex<charT, traits>& e,
 //                    regex_constants::match_flag_type flags
 //                                            = regex_constants::match_default);
 
-// TODO: investigation needed
-// TODO(netbsd): incomplete support for locales
-// XFAIL: linux-gnu, netbsd
-// REQUIRES: locale.cs_CZ.ISO8859-2
-
 #include <regex>
 #include <cassert>
 #include "test_macros.h"
 #include "test_iterators.h"
 
-#include "platform_support.h" // locale name macros
-
 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());
int main(int, char**)
     }
     {
         std::cmatch m;
         const char s[] = "m";
         assert(!std::regex_match(s, m, std::regex("[a[.hyphen.]z]",
                                                  std::regex_constants::awk)));
         assert(m.size() == 0);
     }
-    std::locale::global(std::locale(LOCALE_cs_CZ_ISO8859_2));
-    {
-        std::cmatch m;
-        const char s[] = "m";
-        assert(std::regex_match(s, m,
-                      std::regex("[a[=M=]z]", std::regex_constants::awk)));
-        assert(m.size() == 1);
-        assert(!m.prefix().matched);
-        assert(m.prefix().first == s);
-        assert(m.prefix().second == m[0].first);
-        assert(!m.suffix().matched);
-        assert(m.suffix().first == m[0].second);
-        assert(m.suffix().second == m[0].second);
-        assert((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[] = "Ch";
-        assert(std::regex_match(s, m, std::regex("[a[.ch.]z]",
-                   std::regex_constants::awk | std::regex_constants::icase)));
-        assert(m.size() == 1);
-        assert(!m.prefix().matched);
-        assert(m.prefix().first == s);
-        assert(m.prefix().second == m[0].first);
-        assert(!m.suffix().matched);
-        assert(m.suffix().first == m[0].second);
-        assert(m.suffix().second == m[0].second);
-        assert((size_t)m.length(0) == std::char_traits<char>::length(s));
-        assert(m.position(0) == 0);
-        assert(m.str(0) == s);
-    }
-    std::locale::global(std::locale("C"));
-    {
-        std::cmatch m;
-        const char s[] = "m";
-        assert(!std::regex_match(s, m, std::regex("[a[=M=]z]",
-                                                 std::regex_constants::awk)));
-        assert(m.size() == 0);
-    }
     {
         std::cmatch m;
         const char s[] = "01a45cef9";
         assert(!std::regex_match(s, m, std::regex("[ace1-9]*",
                                                  std::regex_constants::awk)));
         assert(m.size() == 0);
     }
     {

     }
     {
         std::wcmatch m;
         const wchar_t s[] = L"m";
         assert(!std::regex_match(s, m, std::wregex(L"[a[.hyphen.]z]",
                                                  std::regex_constants::awk)));
         assert(m.size() == 0);
     }
-    std::locale::global(std::locale(LOCALE_cs_CZ_ISO8859_2));
-    {
-        std::wcmatch m;
-        const wchar_t s[] = L"m";
-        assert(std::regex_match(s, m, std::wregex(L"[a[=M=]z]",
-                                                 std::regex_constants::awk)));
-        assert(m.size() == 1);
-        assert(!m.prefix().matched);
-        assert(m.prefix().first == s);
-        assert(m.prefix().second == m[0].first);
-        assert(!m.suffix().matched);
-        assert(m.suffix().first == m[0].second);
-        assert(m.suffix().second == m[0].second);
-        assert((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"Ch";
-        assert(std::regex_match(s, m, std::wregex(L"[a[.ch.]z]",
-                   std::regex_constants::awk | std::regex_constants::icase)));
-        assert(m.size() == 1);
-        assert(!m.prefix().matched);
-        assert(m.prefix().first == s);
-        assert(m.prefix().second == m[0].first);
-        assert(!m.suffix().matched);
-        assert(m.suffix().first == m[0].second);
-        assert(m.suffix().second == m[0].second);
-        assert((size_t)m.length(0) == std::char_traits<wchar_t>::length(s));
-        assert(m.position(0) == 0);
-        assert(m.str(0) == s);
-    }
-    std::locale::global(std::locale("C"));
-    {
-        std::wcmatch m;
-        const wchar_t s[] = L"m";
-        assert(!std::regex_match(s, m, std::wregex(L"[a[=M=]z]",
-                                                 std::regex_constants::awk)));
-        assert(m.size() == 0);
-    }
     {
         std::wcmatch m;
         const wchar_t s[] = L"01a45cef9";
         assert(!std::regex_match(s, m, std::wregex(L"[ace1-9]*",
                                                  std::regex_constants::awk)));
         assert(m.size() == 0);
     }
     {

libcxx/test/std/re/re.alg/re.alg.match/basic.locale.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// NetBSD does not support LC_COLLATE at the moment
+// XFAIL: netbsd
+
+// REQUIRES: locale.cs_CZ.ISO8859-2
+
+// <regex>
+
+// template <class BidirectionalIterator, class Allocator, class charT, class traits>
+//     bool
+//     regex_match(BidirectionalIterator first, BidirectionalIterator last,
+//                  match_results<BidirectionalIterator, Allocator>& m,
+//                  const basic_regex<charT, traits>& e,
+//                  regex_constants::match_flag_type flags = regex_constants::match_default);
+
+// TODO: investigation needed
+// XFAIL: linux-gnu, freebsd
+
+#include <regex>
+#include <cassert>
+#include "test_macros.h"
+#include "test_iterators.h"
+
+#include "platform_support.h" // locale name macros
+
+int main(int, char**)
+{
+    std::locale::global(std::locale(LOCALE_cs_CZ_ISO8859_2));
+    {
+        std::cmatch m;
+        const char s[] = "m";
+        assert(std::regex_match(s, m, std::regex("[a[=M=]z]",
+                                                 std::regex_constants::basic)));
+        assert(m.size() == 1);
+        assert(!m.prefix().matched);
+        assert(m.prefix().first == s);
+        assert(m.prefix().second == m[0].first);
+        assert(!m.suffix().matched);
+        assert(m.suffix().first == m[0].second);
+        assert(m.suffix().second == m[0].second);
+        assert(m.length(0) >= 0 && static_cast<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[] = "Ch";
+        assert(std::regex_match(s, m, std::regex("[a[.ch.]z]",
+                   std::regex_constants::basic | std::regex_constants::icase)));
+        assert(m.size() == 1);
+        assert(!m.prefix().matched);
+        assert(m.prefix().first == s);
+        assert(m.prefix().second == m[0].first);
+        assert(!m.suffix().matched);
+        assert(m.suffix().first == m[0].second);
+        assert(m.suffix().second == m[0].second);
+        assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<char>::length(s));
+        assert(m.position(0) == 0);
+        assert(m.str(0) == s);
+    }
+    std::locale::global(std::locale("C"));
+    {
+        std::cmatch m;
+        const char s[] = "m";
+        assert(!std::regex_match(s, m, std::regex("[a[=M=]z]",
+                                                 std::regex_constants::basic)));
+        assert(m.size() == 0);
+    }
+    std::locale::global(std::locale(LOCALE_cs_CZ_ISO8859_2));
+    {
+        std::wcmatch m;
+        const wchar_t s[] = L"m";
+        assert(std::regex_match(s, m, std::wregex(L"[a[=M=]z]",
+                                                 std::regex_constants::basic)));
+        assert(m.size() == 1);
+        assert(!m.prefix().matched);
+        assert(m.prefix().first == s);
+        assert(m.prefix().second == m[0].first);
+        assert(!m.suffix().matched);
+        assert(m.suffix().first == m[0].second);
+        assert(m.suffix().second == m[0].second);
+        assert(m.length(0) >= 0 && static_cast<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"Ch";
+        assert(std::regex_match(s, m, std::wregex(L"[a[.ch.]z]",
+                   std::regex_constants::basic | std::regex_constants::icase)));
+        assert(m.size() == 1);
+        assert(!m.prefix().matched);
+        assert(m.prefix().first == s);
+        assert(m.prefix().second == m[0].first);
+        assert(!m.suffix().matched);
+        assert(m.suffix().first == m[0].second);
+        assert(m.suffix().second == m[0].second);
+        assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<wchar_t>::length(s));
+        assert(m.position(0) == 0);
+        assert(m.str(0) == s);
+    }
+    std::locale::global(std::locale("C"));
+    {
+        std::wcmatch m;
+        const wchar_t s[] = L"m";
+        assert(!std::regex_match(s, m, std::wregex(L"[a[=M=]z]",
+                                                 std::regex_constants::basic)));
+        assert(m.size() == 0);
+    }
+    return 0;
+}

libcxx/test/std/re/re.alg/re.alg.match/basic.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
-// NetBSD does not support LC_COLLATE at the moment
-// XFAIL: netbsd
-
-// REQUIRES: locale.cs_CZ.ISO8859-2
 
 // <regex>
 
 // template <class BidirectionalIterator, class Allocator, class charT, class traits>
 //     bool
 //     regex_match(BidirectionalIterator first, BidirectionalIterator last,
 //                  match_results<BidirectionalIterator, Allocator>& m,
 //                  const basic_regex<charT, traits>& e,
 //                  regex_constants::match_flag_type flags = regex_constants::match_default);
 
-// TODO: investigation needed
-// XFAIL: linux-gnu
-
 #include <regex>
 #include <cassert>
 #include "test_macros.h"
 #include "test_iterators.h"
 
-#include "platform_support.h" // locale name macros
-
 int main(int, char**)
 {
     {
         std::cmatch m;
         assert(!std::regex_match("a", m, std::regex()));
         assert(m.size() == 0);
         assert(m.empty());
     }
int main(int, char**)
     }
     {
         std::cmatch m;
         const char s[] = "m";
         assert(!std::regex_match(s, m, std::regex("[a[.hyphen.]z]",
                                                  std::regex_constants::basic)));
         assert(m.size() == 0);
     }
-    std::locale::global(std::locale(LOCALE_cs_CZ_ISO8859_2));
-    {
-        std::cmatch m;
-        const char s[] = "m";
-        assert(std::regex_match(s, m, std::regex("[a[=M=]z]",
-                                                 std::regex_constants::basic)));
-        assert(m.size() == 1);
-        assert(!m.prefix().matched);
-        assert(m.prefix().first == s);
-        assert(m.prefix().second == m[0].first);
-        assert(!m.suffix().matched);
-        assert(m.suffix().first == m[0].second);
-        assert(m.suffix().second == m[0].second);
-        assert(m.length(0) >= 0 && static_cast<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[] = "Ch";
-        assert(std::regex_match(s, m, std::regex("[a[.ch.]z]",
-                   std::regex_constants::basic | std::regex_constants::icase)));
-        assert(m.size() == 1);
-        assert(!m.prefix().matched);
-        assert(m.prefix().first == s);
-        assert(m.prefix().second == m[0].first);
-        assert(!m.suffix().matched);
-        assert(m.suffix().first == m[0].second);
-        assert(m.suffix().second == m[0].second);
-        assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<char>::length(s));
-        assert(m.position(0) == 0);
-        assert(m.str(0) == s);
-    }
-    std::locale::global(std::locale("C"));
-    {
-        std::cmatch m;
-        const char s[] = "m";
-        assert(!std::regex_match(s, m, std::regex("[a[=M=]z]",
-                                                 std::regex_constants::basic)));
-        assert(m.size() == 0);
-    }
     {
         std::cmatch m;
         const char s[] = "01a45cef9";
         assert(!std::regex_match(s, m, std::regex("[ace1-9]*",
                                                  std::regex_constants::basic)));
         assert(m.size() == 0);
     }
     {

     }
     {
         std::wcmatch m;
         const wchar_t s[] = L"m";
         assert(!std::regex_match(s, m, std::wregex(L"[a[.hyphen.]z]",
                                                  std::regex_constants::basic)));
         assert(m.size() == 0);
     }
-    std::locale::global(std::locale(LOCALE_cs_CZ_ISO8859_2));
-    {
-        std::wcmatch m;
-        const wchar_t s[] = L"m";
-        assert(std::regex_match(s, m, std::wregex(L"[a[=M=]z]",
-                                                 std::regex_constants::basic)));
-        assert(m.size() == 1);
-        assert(!m.prefix().matched);
-        assert(m.prefix().first == s);
-        assert(m.prefix().second == m[0].first);
-        assert(!m.suffix().matched);
-        assert(m.suffix().first == m[0].second);
-        assert(m.suffix().second == m[0].second);
-        assert(m.length(0) >= 0 && static_cast<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"Ch";
-        assert(std::regex_match(s, m, std::wregex(L"[a[.ch.]z]",
-                   std::regex_constants::basic | std::regex_constants::icase)));
-        assert(m.size() == 1);
-        assert(!m.prefix().matched);
-        assert(m.prefix().first == s);
-        assert(m.prefix().second == m[0].first);
-        assert(!m.suffix().matched);
-        assert(m.suffix().first == m[0].second);
-        assert(m.suffix().second == m[0].second);
-        assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<wchar_t>::length(s));
-        assert(m.position(0) == 0);
-        assert(m.str(0) == s);
-    }
-    std::locale::global(std::locale("C"));
-    {
-        std::wcmatch m;
-        const wchar_t s[] = L"m";
-        assert(!std::regex_match(s, m, std::wregex(L"[a[=M=]z]",
-                                                 std::regex_constants::basic)));
-        assert(m.size() == 0);
-    }
     {
         std::wcmatch m;
         const wchar_t s[] = L"01a45cef9";
         assert(!std::regex_match(s, m, std::wregex(L"[ace1-9]*",
                                                  std::regex_constants::basic)));
         assert(m.size() == 0);
     }
     {

libcxx/test/std/re/re.alg/re.alg.match/ecma.locale.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// NetBSD does not support LC_COLLATE at the moment
+// XFAIL: netbsd
+
+// REQUIRES: locale.cs_CZ.ISO8859-2
+
+// <regex>
+
+// template <class BidirectionalIterator, class Allocator, class charT, class traits>
+//     bool
+//     regex_match(BidirectionalIterator first, BidirectionalIterator last,
+//                  match_results<BidirectionalIterator, Allocator>& m,
+//                  const basic_regex<charT, traits>& e,
+//                  regex_constants::match_flag_type flags = regex_constants::match_default);
+
+// TODO: investigation needed
+// XFAIL: linux-gnu, freebsd
+
+#include <regex>
+#include <cassert>
+#include "test_macros.h"
+#include "test_iterators.h"
+
+#include "platform_support.h" // locale name macros
+
+int main(int, char**)
+{
+    std::locale::global(std::locale(LOCALE_cs_CZ_ISO8859_2));
+    {
+        std::wcmatch m;
+        const wchar_t s[] = L"m";
+        assert(std::regex_match(s, m, std::wregex(L"[a[=M=]z]")));
+        assert(m.size() == 1);
+        assert(!m.prefix().matched);
+        assert(m.prefix().first == s);
+        assert(m.prefix().second == m[0].first);
+        assert(!m.suffix().matched);
+        assert(m.suffix().first == m[0].second);
+        assert(m.suffix().second == m[0].second);
+        assert(m.length(0) >= 0 && static_cast<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"Ch";
+        assert(std::regex_match(s, m, std::wregex(L"[a[.ch.]z]",
+                   std::regex_constants::icase)));
+        assert(m.size() == 1);
+        assert(!m.prefix().matched);
+        assert(m.prefix().first == s);
+        assert(m.prefix().second == m[0].first);
+        assert(!m.suffix().matched);
+        assert(m.suffix().first == m[0].second);
+        assert(m.suffix().second == m[0].second);
+        assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<wchar_t>::length(s));
+        assert(m.position(0) == 0);
+        assert(m.str(0) == s);
+    }
+    std::locale::global(std::locale("C"));
+    {
+        std::wcmatch m;
+        const wchar_t s[] = L"m";
+        assert(!std::regex_match(s, m, std::wregex(L"[a[=M=]z]")));
+        assert(m.size() == 0);
+    }
+    return 0;
+}

libcxx/test/std/re/re.alg/re.alg.match/ecma.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
-// NetBSD does not support LC_COLLATE at the moment
-// XFAIL: netbsd
-
-// REQUIRES: locale.cs_CZ.ISO8859-2
 
 // <regex>
 
 // template <class BidirectionalIterator, class Allocator, class charT, class traits>
 //     bool
 //     regex_match(BidirectionalIterator first, BidirectionalIterator last,
 //                  match_results<BidirectionalIterator, Allocator>& m,
 //                  const basic_regex<charT, traits>& e,
 //                  regex_constants::match_flag_type flags = regex_constants::match_default);
 
-// TODO: investigation needed
-// XFAIL: linux-gnu
-
 #include <regex>
 #include <cassert>
 #include "test_macros.h"
 #include "test_iterators.h"
 
-#include "platform_support.h" // locale name macros
-
 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());
int main(int, char**)
         assert(m.str(0) == s);
     }
     {
         std::cmatch m;
         const char s[] = "m";
         assert(!std::regex_match(s, m, std::regex("[a[.hyphen.]z]")));
         assert(m.size() == 0);
     }
-    std::locale::global(std::locale(LOCALE_cs_CZ_ISO8859_2));
-    {
-        std::cmatch m;
-        const char s[] = "m";
-        assert(std::regex_match(s, m, std::regex("[a[=M=]z]")));
-        assert(m.size() == 1);
-        assert(!m.prefix().matched);
-        assert(m.prefix().first == s);
-        assert(m.prefix().second == m[0].first);
-        assert(!m.suffix().matched);
-        assert(m.suffix().first == m[0].second);
-        assert(m.suffix().second == m[0].second);
-        assert(m.length(0) >= 0 && static_cast<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[] = "Ch";
-        assert(std::regex_match(s, m, std::regex("[a[.ch.]z]",
-                   std::regex_constants::icase)));
-        assert(m.size() == 1);
-        assert(!m.prefix().matched);
-        assert(m.prefix().first == s);
-        assert(m.prefix().second == m[0].first);
-        assert(!m.suffix().matched);
-        assert(m.suffix().first == m[0].second);
-        assert(m.suffix().second == m[0].second);
-        assert(m.length(0) >= 0 && static_cast<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[] = "foobar";
         assert(std::regex_match(s, m, std::regex("[^\\0]*")));
         assert(m.size() == 1);
     }
     {
         std::cmatch m;
         const char s[] = "foo\0bar";
         assert(std::regex_match(s, s+7, m, std::regex("[abfor\\0]*")));
         assert(m.size() == 1);
     }
-    std::locale::global(std::locale("C"));
-    {
-        std::cmatch m;
-        const char s[] = "m";
-        assert(!std::regex_match(s, m, std::regex("[a[=M=]z]")));
-        assert(m.size() == 0);
-    }
     {
         std::cmatch m;
         const char s[] = "01a45cef9";
         assert(!std::regex_match(s, m, std::regex("[ace1-9]*")));
         assert(m.size() == 0);
     }
     {
         std::cmatch m;

         assert(m.str(0) == s);
     }
     {
         std::wcmatch m;
         const wchar_t s[] = L"m";
         assert(!std::regex_match(s, m, std::wregex(L"[a[.hyphen.]z]")));
         assert(m.size() == 0);
     }
-    std::locale::global(std::locale(LOCALE_cs_CZ_ISO8859_2));
-    {
-        std::wcmatch m;
-        const wchar_t s[] = L"m";
-        assert(std::regex_match(s, m, std::wregex(L"[a[=M=]z]")));
-        assert(m.size() == 1);
-        assert(!m.prefix().matched);
-        assert(m.prefix().first == s);
-        assert(m.prefix().second == m[0].first);
-        assert(!m.suffix().matched);
-        assert(m.suffix().first == m[0].second);
-        assert(m.suffix().second == m[0].second);
-        assert(m.length(0) >= 0 && static_cast<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"Ch";
-        assert(std::regex_match(s, m, std::wregex(L"[a[.ch.]z]",
-                   std::regex_constants::icase)));
-        assert(m.size() == 1);
-        assert(!m.prefix().matched);
-        assert(m.prefix().first == s);
-        assert(m.prefix().second == m[0].first);
-        assert(!m.suffix().matched);
-        assert(m.suffix().first == m[0].second);
-        assert(m.suffix().second == m[0].second);
-        assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<wchar_t>::length(s));
-        assert(m.position(0) == 0);
-        assert(m.str(0) == s);
-    }
-    std::locale::global(std::locale("C"));
-    {
-        std::wcmatch m;
-        const wchar_t s[] = L"m";
-        assert(!std::regex_match(s, m, std::wregex(L"[a[=M=]z]")));
-        assert(m.size() == 0);
-    }
     {
         std::wcmatch m;
         const wchar_t s[] = L"01a45cef9";
         assert(!std::regex_match(s, m, std::wregex(L"[ace1-9]*")));
         assert(m.size() == 0);
     }
     {
         std::wcmatch m;

libcxx/test/std/re/re.alg/re.alg.match/extended.locale.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// NetBSD does not support LC_COLLATE at the moment
+// XFAIL: netbsd
+
+// REQUIRES: locale.cs_CZ.ISO8859-2
+
+// <regex>
+
+// template <class BidirectionalIterator, class Allocator, class charT, class traits>
+//     bool
+//     regex_match(BidirectionalIterator first, BidirectionalIterator last,
+//                  match_results<BidirectionalIterator, Allocator>& m,
+//                  const basic_regex<charT, traits>& e,
+//                  regex_constants::match_flag_type flags = regex_constants::match_default);
+
+// TODO: investigation needed
+// XFAIL: linux-gnu, freebsd
+
+#include <regex>
+#include <cassert>
+#include "test_macros.h"
+#include "test_iterators.h"
+
+#include "platform_support.h" // locale name macros
+
+int main(int, char**)
+{
+    std::locale::global(std::locale(LOCALE_cs_CZ_ISO8859_2));
+    {
+        std::cmatch m;
+        const char s[] = "m";
+        assert(std::regex_match(s, m, std::regex("[a[=M=]z]",
+                                                 std::regex_constants::extended)));
+        assert(m.size() == 1);
+        assert(!m.prefix().matched);
+        assert(m.prefix().first == s);
+        assert(m.prefix().second == m[0].first);
+        assert(!m.suffix().matched);
+        assert(m.suffix().first == m[0].second);
+        assert(m.suffix().second == m[0].second);
+        assert(m.length(0) >= 0 && static_cast<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[] = "Ch";
+        assert(std::regex_match(s, m, std::regex("[a[.ch.]z]",
+                   std::regex_constants::extended | std::regex_constants::icase)));
+        assert(m.size() == 1);
+        assert(!m.prefix().matched);
+        assert(m.prefix().first == s);
+        assert(m.prefix().second == m[0].first);
+        assert(!m.suffix().matched);
+        assert(m.suffix().first == m[0].second);
+        assert(m.suffix().second == m[0].second);
+        assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<char>::length(s));
+        assert(m.position(0) == 0);
+        assert(m.str(0) == s);
+    }
+    std::locale::global(std::locale("C"));
+    {
+        std::cmatch m;
+        const char s[] = "m";
+        assert(!std::regex_match(s, m, std::regex("[a[=M=]z]",
+                                                 std::regex_constants::extended)));
+        assert(m.size() == 0);
+    }
+    std::locale::global(std::locale(LOCALE_cs_CZ_ISO8859_2));
+    {
+        std::wcmatch m;
+        const wchar_t s[] = L"m";
+        assert(std::regex_match(s, m, std::wregex(L"[a[=M=]z]",
+                                                 std::regex_constants::extended)));
+        assert(m.size() == 1);
+        assert(!m.prefix().matched);
+        assert(m.prefix().first == s);
+        assert(m.prefix().second == m[0].first);
+        assert(!m.suffix().matched);
+        assert(m.suffix().first == m[0].second);
+        assert(m.suffix().second == m[0].second);
+        assert(m.length(0) >= 0 && static_cast<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"Ch";
+        assert(std::regex_match(s, m, std::wregex(L"[a[.ch.]z]",
+                   std::regex_constants::extended | std::regex_constants::icase)));
+        assert(m.size() == 1);
+        assert(!m.prefix().matched);
+        assert(m.prefix().first == s);
+        assert(m.prefix().second == m[0].first);
+        assert(!m.suffix().matched);
+        assert(m.suffix().first == m[0].second);
+        assert(m.suffix().second == m[0].second);
+        assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<wchar_t>::length(s));
+        assert(m.position(0) == 0);
+        assert(m.str(0) == s);
+    }
+    std::locale::global(std::locale("C"));
+    {
+        std::wcmatch m;
+        const wchar_t s[] = L"m";
+        assert(!std::regex_match(s, m, std::wregex(L"[a[=M=]z]",
+                                                 std::regex_constants::extended)));
+        assert(m.size() == 0);
+    }
+    return 0;
+}

libcxx/test/std/re/re.alg/re.alg.match/extended.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
-// NetBSD does not support LC_COLLATE at the moment
-// XFAIL: netbsd
-
-// REQUIRES: locale.cs_CZ.ISO8859-2
-
 // <regex>
 
 // template <class BidirectionalIterator, class Allocator, class charT, class traits>
 //     bool
 //     regex_match(BidirectionalIterator first, BidirectionalIterator last,
 //                  match_results<BidirectionalIterator, Allocator>& m,
 //                  const basic_regex<charT, traits>& e,
 //                  regex_constants::match_flag_type flags = regex_constants::match_default);
 
-// TODO: investigation needed
-// XFAIL: linux-gnu
-
 #include <regex>
 #include <cassert>
 #include "test_macros.h"
 #include "test_iterators.h"
 
-#include "platform_support.h" // locale name macros
-
 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());
int main(int, char**)
     }
     {
         std::cmatch m;
         const char s[] = "m";
         assert(!std::regex_match(s, m, std::regex("[a[.hyphen.]z]",
                                                  std::regex_constants::extended)));
         assert(m.size() == 0);
     }
-    std::locale::global(std::locale(LOCALE_cs_CZ_ISO8859_2));
-    {
-        std::cmatch m;
-        const char s[] = "m";
-        assert(std::regex_match(s, m, std::regex("[a[=M=]z]",
-                                                 std::regex_constants::extended)));
-        assert(m.size() == 1);
-        assert(!m.prefix().matched);
-        assert(m.prefix().first == s);
-        assert(m.prefix().second == m[0].first);
-        assert(!m.suffix().matched);
-        assert(m.suffix().first == m[0].second);
-        assert(m.suffix().second == m[0].second);
-        assert(m.length(0) >= 0 && static_cast<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[] = "Ch";
-        assert(std::regex_match(s, m, std::regex("[a[.ch.]z]",
-                   std::regex_constants::extended | std::regex_constants::icase)));
-        assert(m.size() == 1);
-        assert(!m.prefix().matched);
-        assert(m.prefix().first == s);
-        assert(m.prefix().second == m[0].first);
-        assert(!m.suffix().matched);
-        assert(m.suffix().first == m[0].second);
-        assert(m.suffix().second == m[0].second);
-        assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<char>::length(s));
-        assert(m.position(0) == 0);
-        assert(m.str(0) == s);
-    }
-    std::locale::global(std::locale("C"));
-    {
-        std::cmatch m;
-        const char s[] = "m";
-        assert(!std::regex_match(s, m, std::regex("[a[=M=]z]",
-                                                 std::regex_constants::extended)));
-        assert(m.size() == 0);
-    }
     {
         std::cmatch m;
         const char s[] = "01a45cef9";
         assert(!std::regex_match(s, m, std::regex("[ace1-9]*",
                                                  std::regex_constants::extended)));
         assert(m.size() == 0);
     }
     {

     }
     {
         std::wcmatch m;
         const wchar_t s[] = L"m";
         assert(!std::regex_match(s, m, std::wregex(L"[a[.hyphen.]z]",
                                                  std::regex_constants::extended)));
         assert(m.size() == 0);
     }
-    std::locale::global(std::locale(LOCALE_cs_CZ_ISO8859_2));
-    {
-        std::wcmatch m;
-        const wchar_t s[] = L"m";
-        assert(std::regex_match(s, m, std::wregex(L"[a[=M=]z]",
-                                                 std::regex_constants::extended)));
-        assert(m.size() == 1);
-        assert(!m.prefix().matched);
-        assert(m.prefix().first == s);
-        assert(m.prefix().second == m[0].first);
-        assert(!m.suffix().matched);
-        assert(m.suffix().first == m[0].second);
-        assert(m.suffix().second == m[0].second);
-        assert(m.length(0) >= 0 && static_cast<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"Ch";
-        assert(std::regex_match(s, m, std::wregex(L"[a[.ch.]z]",
-                   std::regex_constants::extended | std::regex_constants::icase)));
-        assert(m.size() == 1);
-        assert(!m.prefix().matched);
-        assert(m.prefix().first == s);
-        assert(m.prefix().second == m[0].first);
-        assert(!m.suffix().matched);
-        assert(m.suffix().first == m[0].second);
-        assert(m.suffix().second == m[0].second);
-        assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<wchar_t>::length(s));
-        assert(m.position(0) == 0);
-        assert(m.str(0) == s);
-    }
-    std::locale::global(std::locale("C"));
-    {
-        std::wcmatch m;
-        const wchar_t s[] = L"m";
-        assert(!std::regex_match(s, m, std::wregex(L"[a[=M=]z]",
-                                                 std::regex_constants::extended)));
-        assert(m.size() == 0);
-    }
     {
         std::wcmatch m;
         const wchar_t s[] = L"01a45cef9";
         assert(!std::regex_match(s, m, std::wregex(L"[ace1-9]*",
                                                  std::regex_constants::extended)));
         assert(m.size() == 0);
     }
     {

libcxx/test/std/re/re.alg/re.alg.search/awk.locale.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// NetBSD does not support LC_COLLATE at the moment
+// XFAIL: netbsd
+
+// REQUIRES: locale.cs_CZ.ISO8859-2
+
+// <regex>
+
+// template <class BidirectionalIterator, class Allocator, class charT, class traits>
+//     bool
+//     regex_search(BidirectionalIterator first, BidirectionalIterator last,
+//                  match_results<BidirectionalIterator, Allocator>& m,
+//                  const basic_regex<charT, traits>& e,
+//                  regex_constants::match_flag_type flags = regex_constants::match_default);
+
+// TODO: investigation needed
+// XFAIL: linux-gnu, freebsd
+
+#include <regex>
+#include <cassert>
+#include "test_macros.h"
+#include "test_iterators.h"
+
+#include "platform_support.h" // locale name macros
+
+int main(int, char**)
+{
+    std::locale::global(std::locale(LOCALE_cs_CZ_ISO8859_2));
+    {
+        std::cmatch m;
+        const char s[] = "m";
+        assert(std::regex_search(s, m, std::regex("[a[=M=]z]",
+                                                 std::regex_constants::awk)));
+        assert(m.size() == 1);
+        assert(!m.prefix().matched);
+        assert(m.prefix().first == s);
+        assert(m.prefix().second == m[0].first);
+        assert(!m.suffix().matched);
+        assert(m.suffix().first == m[0].second);
+        assert(m.suffix().second == m[0].second);
+        assert(m.length(0) >= 0 && static_cast<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[] = "Ch";
+        assert(std::regex_search(s, m, std::regex("[a[.ch.]z]",
+                   std::regex_constants::awk | std::regex_constants::icase)));
+        assert(m.size() == 1);
+        assert(!m.prefix().matched);
+        assert(m.prefix().first == s);
+        assert(m.prefix().second == m[0].first);
+        assert(!m.suffix().matched);
+        assert(m.suffix().first == m[0].second);
+        assert(m.suffix().second == m[0].second);
+        assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<char>::length(s));
+        assert(m.position(0) == 0);
+        assert(m.str(0) == s);
+    }
+    std::locale::global(std::locale("C"));
+    {
+        std::cmatch m;
+        const char s[] = "m";
+        assert(!std::regex_search(s, m, std::regex("[a[=M=]z]",
+                                                 std::regex_constants::awk)));
+        assert(m.size() == 0);
+    }
+    std::locale::global(std::locale(LOCALE_cs_CZ_ISO8859_2));
+    {
+        std::wcmatch m;
+        const wchar_t s[] = L"m";
+        assert(std::regex_search(s, m, std::wregex(L"[a[=M=]z]",
+                                                 std::regex_constants::awk)));
+        assert(m.size() == 1);
+        assert(!m.prefix().matched);
+        assert(m.prefix().first == s);
+        assert(m.prefix().second == m[0].first);
+        assert(!m.suffix().matched);
+        assert(m.suffix().first == m[0].second);
+        assert(m.suffix().second == m[0].second);
+        assert(m.length(0) >= 0 && static_cast<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"Ch";
+        assert(std::regex_search(s, m, std::wregex(L"[a[.ch.]z]",
+                   std::regex_constants::awk | std::regex_constants::icase)));
+        assert(m.size() == 1);
+        assert(!m.prefix().matched);
+        assert(m.prefix().first == s);
+        assert(m.prefix().second == m[0].first);
+        assert(!m.suffix().matched);
+        assert(m.suffix().first == m[0].second);
+        assert(m.suffix().second == m[0].second);
+        assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<wchar_t>::length(s));
+        assert(m.position(0) == 0);
+        assert(m.str(0) == s);
+    }
+    std::locale::global(std::locale("C"));
+    {
+        std::wcmatch m;
+        const wchar_t s[] = L"m";
+        assert(!std::regex_search(s, m, std::wregex(L"[a[=M=]z]",
+                                                 std::regex_constants::awk)));
+        assert(m.size() == 0);
+    }
+    return 0;
+}

libcxx/test/std/re/re.alg/re.alg.search/awk.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
-// NetBSD does not support LC_COLLATE at the moment
-// XFAIL: netbsd
-
-// REQUIRES: locale.cs_CZ.ISO8859-2
 
 // <regex>
 
 // template <class BidirectionalIterator, class Allocator, class charT, class traits>
 //     bool
 //     regex_search(BidirectionalIterator first, BidirectionalIterator last,
 //                  match_results<BidirectionalIterator, Allocator>& m,
 //                  const basic_regex<charT, traits>& e,
 //                  regex_constants::match_flag_type flags = regex_constants::match_default);
 
-// TODO: investigation needed
-// XFAIL: linux-gnu
-
 #include <regex>
 #include <cassert>
 #include "test_macros.h"
 #include "test_iterators.h"
 
-#include "platform_support.h" // locale name macros
-
 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());
int main(int, char**)
     }
     {
         std::cmatch m;
         const char s[] = "m";
         assert(!std::regex_search(s, m, std::regex("[a[.hyphen.]z]",
                                                  std::regex_constants::awk)));
         assert(m.size() == 0);
     }
-    std::locale::global(std::locale(LOCALE_cs_CZ_ISO8859_2));
-    {
-        std::cmatch m;
-        const char s[] = "m";
-        assert(std::regex_search(s, m, std::regex("[a[=M=]z]",
-                                                 std::regex_constants::awk)));
-        assert(m.size() == 1);
-        assert(!m.prefix().matched);
-        assert(m.prefix().first == s);
-        assert(m.prefix().second == m[0].first);
-        assert(!m.suffix().matched);
-        assert(m.suffix().first == m[0].second);
-        assert(m.suffix().second == m[0].second);
-        assert(m.length(0) >= 0 && static_cast<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[] = "Ch";
-        assert(std::regex_search(s, m, std::regex("[a[.ch.]z]",
-                   std::regex_constants::awk | std::regex_constants::icase)));
-        assert(m.size() == 1);
-        assert(!m.prefix().matched);
-        assert(m.prefix().first == s);
-        assert(m.prefix().second == m[0].first);
-        assert(!m.suffix().matched);
-        assert(m.suffix().first == m[0].second);
-        assert(m.suffix().second == m[0].second);
-        assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<char>::length(s));
-        assert(m.position(0) == 0);
-        assert(m.str(0) == s);
-    }
-    std::locale::global(std::locale("C"));
-    {
-        std::cmatch m;
-        const char s[] = "m";
-        assert(!std::regex_search(s, m, std::regex("[a[=M=]z]",
-                                                 std::regex_constants::awk)));
-        assert(m.size() == 0);
-    }
     {
         std::cmatch m;
         const char s[] = "01a45cef9";
         assert(std::regex_search(s, m, std::regex("[ace1-9]*",
                                                  std::regex_constants::awk)));
         assert(m.size() == 1);
         assert(!m.prefix().matched);
         assert(m.prefix().first == s);

     }
     {
         std::wcmatch m;
         const wchar_t s[] = L"m";
         assert(!std::regex_search(s, m, std::wregex(L"[a[.hyphen.]z]",
                                                  std::regex_constants::awk)));
         assert(m.size() == 0);
     }
-    std::locale::global(std::locale(LOCALE_cs_CZ_ISO8859_2));
-    {
-        std::wcmatch m;
-        const wchar_t s[] = L"m";
-        assert(std::regex_search(s, m, std::wregex(L"[a[=M=]z]",
-                                                 std::regex_constants::awk)));
-        assert(m.size() == 1);
-        assert(!m.prefix().matched);
-        assert(m.prefix().first == s);
-        assert(m.prefix().second == m[0].first);
-        assert(!m.suffix().matched);
-        assert(m.suffix().first == m[0].second);
-        assert(m.suffix().second == m[0].second);
-        assert(m.length(0) >= 0 && static_cast<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"Ch";
-        assert(std::regex_search(s, m, std::wregex(L"[a[.ch.]z]",
-                   std::regex_constants::awk | std::regex_constants::icase)));
-        assert(m.size() == 1);
-        assert(!m.prefix().matched);
-        assert(m.prefix().first == s);
-        assert(m.prefix().second == m[0].first);
-        assert(!m.suffix().matched);
-        assert(m.suffix().first == m[0].second);
-        assert(m.suffix().second == m[0].second);
-        assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<wchar_t>::length(s));
-        assert(m.position(0) == 0);
-        assert(m.str(0) == s);
-    }
-    std::locale::global(std::locale("C"));
-    {
-        std::wcmatch m;
-        const wchar_t s[] = L"m";
-        assert(!std::regex_search(s, m, std::wregex(L"[a[=M=]z]",
-                                                 std::regex_constants::awk)));
-        assert(m.size() == 0);
-    }
     {
         std::wcmatch m;
         const wchar_t s[] = L"01a45cef9";
         assert(std::regex_search(s, m, std::wregex(L"[ace1-9]*",
                                                  std::regex_constants::awk)));
         assert(m.size() == 1);
         assert(!m.prefix().matched);
         assert(m.prefix().first == s);

libcxx/test/std/re/re.alg/re.alg.search/basic.locale.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// NetBSD does not support LC_COLLATE at the moment
+// XFAIL: netbsd
+
+// REQUIRES: locale.cs_CZ.ISO8859-2
+
+// <regex>
+
+// template <class BidirectionalIterator, class Allocator, class charT, class traits>
+//     bool
+//     regex_search(BidirectionalIterator first, BidirectionalIterator last,
+//                  match_results<BidirectionalIterator, Allocator>& m,
+//                  const basic_regex<charT, traits>& e,
+//                  regex_constants::match_flag_type flags = regex_constants::match_default);
+
+// TODO: investigation needed
+// XFAIL: linux-gnu, freebsd
+
+#include <regex>
+#include <cassert>
+#include "test_macros.h"
+#include "test_iterators.h"
+
+#include "platform_support.h" // locale name macros
+
+int main(int, char**)
+{
+    std::locale::global(std::locale(LOCALE_cs_CZ_ISO8859_2));
+    {
+        std::cmatch m;
+        const char s[] = "m";
+        assert(std::regex_search(s, m, std::regex("[a[=M=]z]",
+                                                 std::regex_constants::basic)));
+        assert(m.size() == 1);
+        assert(!m.prefix().matched);
+        assert(m.prefix().first == s);
+        assert(m.prefix().second == m[0].first);
+        assert(!m.suffix().matched);
+        assert(m.suffix().first == m[0].second);
+        assert(m.suffix().second == m[0].second);
+        assert(m.length(0) >= 0 && static_cast<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[] = "Ch";
+        assert(std::regex_search(s, m, std::regex("[a[.ch.]z]",
+                   std::regex_constants::basic | std::regex_constants::icase)));
+        assert(m.size() == 1);
+        assert(!m.prefix().matched);
+        assert(m.prefix().first == s);
+        assert(m.prefix().second == m[0].first);
+        assert(!m.suffix().matched);
+        assert(m.suffix().first == m[0].second);
+        assert(m.suffix().second == m[0].second);
+        assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<char>::length(s));
+        assert(m.position(0) == 0);
+        assert(m.str(0) == s);
+    }
+    std::locale::global(std::locale("C"));
+    {
+        std::cmatch m;
+        const char s[] = "m";
+        assert(!std::regex_search(s, m, std::regex("[a[=M=]z]",
+                                                 std::regex_constants::basic)));
+        assert(m.size() == 0);
+    }
+    std::locale::global(std::locale(LOCALE_cs_CZ_ISO8859_2));
+    {
+        std::wcmatch m;
+        const wchar_t s[] = L"m";
+        assert(std::regex_search(s, m, std::wregex(L"[a[=M=]z]",
+                                                 std::regex_constants::basic)));
+        assert(m.size() == 1);
+        assert(!m.prefix().matched);
+        assert(m.prefix().first == s);
+        assert(m.prefix().second == m[0].first);
+        assert(!m.suffix().matched);
+        assert(m.suffix().first == m[0].second);
+        assert(m.suffix().second == m[0].second);
+        assert(m.length(0) >= 0 && static_cast<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"Ch";
+        assert(std::regex_search(s, m, std::wregex(L"[a[.ch.]z]",
+                   std::regex_constants::basic | std::regex_constants::icase)));
+        assert(m.size() == 1);
+        assert(!m.prefix().matched);
+        assert(m.prefix().first == s);
+        assert(m.prefix().second == m[0].first);
+        assert(!m.suffix().matched);
+        assert(m.suffix().first == m[0].second);
+        assert(m.suffix().second == m[0].second);
+        assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<wchar_t>::length(s));
+        assert(m.position(0) == 0);
+        assert(m.str(0) == s);
+    }
+    std::locale::global(std::locale("C"));
+    {
+        std::wcmatch m;
+        const wchar_t s[] = L"m";
+        assert(!std::regex_search(s, m, std::wregex(L"[a[=M=]z]",
+                                                 std::regex_constants::basic)));
+        assert(m.size() == 0);
+    }
+    return 0;
+}

libcxx/test/std/re/re.alg/re.alg.search/basic.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
-// NetBSD does not support LC_COLLATE at the moment
-// XFAIL: netbsd
-
-// REQUIRES: locale.cs_CZ.ISO8859-2
 
 // <regex>
 
 // template <class BidirectionalIterator, class Allocator, class charT, class traits>
 //     bool
 //     regex_search(BidirectionalIterator first, BidirectionalIterator last,
 //                  match_results<BidirectionalIterator, Allocator>& m,
 //                  const basic_regex<charT, traits>& e,
 //                  regex_constants::match_flag_type flags = regex_constants::match_default);
 
-// TODO: investigation needed
-// XFAIL: linux-gnu
-
 #include <regex>
 #include <cassert>
 #include "test_macros.h"
 #include "test_iterators.h"
 
-#include "platform_support.h" // locale name macros
-
 int main(int, char**)
 {
     {
         std::cmatch m;
         assert(!std::regex_search("a", m, std::regex()));
         assert(m.size() == 0);
         assert(m.empty());
     }
int main(int, char**)
     }
     {
         std::cmatch m;
         const char s[] = "m";
         assert(!std::regex_search(s, m, std::regex("[a[.hyphen.]z]",
                                                  std::regex_constants::basic)));
         assert(m.size() == 0);
     }
-    std::locale::global(std::locale(LOCALE_cs_CZ_ISO8859_2));
-    {
-        std::cmatch m;
-        const char s[] = "m";
-        assert(std::regex_search(s, m, std::regex("[a[=M=]z]",
-                                                 std::regex_constants::basic)));
-        assert(m.size() == 1);
-        assert(!m.prefix().matched);
-        assert(m.prefix().first == s);
-        assert(m.prefix().second == m[0].first);
-        assert(!m.suffix().matched);
-        assert(m.suffix().first == m[0].second);
-        assert(m.suffix().second == m[0].second);
-        assert(m.length(0) >= 0 && static_cast<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[] = "Ch";
-        assert(std::regex_search(s, m, std::regex("[a[.ch.]z]",
-                   std::regex_constants::basic | std::regex_constants::icase)));
-        assert(m.size() == 1);
-        assert(!m.prefix().matched);
-        assert(m.prefix().first == s);
-        assert(m.prefix().second == m[0].first);
-        assert(!m.suffix().matched);
-        assert(m.suffix().first == m[0].second);
-        assert(m.suffix().second == m[0].second);
-        assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<char>::length(s));
-        assert(m.position(0) == 0);
-        assert(m.str(0) == s);
-    }
-    std::locale::global(std::locale("C"));
-    {
-        std::cmatch m;
-        const char s[] = "m";
-        assert(!std::regex_search(s, m, std::regex("[a[=M=]z]",
-                                                 std::regex_constants::basic)));
-        assert(m.size() == 0);
-    }
     {
         std::cmatch m;
         const char s[] = "01a45cef9";
         assert(std::regex_search(s, m, std::regex("[ace1-9]*",
                                                  std::regex_constants::basic)));
         assert(m.size() == 1);
         assert(!m.prefix().matched);
         assert(m.prefix().first == s);

     }
     {
         std::wcmatch m;
         const wchar_t s[] = L"m";
         assert(!std::regex_search(s, m, std::wregex(L"[a[.hyphen.]z]",
                                                  std::regex_constants::basic)));
         assert(m.size() == 0);
     }
-    std::locale::global(std::locale(LOCALE_cs_CZ_ISO8859_2));
-    {
-        std::wcmatch m;
-        const wchar_t s[] = L"m";
-        assert(std::regex_search(s, m, std::wregex(L"[a[=M=]z]",
-                                                 std::regex_constants::basic)));
-        assert(m.size() == 1);
-        assert(!m.prefix().matched);
-        assert(m.prefix().first == s);
-        assert(m.prefix().second == m[0].first);
-        assert(!m.suffix().matched);
-        assert(m.suffix().first == m[0].second);
-        assert(m.suffix().second == m[0].second);
-        assert(m.length(0) >= 0 && static_cast<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"Ch";
-        assert(std::regex_search(s, m, std::wregex(L"[a[.ch.]z]",
-                   std::regex_constants::basic | std::regex_constants::icase)));
-        assert(m.size() == 1);
-        assert(!m.prefix().matched);
-        assert(m.prefix().first == s);
-        assert(m.prefix().second == m[0].first);
-        assert(!m.suffix().matched);
-        assert(m.suffix().first == m[0].second);
-        assert(m.suffix().second == m[0].second);
-        assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<wchar_t>::length(s));
-        assert(m.position(0) == 0);
-        assert(m.str(0) == s);
-    }
-    std::locale::global(std::locale("C"));
-    {
-        std::wcmatch m;
-        const wchar_t s[] = L"m";
-        assert(!std::regex_search(s, m, std::wregex(L"[a[=M=]z]",
-                                                 std::regex_constants::basic)));
-        assert(m.size() == 0);
-    }
     {
         std::wcmatch m;
         const wchar_t s[] = L"01a45cef9";
         assert(std::regex_search(s, m, std::wregex(L"[ace1-9]*",
                                                  std::regex_constants::basic)));
         assert(m.size() == 1);
         assert(!m.prefix().matched);
         assert(m.prefix().first == s);

libcxx/test/std/re/re.alg/re.alg.search/ecma.locale.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// NetBSD does not support LC_COLLATE at the moment
+// XFAIL: netbsd
+
+// REQUIRES: locale.cs_CZ.ISO8859-2
+
+// <regex>
+
+// template <class BidirectionalIterator, class Allocator, class charT, class traits>
+//     bool
+//     regex_search(BidirectionalIterator first, BidirectionalIterator last,
+//                  match_results<BidirectionalIterator, Allocator>& m,
+//                  const basic_regex<charT, traits>& e,
+//                  regex_constants::match_flag_type flags = regex_constants::match_default);
+
+// TODO: investigation needed
+// XFAIL: linux-gnu, freebsd
+
+#include <regex>
+#include <cassert>
+#include "test_macros.h"
+#include "test_iterators.h"
+
+#include "platform_support.h" // locale name macros
+
+int main(int, char**)
+{
+    std::locale::global(std::locale(LOCALE_cs_CZ_ISO8859_2));
+    {
+        std::cmatch m;
+        const char s[] = "m";
+        assert(std::regex_search(s, m, std::regex("[a[=M=]z]")));
+        assert(m.size() == 1);
+        assert(!m.prefix().matched);
+        assert(m.prefix().first == s);
+        assert(m.prefix().second == m[0].first);
+        assert(!m.suffix().matched);
+        assert(m.suffix().first == m[0].second);
+        assert(m.suffix().second == m[0].second);
+        assert(m.length(0) >= 0 && static_cast<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[] = "Ch";
+        assert(std::regex_search(s, m, std::regex("[a[.ch.]z]",
+                   std::regex_constants::icase)));
+        assert(m.size() == 1);
+        assert(!m.prefix().matched);
+        assert(m.prefix().first == s);
+        assert(m.prefix().second == m[0].first);
+        assert(!m.suffix().matched);
+        assert(m.suffix().first == m[0].second);
+        assert(m.suffix().second == m[0].second);
+        assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<char>::length(s));
+        assert(m.position(0) == 0);
+        assert(m.str(0) == s);
+    }
+    std::locale::global(std::locale("C"));
+    {
+        std::cmatch m;
+        const char s[] = "m";
+        assert(!std::regex_search(s, m, std::regex("[a[=M=]z]")));
+        assert(m.size() == 0);
+    }
+    std::locale::global(std::locale(LOCALE_cs_CZ_ISO8859_2));
+    {
+        std::wcmatch m;
+        const wchar_t s[] = L"m";
+        assert(std::regex_search(s, m, std::wregex(L"[a[=M=]z]")));
+        assert(m.size() == 1);
+        assert(!m.prefix().matched);
+        assert(m.prefix().first == s);
+        assert(m.prefix().second == m[0].first);
+        assert(!m.suffix().matched);
+        assert(m.suffix().first == m[0].second);
+        assert(m.suffix().second == m[0].second);
+        assert(m.length(0) >= 0 && static_cast<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"Ch";
+        assert(std::regex_search(s, m, std::wregex(L"[a[.ch.]z]",
+                   std::regex_constants::icase)));
+        assert(m.size() == 1);
+        assert(!m.prefix().matched);
+        assert(m.prefix().first == s);
+        assert(m.prefix().second == m[0].first);
+        assert(!m.suffix().matched);
+        assert(m.suffix().first == m[0].second);
+        assert(m.suffix().second == m[0].second);
+        assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<wchar_t>::length(s));
+        assert(m.position(0) == 0);
+        assert(m.str(0) == s);
+    }
+    std::locale::global(std::locale("C"));
+    {
+        std::wcmatch m;
+        const wchar_t s[] = L"m";
+        assert(!std::regex_search(s, m, std::wregex(L"[a[=M=]z]")));
+        assert(m.size() == 0);
+    }
+    return 0;
+}

libcxx/test/std/re/re.alg/re.alg.search/ecma.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
-// NetBSD does not support LC_COLLATE at the moment
-// XFAIL: netbsd
-
-// REQUIRES: locale.cs_CZ.ISO8859-2
 
 // <regex>
 
 // template <class BidirectionalIterator, class Allocator, class charT, class traits>
 //     bool
 //     regex_search(BidirectionalIterator first, BidirectionalIterator last,
 //                  match_results<BidirectionalIterator, Allocator>& m,
 //                  const basic_regex<charT, traits>& e,
 //                  regex_constants::match_flag_type flags = regex_constants::match_default);
 
-// TODO: investigation needed
-// XFAIL: linux-gnu
-
 #include <regex>
 #include <cassert>
 #include "test_macros.h"
 #include "test_iterators.h"
 
-#include "platform_support.h" // locale name macros
-
 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());
int main(int, char**)
         assert(m.str(0) == s);
     }
     {
         std::cmatch m;
         const char s[] = "m";
         assert(!std::regex_search(s, m, std::regex("[a[.hyphen.]z]")));
         assert(m.size() == 0);
     }
-    std::locale::global(std::locale(LOCALE_cs_CZ_ISO8859_2));
-    {
-        std::cmatch m;
-        const char s[] = "m";
-        assert(std::regex_search(s, m, std::regex("[a[=M=]z]")));
-        assert(m.size() == 1);
-        assert(!m.prefix().matched);
-        assert(m.prefix().first == s);
-        assert(m.prefix().second == m[0].first);
-        assert(!m.suffix().matched);
-        assert(m.suffix().first == m[0].second);
-        assert(m.suffix().second == m[0].second);
-        assert(m.length(0) >= 0 && static_cast<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[] = "Ch";
-        assert(std::regex_search(s, m, std::regex("[a[.ch.]z]",
-                   std::regex_constants::icase)));
-        assert(m.size() == 1);
-        assert(!m.prefix().matched);
-        assert(m.prefix().first == s);
-        assert(m.prefix().second == m[0].first);
-        assert(!m.suffix().matched);
-        assert(m.suffix().first == m[0].second);
-        assert(m.suffix().second == m[0].second);
-        assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<char>::length(s));
-        assert(m.position(0) == 0);
-        assert(m.str(0) == s);
-    }
-    std::locale::global(std::locale("C"));
-    {
-        std::cmatch m;
-        const char s[] = "m";
-        assert(!std::regex_search(s, m, std::regex("[a[=M=]z]")));
-        assert(m.size() == 0);
-    }
     {
         std::cmatch m;
         const char s[] = "01a45cef9";
         assert(std::regex_search(s, m, std::regex("[ace1-9]*")));
         assert(m.size() == 1);
         assert(!m.prefix().matched);
         assert(m.prefix().first == s);
         assert(m.prefix().second == m[0].first);

         assert(m.str(0) == s);
     }
     {
         std::wcmatch m;
         const wchar_t s[] = L"m";
         assert(!std::regex_search(s, m, std::wregex(L"[a[.hyphen.]z]")));
         assert(m.size() == 0);
     }
-    std::locale::global(std::locale(LOCALE_cs_CZ_ISO8859_2));
-    {
-        std::wcmatch m;
-        const wchar_t s[] = L"m";
-        assert(std::regex_search(s, m, std::wregex(L"[a[=M=]z]")));
-        assert(m.size() == 1);
-        assert(!m.prefix().matched);
-        assert(m.prefix().first == s);
-        assert(m.prefix().second == m[0].first);
-        assert(!m.suffix().matched);
-        assert(m.suffix().first == m[0].second);
-        assert(m.suffix().second == m[0].second);
-        assert(m.length(0) >= 0 && static_cast<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"Ch";
-        assert(std::regex_search(s, m, std::wregex(L"[a[.ch.]z]",
-                   std::regex_constants::icase)));
-        assert(m.size() == 1);
-        assert(!m.prefix().matched);
-        assert(m.prefix().first == s);
-        assert(m.prefix().second == m[0].first);
-        assert(!m.suffix().matched);
-        assert(m.suffix().first == m[0].second);
-        assert(m.suffix().second == m[0].second);
-        assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<wchar_t>::length(s));
-        assert(m.position(0) == 0);
-        assert(m.str(0) == s);
-    }
-    std::locale::global(std::locale("C"));
-    {
-        std::wcmatch m;
-        const wchar_t s[] = L"m";
-        assert(!std::regex_search(s, m, std::wregex(L"[a[=M=]z]")));
-        assert(m.size() == 0);
-    }
     {
         std::wcmatch m;
         const wchar_t s[] = L"01a45cef9";
         assert(std::regex_search(s, m, std::wregex(L"[ace1-9]*")));
         assert(m.size() == 1);
         assert(!m.prefix().matched);
         assert(m.prefix().first == s);
         assert(m.prefix().second == m[0].first);

libcxx/test/std/re/re.alg/re.alg.search/extended.locale.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// NetBSD does not support LC_COLLATE at the moment
+// XFAIL: netbsd
+
+// REQUIRES: locale.cs_CZ.ISO8859-2
+
+// <regex>
+
+// template <class BidirectionalIterator, class Allocator, class charT, class traits>
+//     bool
+//     regex_search(BidirectionalIterator first, BidirectionalIterator last,
+//                  match_results<BidirectionalIterator, Allocator>& m,
+//                  const basic_regex<charT, traits>& e,
+//                  regex_constants::match_flag_type flags = regex_constants::match_default);
+
+// TODO: investigation needed
+// XFAIL: linux-gnu, freebsd
+
+#include <regex>
+#include <cassert>
+#include "test_macros.h"
+#include "test_iterators.h"
+
+#include "platform_support.h" // locale name macros
+
+int main(int, char**)
+{
+    std::locale::global(std::locale(LOCALE_cs_CZ_ISO8859_2));
+    {
+        std::cmatch m;
+        const char s[] = "m";
+        assert(std::regex_search(s, m, std::regex("[a[=M=]z]",
+                                                 std::regex_constants::extended)));
+        assert(m.size() == 1);
+        assert(!m.prefix().matched);
+        assert(m.prefix().first == s);
+        assert(m.prefix().second == m[0].first);
+        assert(!m.suffix().matched);
+        assert(m.suffix().first == m[0].second);
+        assert(m.suffix().second == m[0].second);
+        assert(m.length(0) >= 0 && static_cast<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[] = "Ch";
+        assert(std::regex_search(s, m, std::regex("[a[.ch.]z]",
+                   std::regex_constants::extended | std::regex_constants::icase)));
+        assert(m.size() == 1);
+        assert(!m.prefix().matched);
+        assert(m.prefix().first == s);
+        assert(m.prefix().second == m[0].first);
+        assert(!m.suffix().matched);
+        assert(m.suffix().first == m[0].second);
+        assert(m.suffix().second == m[0].second);
+        assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<char>::length(s));
+        assert(m.position(0) == 0);
+        assert(m.str(0) == s);
+    }
+    std::locale::global(std::locale("C"));
+    {
+        std::cmatch m;
+        const char s[] = "m";
+        assert(!std::regex_search(s, m, std::regex("[a[=M=]z]",
+                                                 std::regex_constants::extended)));
+        assert(m.size() == 0);
+    }
+    std::locale::global(std::locale(LOCALE_cs_CZ_ISO8859_2));
+    {
+        std::wcmatch m;
+        const wchar_t s[] = L"m";
+        assert(std::regex_search(s, m, std::wregex(L"[a[=M=]z]",
+                                                 std::regex_constants::extended)));
+        assert(m.size() == 1);
+        assert(!m.prefix().matched);
+        assert(m.prefix().first == s);
+        assert(m.prefix().second == m[0].first);
+        assert(!m.suffix().matched);
+        assert(m.suffix().first == m[0].second);
+        assert(m.suffix().second == m[0].second);
+        assert(m.length(0) >= 0 && static_cast<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"Ch";
+        assert(std::regex_search(s, m, std::wregex(L"[a[.ch.]z]",
+                   std::regex_constants::extended | std::regex_constants::icase)));
+        assert(m.size() == 1);
+        assert(!m.prefix().matched);
+        assert(m.prefix().first == s);
+        assert(m.prefix().second == m[0].first);
+        assert(!m.suffix().matched);
+        assert(m.suffix().first == m[0].second);
+        assert(m.suffix().second == m[0].second);
+        assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<wchar_t>::length(s));
+        assert(m.position(0) == 0);
+        assert(m.str(0) == s);
+    }
+    std::locale::global(std::locale("C"));
+    {
+        std::wcmatch m;
+        const wchar_t s[] = L"m";
+        assert(!std::regex_search(s, m, std::wregex(L"[a[=M=]z]",
+                                                 std::regex_constants::extended)));
+        assert(m.size() == 0);
+    }
+    return 0;
+}

libcxx/test/std/re/re.alg/re.alg.search/extended.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
-// NetBSD does not support LC_COLLATE at the moment
-// XFAIL: netbsd
-
-// REQUIRES: locale.cs_CZ.ISO8859-2
 
 // <regex>
 
 // template <class BidirectionalIterator, class Allocator, class charT, class traits>
 //     bool
 //     regex_search(BidirectionalIterator first, BidirectionalIterator last,
 //                  match_results<BidirectionalIterator, Allocator>& m,
 //                  const basic_regex<charT, traits>& e,
 //                  regex_constants::match_flag_type flags = regex_constants::match_default);
 
-// TODO: investigation needed
-// XFAIL: linux-gnu
-
 #include <regex>
 #include <cassert>
 #include "test_macros.h"
 #include "test_iterators.h"
 
-#include "platform_support.h" // locale name macros
-
 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());
int main(int, char**)
     }
     {
         std::cmatch m;
         const char s[] = "m";
         assert(!std::regex_search(s, m, std::regex("[a[.hyphen.]z]",
                                                  std::regex_constants::extended)));
         assert(m.size() == 0);
     }
-    std::locale::global(std::locale(LOCALE_cs_CZ_ISO8859_2));
-    {
-        std::cmatch m;
-        const char s[] = "m";
-        assert(std::regex_search(s, m, std::regex("[a[=M=]z]",
-                                                 std::regex_constants::extended)));
-        assert(m.size() == 1);
-        assert(!m.prefix().matched);
-        assert(m.prefix().first == s);
-        assert(m.prefix().second == m[0].first);
-        assert(!m.suffix().matched);
-        assert(m.suffix().first == m[0].second);
-        assert(m.suffix().second == m[0].second);
-        assert(m.length(0) >= 0 && static_cast<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[] = "Ch";
-        assert(std::regex_search(s, m, std::regex("[a[.ch.]z]",
-                   std::regex_constants::extended | std::regex_constants::icase)));
-        assert(m.size() == 1);
-        assert(!m.prefix().matched);
-        assert(m.prefix().first == s);
-        assert(m.prefix().second == m[0].first);
-        assert(!m.suffix().matched);
-        assert(m.suffix().first == m[0].second);
-        assert(m.suffix().second == m[0].second);
-        assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<char>::length(s));
-        assert(m.position(0) == 0);
-        assert(m.str(0) == s);
-    }
-    std::locale::global(std::locale("C"));
-    {
-        std::cmatch m;
-        const char s[] = "m";
-        assert(!std::regex_search(s, m, std::regex("[a[=M=]z]",
-                                                 std::regex_constants::extended)));
-        assert(m.size() == 0);
-    }
     {
         std::cmatch m;
         const char s[] = "01a45cef9";
         assert(std::regex_search(s, m, std::regex("[ace1-9]*",
                                                  std::regex_constants::extended)));
         assert(m.size() == 1);
         assert(!m.prefix().matched);
         assert(m.prefix().first == s);

     }
     {
         std::wcmatch m;
         const wchar_t s[] = L"m";
         assert(!std::regex_search(s, m, std::wregex(L"[a[.hyphen.]z]",
                                                  std::regex_constants::extended)));
         assert(m.size() == 0);
     }
-    std::locale::global(std::locale(LOCALE_cs_CZ_ISO8859_2));
-    {
-        std::wcmatch m;
-        const wchar_t s[] = L"m";
-        assert(std::regex_search(s, m, std::wregex(L"[a[=M=]z]",
-                                                 std::regex_constants::extended)));
-        assert(m.size() == 1);
-        assert(!m.prefix().matched);
-        assert(m.prefix().first == s);
-        assert(m.prefix().second == m[0].first);
-        assert(!m.suffix().matched);
-        assert(m.suffix().first == m[0].second);
-        assert(m.suffix().second == m[0].second);
-        assert(m.length(0) >= 0 && static_cast<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"Ch";
-        assert(std::regex_search(s, m, std::wregex(L"[a[.ch.]z]",
-                   std::regex_constants::extended | std::regex_constants::icase)));
-        assert(m.size() == 1);
-        assert(!m.prefix().matched);
-        assert(m.prefix().first == s);
-        assert(m.prefix().second == m[0].first);
-        assert(!m.suffix().matched);
-        assert(m.suffix().first == m[0].second);
-        assert(m.suffix().second == m[0].second);
-        assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<wchar_t>::length(s));
-        assert(m.position(0) == 0);
-        assert(m.str(0) == s);
-    }
-    std::locale::global(std::locale("C"));
-    {
-        std::wcmatch m;
-        const wchar_t s[] = L"m";
-        assert(!std::regex_search(s, m, std::wregex(L"[a[=M=]z]",
-                                                 std::regex_constants::extended)));
-        assert(m.size() == 0);
-    }
     {
         std::wcmatch m;
         const wchar_t s[] = L"01a45cef9";
         assert(std::regex_search(s, m, std::wregex(L"[ace1-9]*",
                                                  std::regex_constants::extended)));
         assert(m.size() == 1);
         assert(!m.prefix().matched);
         assert(m.prefix().first == s);

libcxx/utils/libcxx/test/features.py

DEFAULT_FEATURES.append(Feature(name='locale.{}'.format(locale),
                                   when=lambda cfg, alts=alts: hasAnyLocale(cfg, alts)))
 
 
 # Add features representing the platform name: darwin, linux, windows, etc...
 DEFAULT_FEATURES += [
   Feature(name='darwin', when=lambda cfg: '__APPLE__' in compilerMacros(cfg)),
   Feature(name='windows', when=lambda cfg: '_WIN32' in compilerMacros(cfg)),
   Feature(name='linux', when=lambda cfg: '__linux__' in compilerMacros(cfg)),
-  Feature(name='netbsd', when=lambda cfg: '__NetBSD__' in compilerMacros(cfg))
+  Feature(name='netbsd', when=lambda cfg: '__NetBSD__' in compilerMacros(cfg)),
+  Feature(name='freebsd', when=lambda cfg: '__FreeBSD__' in compilerMacros(cfg))
 ]
 
 
 # Detect whether GDB is on the system, and if so add a substitution to access it.
 DEFAULT_FEATURES += [
   Feature(name='host-has-gdb',
     when=lambda cfg: shutil.which('gdb') is not None,
     actions=[AddSubstitution('%{gdb}', lambda cfg: shutil.which('gdb'))]