Refactor in a better way

Author: winner245

libcxx/test/std/containers/sequences/vector.bool/ctor_exceptions.pass.cpp

@@ -12,133 +12,121 @@
 // Check that vector<bool> constructors don't leak memory when an operation inside the constructor throws an exception
 
 #include <cstddef>
-#include <type_traits>
 #include <memory>
+#include <type_traits>
 #include <vector>
 
+#include "../vector/common.h"
 #include "count_new.h"
 #include "test_iterators.h"
 
-template <class T>
-struct Allocator {
-  using value_type      = T;
-  using is_always_equal = std::false_type;
-
-  template <class U>
-  Allocator(const Allocator<U>&) {}
-
-  Allocator(bool should_throw = true) {
-    if (should_throw)
-      throw 0;
-  }
-
-  T* allocate(std::size_t n) { return std::allocator<T>().allocate(n); }
-  void deallocate(T* ptr, std::size_t n) { std::allocator<T>().deallocate(ptr, n); }
-
-  template <class U>
-  friend bool operator==(const Allocator&, const Allocator<U>&) { return true; }
-};
-
-template <class IterCat>
-struct Iterator {
-  using iterator_category = IterCat;
-  using difference_type   = std::ptrdiff_t;
-  using value_type        = bool;
-  using reference         = bool&;
-  using pointer           = bool*;
-
-  int i_;
-  bool b_ = true;
-  Iterator(int i = 0) : i_(i) {}
-  bool& operator*() {
-    if (i_ == 1)
-      throw 1;
-    return b_;
-  }
-
-  friend bool operator==(const Iterator& lhs, const Iterator& rhs) { return lhs.i_ == rhs.i_; }
-
-  friend bool operator!=(const Iterator& lhs, const Iterator& rhs) { return lhs.i_ != rhs.i_; }
-
-  Iterator& operator++() {
-    ++i_;
-    return *this;
-  }
+int main(int, char**) {
+  using AllocVec = std::vector<bool, throwing_allocator<bool> >;
 
-  Iterator operator++(int) {
-    auto tmp = *this;
-    ++i_;
-    return tmp;
+  try { // Throw in vector() from allocator
+    AllocVec vec;
+  } catch (int) {
   }
-};
-
-void check_new_delete_called() {
-  assert(globalMemCounter.new_called == globalMemCounter.delete_called);
-  assert(globalMemCounter.new_array_called == globalMemCounter.delete_array_called);
-  assert(globalMemCounter.aligned_new_called == globalMemCounter.aligned_delete_called);
-  assert(globalMemCounter.aligned_new_array_called == globalMemCounter.aligned_delete_array_called);
-}
-
-int main(int, char**) {
-  using AllocVec = std::vector<bool, Allocator<bool> >;
+  check_new_delete_called();
 
 #if TEST_STD_VER >= 14
-  try { // Throw in vector(size_type, const allocator_type&) from allocator
-    Allocator<bool> alloc(false);
+  try { // Throw in vector(size_type, const allocator_type&) from allocator 
+    throwing_allocator<bool> alloc(/*throw_on_ctor = */ false, /*throw_on_copy = */ true);
     AllocVec get_alloc(0, alloc);
   } catch (int) {
   }
   check_new_delete_called();
-#endif  // TEST_STD_VER >= 14
+#endif // TEST_STD_VER >= 14
+
+  try { // Throw in vector(size_type, const value_type&, const allocator_type&) from allocator
+    throwing_allocator<bool> alloc(/*throw_on_ctor = */ false, /*throw_on_copy = */ true);
+    AllocVec get_alloc(0, true, alloc);
+  } catch (int) {
+  }
+  check_new_delete_called();
 
   try { // Throw in vector(InputIterator, InputIterator) from input iterator
-    std::vector<bool> vec((Iterator<std::input_iterator_tag>()), Iterator<std::input_iterator_tag>(2));
+    std::vector<bool> vec(
+        throwing_iterator<bool, std::input_iterator_tag>(), throwing_iterator<bool, std::input_iterator_tag>(2));
   } catch (int) {
   }
   check_new_delete_called();
 
   try { // Throw in vector(InputIterator, InputIterator) from forward iterator
-    std::vector<bool> vec((Iterator<std::forward_iterator_tag>()), Iterator<std::forward_iterator_tag>(2));
+    std::vector<bool> vec(
+        throwing_iterator<bool, std::forward_iterator_tag>(), throwing_iterator<bool, std::forward_iterator_tag>(2));
   } catch (int) {
   }
   check_new_delete_called();
 
   try { // Throw in vector(InputIterator, InputIterator) from allocator
-    int a[] = {1, 2};
-    AllocVec vec(cpp17_input_iterator<int*>(a), cpp17_input_iterator<int*>(a + 2));
+    bool a[] = {true, true};
+    AllocVec vec(cpp17_input_iterator<bool*>(a), cpp17_input_iterator<bool*>(a + 2));
   } catch (int) {
   }
   check_new_delete_called();
 
   try { // Throw in vector(InputIterator, InputIterator, const allocator_type&) from input iterator
     std::allocator<bool> alloc;
-    std::vector<bool> vec(Iterator<std::input_iterator_tag>(), Iterator<std::input_iterator_tag>(2), alloc);
+    std::vector<bool> vec(
+        throwing_iterator<bool, std::input_iterator_tag>(), throwing_iterator<bool, std::input_iterator_tag>(2), alloc);
   } catch (int) {
   }
   check_new_delete_called();
 
   try { // Throw in vector(InputIterator, InputIterator, const allocator_type&) from forward iterator
     std::allocator<bool> alloc;
-    std::vector<bool> vec(Iterator<std::forward_iterator_tag>(), Iterator<std::forward_iterator_tag>(2), alloc);
+    std::vector<bool> vec(throwing_iterator<bool, std::forward_iterator_tag>(),
+                          throwing_iterator<bool, std::forward_iterator_tag>(2),
+                          alloc);
   } catch (int) {
   }
   check_new_delete_called();
 
   try { // Throw in vector(InputIterator, InputIterator, const allocator_type&) from allocator
-    bool a[] = {true, false};
-    Allocator<bool> alloc(false);
+    bool a[] = {true, false}; 
+    throwing_allocator<bool> alloc(/*throw_on_ctor = */ false, /*throw_on_copy = */ true);
     AllocVec vec(cpp17_input_iterator<bool*>(a), cpp17_input_iterator<bool*>(a + 2), alloc);
   } catch (int) {
   }
   check_new_delete_called();
 
   try { // Throw in vector(InputIterator, InputIterator, const allocator_type&) from allocator
-    bool a[] = {true, false};
-    Allocator<bool> alloc(false);
+    bool a[] = {true, false}; 
+    throwing_allocator<bool> alloc(/*throw_on_ctor = */ false, /*throw_on_copy = */ true);
     AllocVec vec(forward_iterator<bool*>(a), forward_iterator<bool*>(a + 2), alloc);
   } catch (int) {
   }
   check_new_delete_called();
 
+#if TEST_STD_VER >= 11
+  try { // Throw in vector(const vector&, const allocator_type&) from allocator
+    throwing_allocator<bool> alloc(/*throw_on_ctor = */ false, /*throw_on_copy = */ false);
+    AllocVec vec(alloc);
+    vec.push_back(true);
+    alloc.throw_on_copy_ = true;
+    AllocVec vec2(vec, alloc);
+  } catch (int) {
+  }
+  check_new_delete_called();
+
+  try { // Throw in vector(vector&&, const allocator_type&) from allocator
+    throwing_allocator<bool> alloc(/*throw_on_ctor = */ false, /*throw_on_copy = */ false);
+    AllocVec vec(alloc);
+    vec.push_back(true);
+    alloc.throw_on_copy_ = true;
+    AllocVec vec2(std::move(vec), alloc);
+  } catch (int) {
+  }
+  check_new_delete_called();
+
+  try { // Throw in vector(initializer_list<value_type>, const allocator_type&) constructor from allocator
+    throwing_allocator<bool> alloc(/*throw_on_ctor = */ false, /*throw_on_copy = */ true);
+    AllocVec vec({true, true}, alloc);
+  } catch (int) {
+  }
+  check_new_delete_called();
+#endif // TEST_STD_VER >= 11
+
   return 0;
 }

libcxx/test/std/containers/sequences/vector.bool/exceptions.pass.cpp

@@ -6,8 +6,13 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef EXCEPTION_TEST_HELPERS_H
-#define EXCEPTION_TEST_HELPERS_H
+#ifndef COMMON_H
+#define COMMON_H
+
+#include <cassert>
+#include <cstddef>
+#include <memory>
+#include <type_traits>
 
 #include "count_new.h"
 
@@ -18,7 +23,9 @@ struct throwing_allocator {
 
   bool throw_on_copy_ = false;
 
-  throwing_allocator(bool throw_on_ctor = true, bool throw_on_copy = false) : throw_on_copy_(throw_on_copy) {
+  throwing_allocator() : throwing_allocator(/*throw_on_ctor = */ true, /*throw_on_copy = */ false) {}
+
+  explicit throwing_allocator(bool throw_on_ctor, bool throw_on_copy) : throw_on_copy_(throw_on_copy) {
     if (throw_on_ctor)
       throw 0;
   }
@@ -84,4 +91,4 @@ inline void check_new_delete_called() {
   assert(globalMemCounter.aligned_new_array_called == globalMemCounter.aligned_delete_array_called);
 }
 
-#endif // EXCEPTION_TEST_HELPERS_H
+#endif // COMMON_H