Inline call to std::copy and enhance test coverage

Author: winner245

libcxx/include/__vector/vector_bool.h

@@ -417,8 +417,6 @@ class _LIBCPP_TEMPLATE_VIS vector<bool, _Allocator> {
     __guard.__complete();
   }
 
-  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void __alloc_and_copy(const vector& __v);
-
   template <class _Iterator, class _Sentinel>
   _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void __assign_with_sentinel(_Iterator __first, _Sentinel __last);
 
@@ -694,30 +692,27 @@ vector<bool, _Allocator>::vector(initializer_list<value_type> __il, const alloca
 
 #endif // _LIBCPP_CXX03_LANG
 
-// This function copies each storage word as a whole, which is substantially more efficient than copying
-// individual bits within each word
-template <class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void vector<bool, _Allocator>::__alloc_and_copy(const vector& __v) {
-  if (__v.__size_) {
-    __vallocate(__v.__size_);
-    std::copy(__v.__begin_, __v.__begin_ + __external_cap_to_internal(__v.__size_), __begin_);
-  }
-  __size_ = __v.__size_;
-}
-
 template <class _Allocator>
 _LIBCPP_CONSTEXPR_SINCE_CXX20 vector<bool, _Allocator>::vector(const vector& __v)
     : __begin_(nullptr),
       __size_(0),
       __cap_(0),
       __alloc_(__storage_traits::select_on_container_copy_construction(__v.__alloc_)) {
-  __alloc_and_copy(__v);
+  if (__v.size() > 0) {
+    __vallocate(__v.size());
+    std::copy(__v.__begin_, __v.__begin_ + __external_cap_to_internal(__v.size()), __begin_);
+    __size_ = __v.size();
+  }
 }
 
 template <class _Allocator>
 _LIBCPP_CONSTEXPR_SINCE_CXX20 vector<bool, _Allocator>::vector(const vector& __v, const allocator_type& __a)
     : __begin_(nullptr), __size_(0), __cap_(0), __alloc_(__a) {
-  __alloc_and_copy(__v);
+  if (__v.size() > 0) {
+    __vallocate(__v.size());
+    std::copy(__v.__begin_, __v.__begin_ + __external_cap_to_internal(__v.size()), __begin_);
+    __size_ = __v.size();
+  }
 }
 
 template <class _Allocator>
@@ -762,8 +757,10 @@ vector<bool, _Allocator>::vector(vector&& __v, const __type_identity_t<allocator
     this->__cap_   = __v.__cap_;
     __v.__begin_   = nullptr;
     __v.__cap_ = __v.__size_ = 0;
-  } else {
-    __alloc_and_copy(__v);
+  } else if (__v.size() > 0) {
+    __vallocate(__v.size());
+    std::copy(__v.__begin_, __v.__begin_ + __external_cap_to_internal(__v.size()), __begin_);
+    __size_ = __v.size();
   }
 }
 

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

@@ -11,64 +11,76 @@
 
 // vector(const vector& v);
 
-#include <vector>
 #include <cassert>
+#include <memory>
+#include <vector>
 
-#include "test_macros.h"
-#include "test_allocator.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
+#include "test_macros.h"
 
-template <class C>
-TEST_CONSTEXPR_CXX20 void test(const C& x)
-{
-    typename C::size_type s = x.size();
-    C c(x);
-    LIBCPP_ASSERT(c.__invariants());
-    assert(c.size() == s);
-    assert(c == x);
-}
-
-TEST_CONSTEXPR_CXX20 bool tests()
-{
-    {
-        bool a[] = {0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0};
-        bool* an = a + sizeof(a)/sizeof(a[0]);
-        test(std::vector<bool>(a, an));
-    }
-    {
-        std::vector<bool, test_allocator<bool> > v(3, true, test_allocator<bool>(5));
-        std::vector<bool, test_allocator<bool> > v2 = v;
-        assert(v2 == v);
-        assert(v2.get_allocator() == v.get_allocator());
-    }
+template <class A>
+TEST_CONSTEXPR_CXX20 void test(const std::vector<bool, A>& x) {
+  std::vector<bool, A> c(x);
+  LIBCPP_ASSERT(c.__invariants());
+  assert(c.size() == x.size());
+  assert(c == x);
 #if TEST_STD_VER >= 11
-    {
-        std::vector<bool, other_allocator<bool> > v(3, true, other_allocator<bool>(5));
-        std::vector<bool, other_allocator<bool> > v2 = v;
-        assert(v2 == v);
-        assert(v2.get_allocator() == other_allocator<bool>(-2));
-    }
-    {
-        bool a[] = {0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0};
-        bool* an = a + sizeof(a)/sizeof(a[0]);
-        test(std::vector<bool, min_allocator<bool>>(a, an));
-    }
-    {
-        std::vector<bool, min_allocator<bool> > v(3, true, min_allocator<bool>());
-        std::vector<bool, min_allocator<bool> > v2 = v;
-        assert(v2 == v);
-        assert(v2.get_allocator() == v.get_allocator());
-    }
+  assert(c.get_allocator() == std::allocator_traits<A>::select_on_container_copy_construction(x.get_allocator()));
 #endif
+}
+
+TEST_CONSTEXPR_CXX20 bool tests() {
+  bool a05[5]  = {1, 0, 1, 0, 1};
+  bool a17[17] = {0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1};
+  bool a33[33] = {1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1};
+  bool a65[65] = {0, 0, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0};
+
+  { // Test the copy constructor with the default allocator
+    test(std::vector<bool>(a05, a05 + sizeof(a05) / sizeof(a05[0])));
+    test(std::vector<bool>(a17, a17 + sizeof(a17) / sizeof(a17[0])));
+    test(std::vector<bool>(a33, a33 + sizeof(a33) / sizeof(a33[0])));
+    test(std::vector<bool>(a65, a65 + sizeof(a65) / sizeof(a65[0])));
+    test(std::vector<bool>(257, true));
+  }
+
+  { // Test the copy constructor with test_allocator
+    using A = test_allocator<bool>;
+    using C = std::vector<bool, A>;
+    test(C(a05, a05 + sizeof(a05) / sizeof(a05[0]), A(5)));
+    test(C(a17, a17 + sizeof(a17) / sizeof(a17[0]), A(5)));
+    test(C(a33, a33 + sizeof(a33) / sizeof(a33[0]), A(5)));
+    test(C(a65, a65 + sizeof(a65) / sizeof(a65[0]), A(5)));
+    test(C(257, true, A(5)));
+  }
+
+  { // Test the copy constructor with other_allocator
+    using A = other_allocator<bool>;
+    using C = std::vector<bool, A>;
+    test(C(a05, a05 + sizeof(a05) / sizeof(a05[0]), A(5)));
+    test(C(a17, a17 + sizeof(a17) / sizeof(a17[0]), A(5)));
+    test(C(a33, a33 + sizeof(a33) / sizeof(a33[0]), A(5)));
+    test(C(a65, a65 + sizeof(a65) / sizeof(a65[0]), A(5)));
+    test(C(257, true, A(5)));
+  }
+
+  { // Test the copy constructor with min_allocator
+    using A = min_allocator<bool>;
+    using C = std::vector<bool, A>;
+    test(C(a05, a05 + sizeof(a05) / sizeof(a05[0]), A()));
+    test(C(a17, a17 + sizeof(a17) / sizeof(a17[0]), A()));
+    test(C(a33, a33 + sizeof(a33) / sizeof(a33[0]), A()));
+    test(C(a65, a65 + sizeof(a65) / sizeof(a65[0]), A()));
+    test(C(257, true, A()));
+  }
 
-    return true;
+  return true;
 }
 
-int main(int, char**)
-{
-    tests();
-#if TEST_STD_VER > 17
-    static_assert(tests());
+int main(int, char**) {
+  tests();
+#if TEST_STD_VER >= 20
+  static_assert(tests());
 #endif
-    return 0;
+  return 0;
 }

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

@@ -7,67 +7,77 @@
 //===----------------------------------------------------------------------===//
 
 // <vector>
+// vector<bool>
 
 // vector(const vector& v, const allocator_type& a);
 
-#include <vector>
 #include <cassert>
+#include <vector>
 
-#include "test_macros.h"
-#include "test_allocator.h"
 #include "min_allocator.h"
+#include "test_allocator.h"
+#include "test_macros.h"
 
-template <class C>
-TEST_CONSTEXPR_CXX20 void test(const C& x, const typename C::allocator_type& a)
-{
-    typename C::size_type s = x.size();
-    C c(x, a);
-    LIBCPP_ASSERT(c.__invariants());
-    assert(c.size() == s);
-    assert(c == x);
+template <class A>
+TEST_CONSTEXPR_CXX20 void test(const std::vector<bool, A>& x, const A& a) {
+  std::vector<bool, A> c(x, a);
+  LIBCPP_ASSERT(c.__invariants());
+  assert(c.size() == x.size());
+  assert(c == x);
+  assert(c.get_allocator() == a);
 }
 
-TEST_CONSTEXPR_CXX20 bool tests()
-{
-    {
-        bool a[] = {0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0};
-        bool* an = a + sizeof(a)/sizeof(a[0]);
-        test(std::vector<bool>(a, an), std::allocator<bool>());
-    }
-    {
-        std::vector<bool, test_allocator<bool> > l(3, true, test_allocator<bool>(5));
-        std::vector<bool, test_allocator<bool> > l2(l, test_allocator<bool>(3));
-        assert(l2 == l);
-        assert(l2.get_allocator() == test_allocator<bool>(3));
-    }
-    {
-        std::vector<bool, other_allocator<bool> > l(3, true, other_allocator<bool>(5));
-        std::vector<bool, other_allocator<bool> > l2(l, other_allocator<bool>(3));
-        assert(l2 == l);
-        assert(l2.get_allocator() == other_allocator<bool>(3));
-    }
-#if TEST_STD_VER >= 11
-    {
-        bool a[] = {0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0};
-        bool* an = a + sizeof(a)/sizeof(a[0]);
-        test(std::vector<bool, min_allocator<bool>>(a, an), min_allocator<bool>());
-    }
-    {
-        std::vector<bool, min_allocator<bool> > l(3, true, min_allocator<bool>());
-        std::vector<bool, min_allocator<bool> > l2(l, min_allocator<bool>());
-        assert(l2 == l);
-        assert(l2.get_allocator() == min_allocator<bool>());
-    }
-#endif
+TEST_CONSTEXPR_CXX20 bool tests() {
+  bool a05[5]  = {1, 0, 1, 0, 1};
+  bool a17[17] = {0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1};
+  bool a33[33] = {1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1};
+  bool a65[65] = {0, 0, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0};
+
+  { // Test with the default allocator
+    test(std::vector<bool>(a05, a05 + sizeof(a05) / sizeof(a05[0])), std::allocator<bool>());
+    test(std::vector<bool>(a17, a17 + sizeof(a17) / sizeof(a17[0])), std::allocator<bool>());
+    test(std::vector<bool>(a33, a33 + sizeof(a33) / sizeof(a33[0])), std::allocator<bool>());
+    test(std::vector<bool>(a65, a65 + sizeof(a65) / sizeof(a65[0])), std::allocator<bool>());
+    test(std::vector<bool>(257, true), std::allocator<bool>());
+  }
+
+  { // Test with test_allocator
+    using A = test_allocator<bool>;
+    using C = std::vector<bool, A>;
+    test(C(a05, a05 + sizeof(a05) / sizeof(a05[0]), A(5)), A(3));
+    test(C(a17, a17 + sizeof(a17) / sizeof(a17[0]), A(5)), A(3));
+    test(C(a33, a33 + sizeof(a33) / sizeof(a33[0]), A(5)), A(3));
+    test(C(a65, a65 + sizeof(a65) / sizeof(a65[0]), A(5)), A(3));
+    test(C(257, true, A(5)), A(3));
+  }
+
+  { // Test with other_allocator
+    using A = other_allocator<bool>;
+    using C = std::vector<bool, A>;
+    test(C(a05, a05 + sizeof(a05) / sizeof(a05[0]), A(5)), A(3));
+    test(C(a17, a17 + sizeof(a17) / sizeof(a17[0]), A(5)), A(3));
+    test(C(a33, a33 + sizeof(a33) / sizeof(a33[0]), A(5)), A(3));
+    test(C(a65, a65 + sizeof(a65) / sizeof(a65[0]), A(5)), A(3));
+    test(C(257, true, A(5)), A(3));
+  }
+
+  { // Test with min_allocator
+    using A = min_allocator<bool>;
+    using C = std::vector<bool, A>;
+    test(C(a05, a05 + sizeof(a05) / sizeof(a05[0]), A()), A());
+    test(C(a17, a17 + sizeof(a17) / sizeof(a17[0]), A()), A());
+    test(C(a33, a33 + sizeof(a33) / sizeof(a33[0]), A()), A());
+    test(C(a65, a65 + sizeof(a65) / sizeof(a65[0]), A()), A());
+    test(C(257, true, A()), A());
+  }
 
   return true;
 }
 
-int main(int, char**)
-{
-    tests();
-#if TEST_STD_VER > 17
-    static_assert(tests());
+int main(int, char**) {
+  tests();
+#if TEST_STD_VER >= 20
+  static_assert(tests());
 #endif
-    return 0;
+  return 0;
 }