[libc++][C++03] Remove code in the C++03-specific tests that is guarded on the language version

Author: philnik777

libcxx/test/libcxx-03/algorithms/half_positive.pass.cpp

@@ -41,17 +41,5 @@ int main(int, char**)
 #endif // !defined(TEST_HAS_NO_INT128)
     }
 
-#if TEST_STD_VER >= 11
-    {
-        static_assert(test<char>(), "");
-        static_assert(test<int>(), "");
-        static_assert(test<long>(), "");
-        static_assert(test<std::size_t>(), "");
-#if !defined(TEST_HAS_NO_INT128)
-        static_assert(test<__int128_t>(), "");
-#endif // !defined(TEST_HAS_NO_INT128)
-    }
-#endif // TEST_STD_VER >= 11
-
   return 0;
 }

libcxx/test/libcxx-03/algorithms/robust_against_copying_comparators.pass.cpp

@@ -82,17 +82,6 @@ struct BinaryTransform {
   TEST_CONSTEXPR T operator()(T, T) const { return 0; }
 };
 
-#if TEST_STD_VER > 17
-template <class T>
-struct ThreeWay {
-  int* copies_;
-  constexpr explicit ThreeWay(int* copies) : copies_(copies) {}
-  constexpr ThreeWay(const ThreeWay& rhs) : copies_(rhs.copies_) { *copies_ += 1; }
-  constexpr ThreeWay& operator=(const ThreeWay&) = default;
-  constexpr std::strong_ordering operator()(T, T) const { return std::strong_ordering::equal; }
-};
-#endif
-
 template <class T>
 TEST_CONSTEXPR_CXX20 bool all_the_algorithms() {
   T a[10]   = {};
@@ -109,28 +98,14 @@ TEST_CONSTEXPR_CXX20 bool all_the_algorithms() {
   int copies = 0;
   (void)std::adjacent_find(first, last, Equal<T>(&copies));
   assert(copies == 0);
-#if TEST_STD_VER >= 11
-  (void)std::all_of(first, last, UnaryTrue<T>(&copies));
-  assert(copies == 0);
-  (void)std::any_of(first, last, UnaryTrue<T>(&copies));
-  assert(copies == 0);
-#endif
   (void)std::binary_search(first, last, value, Less<T>(&copies));
   assert(copies == 0);
-#if TEST_STD_VER > 17
-  (void)std::clamp(value, value, value, Less<T>(&copies));
-  assert(copies == 0);
-#endif
   (void)std::count_if(first, last, UnaryTrue<T>(&copies));
   assert(copies == 0);
   (void)std::copy_if(first, last, first2, UnaryTrue<T>(&copies));
   assert(copies == 0);
   (void)std::equal(first, last, first2, Equal<T>(&copies));
   assert(copies == 0);
-#if TEST_STD_VER > 11
-  (void)std::equal(first, last, first2, last2, Equal<T>(&copies));
-  assert(copies == 0);
-#endif
   (void)std::equal_range(first, last, value, Less<T>(&copies));
   assert(copies == 0);
   (void)std::find_end(first, last, first2, mid2, Equal<T>(&copies));
@@ -144,10 +119,6 @@ TEST_CONSTEXPR_CXX20 bool all_the_algorithms() {
   (void)std::for_each(first, last, UnaryVoid<T>(&copies));
   assert(copies == 1);
   copies = 0;
-#if TEST_STD_VER > 14
-  (void)std::for_each_n(first, count, UnaryVoid<T>(&copies));
-  assert(copies == 0);
-#endif
   (void)std::generate(first, last, NullaryValue<T>(&copies));
   assert(copies == 0);
   (void)std::generate_n(first, count, NullaryValue<T>(&copies));
@@ -162,10 +133,6 @@ TEST_CONSTEXPR_CXX20 bool all_the_algorithms() {
   assert(copies == 0);
   (void)std::is_permutation(first, last, first2, Equal<T>(&copies));
   assert(copies == 0);
-#if TEST_STD_VER > 11
-  (void)std::is_permutation(first, last, first2, last2, Equal<T>(&copies));
-  assert(copies == 0);
-#endif
   (void)std::is_sorted(first, last, Less<T>(&copies));
   assert(copies == 0);
   (void)std::is_sorted_until(first, last, Less<T>(&copies));
@@ -176,52 +143,28 @@ TEST_CONSTEXPR_CXX20 bool all_the_algorithms() {
   }
   (void)std::lexicographical_compare(first, last, first2, last2, Less<T>(&copies));
   assert(copies == 0);
-#if TEST_STD_VER > 17
-  (void)std::lexicographical_compare_three_way(first, last, first2, last2, ThreeWay<T>(&copies));
-  assert(copies == 0);
-#endif
   (void)std::lower_bound(first, last, value, Less<T>(&copies));
   assert(copies == 0);
   (void)std::make_heap(first, last, Less<T>(&copies));
   assert(copies == 0);
   (void)std::max(value, value, Less<T>(&copies));
   assert(copies == 0);
-#if TEST_STD_VER >= 11
-  (void)std::max({value, value}, Less<T>(&copies));
-  assert(copies == 0);
-#endif
   (void)std::max_element(first, last, Less<T>(&copies));
   assert(copies == 0);
   (void)std::merge(first, mid, mid, last, first2, Less<T>(&copies));
   assert(copies == 0);
   (void)std::min(value, value, Less<T>(&copies));
   assert(copies == 0);
-#if TEST_STD_VER >= 11
-  (void)std::min({value, value}, Less<T>(&copies));
-  assert(copies == 0);
-#endif
   (void)std::min_element(first, last, Less<T>(&copies));
   assert(copies == 0);
   (void)std::minmax(value, value, Less<T>(&copies));
   assert(copies == 0);
-#if TEST_STD_VER >= 11
-  (void)std::minmax({value, value}, Less<T>(&copies));
-  assert(copies == 0);
-#endif
   (void)std::minmax_element(first, last, Less<T>(&copies));
   assert(copies == 0);
   (void)std::mismatch(first, last, first2, Equal<T>(&copies));
   assert(copies == 0);
-#if TEST_STD_VER > 11
-  (void)std::mismatch(first, last, first2, last2, Equal<T>(&copies));
-  assert(copies == 0);
-#endif
   (void)std::next_permutation(first, last, Less<T>(&copies));
   assert(copies == 0);
-#if TEST_STD_VER >= 11
-  (void)std::none_of(first, last, UnaryTrue<T>(&copies));
-  assert(copies == 0);
-#endif
   (void)std::nth_element(first, mid, last, Less<T>(&copies));
   assert(copies == 0);
   (void)std::partial_sort(first, mid, last, Less<T>(&copies));
@@ -299,25 +242,13 @@ bool test_segmented_iterator() {
   assert(copies == 1);
   copies = 0;
 
-#if TEST_STD_VER >= 20
-  std::vector<std::vector<int>> vecs(3, std::vector<int>(10));
-  auto v = std::views::join(vecs);
-  (void)std::for_each(v.begin(), v.end(), UnaryVoid<int>(&copies));
-  assert(copies == 1);
-  copies = 0;
-#endif
-
   return true;
 }
 
 int main(int, char**) {
   all_the_algorithms<void*>();
   all_the_algorithms<int>();
   assert(test_segmented_iterator());
-#if TEST_STD_VER > 17
-  static_assert(all_the_algorithms<void*>());
-  static_assert(all_the_algorithms<int>());
-#endif
 
   return 0;
 }

libcxx/test/libcxx-03/algorithms/robust_against_cpp20_hostile_iterators.compile.pass.cpp

@@ -99,10 +99,6 @@ void test() {
   (void) std::equal_range(it, it, 0, pred);
   (void) std::equal(it, it, it);
   (void) std::equal(it, it, it, pred);
-#if TEST_STD_VER > 11
-  (void) std::equal(it, it, it, it);
-  (void) std::equal(it, it, it, it, pred);
-#endif
   (void) std::fill_n(it, 0, 0);
   (void) std::fill(it, it, 0);
   (void) std::find_end(it, it, it, it);
@@ -112,9 +108,6 @@ void test() {
   (void) std::find_if_not(it, it, pred);
   (void) std::find_if(it, it, pred);
   (void) std::find(it, it, 0);
-#if TEST_STD_VER > 14
-  (void) std::for_each_n(it, 0, pred);
-#endif
   (void) std::for_each(it, it, pred);
   (void) std::generate_n(it, 0, pred);
   (void) std::generate(it, it, pred);
@@ -129,20 +122,12 @@ void test() {
   (void) std::is_partitioned(it, it, pred);
   (void) std::is_permutation(it, it, it);
   (void) std::is_permutation(it, it, it, pred);
-#if TEST_STD_VER > 11
-  (void) std::is_permutation(it, it, it, it);
-  (void) std::is_permutation(it, it, it, it, pred);
-#endif
   (void) std::is_sorted_until(it, it);
   (void) std::is_sorted_until(it, it, pred);
   (void) std::is_sorted(it, it);
   (void) std::is_sorted(it, it, pred);
   (void) std::lexicographical_compare(it, it, it, it);
   (void) std::lexicographical_compare(it, it, it, it, pred);
-#if TEST_STD_VER > 17
-  (void)std::lexicographical_compare_three_way(it, it, it, it);
-  (void)std::lexicographical_compare_three_way(it, it, it, it, std::compare_three_way());
-#endif
   (void) std::lower_bound(it, it, 0);
   (void) std::lower_bound(it, it, 0, pred);
   (void) std::make_heap(it, it);
@@ -189,14 +174,8 @@ void test() {
   (void) std::reverse(it, it);
   (void) std::rotate_copy(it, it, it, it);
   (void) std::rotate(it, it, it);
-#if TEST_STD_VER > 14
-  (void) std::sample(it, it, it, 0, rng);
-#endif
   (void) std::search(it, it, it, it);
   (void) std::search(it, it, it, it, pred);
-#if TEST_STD_VER > 14
-  (void) std::search(it, it, std::default_searcher<Cpp20HostileIterator<int*>>(it, it));
-#endif
   (void) std::set_difference(it, it, it, it, it);
   (void) std::set_difference(it, it, it, it, it, pred);
   (void) std::set_intersection(it, it, it, it, it);
@@ -205,10 +184,6 @@ void test() {
   (void) std::set_symmetric_difference(it, it, it, it, it, pred);
   (void) std::set_union(it, it, it, it, it);
   (void) std::set_union(it, it, it, it, it, pred);
-#if TEST_STD_VER > 17
-  (void) std::shift_left(it, it, 0);
-  (void) std::shift_right(it, it, 0);
-#endif
   (void) std::shuffle(it, it, rng);
   (void) std::sort_heap(it, it);
   (void) std::sort_heap(it, it, pred);

libcxx/test/libcxx-03/containers/sequences/vector/asan.pass.cpp

@@ -26,29 +26,6 @@ extern "C" void __sanitizer_set_death_callback(void (*callback)(void));
 void do_exit() { exit(0); }
 
 int main(int, char**) {
-#if TEST_STD_VER >= 11
-  {
-    typedef int T;
-    typedef cpp17_input_iterator<T*> MyInputIter;
-    std::vector<T, min_allocator<T>> v;
-    v.reserve(1);
-    int i[] = {42};
-    v.insert(v.begin(), MyInputIter(i), MyInputIter(i + 1));
-    assert(v[0] == 42);
-    assert(is_contiguous_container_asan_correct(v));
-  }
-  {
-    typedef char T;
-    typedef cpp17_input_iterator<T*> MyInputIter;
-    std::vector<T, unaligned_allocator<T>> v;
-    v.reserve(1);
-    char i[] = {'a', 'b'};
-    v.insert(v.begin(), MyInputIter(i), MyInputIter(i + 2));
-    assert(v[0] == 'a');
-    assert(v[1] == 'b');
-    assert(is_contiguous_container_asan_correct(v));
-  }
-#endif // TEST_STD_VER >= 11
   {
     typedef cpp17_input_iterator<int*> MyInputIter;
     // Sould not trigger ASan.

libcxx/test/libcxx-03/containers/sequences/vector/asan_throw.pass.cpp

@@ -68,23 +68,6 @@ void test_push_back() {
   assert(is_contiguous_container_asan_correct(v));
 }
 
-void test_emplace_back() {
-#if TEST_STD_VER >= 11
-  std::vector<X> v;
-  v.reserve(2);
-  v.push_back(X(2));
-  assert(v.size() == 1);
-  try {
-    v.emplace_back(42);
-    assert(0);
-  } catch (int e) {
-    assert(v.size() == 1);
-  }
-  assert(v.size() == 1);
-  assert(is_contiguous_container_asan_correct(v));
-#endif
-}
-
 void test_insert_range() {
   std::vector<X> v;
   v.reserve(4);
@@ -119,24 +102,6 @@ void test_insert() {
   assert(is_contiguous_container_asan_correct(v));
 }
 
-void test_emplace() {
-#if TEST_STD_VER >= 11
-  std::vector<X> v;
-  v.reserve(3);
-  v.insert(v.end(), X(1));
-  v.insert(v.begin(), X(2));
-  assert(v.size() == 2);
-  try {
-    v.emplace(v.end(), 42);
-    assert(0);
-  } catch (int e) {
-    assert(v.size() == 2);
-  }
-  assert(v.size() == 2);
-  assert(is_contiguous_container_asan_correct(v));
-#endif
-}
-
 void test_insert_range2() {
   std::vector<X> v;
   v.reserve(4);
@@ -219,10 +184,8 @@ void test_resize_param() {
 
 int main(int, char**) {
   test_push_back();
-  test_emplace_back();
   test_insert_range();
   test_insert();
-  test_emplace();
   test_insert_range2();
   test_insert_n();
   test_insert_n2();

libcxx/test/libcxx-03/depr/depr.default.allocator/allocator.members/construct.cxx20.pass.cpp

@@ -38,24 +38,6 @@ struct A {
 
 int move_only_constructed = 0;
 
-#if TEST_STD_VER >= 11
-class move_only {
-  move_only(const move_only&)            = delete;
-  move_only& operator=(const move_only&) = delete;
-
-public:
-  move_only(move_only&&) { ++move_only_constructed; }
-  move_only& operator=(move_only&&) { return *this; }
-
-  move_only() { ++move_only_constructed; }
-  ~move_only() { --move_only_constructed; }
-
-public:
-  int data; // unused other than to make sizeof(move_only) == sizeof(int).
-            // but public to suppress "-Wunused-private-field"
-};
-#endif // TEST_STD_VER >= 11
-
 int main(int, char**) {
   globalMemCounter.reset();
   {
@@ -107,41 +89,6 @@ int main(int, char**) {
     assert(globalMemCounter.checkOutstandingNewEq(0));
     assert(A_constructed == 0);
   }
-#if TEST_STD_VER >= 11
-  {
-    std::allocator<move_only> a;
-    assert(globalMemCounter.checkOutstandingNewEq(0));
-    assert(move_only_constructed == 0);
-
-    globalMemCounter.last_new_size = 0;
-    move_only* ap                  = a.allocate(3);
-    DoNotOptimize(ap);
-    assert(globalMemCounter.checkOutstandingNewEq(1));
-    assert(globalMemCounter.checkLastNewSizeEq(3 * sizeof(int)));
-    assert(move_only_constructed == 0);
-
-    a.construct(ap);
-    assert(globalMemCounter.checkOutstandingNewEq(1));
-    assert(move_only_constructed == 1);
-
-    a.destroy(ap);
-    assert(globalMemCounter.checkOutstandingNewEq(1));
-    assert(move_only_constructed == 0);
-
-    a.construct(ap, move_only());
-    assert(globalMemCounter.checkOutstandingNewEq(1));
-    assert(move_only_constructed == 1);
-
-    a.destroy(ap);
-    assert(globalMemCounter.checkOutstandingNewEq(1));
-    assert(move_only_constructed == 0);
-
-    a.deallocate(ap, 3);
-    DoNotOptimize(ap);
-    assert(globalMemCounter.checkOutstandingNewEq(0));
-    assert(move_only_constructed == 0);
-  }
-#endif
 
   return 0;
 }