Apply philnik777's suggestions

Author: winner245

libcxx/test/std/algorithms/alg.modifying.operations/alg.copy/common.h

@@ -16,30 +16,24 @@
 #include <cassert>
 #include <vector>
 
-#include "common.h"
 #include "test_macros.h"
 #include "test_iterators.h"
 #include "type_algorithms.h"
 
-TEST_CONSTEXPR_CXX20 void test_padding() {
-  { // Make sure that padding bits aren't copied
-    Derived src(1, 2, 3);
-    Derived dst(4, 5, 6);
-    std::copy(static_cast<PaddedBase*>(&src), static_cast<PaddedBase*>(&src) + 1, static_cast<PaddedBase*>(&dst));
-    assert(dst.a_ == 1);
-    assert(dst.b_ == 2);
-    assert(dst.c_ == 6);
-  }
-}
+class PaddedBase {
+public:
+  TEST_CONSTEXPR PaddedBase(std::int16_t a, std::int8_t b) : a_(a), b_(b) {}
 
-TEST_CONSTEXPR_CXX20 void test_overlapping() {
-  { // Make sure that overlapping ranges can be copied
-    int a[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
-    std::copy(a + 3, a + 10, a);
-    int expected[] = {4, 5, 6, 7, 8, 9, 10, 8, 9, 10};
-    assert(std::equal(a, a + 10, expected));
-  }
-}
+  std::int16_t a_;
+  std::int8_t b_;
+};
+
+class Derived : public PaddedBase {
+public:
+  TEST_CONSTEXPR Derived(std::int16_t a, std::int8_t b, std::int8_t c) : PaddedBase(a, b), c_(c) {}
+
+  std::int8_t c_;
+};
 
 template <class InIter>
 struct Test {
@@ -89,8 +83,21 @@ TEST_CONSTEXPR_CXX20 bool test_vector_bool(std::size_t N) {
 
 TEST_CONSTEXPR_CXX20 bool test() {
   types::for_each(types::cpp17_input_iterator_list<const int*>(), TestInIters());
-  test_padding();
-  test_overlapping();
+
+  { // Make sure that padding bits aren't copied
+    Derived src(1, 2, 3);
+    Derived dst(4, 5, 6);
+    std::copy(static_cast<PaddedBase*>(&src), static_cast<PaddedBase*>(&src) + 1, static_cast<PaddedBase*>(&dst));
+    assert(dst.a_ == 1);
+    assert(dst.b_ == 2);
+    assert(dst.c_ == 6);
+  }
+  { // Make sure that overlapping ranges can be copied
+    int a[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+    std::copy(a + 3, a + 10, a);
+    int expected[] = {4, 5, 6, 7, 8, 9, 10, 8, 9, 10};
+    assert(std::equal(a, a + 10, expected));
+  }
 
   { // Test vector<bool>::iterator optimization
     assert(test_vector_bool(8));

libcxx/test/std/algorithms/alg.modifying.operations/alg.copy/copy.pass.cpp

@@ -17,7 +17,6 @@
 #include <cassert>
 #include <vector>
 
-#include "common.h"
 #include "test_macros.h"
 #include "test_iterators.h"
 #include "type_algorithms.h"
@@ -80,11 +79,11 @@ TEST_CONSTEXPR_CXX20 bool test_vector_bool(std::size_t N) {
   }
 
   return true;
-} 
+}
 
 TEST_CONSTEXPR_CXX20 bool test() {
   types::for_each(types::bidirectional_iterator_list<const int*>(), TestIterators());
-  
+
   { // Make sure that padding bits aren't copied
     Derived src(1, 2, 3);
     Derived dst(4, 5, 6);
@@ -94,7 +93,7 @@ TEST_CONSTEXPR_CXX20 bool test() {
     assert(dst.b_ == 2);
     assert(dst.c_ == 6);
   }
-  
+
   { // Make sure that overlapping ranges can be copied
     int a[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
     std::copy_backward(a, a + 7, a + 10);

libcxx/test/std/algorithms/alg.modifying.operations/alg.copy/copy_backward.pass.cpp

@@ -16,12 +16,26 @@
 #include <cassert>
 #include <vector>
 
-#include "common.h"
 #include "test_macros.h"
 #include "test_iterators.h"
 #include "type_algorithms.h"
 #include "user_defined_integral.h"
 
+class PaddedBase {
+public:
+  TEST_CONSTEXPR PaddedBase(std::int16_t a, std::int8_t b) : a_(a), b_(b) {}
+
+  std::int16_t a_;
+  std::int8_t b_;
+};
+
+class Derived : public PaddedBase {
+public:
+  TEST_CONSTEXPR Derived(std::int16_t a, std::int8_t b, std::int8_t c) : PaddedBase(a, b), c_(c) {}
+
+  std::int8_t c_;
+};
+
 typedef UserDefinedIntegral<unsigned> UDI;
 
 class PaddedBase {
@@ -95,7 +109,7 @@ TEST_CONSTEXPR_CXX20 bool test() {
     assert(dst.a_ == 1);
     assert(dst.b_ == 2);
     assert(dst.c_ == 6);
-  } 
+  }
 
   { // Make sure that overlapping ranges can be copied
     int a[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

libcxx/test/std/algorithms/alg.modifying.operations/alg.copy/copy_n.pass.cpp

@@ -40,7 +40,7 @@ static_assert(!HasCopyNIt<int*, int*, SentinelForNotWeaklyEqualityComparableWith
 
 static_assert(std::is_same_v<std::ranges::copy_result<int, long>, std::ranges::in_out_result<int, long>>);
 
-template <class In, class Out, class Sent = In>
+template <class In, class Out>
 constexpr void test_iterators() {
   { // simple test
     std::array in{1, 2, 3, 4};
@@ -61,26 +61,6 @@ constexpr void test_iterators() {
   }
 }
 
-template <class Out>
-constexpr void test_in_iterators() {
-  test_iterators<cpp20_input_iterator<int*>, Out, sentinel_wrapper<cpp20_input_iterator<int*>>>();
-  test_iterators<forward_iterator<int*>, Out>();
-  test_iterators<bidirectional_iterator<int*>, Out>();
-  test_iterators<random_access_iterator<int*>, Out>();
-  test_iterators<contiguous_iterator<int*>, Out>();
-}
-
-template <class Out>
-constexpr void test_proxy_in_iterators() {
-  test_iterators<ProxyIterator<cpp20_input_iterator<int*>>,
-                 Out,
-                 sentinel_wrapper<ProxyIterator<cpp20_input_iterator<int*>>>>();
-  test_iterators<ProxyIterator<forward_iterator<int*>>, Out>();
-  test_iterators<ProxyIterator<bidirectional_iterator<int*>>, Out>();
-  test_iterators<ProxyIterator<random_access_iterator<int*>>, Out>();
-  test_iterators<ProxyIterator<contiguous_iterator<int*>>, Out>();
-}
-
 #if TEST_STD_VER >= 23
 constexpr bool test_vector_bool(std::size_t N) {
   std::vector<bool> in(N, false);
@@ -104,17 +84,12 @@ constexpr bool test_vector_bool(std::size_t N) {
 #endif
 
 constexpr bool test() {
-  test_in_iterators<cpp20_input_iterator<int*>>();
-  test_in_iterators<forward_iterator<int*>>();
-  test_in_iterators<bidirectional_iterator<int*>>();
-  test_in_iterators<random_access_iterator<int*>>();
-  test_in_iterators<contiguous_iterator<int*>>();
-
-  test_proxy_in_iterators<ProxyIterator<cpp20_input_iterator<int*>>>();
-  test_proxy_in_iterators<ProxyIterator<forward_iterator<int*>>>();
-  test_proxy_in_iterators<ProxyIterator<bidirectional_iterator<int*>>>();
-  test_proxy_in_iterators<ProxyIterator<random_access_iterator<int*>>>();
-  test_proxy_in_iterators<ProxyIterator<contiguous_iterator<int*>>>();
+  types::for_each(types::cpp20_input_iterator_list<int*>{}, []<class Out>() {
+    types::for_each(types::cpp20_input_iterator_list<int*>{}, []<class In>() {
+      test_iterators<In, Out>();
+      test_iterators<ProxyIterator<In>, ProxyIterator<Out>>();
+    });
+  });
 
   { // check that every element is copied exactly once
     struct CopyOnce {

libcxx/test/std/algorithms/alg.modifying.operations/alg.copy/ranges.copy_n.pass.cpp

@@ -29,13 +29,9 @@ typedef UserDefinedIntegral<unsigned> UDI;
 
 template <class Iter, class Container>
 TEST_CONSTEXPR_CXX20 void
-test(Container& in,
-     typename Container::iterator first,
-     size_t n,
-     typename Container::value_type value,
-     const Container& expected) {
-  Iter it = std::fill_n(Iter(first), UDI(n), value);
-  assert(base(it) == first + n);
+test(Container in, size_t from, size_t n, typename Container::value_type value, Container expected) {
+  Iter it = std::fill_n(Iter(in.data() + from), UDI(n), value);
+  assert(base(it) == in.data() + from + n);
   assert(in == expected);
 }
 
@@ -46,22 +42,23 @@ struct Test {
     {
       std::array<T, 4> in       = {1, 2, 3, 4};
       std::array<T, 4> expected = {5, 5, 5, 5};
-      test<Iter>(in, in.begin(), 4, 5, expected);
+      test<Iter>(in, 0, 4, 5, expected);
     }
     {
       std::array<T, 4> in       = {1, 2, 3, 4};
       std::array<T, 4> expected = {1, 5, 5, 4};
-      test<Iter>(in, in.begin() + 1, 2, 5, expected);
+      test<Iter>(in, 1, 2, 5, expected);
     }
   }
 };
 
-TEST_CONSTEXPR void test_int_array() {
+TEST_CONSTEXPR_CXX20 void test_int_array() {
   {
     int a[4] = {};
     assert(std::fill_n(a, UDI(4), static_cast<char>(1)) == a + 4);
     assert(a[0] == 1 && a[1] == 1 && a[2] == 1 && a[3] == 1);
   }
+#if TEST_STD_VER >= 11
   {
     const std::size_t N = 5;
     int ib[]            = {0, 0, 0, 0, 0, 0}; // one bigger than N
@@ -71,6 +68,7 @@ TEST_CONSTEXPR void test_int_array() {
            *it == 0 // don't overwrite the last value in the output array
     );
   }
+#endif
 }
 
 struct source {
@@ -153,12 +151,12 @@ TEST_CONSTEXPR_CXX20 void test_struct_array() {
     assert(a[2] == A('a'));
   }
   {
-    B test1a[4] = {};
-    assert(std::fill_n(test1a, UDI(4), static_cast<char>(10)) == test1a + 4);
-    assert(test1a[0].c == 11);
-    assert(test1a[1].c == 11);
-    assert(test1a[2].c == 11);
-    assert(test1a[3].c == 11);
+    B b[4] = {};
+    assert(std::fill_n(b, UDI(4), static_cast<char>(10)) == b + 4);
+    assert(b[0].c == 11);
+    assert(b[1].c == 11);
+    assert(b[2].c == 11);
+    assert(b[3].c == 11);
   }
   {
     Storage foo[5];