[libcxx] Portability fix: regex algorithms exceptions made optional.

[amakc11]

Summary

The section r.alg of the standard specifies three regular expressions algorithms: regex_­match, regex_­search and regex_­replace. The preamble section specifies the requirement to optional exception thrown by these algorithms: "The algorithms described in this subclause may throw an exception of type regex_­error". However, the exponential tests for regex_­match and regex_­search consider these exceptions to be mandatory, which makes these tests fail under some conformant implementations. This patch makes the mentioned tests consider these exceptions optional as required by the standard. Additionally, the patch introduces the missing exponential test for regex_­replace algorithm to improve test coverage.

[mclow.lists]

Other than the missing // UNSUPPORTED bits, this looks good to me.
Do you need me to commit this?

test/std/re/re.alg/re.alg.replace/exponential.pass.cpp

11

Needs a // UNSUPPORTED: libcpp-no-exceptions

The other "exponential" tests also have a // UNSUPPORTED: c++98, c++03; but I'm not sure why. Please add it here, and I'll investigate.

[amakc11]

In D57391#1377598, @mclow.lists wrote:

Other than the missing // UNSUPPORTED bits, this looks good to me.
Do you need me to commit this?

Yes. I don't have commit permissions.

The other "exponential" tests also have a // UNSUPPORTED: c++98, c++03; but I'm not sure why.

These other "exponential" tests use std::regex_constants::syntax_option_type introduced in C++11. The new test I added does not use this type and associated constants, so it does not require this UNSUPPORTED directive. Besides, I made this new test consistent with all other tests in the same directory, which do not have UNSUPPORTED: c++98, c++03 for the same reason. However, if you disagree, I will add it along with UNSUPPORTED: libcpp-no-exceptions, but I'd like to now the reason eventually.

[amakc11]

// UNSUPPORTED: libcpp-no-exceptions added. I ran the new test against libc++ in c++98 and c++03 modes once again to make sure it passes. It means that // UNSUPPORTED: c++98, c++03; is not needed for the reason I mentioned in my previous comment.

[mclow.lists]

Committed as revision 352781.

test/std/re/re.alg/re.alg.match/exponential.pass.cpp

 //                  match_results<BidirectionalIterator, Allocator>& m,
 //                  const basic_regex<charT, traits>& e,
 //                  regex_constants::match_flag_type flags = regex_constants::match_default);
 
 // Throw exception after spent too many cycles with respect to the length of the input string.
 
 #include <regex>
 #include <cassert>
+#include "test_macros.h"
 
 int main() {
   for (std::regex_constants::syntax_option_type op :
        {std::regex::ECMAScript, std::regex::extended, std::regex::egrep,
         std::regex::awk}) {
     try {
-      std::regex_match(
+      bool b = std::regex_match(
           "aaaaaaaaaaaaaaaaaaaa",
           std::regex(
               "a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?aaaaaaaaaaaaaaaaaaaa",
               op));
-      assert(false);
+      LIBCPP_ASSERT(false);
+      assert(b);
     } catch (const std::regex_error &e) {
       assert(e.code() == std::regex_constants::error_complexity);
     }
   }
   std::string s(100000, 'a');
   for (std::regex_constants::syntax_option_type op :
        {std::regex::ECMAScript, std::regex::extended, std::regex::egrep,
         std::regex::awk}) {
     assert(std::regex_match(s, std::regex("a*", op)));
   }
   return 0;
 }

test/std/re/re.alg/re.alg.replace/exponential.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>
+// UNSUPPORTED: libcpp-no-exceptions
+
+// template <class OutputIterator, class BidirectionalIterator,
+//           class traits, class charT, class ST, class SA>
+//     OutputIterator
+//     regex_replace(OutputIterator out,
+//                   BidirectionalIterator first, BidirectionalIterator last,
+//                   const basic_regex<charT, traits>& e,
+//                   const basic_string<charT, ST, SA>& fmt,
+//                   regex_constants::match_flag_type flags =
+//                                              regex_constants::match_default);
+
+#include <regex>
+#include <cassert>
+
+#include "test_macros.h"
+
+int main()
+{
+    try {
+        std::regex re("a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?aaaaaaaaaaaaaaaaaaaa");
+        const char s[] = "aaaaaaaaaaaaaaaaaaaa";
+        std::string r = std::regex_replace(s, re, "123-&", std::regex_constants::format_sed);
+        LIBCPP_ASSERT(false);
+        assert(r == "123-aaaaaaaaaaaaaaaaaaaa");
+    } catch (const std::regex_error &e) {
+      assert(e.code() == std::regex_constants::error_complexity);
+    }
+}

test/std/re/re.alg/re.alg.search/exponential.pass.cpp

 //                  match_results<BidirectionalIterator, Allocator>& m,
 //                  const basic_regex<charT, traits>& e,
 //                  regex_constants::match_flag_type flags = regex_constants::match_default);
 
 // Throw exception after spent too many cycles with respect to the length of the input string.
 
 #include <regex>
 #include <cassert>
+#include "test_macros.h"
 
 int main() {
   for (std::regex_constants::syntax_option_type op :
        {std::regex::ECMAScript, std::regex::extended, std::regex::egrep,
         std::regex::awk}) {
     try {
-      std::regex_search(
+      bool b = std::regex_search(
           "aaaaaaaaaaaaaaaaaaaa",
           std::regex(
               "a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?aaaaaaaaaaaaaaaaaaaa",
               op));
-      assert(false);
+      LIBCPP_ASSERT(false);
+      assert(b);
     } catch (const std::regex_error &e) {
       assert(e.code() == std::regex_constants::error_complexity);
     }
   }
   std::string s(100000, 'a');
   for (std::regex_constants::syntax_option_type op :
        {std::regex::ECMAScript, std::regex::extended, std::regex::egrep,
         std::regex::awk}) {
     assert(std::regex_search(s, std::regex("a*", op)));
   }
   return 0;
 }