Protect smart-pointer tests under no exceptions

[rogfer01]

Summary

Skip tests that expect an exception be thrown under no-exceptions.

[rmaprath]

LGTM.

[rogfer01]

Ping? :)

test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/unique_ptr.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
 // UNSUPPORTED: sanitizer-new-delete
 
 // <memory>
 
 // template <class Y, class D> explicit shared_ptr(unique_ptr<Y, D>&&r);
 
 #include <memory>
 #include <new>
int main()
         A* raw_ptr = ptr.get();
         std::shared_ptr<B> p(std::move(ptr));
         assert(A::count == 1);
         assert(B::count == 1);
         assert(p.use_count() == 1);
         assert(p.get() == raw_ptr);
         assert(ptr.get() == 0);
     }
+#ifndef TEST_HAS_NO_EXCEPTIONS
     assert(A::count == 0);
     {
         std::unique_ptr<A> ptr(new A);
         A* raw_ptr = ptr.get();
         globalMemCounter.throw_after = 0;
         try
         {
             std::shared_ptr<B> p(std::move(ptr));
             assert(false);
         }
         catch (...)
         {
 #if TEST_STD_VER >= 11
             assert(A::count == 1);
             assert(B::count == 1);
             assert(ptr.get() == raw_ptr);
 #else
             assert(A::count == 0);
             assert(B::count == 0);
             assert(ptr.get() == 0);
 #endif
         }
     }
+#endif
     assert(A::count == 0);
     { // LWG 2399
         fn(std::unique_ptr<int>(new int));
     }
 #if TEST_STD_VER >= 14
     { // LWG 2415
         std::unique_ptr<int, void (*)(int*)> p(nullptr, assert_deleter<int>);
         std::shared_ptr<int> p2(std::move(p)); // should not call deleter when going out of scope
     }
 #endif
 }

test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/weak_ptr.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
 // <memory>
 
 // shared_ptr
 
 // template<class Y> explicit shared_ptr(const weak_ptr<Y>& r);
 
 #include <memory>
 #include <cassert>
 
+#include "test_macros.h"
+
 struct B
 {
     static int count;
 
     B() {++count;}
     B(const B&) {++count;}
     virtual ~B() {--count;}
 };
struct A
     A(const A&) {++count;}
     ~A() {--count;}
 };
 
 int A::count = 0;
 
 int main()
 {
+#ifndef TEST_HAS_NO_EXCEPTIONS
     {
         std::weak_ptr<A> wp;
         try
         {
             std::shared_ptr<A> sp(wp);
             assert(false);
         }
         catch (std::bad_weak_ptr&)
         {
         }
         assert(A::count == 0);
     }
+#endif
     {
         std::shared_ptr<A> sp0(new A);
         std::weak_ptr<A> wp(sp0);
         std::shared_ptr<A> sp(wp);
         assert(sp.use_count() == 2);
         assert(sp.get() == sp0.get());
         assert(A::count == 1);
     }
     assert(A::count == 0);
+#ifndef TEST_HAS_NO_EXCEPTIONS
     {
         std::shared_ptr<A> sp0(new A);
         std::weak_ptr<A> wp(sp0);
         sp0.reset();
         try
         {
             std::shared_ptr<A> sp(wp);
             assert(false);
         }
         catch (std::bad_weak_ptr&)
         {
         }
     }
     assert(A::count == 0);
+#endif
 }