Protect nested-exceptions tests under no-exceptions

[rogfer01]

Summary

Skip tests that expect an exception be thrown.

[rmaprath]

Not sure if either of these tests add much value to the no-exceptions variant, using std::nested_exception with such a library seem pointless to me. Perhaps marking these as UNSUPPORTED is a better fix?

[rmaprath]

In D26458#590865, @rmaprath wrote:

Not sure if either of these tests add much value to the no-exceptions variant, using std::nested_exception with such a library seem pointless to me. Perhaps marking these as UNSUPPORTED is a better fix?

Also, it seems like we are saving the same assert in all the three tests. If we want to save it that badly, perhaps creating a new test case with a REQUIRES: libcpp-no-exceptions is a better fix.

[rogfer01]

@rmaprath well each case is testing a different special member: the assignment operator, the copy constructor and the default constructor. My feeling is that at least the non-throwing part must be tested under no-exceptions. But I understand, that this class is probably useless in the context of no-exceptions.

[EricWF]

In D26458#590865, @rmaprath wrote:

Not sure if either of these tests add much value to the no-exceptions variant, using std::nested_exception with such a library seem pointless to me. Perhaps marking these as UNSUPPORTED is a better fix?

There are cases where it is useful to be able to name std::nested_exception while exceptions are disabled. I agree with @rogfer01 on this patch.

[rmaprath]

In D26458#594069, @EricWF wrote:

There are cases where it is useful to be able to name std::nested_exception while exceptions are disabled.

I was thinking about the opposite. That is, we might want to consider disabling the <exception> header altogether when compiling with -fno-exceptions. My particular use case is to do with futures:

void make_hello(std::promise<std::string> &p, bool set_exception) {
  if (set_exception)
    p.set_exception(std::make_exception_ptr(
         std::runtime_error {"No hellos left."}));
  else
    p.set_value("Hello world!");
}

This will compile fine with -fno-exceptions and when the client thread attempts to read from the promise, whole program would crash. May be they deserve it, but I feel like it's something we can help with; if we disable the <exception> header, this code wouldn't compile under -fno-exceptions.

In what cases do we need to allow various exception types under -fno-exceptions?

Cheers,

/ Asiri

[rmaprath]

On the other hand, disabling <exception> would mean disabling some parts of the library as well (in this case, std::promise::set_exception). Perhaps that's a bad path to follow. Not sure.

libcxx/trunk/test/std/language.support/support.exception/except.nested/assign.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
 // <exception>
 
 // class nested_exception;
 
 // nested_exception& operator=(const nested_exception&) throw() = default;
 
 #include <exception>
 #include <cassert>
 
+#include "test_macros.h"
+
 class A
 {
     int data_;
 public:
     explicit A(int data) : data_(data) {}
 
     friend bool operator==(const A& x, const A& y) {return x.data_ == y.data_;}
 };
 
 int main()
 {
     {
         std::nested_exception e0;
         std::nested_exception e;
         e = e0;
         assert(e.nested_ptr() == nullptr);
     }
+#ifndef TEST_HAS_NO_EXCEPTIONS
     {
         try
         {
             throw A(2);
             assert(false);
         }
         catch (const A&)
         {
             std::nested_exception e0;
             std::nested_exception e;
             e = e0;
             assert(e.nested_ptr() != nullptr);
             try
             {
                 rethrow_exception(e.nested_ptr());
                 assert(false);
             }
             catch (const A& a)
             {
                 assert(a == A(2));
             }
         }
     }
+#endif
 }

libcxx/trunk/test/std/language.support/support.exception/except.nested/ctor_copy.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
 // <exception>
 
 // class nested_exception;
 
 // nested_exception(const nested_exception&) throw() = default;
 
 #include <exception>
 #include <cassert>
 
+#include "test_macros.h"
+
 class A
 {
     int data_;
 public:
     explicit A(int data) : data_(data) {}
 
     friend bool operator==(const A& x, const A& y) {return x.data_ == y.data_;}
 };
 
 int main()
 {
     {
         std::nested_exception e0;
         std::nested_exception e = e0;
         assert(e.nested_ptr() == nullptr);
     }
+#ifndef TEST_HAS_NO_EXCEPTIONS
     {
         try
         {
             throw A(2);
             assert(false);
         }
         catch (const A&)
         {
             std::nested_exception e0;
             std::nested_exception e = e0;
             assert(e.nested_ptr() != nullptr);
             try
             {
                 rethrow_exception(e.nested_ptr());
                 assert(false);
             }
             catch (const A& a)
             {
                 assert(a == A(2));
             }
         }
     }
+#endif
 }

libcxx/trunk/test/std/language.support/support.exception/except.nested/ctor_default.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
 // <exception>
 
 // class nested_exception;
 
 // nested_exception() throw();
 
 #include <exception>
 #include <cassert>
 
+#include "test_macros.h"
+
 class A
 {
     int data_;
 public:
     explicit A(int data) : data_(data) {}
 
     friend bool operator==(const A& x, const A& y) {return x.data_ == y.data_;}
 };
 
 int main()
 {
     {
         std::nested_exception e;
         assert(e.nested_ptr() == nullptr);
     }
+#ifndef TEST_HAS_NO_EXCEPTIONS
     {
         try
         {
             throw A(2);
             assert(false);
         }
         catch (const A&)
         {
             std::nested_exception e;
             assert(e.nested_ptr() != nullptr);
             try
             {
                 rethrow_exception(e.nested_ptr());
                 assert(false);
             }
             catch (const A& a)
             {
                 assert(a == A(2));
             }
         }
     }
+#endif
 }