[libc++][CI][AIX] modify the equivalence classes of regex_match for locale "cs_CZ.ISO8859-2"

[DiggerLin]

Summary

1. AIX supports character equivalence classes. What the contents of the class are depends on the locale and the standards do not specify any locale other than C/POSIX.
2. add if define(_AIX) to exclude "regex_match do not support Collating Elements: [[.ch.]] for wchar_t" and need further investigation.

[ldionne]

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

39–40

Even after reading the comment, I don't really understand why it needs to be [=m=] on AIX and [=M=] elsewhere. Can you explain?

[Mordante]

We're moving to GitHub PRs and we like to clean up our review queue. Are you still interested in working on this patch? If not please abandon it.

[DiggerLin]

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

39–40

in the C/POSIX , it define "An equivalence class includes both the lowercase and uppercase versions of a character in the class."

https://www.datafix.com.au/BASHing/2020-06-17.html#:~:text=An%20equivalence%20class%20includes%20both,a%20character%20in%20the%20class.&text=As%20it%20says%20in%20the,range%20expression%20produces%20unspecified%20results.

so [=m=] and [=M=] will has the same set of characters in the C/POSIX .

but in AIX, the specific not define "the [=m=] and [=M=] will has the same set of characters ."

[DiggerLin]

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

39–40

@ldionne

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
-// XFAIL: LIBCXX-AIX-FIXME
 
 // REQUIRES: locale.cs_CZ.ISO8859-2
 
 // <regex>
 
 // template <class BidirectionalIterator, class Allocator, class charT, class traits>
 //     bool
 //     regex_match(BidirectionalIterator first, BidirectionalIterator last,

 #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";
+// AIX supports character equivalence classes. What the contents of the class are depends
+// on the locale and the standards do not specify any locale other than C/POSIX.
+#if defined(_AIX)
+        assert(std::regex_match(s, m, std::regex("[a[=m=]z]",
+                                                 std::regex_constants::basic)));
+#else
         assert(std::regex_match(s, m, std::regex("[a[=M=]z]",
                                                  std::regex_constants::basic)));
+#endif
         assert(m.size() == 1);
         assert(!m.prefix().matched);
         assert(m.prefix().first == s);
         assert(m.prefix().second == m[0].first);
         assert(!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));
std::locale::global(std::locale("C"));
         assert(m.size() == 0);
     }
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
     std::locale::global(std::locale(LOCALE_cs_CZ_ISO8859_2));
     {
         std::wcmatch m;
         const wchar_t s[] = L"m";
+#if defined(_AIX)
+        assert(std::regex_match(s, m, std::wregex(L"[a[=m=]z]",
+                                                 std::regex_constants::basic)));
+#else
         assert(std::regex_match(s, m, std::wregex(L"[a[=M=]z]",
                                                  std::regex_constants::basic)));
+#endif
         assert(m.size() == 1);
         assert(!m.prefix().matched);
         assert(m.prefix().first == s);
         assert(m.prefix().second == m[0].first);
         assert(!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);
     }
+//TODO: Need to be investigated for AIX OS
+#if !defined(_AIX)
     {
         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);
     }
+#endif
     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);
     }
 #endif // TEST_HAS_NO_WIDE_CHARACTERS
 
     return 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
-// XFAIL: LIBCXX-AIX-FIXME
 
 // REQUIRES: locale.cs_CZ.ISO8859-2
 
 // <regex>
 
 // template <class BidirectionalIterator, class Allocator, class charT, class traits>
 //     bool
 //     regex_match(BidirectionalIterator first, BidirectionalIterator last,

 #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";
+// AIX supports character equivalence classes. What the contents of the class are depends
+// on the locale and the standards do not specify any locale other than C/POSIX.
+#if defined(_AIX)
+        assert(std::regex_match(s, m, std::regex("[a[=m=]z]")));
+#else
         assert(std::regex_match(s, m, std::regex("[a[=M=]z]")));
+#endif
         assert(m.size() == 1);
         assert(!m.prefix().matched);
         assert(m.prefix().first == s);
         assert(m.prefix().second == m[0].first);
         assert(!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));
std::locale::global(std::locale("C"));
         assert(m.size() == 0);
     }
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
     std::locale::global(std::locale(LOCALE_cs_CZ_ISO8859_2));
     {
         std::wcmatch m;
         const wchar_t s[] = L"m";
+#if defined(_AIX)
+        assert(std::regex_match(s, m, std::wregex(L"[a[=m=]z]")));
+#else
         assert(std::regex_match(s, m, std::wregex(L"[a[=M=]z]")));
+#endif
         assert(m.size() == 1);
         assert(!m.prefix().matched);
         assert(m.prefix().first == s);
         assert(m.prefix().second == m[0].first);
         assert(!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);
     }
+//TODO: Need to be investigated for AIX OS
+#if !defined(_AIX)
     {
         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);
     }
+#endif
     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);
     }
 #endif // TEST_HAS_NO_WIDE_CHARACTERS
 
     return 0;
 }

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
-// XFAIL: LIBCXX-AIX-FIXME
 
 // REQUIRES: locale.cs_CZ.ISO8859-2
 
 // <regex>
 
 // template <class BidirectionalIterator, class Allocator, class charT, class traits>
 //     bool
 //     regex_match(BidirectionalIterator first, BidirectionalIterator last,

 #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";
+// AIX supports character equivalence classes. What the contents of the class are depends
+// on the locale and the standards do not specify any locale other than C/POSIX.
+#if defined(_AIX)
+        assert(std::regex_match(s, m, std::regex("[a[=m=]z]",
+                                                 std::regex_constants::extended)));
+#else
         assert(std::regex_match(s, m, std::regex("[a[=M=]z]",
                                                  std::regex_constants::extended)));
+#endif
         assert(m.size() == 1);
         assert(!m.prefix().matched);
         assert(m.prefix().first == s);
         assert(m.prefix().second == m[0].first);
         assert(!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));
std::locale::global(std::locale("C"));
         assert(m.size() == 0);
     }
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
     std::locale::global(std::locale(LOCALE_cs_CZ_ISO8859_2));
     {
         std::wcmatch m;
         const wchar_t s[] = L"m";
+#if defined(_AIX)
+        assert(std::regex_match(s, m, std::wregex(L"[a[=m=]z]",
+                                                 std::regex_constants::extended)));
+#else
         assert(std::regex_match(s, m, std::wregex(L"[a[=M=]z]",
                                                  std::regex_constants::extended)));
+#endif
         assert(m.size() == 1);
         assert(!m.prefix().matched);
         assert(m.prefix().first == s);
         assert(m.prefix().second == m[0].first);
         assert(!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);
     }
+//TODO: Need to be investigated for AIX OS
+#if !defined(_AIX)
     {
         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);
     }
+#endif
     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);
     }
 #endif // TEST_HAS_NO_WIDE_CHARACTERS
 
     return 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
-// XFAIL: LIBCXX-AIX-FIXME
 
 // REQUIRES: locale.cs_CZ.ISO8859-2
 
 // <regex>
 
 // template <class BidirectionalIterator, class Allocator, class charT, class traits>
 //     bool
 //     regex_search(BidirectionalIterator first, BidirectionalIterator last,

 #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";
+// AIX supports character equivalence classes. What the contents of the class are depends
+// on the locale and the standards do not specify any locale other than C/POSIX.
+#if defined(_AIX)
+        assert(std::regex_search(s, m, std::regex("[a[=m=]z]",
+                                                 std::regex_constants::awk)));
+#else
         assert(std::regex_search(s, m, std::regex("[a[=M=]z]",
                                                  std::regex_constants::awk)));
+#endif
         assert(m.size() == 1);
         assert(!m.prefix().matched);
         assert(m.prefix().first == s);
         assert(m.prefix().second == m[0].first);
         assert(!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));
std::locale::global(std::locale("C"));
         assert(m.size() == 0);
     }
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
     std::locale::global(std::locale(LOCALE_cs_CZ_ISO8859_2));
     {
         std::wcmatch m;
         const wchar_t s[] = L"m";
+#if defined(_AIX)
+        assert(std::regex_search(s, m, std::wregex(L"[a[=m=]z]",
+                                                 std::regex_constants::awk)));
+#else
         assert(std::regex_search(s, m, std::wregex(L"[a[=M=]z]",
                                                  std::regex_constants::awk)));
+#endif
         assert(m.size() == 1);
         assert(!m.prefix().matched);
         assert(m.prefix().first == s);
         assert(m.prefix().second == m[0].first);
         assert(!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);
     }
+//TODO: Need to be investigated for AIX OS
+#if !defined(_AIX)
     {
         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);
     }
+#endif
     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);
     }
 #endif // TEST_HAS_NO_WIDE_CHARACTERS
 
     return 0;
 }

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
-// XFAIL: LIBCXX-AIX-FIXME
 
 // REQUIRES: locale.cs_CZ.ISO8859-2
 
 // <regex>
 
 // template <class BidirectionalIterator, class Allocator, class charT, class traits>
 //     bool
 //     regex_search(BidirectionalIterator first, BidirectionalIterator last,

 #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";
+// AIX supports character equivalence classes. What the contents of the class are depends
+// on the locale and the standards do not specify any locale other than C/POSIX.
+#if defined(_AIX)
+        assert(std::regex_search(s, m, std::regex("[a[=m=]z]",
+                                                 std::regex_constants::basic)));
+#else
         assert(std::regex_search(s, m, std::regex("[a[=M=]z]",
                                                  std::regex_constants::basic)));
+#endif
         assert(m.size() == 1);
         assert(!m.prefix().matched);
         assert(m.prefix().first == s);
         assert(m.prefix().second == m[0].first);
         assert(!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));
std::locale::global(std::locale("C"));
         assert(m.size() == 0);
     }
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
     std::locale::global(std::locale(LOCALE_cs_CZ_ISO8859_2));
     {
         std::wcmatch m;
         const wchar_t s[] = L"m";
+#if defined(_AIX)
+        assert(std::regex_search(s, m, std::wregex(L"[a[=m=]z]",
+                                                 std::regex_constants::basic)));
+#else
         assert(std::regex_search(s, m, std::wregex(L"[a[=M=]z]",
                                                  std::regex_constants::basic)));
+#endif
         assert(m.size() == 1);
         assert(!m.prefix().matched);
         assert(m.prefix().first == s);
         assert(m.prefix().second == m[0].first);
         assert(!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);
     }
+//TODO: Need to be investigated for AIX OS
+#if !defined(_AIX)
     {
         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);
     }
+#endif
     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);
     }
 #endif // TEST_HAS_NO_WIDE_CHARACTERS
 
     return 0;
 }

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
-// XFAIL: LIBCXX-AIX-FIXME
 
 // REQUIRES: locale.cs_CZ.ISO8859-2
 
 // <regex>
 
 // template <class BidirectionalIterator, class Allocator, class charT, class traits>
 //     bool
 //     regex_search(BidirectionalIterator first, BidirectionalIterator last,

 #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";
+// AIX supports character equivalence classes. What the contents of the class are depends
+// on the locale and the standards do not specify any locale other than C/POSIX.
+#if defined(_AIX)
+        assert(std::regex_search(s, m, std::regex("[a[=m=]z]")));
+#else
         assert(std::regex_search(s, m, std::regex("[a[=M=]z]")));
+#endif
         assert(m.size() == 1);
         assert(!m.prefix().matched);
         assert(m.prefix().first == s);
         assert(m.prefix().second == m[0].first);
         assert(!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));
std::locale::global(std::locale("C"));
         assert(m.size() == 0);
     }
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
     std::locale::global(std::locale(LOCALE_cs_CZ_ISO8859_2));
     {
         std::wcmatch m;
         const wchar_t s[] = L"m";
+#if defined(_AIX)
+        assert(std::regex_search(s, m, std::wregex(L"[a[=m=]z]")));
+#else
         assert(std::regex_search(s, m, std::wregex(L"[a[=M=]z]")));
+#endif
         assert(m.size() == 1);
         assert(!m.prefix().matched);
         assert(m.prefix().first == s);
         assert(m.prefix().second == m[0].first);
         assert(!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);
     }
+//TODO: Need to be investigated for AIX OS
+#if !defined(_AIX)
     {
         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);
     }
+#endif
     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);
     }
 #endif // TEST_HAS_NO_WIDE_CHARACTERS
 
     return 0;
 }

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
-// XFAIL: LIBCXX-AIX-FIXME
 
 // REQUIRES: locale.cs_CZ.ISO8859-2
 
 // <regex>
 
 // template <class BidirectionalIterator, class Allocator, class charT, class traits>
 //     bool
 //     regex_search(BidirectionalIterator first, BidirectionalIterator last,

 #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";
+// AIX supports character equivalence classes. What the contents of the class are depends
+// on the locale and the standards do not specify any locale other than C/POSIX.
+#if defined(_AIX)
+        assert(std::regex_search(s, m, std::regex("[a[=m=]z]",
+                                                 std::regex_constants::extended)));
+#else
         assert(std::regex_search(s, m, std::regex("[a[=M=]z]",
                                                  std::regex_constants::extended)));
+#endif
         assert(m.size() == 1);
         assert(!m.prefix().matched);
         assert(m.prefix().first == s);
         assert(m.prefix().second == m[0].first);
         assert(!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));
std::locale::global(std::locale("C"));
         assert(m.size() == 0);
     }
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
     std::locale::global(std::locale(LOCALE_cs_CZ_ISO8859_2));
     {
         std::wcmatch m;
         const wchar_t s[] = L"m";
+#if defined(_AIX)
+        assert(std::regex_search(s, m, std::wregex(L"[a[=m=]z]",
+                                                 std::regex_constants::extended)));
+#else
         assert(std::regex_search(s, m, std::wregex(L"[a[=M=]z]",
                                                  std::regex_constants::extended)));
+#endif
         assert(m.size() == 1);
         assert(!m.prefix().matched);
         assert(m.prefix().first == s);
         assert(m.prefix().second == m[0].first);
         assert(!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);
     }
+//TODO: Need to be investigated for AIX OS
+#if !defined(_AIX)
     {
         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);
     }
+#endif
     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);
     }
 #endif // TEST_HAS_NO_WIDE_CHARACTERS
 
     return 0;
 }

libcxx/test/std/re/re.traits/lookup_collatename.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
-// XFAIL: LIBCXX-AIX-FIXME
 
 // REQUIRES: locale.cs_CZ.ISO8859-2
 
 // <regex>
 
 // template <class charT> struct regex_traits;
 
 // template <class ForwardIterator>
#ifndef TEST_HAS_NO_WIDE_CHARACTERS
     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""));
+
+//TODO: Need to be investigated for AIX OS
+#if !defined(_AIX)
     std::locale::global(std::locale(LOCALE_cs_CZ_ISO8859_2));
     test(L"ch", std::wstring(L"ch"));
+#endif
+
     std::locale::global(std::locale("C"));
 #endif // TEST_HAS_NO_WIDE_CHARACTERS
 
   return 0;
 }