Protect tests for std::uninitialized_{copy,fill} under libcpp-no-exceptions

[rogfer01]

Summary

Skip tests that expect an exception be thrown.

[rogfer01]

Ping? :)

[jmolloy]

Hi,

This looks fairly obviously correct to me, but perhaps someone more familiar with libcxx should look too: Asiri?

James

test/std/utilities/memory/specialized.algorithms/uninitialized.copy/uninitialized_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
 // <memory>
 
 // template <class InputIterator, class ForwardIterator>
 //   ForwardIterator
 //   uninitialized_copy(InputIterator first, InputIterator last,
 //                      ForwardIterator result);
 
 #include <memory>
 #include <cassert>
 
+#include "test_macros.h"
+
 struct B
 {
     static int count_;
     static int population_;
     int data_;
     explicit B() : data_(1) { ++population_; }
-    B(const B& b) {if (++count_ == 3) throw 1; data_ = b.data_; ++population_; }
+    B(const B &b) {
+      ++count_;
+      if (count_ == 3)
+        TEST_THROW(1);
+      data_ = b.data_;
+      ++population_;
+    }
     ~B() {data_ = 0; --population_; }
 };
 
 int B::count_ = 0;
 int B::population_ = 0;
 
 struct Nasty
 {
     Nasty() : i_ ( counter_++ ) {}
     Nasty * operator &() const { return NULL; }
     int i_;
     static int counter_;
 };
 
 int Nasty::counter_ = 0;
 
 int main()
 {
     {
     const int N = 5;
     char pool[sizeof(B)*N] = {0};
     B* bp = (B*)pool;
     B b[N];
     assert(B::population_ == N);
+#ifndef TEST_HAS_NO_EXCEPTIONS
     try
     {
         std::uninitialized_copy(b, b+N, bp);
         assert(false);
     }
     catch (...)
     {
         assert(B::population_ == N);
     }
+#endif
     B::count_ = 0;
     std::uninitialized_copy(b, b+2, bp);
     for (int i = 0; i < 2; ++i)
         assert(bp[i].data_ == 1);
   assert(B::population_ == N + 2);
     }
 
     {

test/std/utilities/memory/specialized.algorithms/uninitialized.copy/uninitialized_copy_n.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>
 
 // template <class InputIterator, class Size, class ForwardIterator>
 //   ForwardIterator
 //   uninitialized_copy_n(InputIterator first, Size n,
 //                        ForwardIterator result);
 
 #include <memory>
 #include <cassert>
 
+#include "test_macros.h"
+
 struct B
 {
     static int count_;
     static int population_;
     int data_;
     explicit B() : data_(1) { ++population_; }
-    B(const B& b) {if (++count_ == 3) throw 1; data_ = b.data_; ++population_; }
+    B(const B &b) {
+      ++count_;
+      if (count_ == 3)
+        TEST_THROW(1);
+      data_ = b.data_;
+      ++population_;
+    }
     ~B() {data_ = 0; --population_; }
 };
 
 int B::population_ = 0;
 int B::count_ = 0;
 
 struct Nasty
 {
     Nasty() : i_ ( counter_++ ) {}
     Nasty * operator &() const { return NULL; }
     int i_;
     static int counter_;
 };
 
 int Nasty::counter_ = 0;
 
 int main()
 {
     {
     const int N = 5;
     char pool[sizeof(B)*N] = {0};
     B* bp = (B*)pool;
     B b[N];
     assert(B::population_ == N);
+#ifndef TEST_HAS_NO_EXCEPTIONS
     try
     {
         std::uninitialized_copy_n(b, 5, bp);
         assert(false);
     }
     catch (...)
     {
         assert(B::population_ == N);
     }
+#endif
     B::count_ = 0;
     std::uninitialized_copy_n(b, 2, bp);
     for (int i = 0; i < 2; ++i)
         assert(bp[i].data_ == 1);
     assert(B::population_ == N + 2);
     }
 
     {

test/std/utilities/memory/specialized.algorithms/uninitialized.fill.n/uninitialized_fill_n.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>
 
 // template <class ForwardIterator, class Size, class T>
 //   ForwardIterator
 //   uninitialized_fill_n(ForwardIterator first, Size n, const T& x);
 
 #include <memory>
 #include <cassert>
 
+#include "test_macros.h"
+
 struct B
 {
     static int count_;
     static int population_;
     int data_;
     explicit B() : data_(1) { ++population_; }
-    B(const B& b) {if (++count_ == 3) throw 1; data_ = b.data_; ++population_; }
+    B(const B &b) {
+      ++count_;
+      if (count_ == 3)
+        TEST_THROW(1);
+      data_ = b.data_;
+      ++population_;
+    }
     ~B() {data_ = 0; --population_; }
 };
 
 int B::count_ = 0;
 int B::population_ = 0;
 
 struct Nasty
 {
     Nasty() : i_ ( counter_++ ) {}
     Nasty * operator &() const { return NULL; }
     int i_;
     static int counter_;
 };
 
 int Nasty::counter_ = 0;
 
 int main()
 {
     {
     const int N = 5;
     char pool[sizeof(B)*N] = {0};
     B* bp = (B*)pool;
     assert(B::population_ == 0);
+#ifndef TEST_HAS_NO_EXCEPTIONS
     try
     {
         std::uninitialized_fill_n(bp, 5, B());
         assert(false);
     }
     catch (...)
     {
         assert(B::population_ == 0);
     }
+#endif
     B::count_ = 0;
     B* r = std::uninitialized_fill_n(bp, 2, B());
     assert(r == bp + 2);
     for (int i = 0; i < 2; ++i)
         assert(bp[i].data_ == 1);
     assert(B::population_ == 2);
     }
     {

test/std/utilities/memory/specialized.algorithms/uninitialized.fill/uninitialized_fill.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>
 
 // template <class ForwardIterator, class T>
 //   void
 //   uninitialized_fill(ForwardIterator first, ForwardIterator last,
 //                      const T& x);
 
 #include <memory>
 #include <cassert>
 
+#include "test_macros.h"
+
 struct B
 {
     static int count_;
     static int population_;
     int data_;
     explicit B() : data_(1) { ++population_; }
-    B(const B& b) {if (++count_ == 3) throw 1; data_ = b.data_; ++population_; }
+    B(const B &b) {
+      ++count_;
+      if (count_ == 3)
+        TEST_THROW(1);
+      data_ = b.data_;
+      ++population_;
+    }
     ~B() {data_ = 0; --population_; }
 };
 
 int B::count_ = 0;
 int B::population_ = 0;
 
 struct Nasty
 {
     Nasty() : i_ ( counter_++ ) {}
     Nasty * operator &() const { return NULL; }
     int i_;
     static int counter_;
 };
 
 int Nasty::counter_ = 0;
 
 int main()
 {
     {
     const int N = 5;
     char pool[sizeof(B)*N] = {0};
     B* bp = (B*)pool;
     assert(B::population_ == 0);
+#ifndef TEST_HAS_NO_EXCEPTIONS
     try
     {
         std::uninitialized_fill(bp, bp+N, B());
         assert(false);
     }
     catch (...)
     {
         assert(B::population_ == 0);
     }
+#endif
     B::count_ = 0;
     std::uninitialized_fill(bp, bp+2, B());
     for (int i = 0; i < 2; ++i)
         assert(bp[i].data_ == 1);
     assert(B::population_ == 2);
     }
     {
     const int N = 5;