Remove remaining C++03 compatibility from unit tests

libcudacxx/libcxx/test/libcxx/algorithms/half_positive.pass.cpp

@@ -41,7 +41,6 @@ int main(int, char**)
 #endif  // !defined(_LIBCUDACXX_HAS_NO_INT128)
     }
 
-#if TEST_STD_VER >= 2011
     {
         static_assert(test<char>(), "");
         static_assert(test<int>(), "");
@@ -51,7 +50,6 @@ int main(int, char**)
         static_assert(test<__int128_t>(), "");
 #endif  // !defined(_LIBCUDACXX_HAS_NO_INT128)
     }
-#endif // TEST_STD_VER >= 2011
 
   return 0;
 }

libcudacxx/libcxx/test/libcxx/atomics/atomics.flag/init_bool.pass.cpp

@@ -19,19 +19,15 @@
 
 #include "test_macros.h"
 
-#if TEST_STD_VER >= 2011
 // Ensure that static initialization happens; this is PR#37226
 extern std::atomic_flag global;
 struct X { X() { global.test_and_set(); }};
 X x;
 std::atomic_flag global = ATOMIC_FLAG_INIT;
-#endif
 
 int main(int, char**)
 {
-#if TEST_STD_VER >= 2011
     assert(global.test_and_set() == 1);
-#endif
     {
         std::atomic_flag f(false);
         assert(f.test_and_set() == 0);

libcudacxx/libcxx/test/libcxx/containers/sequences/vector/asan.pass.cpp

@@ -30,7 +30,6 @@ void do_exit() {
 
 int main(int, char**)
 {
-#if TEST_STD_VER >= 2011
     {
         typedef int T;
         typedef std::vector<T, min_allocator<T>> C;
@@ -40,7 +39,6 @@ int main(int, char**)
         volatile T foo = c[c.size()];    // bad, but not caught by ASAN
         ((void)foo);
     }
-#endif
 
     {
         typedef cpp17_input_iterator<int*> MyInputIter;

libcudacxx/libcxx/test/libcxx/containers/sequences/vector/asan_throw.pass.cpp

@@ -71,7 +71,6 @@ void test_push_back() {
 }
 
 void test_emplace_back() {
-#if TEST_STD_VER >= 2011
   std::vector<X> v;
   v.reserve(2);
   v.push_back(X(2));
@@ -84,7 +83,6 @@ void test_emplace_back() {
   }
   assert(v.size() == 1);
   assert(is_contiguous_container_asan_correct(v));
-#endif
 }
 
 void test_insert_range() {
@@ -122,7 +120,6 @@ void test_insert() {
 }
 
 void test_emplace() {
-#if TEST_STD_VER >= 2011
   std::vector<X> v;
   v.reserve(3);
   v.insert(v.end(), X(1));
@@ -136,7 +133,6 @@ void test_emplace() {
   }
   assert(v.size() == 2);
   assert(is_contiguous_container_asan_correct(v));
-#endif
 }
 
 void test_insert_range2() {

libcudacxx/libcxx/test/libcxx/containers/unord/unord.map/db_iterators_7.pass.cpp

@@ -36,7 +36,6 @@ int main(int, char**)
     ++i;
     assert(false);
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>,
                         min_allocator<std::pair<const int, std::string>>> C;
@@ -48,7 +47,6 @@ int main(int, char**)
     ++i;
     assert(false);
     }
-#endif
 }
 
 #else

libcudacxx/libcxx/test/libcxx/containers/unord/unord.map/db_iterators_8.pass.cpp

@@ -34,7 +34,6 @@ int main(int, char**)
     C::value_type j = *i;
     assert(false);
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>,
                         min_allocator<std::pair<const int, std::string>>> C;
@@ -44,7 +43,6 @@ int main(int, char**)
     C::value_type j = *i;
     assert(false);
     }
-#endif
 }
 
 #else

libcudacxx/libcxx/test/libcxx/containers/unord/unord.map/db_local_iterators_7.pass.cpp

@@ -34,7 +34,6 @@ int main(int, char**)
     ++i;
     assert(false);
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>,
                         min_allocator<std::pair<const int, std::string>>> C;
@@ -44,7 +43,6 @@ int main(int, char**)
     ++i;
     assert(false);
     }
-#endif
 
 }
 

libcudacxx/libcxx/test/libcxx/containers/unord/unord.map/db_local_iterators_8.pass.cpp

@@ -33,7 +33,6 @@ int main(int, char**)
     C::value_type j = *i;
     assert(false);
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>,
                         min_allocator<std::pair<const int, std::string>>> C;
@@ -42,7 +41,6 @@ int main(int, char**)
     C::value_type j = *i;
     assert(false);
     }
-#endif
 }
 
 #else

libcudacxx/libcxx/test/libcxx/diagnostics/nodiscard_extensions.pass.cpp

@@ -99,26 +99,20 @@ int main(int, char**) {
   std::max_element(std::begin(arr), std::end(arr), std::greater<int>());
   std::max(1, 2);
   std::max(1, 2, std::greater<int>());
-#if TEST_STD_VER >= 2011
   std::max({1, 2, 3});
   std::max({1, 2, 3}, std::greater<int>());
-#endif
   std::min_element(std::begin(arr), std::end(arr));
   std::min_element(std::begin(arr), std::end(arr), std::greater<int>());
   std::min(1, 2);
   std::min(1, 2, std::greater<int>());
-#if TEST_STD_VER >= 2011
   std::min({1, 2, 3});
   std::min({1, 2, 3}, std::greater<int>());
-#endif
   std::minmax_element(std::begin(arr), std::end(arr));
   std::minmax_element(std::begin(arr), std::end(arr), std::greater<int>());
   std::minmax(1, 2);
   std::minmax(1, 2, std::greater<int>());
-#if TEST_STD_VER >= 2011
   std::minmax({1, 2, 3});
   std::minmax({1, 2, 3}, std::greater<int>());
-#endif
   std::mismatch(std::begin(arr), std::end(arr), std::begin(arr));
   std::mismatch(std::begin(arr), std::end(arr), std::begin(arr),
                 std::greater<int>());

libcudacxx/libcxx/test/libcxx/iterators/trivial_iterators.pass.cpp

@@ -27,12 +27,6 @@
 #include "test_macros.h"
 #include "test_iterators.h"
 
-#if TEST_STD_VER >= 2011
-#define DELETE_FUNCTION = delete
-#else
-#define DELETE_FUNCTION
-#endif
-
 class T;  // incomplete
 
 class my_input_iterator_tag : public std::input_iterator_tag {};
@@ -70,7 +64,7 @@ class my_input_iterator
         {return !(x == y);}
 
     template <class T>
-    void operator,(T const &) DELETE_FUNCTION;
+    void operator,(T const &) = delete;
 };
 
 template <class T, class U>
@@ -178,11 +172,9 @@ int main(int, char**)
     static_assert(( std::__libcpp_is_trivial_iterator<std::basic_string<char>::reverse_iterator>      ::value), "");
     static_assert(( std::__libcpp_is_trivial_iterator<std::basic_string<char>::const_reverse_iterator>::value), "");
 
-#if TEST_STD_VER >= 2011
 //  Initializer list  (which has no reverse iterators)
     static_assert(( std::__libcpp_is_trivial_iterator<std::initializer_list<char>::iterator>              ::value), "");
     static_assert(( std::__libcpp_is_trivial_iterator<std::initializer_list<char>::const_iterator>        ::value), "");
-#endif
 
 
   return 0;

libcudacxx/libcxx/test/libcxx/language.support/support.dynamic/libcpp_deallocate.sh.cpp

@@ -216,13 +216,11 @@ void test_allocator_and_new_match() {
   stats.reset();
 #elif defined(NO_SIZE)
   stats.reset();
-#if TEST_STD_VER >= 2011
   {
     int* x = new int(42);
     delete x;
     assert(stats.expect_plain());
   }
-#endif
   stats.reset();
   {
     AlignedType* a = new AlignedType();

libcudacxx/libcxx/test/libcxx/language.support/support.dynamic/new_faligned_allocation.sh.cpp

@@ -43,11 +43,7 @@ int main(int, char**) {
   }
   {
     static_assert((!std::is_constructible<std::align_val_t, std::size_t>::value), "");
-#if TEST_STD_VER >= 2011
     static_assert(!std::is_constructible<std::size_t, std::align_val_t>::value, "");
-#else
-    static_assert((std::is_constructible<std::size_t, std::align_val_t>::value), "");
-#endif
   }
   {
     std::align_val_t a = std::align_val_t(0);

libcudacxx/libcxx/test/libcxx/libcpp_alignof.pass.cpp

@@ -20,9 +20,7 @@ template <class T>
 void test() {
   static_assert(_LIBCUDACXX_ALIGNOF(T) == std::alignment_of<T>::value, "");
   static_assert(_LIBCUDACXX_ALIGNOF(T) == TEST_ALIGNOF(T), "");
-#if TEST_STD_VER >= 2011
   static_assert(_LIBCUDACXX_ALIGNOF(T) == alignof(T), "");
-#endif
 #ifdef TEST_COMPILER_CLANG
   static_assert(_LIBCUDACXX_ALIGNOF(T) == _Alignof(T), "");
 #endif

libcudacxx/libcxx/test/libcxx/strings/basic.string/string.modifiers/erase_iter_db1.pass.cpp

@@ -30,15 +30,13 @@ int main(int, char**)
     l1.erase(i);
     assert(false);
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     S l1("123");
     S::const_iterator i = l1.end();
     l1.erase(i);
     assert(false);
     }
-#endif
 }
 
 #else

libcudacxx/libcxx/test/libcxx/strings/basic.string/string.modifiers/erase_iter_db2.pass.cpp

@@ -31,7 +31,6 @@ int main(int, char**)
     l1.erase(i);
     assert(false);
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     S l1("123");
@@ -40,7 +39,6 @@ int main(int, char**)
     l1.erase(i);
     assert(false);
     }
-#endif
 }
 
 #else

libcudacxx/libcxx/test/libcxx/strings/basic.string/string.modifiers/erase_iter_iter_db1.pass.cpp

@@ -30,15 +30,13 @@ int main(int, char**)
     std::string::iterator i = l1.erase(l2.cbegin(), l1.cbegin()+1);
     assert(false);
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     S l1("123");
     S l2("123");
     S::iterator i = l1.erase(l2.cbegin(), l1.cbegin()+1);
     assert(false);
     }
-#endif
 }
 
 #else

libcudacxx/libcxx/test/libcxx/strings/basic.string/string.modifiers/erase_iter_iter_db2.pass.cpp

@@ -30,15 +30,13 @@ int main(int, char**)
     std::string::iterator i = l1.erase(l1.cbegin(), l2.cbegin()+1);
     assert(false);
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     S l1("123");
     S l2("123");
     S::iterator i = l1.erase(l1.cbegin(), l2.cbegin()+1);
     assert(false);
     }
-#endif
 }
 
 #else

libcudacxx/libcxx/test/libcxx/strings/basic.string/string.modifiers/erase_iter_iter_db3.pass.cpp

@@ -30,15 +30,13 @@ int main(int, char**)
     std::string::iterator i = l1.erase(l2.cbegin(), l2.cbegin()+1);
     assert(false);
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     S l1("123");
     S l2("123");
     S::iterator i = l1.erase(l2.cbegin(), l2.cbegin()+1);
     assert(false);
     }
-#endif
 }
 
 #else

libcudacxx/libcxx/test/libcxx/strings/basic.string/string.modifiers/erase_iter_iter_db4.pass.cpp

@@ -29,14 +29,12 @@ int main(int, char**)
     std::string::iterator i = l1.erase(l1.cbegin()+1, l1.cbegin());
     assert(false);
     }
-#if TEST_STD_VER >= 2011
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     S l1("123");
     S::iterator i = l1.erase(l1.cbegin()+1, l1.cbegin());
     assert(false);
     }
-#endif
 }
 
 #else

libcudacxx/libcxx/test/libcxx/strings/iterators.exceptions.pass.cpp

@@ -57,11 +57,7 @@ int main(int, char**)
     static_assert(std::__libcpp_string_gets_noexcept_iterator<random_access_iterator<char *> >::value == expected, "");
     static_assert(std::__libcpp_string_gets_noexcept_iterator<ThrowingIterator      <char *> >::value == expected, "");
 
-#if TEST_STD_VER >= 2011
     static_assert(( std::__libcpp_string_gets_noexcept_iterator<NonThrowingIterator   <char *> >::value), "");
-#else
-    static_assert(std::__libcpp_string_gets_noexcept_iterator<NonThrowingIterator   <char *> >::value == expected, "");
-#endif
 
 //
 //  iterators from libc++'s containers
@@ -79,11 +75,9 @@ int main(int, char**)
     static_assert(( std::__libcpp_string_gets_noexcept_iterator<std::basic_string<char>::reverse_iterator>      ::value), "");
     static_assert(( std::__libcpp_string_gets_noexcept_iterator<std::basic_string<char>::const_reverse_iterator>::value), "");
 
-#if TEST_STD_VER >= 2011
 //  Initializer list  (which has no reverse iterators)
     static_assert(( std::__libcpp_string_gets_noexcept_iterator<std::initializer_list<char>::iterator>              ::value), "");
     static_assert(( std::__libcpp_string_gets_noexcept_iterator<std::initializer_list<char>::const_iterator>        ::value), "");
-#endif
 
   return 0;
 }

libcudacxx/libcxx/test/libcxx/strings/iterators.noexcept.pass.cpp

@@ -72,11 +72,9 @@ int main(int, char**)
     static_assert(( std::__libcpp_string_gets_noexcept_iterator<std::basic_string<char>::reverse_iterator>      ::value), "");
     static_assert(( std::__libcpp_string_gets_noexcept_iterator<std::basic_string<char>::const_reverse_iterator>::value), "");
 
-#if TEST_STD_VER >= 2011
 //  Initializer list  (which has no reverse iterators)
     static_assert(( std::__libcpp_string_gets_noexcept_iterator<std::initializer_list<char>::iterator>              ::value), "");
     static_assert(( std::__libcpp_string_gets_noexcept_iterator<std::initializer_list<char>::const_iterator>        ::value), "");
-#endif
 
   return 0;
 }