Protect sequences test under libcpp-no-exceptions

[rogfer01]

Summary

Replace throw with TEST_THROW and protect tests that do throw. Also add missing assert(false).

[mclow.lists]

LGTM>

libcxx/trunk/test/std/containers/sequences/list/list.modifiers/insert_iter_size_value.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
 // <list>
 
 // iterator insert(const_iterator position, size_type n, const value_type& x);
 
 // UNSUPPORTED: sanitizer-new-delete
 
 #include <list>
 #include <cstdlib>
 #include <cassert>
 
 #include "min_allocator.h"
 #include "count_new.hpp"
+#include "test_macros.h"
 
 template <class List>
 void test() {
     int a1[] = {1, 2, 3};
     int a2[] = {1, 4, 4, 4, 4, 4, 2, 3};
     List l1(a1, a1+3);
     typename List::iterator i = l1.insert(next(l1.cbegin()), 5, 4);
     assert(i == next(l1.begin()));
     assert(l1 == List(a2, a2+8));
+#ifndef TEST_HAS_NO_EXCEPTIONS
     globalMemCounter.throw_after = 4;
     int save_count = globalMemCounter.outstanding_new;
     try
     {
         i = l1.insert(i, 5, 5);
         assert(false);
     }
     catch (...)
     {
     }
     assert(globalMemCounter.checkOutstandingNewEq(save_count));
     assert(l1 == List(a2, a2+8));
+#endif
 }
 
 int main()
 {
     test<std::list<int> >();
 #if TEST_STD_VER >= 11
     test<std::list<int, min_allocator<int>>>();
 #endif
 }

libcxx/trunk/test/std/containers/sequences/vector/vector.modifiers/push_back_exception_safety.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
 // <vector>
 
 // void push_back(const value_type& x);
 
 #include <vector>
 #include <cassert>
 
 #include "asan_testing.h"
+#include "test_macros.h"
 
 // Flag that makes the copy constructor for CMyClass throw an exception
-static bool gCopyConstructorShouldThow = false;
-
+static bool gCopyConstructorShouldThrow = false;
 
 class CMyClass {
     public: CMyClass(int tag);
     public: CMyClass(const CMyClass& iOther);
     public: ~CMyClass();
 
     bool equal(const CMyClass &rhs) const
         { return fTag == rhs.fTag && fMagicValue == rhs.fMagicValue; }
CMyClass::CMyClass(int tag) :
     // Signal that the constructor has finished running
     fMagicValue = kFinishedConstructionMagicValue;
 }
 
 CMyClass::CMyClass(const CMyClass& iOther) :
     fMagicValue(kStartedConstructionMagicValue), fTag(iOther.fTag)
 {
     // If requested, throw an exception _before_ setting fMagicValue to kFinishedConstructionMagicValue
-    if (gCopyConstructorShouldThow) {
-        throw std::exception();
+    if (gCopyConstructorShouldThrow) {
+        TEST_THROW(std::exception());
     }
     // Signal that the constructor has finished running
     fMagicValue = kFinishedConstructionMagicValue;
 }
 
 CMyClass::~CMyClass() {
     // Only instances for which the constructor has finished running should be destructed
     assert(fMagicValue == kFinishedConstructionMagicValue);
 }
 
 bool operator==(const CMyClass &lhs, const CMyClass &rhs) { return lhs.equal(rhs); }
 
 int main()
 {
     CMyClass instance(42);
     std::vector<CMyClass> vec;
 
     vec.push_back(instance);
     std::vector<CMyClass> vec2(vec);
     assert(is_contiguous_container_asan_correct(vec));
     assert(is_contiguous_container_asan_correct(vec2));
 
-    gCopyConstructorShouldThow = true;
+#ifndef TEST_HAS_NO_EXCEPTIONS
+    gCopyConstructorShouldThrow = true;
     try {
         vec.push_back(instance);
+        assert(false);
     }
     catch (...) {
         assert(vec==vec2);
         assert(is_contiguous_container_asan_correct(vec));
     }
+#endif
 }