Apply @philnik777 suggestions

Author: winner245

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

@@ -15,30 +15,24 @@
 #include <algorithm>
 #include <cassert>
 
-#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 {
@@ -68,8 +62,20 @@ struct TestInIters {
 
 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));
+  }
 
   return true;
 }

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

@@ -16,12 +16,26 @@
 #include <algorithm>
 #include <cassert>
 
-#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_;
+};
+
 template <class InIter>
 struct TestOutIters {
   template <class OutIter>
@@ -39,7 +53,16 @@ struct TestOutIters {
   }
 };
 
-TEST_CONSTEXPR_CXX20 void test_padding() {
+struct TestInIters {
+  template <class InIter>
+  TEST_CONSTEXPR_CXX20 void operator()() {
+    types::for_each(types::bidirectional_iterator_list<int*>(), TestOutIters<InIter>());
+  }
+};
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  types::for_each(types::bidirectional_iterator_list<const int*>(), TestInIters());
+
   { // Make sure that padding bits aren't copied
     Derived src(1, 2, 3);
     Derived dst(4, 5, 6);
@@ -49,28 +72,12 @@ TEST_CONSTEXPR_CXX20 void test_padding() {
     assert(dst.b_ == 2);
     assert(dst.c_ == 6);
   }
-}
-
-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_backward(a, a + 7, a + 10);
     int expected[] = {1, 2, 3, 1, 2, 3, 4, 5, 6, 7};
     assert(std::equal(a, a + 10, expected));
   }
-}
-
-struct TestInIters {
-  template <class InIter>
-  TEST_CONSTEXPR_CXX20 void operator()() {
-    types::for_each(types::bidirectional_iterator_list<int*>(), TestOutIters<InIter>());
-  }
-};
-
-TEST_CONSTEXPR_CXX20 bool test() {
-  types::for_each(types::bidirectional_iterator_list<const int*>(), TestInIters());
-  test_padding();
-  test_overlapping();
 
   return true;
 }

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

@@ -15,33 +15,27 @@
 #include <algorithm>
 #include <cassert>
 
-#include "common.h"
 #include "test_macros.h"
 #include "test_iterators.h"
 #include "type_algorithms.h"
 #include "user_defined_integral.h"
 
-typedef UserDefinedIntegral<unsigned> UDI;
+class PaddedBase {
+public:
+  TEST_CONSTEXPR PaddedBase(std::int16_t a, std::int8_t b) : a_(a), b_(b) {}
 
-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_n(static_cast<PaddedBase*>(&src), 1, static_cast<PaddedBase*>(&dst));
-    assert(dst.a_ == 1);
-    assert(dst.b_ == 2);
-    assert(dst.c_ == 6);
-  }
-}
+  std::int16_t a_;
+  std::int8_t 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_n(a + 3, 7, a);
-    int expected[] = {4, 5, 6, 7, 8, 9, 10, 8, 9, 10};
-    assert(std::equal(a, a + 10, expected));
-  }
-}
+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;
 
 template <class InIter>
 struct TestOutIters {
@@ -71,8 +65,20 @@ struct TestInIters {
 
 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_n(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_n(a + 3, 7, a);
+    int expected[] = {4, 5, 6, 7, 8, 9, 10, 8, 9, 10};
+    assert(std::equal(a, a + 10, expected));
+  }
 
   return true;
 }

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

@@ -27,13 +27,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);
 }
 
@@ -44,22 +40,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
@@ -69,6 +66,7 @@ TEST_CONSTEXPR void test_int_array() {
            *it == 0 // don't overwrite the last value in the output array
     );
   }
+#endif
 }
 
 struct source {
@@ -118,12 +116,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];