[libcxx] Recover no-exceptions XFAILs

[rmaprath]

Summary

When we added support for the no-exceptions build of libc++, all the tests that used exceptions got a blanket XFAIL for the no-exceptions variety.

Previously, we tried to fix-up these tests with an elaborate setjmp/longjmp hackery (see D14653), which was rejected on the grounds of being too complicated / obtrusive.

The current patch is a representative fix that does the most obvious thing instead: use pre-processor macros to exclude just the bits of the test that use exceptions. Unlike in the previous patch, this means we are not trying to associate / verify a particular behaviour of the no-exceptions library with respect to exceptional situations (like calling abort). Here we simply save the parts of the test that has nothing to do with exceptions, I think this is a fair compromise.

We could also split the test file into two; one that uses exceptions and one that does not, though I can't think of any added benefits of that approach.

If this patch is approved I'll go ahead and update the rest of the tests (~150) to follow the same.

[rmaprath]

(Added more context)

[mclow.lists]

What an awful test. I wonder who wrote such a steaming pile. Probably me.

[rmaprath]

In D24562#542630, @mclow.lists wrote:

What an awful test. I wonder who wrote such a steaming pile. Probably me.

I think I've thrown quite a lot of XFAILs like this in the past, just to get the no-exceptions build passing. Now I've got to clean them up one by one :)

Are you OK with this way of fixing them?

Cheers,

/ Asiri

[EricWF]

This approach looks great. I don't think we need to split things up into separate files. This is exactly how test_macros.h should be used.

Feel free to convert as many tests as possible. I've been doing the same to anything I work on.

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

25

I prefer putting the #if on the inside of the function so you don't also have to #ifdef it out in main() below.

[rmaprath]

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

25

Thanks. That's much better.

I'll convert as much tests as possible and submit and overall patch for a final review.

[Eugene.Zelenko]

Looks like patch was not committed.

[rmaprath]

In D24562#561442, @Eugene.Zelenko wrote:

Looks like patch was not committed.

Need to replicate this to as many tests as possible (~150). I was hoping to do all that and upload another diff for a final review, couldn't get to it I'm afraid. Hope to do this very very soon.

Sorry for the delay.

/ Asiri

[EricWF]

Feel free to send them in 10-20 at a time. It'll be much faster to review that way.

[rmaprath]

First batch of XFAIL fixes.

I've changed some XFAILs to UNSUPPORTED where the test is all about exception handling. In other cases, I've used the test macro TEST_HAS_NO_EXCEPTIONS to conditionally exclude those parts that test
exception handling behaviour.

@EricWF: I can create a separate review if necessary, thought I'll re-use this review for the first batch, will be opening new reviews for the follow-ups.

/ Asiri

[EricWF]

In D24562#562339, @rmaprath wrote:

First batch of XFAIL fixes.

I've changed some XFAILs to UNSUPPORTED where the test is all about exception handling. In other cases, I've used the test macro TEST_HAS_NO_EXCEPTIONS to conditionally exclude those parts that test
exception handling behaviour.

The changes look great! Thanks for the patch.

The only suggestion I have is using TEST_THROW to guard a single throw statement. TEST_THROW will abort if it's executed in a no-exceptions build, which is better than silently passing over code that should throw. See the inline comments for example usage.

@EricWF: I can create a separate review if necessary, thought I'll re-use this review for the first batch, will be opening new reviews for the follow-ups.

Sounds good to me. This batch LGTM but I can't re-approve this review. Please commit w/ requested inline changes and then close this revision.

/ Asiri

test/std/thread/futures/futures.async/async.pass.cpp

76 ↗

(On Diff #73661)

To guard a single throw x; consider using TEST_THROW(x). This way the test will abort ungracefully if it tries to evaluate a throw at runtime.

test/std/thread/futures/futures.promise/move_ctor.pass.cpp

23 ↗

(On Diff #73661)

Nit: I prefer including test_macros.h as the first support header.

test/std/thread/futures/futures.promise/set_value_const.pass.cpp

28 ↗

(On Diff #73661)

Nit: Use TEST_THROW

test/std/thread/thread.threads/thread.thread.class/thread.thread.constr/F.pass.cpp

36 ↗

(On Diff #73661)

Nit: TEST_THROW

[rmaprath]

Final patch to be committed, with all the remaining comments addressed.

[rmaprath]

Committed as r283441.

Thanks!

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

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-// XFAIL: libcpp-no-exceptions
 // <regex>
 
 // template <class BidirectionalIterator, class Allocator, class charT, class traits>
 //     bool
 //     regex_search(BidirectionalIterator first, BidirectionalIterator last,
 //                  match_results<BidirectionalIterator, Allocator>& m,
 //                  const basic_regex<charT, traits>& e,
 //                  regex_constants::match_flag_type flags = regex_constants::match_default);
 
 #include <regex>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 
+#ifndef TEST_HAS_NO_EXCEPTIONS
 extern "C" void LLVMFuzzerTestOneInput(const char *data)
 {
     size_t size = strlen(data);
     if (size > 0)
     {
         try
         {
             std::regex::flag_type flag = std::regex_constants::grep;
             std::string s((const char *)data, size);
             std::regex re(s, flag);
             std::regex_match(s, re);
         }
         catch (std::regex_error &) {}
     }
 }
 
 
 void fuzz_tests()  // patterns that the fuzzer has found
 {
 // Raw string literals are a C++11 feature.
 #if TEST_STD_VER >= 11
     LLVMFuzzerTestOneInput(R"XX(Õ)␕_%()()((\8'␕_%()␕_%()␕_%()␕_%(()␕_%()␕_%()␕_%(.t;)()␕¥f␕()␕_%()(.)␕_%;)()␕!¥f(((()␕()XX");
 #endif
 }
+#endif
 
 int main()
 {
     {
         std::cmatch m;
         const char s[] = "tournament";
         assert(std::regex_search(s, m, std::regex("tour\nto\ntournament",
                 std::regex_constants::grep)));
int main()
         assert(m.prefix().second == m[0].first);
         assert(m.suffix().matched);
         assert(m.suffix().first == m[0].second);
         assert(m.suffix().second == s + std::char_traits<char>::length(s));
         assert(m.length(0) == 0);
         assert(m.position(0) == 0);
         assert(m.str(0) == "");
     }
+#ifndef TEST_HAS_NO_EXCEPTIONS
     fuzz_tests();
+#endif
 }